ZFS - vdev label 的加载与同步

前一篇文章中我们说明了ZFS的Label在磁盘上的存储形式，这篇文章中，我们将详细说明一下Vdev在内存中的组织形式以及相关的实现细节。

 

1. vdev label的内存结构

上一篇中我们介绍过，vdev的Label在磁盘上的存储备份成了4部分，第一部分8KB，对应VTOC的卷标；第二部分8KB，对应Boot Header信息；第三部分112K，对应nvlist键值对；第四部分128K，对应uberblock数组。这四个在以下的结构体（vdev_label）中可以很清楚地看出。

typedef struct vdev_label {
         char             vl_pad1[VDEV_PAD_SIZE];               /* 8K */
         char             vl_pad2[VDEV_PAD_SIZE];               /* 8K */
         vdev_phys_t     vl_vdev_phys;                  /* 112K */
         char             vl_uberblock[VDEV_UBERBLOCK_RING];    /* 128K */
} vdev_label_t;

typedef struct vdev_phys {
         char             vp_nvlist[VDEV_PHYS_SIZE - sizeof (zio_eck_t)];
         zio_eck_t       vp_zbt;
} vdev_phys_t;

typedef struct zio_eck {
         uint64_t zec_magic; /* for validation, endianness */
         zio_cksum_t     zec_cksum; /* 256-bit checksum */
} zio_eck_t;

typedef struct zio_cksum {
         uint64_t zc_word[4];
} zio_cksum_t;

2. vl_pad1和vl_pad2不用特别说明

3. 读取Label信息(配置信息以及uberblock信息)

3.1.  从vdev Label中读取vl_dev_phys结构体

/* 根据给定的虚拟设备，返回其Label中的配置星系，对于没有Label中没有存储txg的设备（比如spares/cache）
   或者没有完全初始化的设备（txg=0），返回找到的第一个合法的Label信息。否则，返回最新的Label（txg值最大的） */
nvlist_t * vdev_label_read_config(vdev_t *vd, uint64_t txg)
{
         spa_t *spa = vd->vdev_spa;
         nvlist_t *config = NULL;
         vdev_phys_t *vp;
         zio_t *zio;
         uint64_t best_txg = 0;
         int error = 0;
         int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL |
             ZIO_FLAG_SPECULATIVE;

         ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);

         if (!vdev_readable(vd)) // 判断该虚拟设备是否可读
                 return (NULL);

         vp = zio_buf_alloc(sizeof (vdev_phys_t));

retry:
         for (int l = 0; l < VDEV_LABELS; l++) {
                 nvlist_t *label = NULL;

                 zio = zio_root(spa, NULL, NULL, flags);

/* 使用zio读取vd设备的label，从Label的16K位置开始读，读出的结果放到vp中 */
                 vdev_label_read(zio, vd, l, vp,
                     offsetof(vdev_label_t, vl_vdev_phys),
                     sizeof (vdev_phys_t), NULL, NULL, flags);
/* 如果读取成功，将读到vp中的结果转换到nvlist类型的label变量中 */
                 if (zio_wait(zio) == 0 &&
                     nvlist_unpack(vp->vp_nvlist, sizeof (vp->vp_nvlist),
                     &label, 0) == 0) {
                          uint64_t label_txg = 0;

 /* 辅助设备（sparse/cache）的Label中没有txg值，新添加的设备可能没有初始化完全，直接返回第一个合法的Label */
                          error = nvlist_lookup_uint64(label,
                              ZPOOL_CONFIG_POOL_TXG, &label_txg);
                          if ((error || label_txg == 0) && !config) {
                                   config = label;
                                   break;
                          } else if (label_txg <= txg && label_txg > best_txg) {
/* 如果不是最佳的Label，继续寻找（找txg值最大的Label） */
                                  best_txg = label_txg;
                                   nvlist_free(config);
                                   config = fnvlist_dup(label);
                          }
                 }

                 if (label != NULL) {
                          nvlist_free(label);
                          label = NULL;
                 }
         }

         if (config == NULL && !(flags & ZIO_FLAG_TRYHARD)) {
                 flags |= ZIO_FLAG_TRYHARD;
                 goto retry;
         }

         zio_buf_free(vp, sizeof (vdev_phys_t));

         return (config);
}

3.2. 加载uberblock

加载uberblock时，需要加载最佳的uberblock以及与之相关的配置信息。首先要读取每个设备的每个Label，记录每个数组中txg值最大的uberblock，然后从相同的设备中读取配置信息。

void vdev_uberblock_load(vdev_t *rvd, uberblock_t *ub, nvlist_t **config)
{
         zio_t *zio;
         spa_t *spa = rvd->vdev_spa;
         struct ubl_cbdata cb;
         int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL |
             ZIO_FLAG_SPECULATIVE | ZIO_FLAG_TRYHARD;

         ASSERT(ub);
         ASSERT(config);

         bzero(ub, sizeof (uberblock_t));
         *config = NULL;

         cb.ubl_ubbest = ub;
         cb.ubl_vd = NULL;

         spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
         zio = zio_root(spa, NULL, &cb, flags);

/* 读取最佳的uberblock，后文给出此函数的详细说明*/
         vdev_uberblock_load_impl(zio, rvd, flags, &cb);
         (void) zio_wait(zio);

/* 找到设备之后，从该设备上获取配置信息 */
         if (cb.ubl_vd != NULL)
                 *config = vdev_label_read_config(cb.ubl_vd, ub->ub_txg);
         spa_config_exit(spa, SCL_ALL, FTAG);
}

static void vdev_uberblock_load_impl(zio_t *zio, vdev_t *vd, int flags,
    struct ubl_cbdata *cbp)
{
         /* 递归查找所有的子设备 */
         for (int c = 0; c < vd->vdev_children; c++)
                 vdev_uberblock_load_impl(zio, vd->vdev_child[c], flags, cbp);
         /* 只针对可读且是叶虚拟设备读取 */
         if (vd->vdev_ops->vdev_op_leaf && vdev_readable(vd)) {
                 for (int l = 0; l < VDEV_LABELS; l++) {
                          for (int n = 0; n < VDEV_UBERBLOCK_COUNT(vd); n++) {
                          /* 从偏移可以看出，值读取Label的uberblock部分 vdev_uberblock_load_done为回调函数,见后文说明*/
                                   vdev_label_read(zio, vd, l,
                                       zio_buf_alloc(VDEV_UBERBLOCK_SIZE(vd)),
                                       VDEV_UBERBLOCK_OFFSET(vd, n),
                                       VDEV_UBERBLOCK_SIZE(vd),
                                       vdev_uberblock_load_done, zio, flags);
                          }
                 }
         }
}

/* 作为vdev_label_read的回调函数, 确保一直持有最佳的uberblock */
static void vdev_uberblock_load_done(zio_t *zio)
{
         vdev_t *vd = zio->io_vd;
         spa_t *spa = zio->io_spa;
         zio_t *rio = zio->io_private;
         uberblock_t *ub = zio->io_data;
         struct ubl_cbdata *cbp = rio->io_private;

         ASSERT3U(zio->io_size, ==, VDEV_UBERBLOCK_SIZE(vd));

         if (zio->io_error == 0 && uberblock_verify(ub) == 0) {
                 mutex_enter(&rio->io_lock);
                 if (ub->ub_txg <= spa->spa_load_max_txg &&
                     vdev_uberblock_compare(ub, cbp->ubl_ubbest) > 0) {
                          /* 通过比较,记录最新的uberblock */
                          *cbp->ubl_ubbest = *ub;
                          cbp->ubl_vd = vd;
                 }
                 mutex_exit(&rio->io_lock);
         }

         zio_buf_free(zio->io_data, zio->io_size);
}

3.3. 同步Label信息

/* 同步uberblock和vdev配置信息的更改，操作的顺序是通过精妙的设计来保证在通过过程中发生系统panic或是断电，
   磁盘上的信息仍然是完整的。代码行中的注释详细说明每个阶段的作用。而且本函数任何阶段发生了错误，可以直接再
   次调用，它可以重新完成未完成的工作 */
int vdev_config_sync(vdev_t **svd, int svdcount, uint64_t txg, boolean_t tryhard)
{
         spa_t *spa = svd[0]->vdev_spa;
         uberblock_t *ub = &spa->spa_uberblock;
         vdev_t *vd;
         zio_t *zio;
         int error;
         int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL;

         /* 一般来说，我们并不辛苦地去写入所有的Label以及uberblock */
         if (tryhard)
                 flags |= ZIO_FLAG_TRYHARD;

         ASSERT(ub->ub_txg <= txg);

         /* 如果这不是由于I/O错误而需要重新同步，而且这个事务组并没有什么修改，配置信息也没有改变，那么这里就不需要做任何工作。 */
         if (ub->ub_txg < txg &&
             uberblock_update(ub, spa->spa_root_vdev, txg) == B_FALSE &&
             list_is_empty(&spa->spa_config_dirty_list))
                 return (0);

         if (txg > spa_freeze_txg(spa))
                 return (0);

         ASSERT(txg <= spa->spa_final_txg);

         /* 将磁盘缓存中的数据修改全都写入磁盘之后在更新uberblock信息 */
         zio = zio_root(spa, NULL, NULL, flags);

         for (vd = txg_list_head(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)); vd;
             vd = txg_list_next(&spa->spa_vdev_txg_list, vd, TXG_CLEAN(txg)))
                 zio_flush(zio, vd);

         (void) zio_wait(zio);

         /* 将偶数Label(L0,L2)同步到每个脏虚拟设备,如果这个过程中系统挂掉了,没关系,所有的奇数Label中信息是合法的.
            这保证了所有的偶数Label在uberblock之前被写入到磁盘中. */
         if ((error = vdev_label_sync_list(spa, 0, txg, flags)) != 0)
                 return (error);

         /* 将uberblock同步到svd[]中所有的vdev，如果系统在这个过程中挂掉，要考虑两种情况：
           1) 如果没有uberblock被写入磁盘，那么之前的uberblock就是最新的，奇数Label（还没有被更新）上的上的uberblock是合法的。
           2) 如果有一个或多个uberblocks已经被写入磁盘，那么它就是最新的，那么偶数Label（已经被成功更新了）上的数据与新的uberblocks一致 */
         if ((error = vdev_uberblock_sync_list(svd, svdcount, ub, flags)) != 0)
                 return (error);

         /* 将奇数Label同步到每个脏虚拟设备，如果系统在这个过程中挂了，偶数Label和新的uberblock对与pool是有效的，
            下一次pool被打开的时候，第一件是要做的就是将所有的磁盘置为脏，这样所有的label都会被更新，在下个事务组开
            始之前就将奇数Label的信息同步到磁盘上 */
         return (vdev_label_sync_list(spa, 1, txg, flags));
}

关于具体的配置信息以及uberblock写入操作,可以查看ZFS源码 vdev_label.c

 

本文乃nnusun原创文章，请勿转载。如须转载请详细标明转载出处。