sys/cddl/contrib/opensolaris/uts/common/fs/zfs/vdev_label.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright (c) 2013 by Delphix. All rights reserved.
  25  */
  26
  27 /*
  28  * Virtual Device Labels
  29  * ---------------------
  30  *
  31  * The vdev label serves several distinct purposes:
  32  *
  33  *      1. Uniquely identify this device as part of a ZFS pool and confirm its
  34  *         identity within the pool.
  35  *
  36  *      2. Verify that all the devices given in a configuration are present
  37  *         within the pool.
  38  *
  39  *      3. Determine the uberblock for the pool.
  40  *
  41  *      4. In case of an import operation, determine the configuration of the
  42  *         toplevel vdev of which it is a part.
  43  *
  44  *      5. If an import operation cannot find all the devices in the pool,
  45  *         provide enough information to the administrator to determine which
  46  *         devices are missing.
  47  *
  48  * It is important to note that while the kernel is responsible for writing the
  49  * label, it only consumes the information in the first three cases.  The
  50  * latter information is only consumed in userland when determining the
  51  * configuration to import a pool.
  52  *
  53  *
  54  * Label Organization
  55  * ------------------
  56  *
  57  * Before describing the contents of the label, it's important to understand how
  58  * the labels are written and updated with respect to the uberblock.
  59  *
  60  * When the pool configuration is altered, either because it was newly created
  61  * or a device was added, we want to update all the labels such that we can deal
  62  * with fatal failure at any point.  To this end, each disk has two labels which
  63  * are updated before and after the uberblock is synced.  Assuming we have
  64  * labels and an uberblock with the following transaction groups:
  65  *
  66  *              L1          UB          L2
  67  *           +------+    +------+    +------+
  68  *           |      |    |      |    |      |
  69  *           | t10  |    | t10  |    | t10  |
  70  *           |      |    |      |    |      |
  71  *           +------+    +------+    +------+
  72  *
  73  * In this stable state, the labels and the uberblock were all updated within
  74  * the same transaction group (10).  Each label is mirrored and checksummed, so
  75  * that we can detect when we fail partway through writing the label.
  76  *
  77  * In order to identify which labels are valid, the labels are written in the
  78  * following manner:
  79  *
  80  *      1. For each vdev, update 'L1' to the new label
  81  *      2. Update the uberblock
  82  *      3. For each vdev, update 'L2' to the new label
  83  *
  84  * Given arbitrary failure, we can determine the correct label to use based on
  85  * the transaction group.  If we fail after updating L1 but before updating the
  86  * UB, we will notice that L1's transaction group is greater than the uberblock,
  87  * so L2 must be valid.  If we fail after writing the uberblock but before
  88  * writing L2, we will notice that L2's transaction group is less than L1, and
  89  * therefore L1 is valid.
  90  *
  91  * Another added complexity is that not every label is updated when the config
  92  * is synced.  If we add a single device, we do not want to have to re-write
  93  * every label for every device in the pool.  This means that both L1 and L2 may
  94  * be older than the pool uberblock, because the necessary information is stored
  95  * on another vdev.
  96  *
  97  *
  98  * On-disk Format
  99  * --------------
 100  *
 101  * The vdev label consists of two distinct parts, and is wrapped within the
 102  * vdev_label_t structure.  The label includes 8k of padding to permit legacy
 103  * VTOC disk labels, but is otherwise ignored.
 104  *
 105  * The first half of the label is a packed nvlist which contains pool wide
 106  * properties, per-vdev properties, and configuration information.  It is
 107  * described in more detail below.
 108  *
 109  * The latter half of the label consists of a redundant array of uberblocks.
 110  * These uberblocks are updated whenever a transaction group is committed,
 111  * or when the configuration is updated.  When a pool is loaded, we scan each
 112  * vdev for the 'best' uberblock.
 113  *
 114  *
 115  * Configuration Information
 116  * -------------------------
 117  *
 118  * The nvlist describing the pool and vdev contains the following elements:
 119  *
 120  *      version         ZFS on-disk version
 121  *      name            Pool name
 122  *      state           Pool state
 123  *      txg             Transaction group in which this label was written
 124  *      pool_guid       Unique identifier for this pool
 125  *      vdev_tree       An nvlist describing vdev tree.
 126  *      features_for_read
 127  *                      An nvlist of the features necessary for reading the MOS.
 128  *
 129  * Each leaf device label also contains the following:
 130  *
 131  *      top_guid        Unique ID for top-level vdev in which this is contained
 132  *      guid            Unique ID for the leaf vdev
 133  *
 134  * The 'vs' configuration follows the format described in 'spa_config.c'.
 135  */
 136
 137 #include <sys/zfs_context.h>
 138 #include <sys/spa.h>
 139 #include <sys/spa_impl.h>
 140 #include <sys/dmu.h>
 141 #include <sys/zap.h>
 142 #include <sys/vdev.h>
 143 #include <sys/vdev_impl.h>
 144 #include <sys/uberblock_impl.h>
 145 #include <sys/metaslab.h>
 146 #include <sys/zio.h>
 147 #include <sys/dsl_scan.h>
 148 #include <sys/trim_map.h>
 149 #include <sys/fs/zfs.h>
 150
 151 static boolean_t vdev_trim_on_init = B_TRUE;
 152 SYSCTL_DECL(_vfs_zfs_vdev);
 153 SYSCTL_INT(_vfs_zfs_vdev, OID_AUTO, trim_on_init, CTLFLAG_RW,
 154     &vdev_trim_on_init, 0, "Enable/disable full vdev trim on initialisation");
 155
 156 /*
 157  * Basic routines to read and write from a vdev label.
 158  * Used throughout the rest of this file.
 159  */
 160 uint64_t
 161 vdev_label_offset(uint64_t psize, int l, uint64_t offset)
 162 {
 163         ASSERT(offset < sizeof (vdev_label_t));
 164         ASSERT(P2PHASE_TYPED(psize, sizeof (vdev_label_t), uint64_t) == 0);
 165
 166         return (offset + l * sizeof (vdev_label_t) + (l < VDEV_LABELS / 2 ?
 167             0 : psize - VDEV_LABELS * sizeof (vdev_label_t)));
 168 }
 169
 170 /*
 171  * Returns back the vdev label associated with the passed in offset.
 172  */
 173 int
 174 vdev_label_number(uint64_t psize, uint64_t offset)
 175 {
 176         int l;
 177
 178         if (offset >= psize - VDEV_LABEL_END_SIZE) {
 179                 offset -= psize - VDEV_LABEL_END_SIZE;
 180                 offset += (VDEV_LABELS / 2) * sizeof (vdev_label_t);
 181         }
 182         l = offset / sizeof (vdev_label_t);
 183         return (l < VDEV_LABELS ? l : -1);
 184 }
 185
 186 static void
 187 vdev_label_read(zio_t *zio, vdev_t *vd, int l, void *buf, uint64_t offset,
 188         uint64_t size, zio_done_func_t *done, void *private, int flags)
 189 {
 190         ASSERT(spa_config_held(zio->io_spa, SCL_STATE_ALL, RW_WRITER) ==
 191             SCL_STATE_ALL);
 192         ASSERT(flags & ZIO_FLAG_CONFIG_WRITER);
 193
 194         zio_nowait(zio_read_phys(zio, vd,
 195             vdev_label_offset(vd->vdev_psize, l, offset),
 196             size, buf, ZIO_CHECKSUM_LABEL, done, private,
 197             ZIO_PRIORITY_SYNC_READ, flags, B_TRUE));
 198 }
 199
 200 static void
 201 vdev_label_write(zio_t *zio, vdev_t *vd, int l, void *buf, uint64_t offset,
 202         uint64_t size, zio_done_func_t *done, void *private, int flags)
 203 {
 204         ASSERT(spa_config_held(zio->io_spa, SCL_ALL, RW_WRITER) == SCL_ALL ||
 205             (spa_config_held(zio->io_spa, SCL_CONFIG | SCL_STATE, RW_READER) ==
 206             (SCL_CONFIG | SCL_STATE) &&
 207             dsl_pool_sync_context(spa_get_dsl(zio->io_spa))));
 208         ASSERT(flags & ZIO_FLAG_CONFIG_WRITER);
 209
 210         zio_nowait(zio_write_phys(zio, vd,
 211             vdev_label_offset(vd->vdev_psize, l, offset),
 212             size, buf, ZIO_CHECKSUM_LABEL, done, private,
 213             ZIO_PRIORITY_SYNC_WRITE, flags, B_TRUE));
 214 }
 215
 216 /*
 217  * Generate the nvlist representing this vdev's config.
 218  */
 219 nvlist_t *
 220 vdev_config_generate(spa_t *spa, vdev_t *vd, boolean_t getstats,
 221     vdev_config_flag_t flags)
 222 {
 223         nvlist_t *nv = NULL;
 224
 225         nv = fnvlist_alloc();
 226
 227         fnvlist_add_string(nv, ZPOOL_CONFIG_TYPE, vd->vdev_ops->vdev_op_type);
 228         if (!(flags & (VDEV_CONFIG_SPARE | VDEV_CONFIG_L2CACHE)))
 229                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_ID, vd->vdev_id);
 230         fnvlist_add_uint64(nv, ZPOOL_CONFIG_GUID, vd->vdev_guid);
 231
 232         if (vd->vdev_path != NULL)
 233                 fnvlist_add_string(nv, ZPOOL_CONFIG_PATH, vd->vdev_path);
 234
 235         if (vd->vdev_devid != NULL)
 236                 fnvlist_add_string(nv, ZPOOL_CONFIG_DEVID, vd->vdev_devid);
 237
 238         if (vd->vdev_physpath != NULL)
 239                 fnvlist_add_string(nv, ZPOOL_CONFIG_PHYS_PATH,
 240                     vd->vdev_physpath);
 241
 242         if (vd->vdev_fru != NULL)
 243                 fnvlist_add_string(nv, ZPOOL_CONFIG_FRU, vd->vdev_fru);
 244
 245         if (vd->vdev_nparity != 0) {
 246                 ASSERT(strcmp(vd->vdev_ops->vdev_op_type,
 247                     VDEV_TYPE_RAIDZ) == 0);
 248
 249                 /*
 250                  * Make sure someone hasn't managed to sneak a fancy new vdev
 251                  * into a crufty old storage pool.
 252                  */
 253                 ASSERT(vd->vdev_nparity == 1 ||
 254                     (vd->vdev_nparity <= 2 &&
 255                     spa_version(spa) >= SPA_VERSION_RAIDZ2) ||
 256                     (vd->vdev_nparity <= 3 &&
 257                     spa_version(spa) >= SPA_VERSION_RAIDZ3));
 258
 259                 /*
 260                  * Note that we'll add the nparity tag even on storage pools
 261                  * that only support a single parity device -- older software
 262                  * will just ignore it.
 263                  */
 264                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_NPARITY, vd->vdev_nparity);
 265         }
 266
 267         if (vd->vdev_wholedisk != -1ULL)
 268                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
 269                     vd->vdev_wholedisk);
 270
 271         if (vd->vdev_not_present)
 272                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 1);
 273
 274         if (vd->vdev_isspare)
 275                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_SPARE, 1);
 276
 277         if (!(flags & (VDEV_CONFIG_SPARE | VDEV_CONFIG_L2CACHE)) &&
 278             vd == vd->vdev_top) {
 279                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_METASLAB_ARRAY,
 280                     vd->vdev_ms_array);
 281                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_METASLAB_SHIFT,
 282                     vd->vdev_ms_shift);
 283                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_ASHIFT, vd->vdev_ashift);
 284                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_ASIZE,
 285                     vd->vdev_asize);
 286                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_LOG, vd->vdev_islog);
 287                 if (vd->vdev_removing)
 288                         fnvlist_add_uint64(nv, ZPOOL_CONFIG_REMOVING,
 289                             vd->vdev_removing);
 290         }
 291
 292         if (vd->vdev_dtl_sm != NULL) {
 293                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_DTL,
 294                     space_map_object(vd->vdev_dtl_sm));
 295         }
 296
 297         if (vd->vdev_crtxg)
 298                 fnvlist_add_uint64(nv, ZPOOL_CONFIG_CREATE_TXG, vd->vdev_crtxg);
 299
 300         if (getstats) {
 301                 vdev_stat_t vs;
 302                 pool_scan_stat_t ps;
 303
 304                 vdev_get_stats(vd, &vs);
 305                 fnvlist_add_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
 306                     (uint64_t *)&vs, sizeof (vs) / sizeof (uint64_t));
 307
 308                 /* provide either current or previous scan information */
 309                 if (spa_scan_get_stats(spa, &ps) == 0) {
 310                         fnvlist_add_uint64_array(nv,
 311                             ZPOOL_CONFIG_SCAN_STATS, (uint64_t *)&ps,
 312                             sizeof (pool_scan_stat_t) / sizeof (uint64_t));
 313                 }
 314         }
 315
 316         if (!vd->vdev_ops->vdev_op_leaf) {
 317                 nvlist_t **child;
 318                 int c, idx;
 319
 320                 ASSERT(!vd->vdev_ishole);
 321
 322                 child = kmem_alloc(vd->vdev_children * sizeof (nvlist_t *),
 323                     KM_SLEEP);
 324
 325                 for (c = 0, idx = 0; c < vd->vdev_children; c++) {
 326                         vdev_t *cvd = vd->vdev_child[c];
 327
 328                         /*
 329                          * If we're generating an nvlist of removing
 330                          * vdevs then skip over any device which is
 331                          * not being removed.
 332                          */
 333                         if ((flags & VDEV_CONFIG_REMOVING) &&
 334                             !cvd->vdev_removing)
 335                                 continue;
 336
 337                         child[idx++] = vdev_config_generate(spa, cvd,
 338                             getstats, flags);
 339                 }
 340
 341                 if (idx) {
 342                         fnvlist_add_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
 343                             child, idx);
 344                 }
 345
 346                 for (c = 0; c < idx; c++)
 347                         nvlist_free(child[c]);
 348
 349                 kmem_free(child, vd->vdev_children * sizeof (nvlist_t *));
 350
 351         } else {
 352                 const char *aux = NULL;
 353
 354                 if (vd->vdev_offline && !vd->vdev_tmpoffline)
 355                         fnvlist_add_uint64(nv, ZPOOL_CONFIG_OFFLINE, B_TRUE);
 356                 if (vd->vdev_resilver_txg != 0)
 357                         fnvlist_add_uint64(nv, ZPOOL_CONFIG_RESILVER_TXG,
 358                             vd->vdev_resilver_txg);
 359                 if (vd->vdev_faulted)
 360                         fnvlist_add_uint64(nv, ZPOOL_CONFIG_FAULTED, B_TRUE);
 361                 if (vd->vdev_degraded)
 362                         fnvlist_add_uint64(nv, ZPOOL_CONFIG_DEGRADED, B_TRUE);
 363                 if (vd->vdev_removed)
 364                         fnvlist_add_uint64(nv, ZPOOL_CONFIG_REMOVED, B_TRUE);
 365                 if (vd->vdev_unspare)
 366                         fnvlist_add_uint64(nv, ZPOOL_CONFIG_UNSPARE, B_TRUE);
 367                 if (vd->vdev_ishole)
 368                         fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_HOLE, B_TRUE);
 369
 370                 switch (vd->vdev_stat.vs_aux) {
 371                 case VDEV_AUX_ERR_EXCEEDED:
 372                         aux = "err_exceeded";
 373                         break;
 374
 375                 case VDEV_AUX_EXTERNAL:
 376                         aux = "external";
 377                         break;
 378                 }
 379
 380                 if (aux != NULL)
 381                         fnvlist_add_string(nv, ZPOOL_CONFIG_AUX_STATE, aux);
 382
 383                 if (vd->vdev_splitting && vd->vdev_orig_guid != 0LL) {
 384                         fnvlist_add_uint64(nv, ZPOOL_CONFIG_ORIG_GUID,
 385                             vd->vdev_orig_guid);
 386                 }
 387         }
 388
 389         return (nv);
 390 }
 391
 392 /*
 393  * Generate a view of the top-level vdevs.  If we currently have holes
 394  * in the namespace, then generate an array which contains a list of holey
 395  * vdevs.  Additionally, add the number of top-level children that currently
 396  * exist.
 397  */
 398 void
 399 vdev_top_config_generate(spa_t *spa, nvlist_t *config)
 400 {
 401         vdev_t *rvd = spa->spa_root_vdev;
 402         uint64_t *array;
 403         uint_t c, idx;
 404
 405         array = kmem_alloc(rvd->vdev_children * sizeof (uint64_t), KM_SLEEP);
 406
 407         for (c = 0, idx = 0; c < rvd->vdev_children; c++) {
 408                 vdev_t *tvd = rvd->vdev_child[c];
 409
 410                 if (tvd->vdev_ishole)
 411                         array[idx++] = c;
 412         }
 413
 414         if (idx) {
 415                 VERIFY(nvlist_add_uint64_array(config, ZPOOL_CONFIG_HOLE_ARRAY,
 416                     array, idx) == 0);
 417         }
 418
 419         VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VDEV_CHILDREN,
 420             rvd->vdev_children) == 0);
 421
 422         kmem_free(array, rvd->vdev_children * sizeof (uint64_t));
 423 }
 424
 425 /*
 426  * Returns the configuration from the label of the given vdev. For vdevs
 427  * which don't have a txg value stored on their label (i.e. spares/cache)
 428  * or have not been completely initialized (txg = 0) just return
 429  * the configuration from the first valid label we find. Otherwise,
 430  * find the most up-to-date label that does not exceed the specified
 431  * 'txg' value.
 432  */
 433 nvlist_t *
 434 vdev_label_read_config(vdev_t *vd, uint64_t txg)
 435 {
 436         spa_t *spa = vd->vdev_spa;
 437         nvlist_t *config = NULL;
 438         vdev_phys_t *vp;
 439         zio_t *zio;
 440         uint64_t best_txg = 0;
 441         int error = 0;
 442         int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL |
 443             ZIO_FLAG_SPECULATIVE;
 444
 445         ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);
 446
 447         if (!vdev_readable(vd))
 448                 return (NULL);
 449
 450         vp = zio_buf_alloc(sizeof (vdev_phys_t));
 451
 452 retry:
 453         for (int l = 0; l < VDEV_LABELS; l++) {
 454                 nvlist_t *label = NULL;
 455
 456                 zio = zio_root(spa, NULL, NULL, flags);
 457
 458                 vdev_label_read(zio, vd, l, vp,
 459                     offsetof(vdev_label_t, vl_vdev_phys),
 460                     sizeof (vdev_phys_t), NULL, NULL, flags);
 461
 462                 if (zio_wait(zio) == 0 &&
 463                     nvlist_unpack(vp->vp_nvlist, sizeof (vp->vp_nvlist),
 464                     &label, 0) == 0) {
 465                         uint64_t label_txg = 0;
 466
 467                         /*
 468                          * Auxiliary vdevs won't have txg values in their
 469                          * labels and newly added vdevs may not have been
 470                          * completely initialized so just return the
 471                          * configuration from the first valid label we
 472                          * encounter.
 473                          */
 474                         error = nvlist_lookup_uint64(label,
 475                             ZPOOL_CONFIG_POOL_TXG, &label_txg);
 476                         if ((error || label_txg == 0) && !config) {
 477                                 config = label;
 478                                 break;
 479                         } else if (label_txg <= txg && label_txg > best_txg) {
 480                                 best_txg = label_txg;
 481                                 nvlist_free(config);
 482                                 config = fnvlist_dup(label);
 483                         }
 484                 }
 485
 486                 if (label != NULL) {
 487                         nvlist_free(label);
 488                         label = NULL;
 489                 }
 490         }
 491
 492         if (config == NULL && !(flags & ZIO_FLAG_TRYHARD)) {
 493                 flags |= ZIO_FLAG_TRYHARD;
 494                 goto retry;
 495         }
 496
 497         zio_buf_free(vp, sizeof (vdev_phys_t));
 498
 499         return (config);
 500 }
 501
 502 /*
 503  * Determine if a device is in use.  The 'spare_guid' parameter will be filled
 504  * in with the device guid if this spare is active elsewhere on the system.
 505  */
 506 static boolean_t
 507 vdev_inuse(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason,
 508     uint64_t *spare_guid, uint64_t *l2cache_guid)
 509 {
 510         spa_t *spa = vd->vdev_spa;
 511         uint64_t state, pool_guid, device_guid, txg, spare_pool;
 512         uint64_t vdtxg = 0;
 513         nvlist_t *label;
 514
 515         if (spare_guid)
 516                 *spare_guid = 0ULL;
 517         if (l2cache_guid)
 518                 *l2cache_guid = 0ULL;
 519
 520         /*
 521          * Read the label, if any, and perform some basic sanity checks.
 522          */
 523         if ((label = vdev_label_read_config(vd, -1ULL)) == NULL)
 524                 return (B_FALSE);
 525
 526         (void) nvlist_lookup_uint64(label, ZPOOL_CONFIG_CREATE_TXG,
 527             &vdtxg);
 528
 529         if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_STATE,
 530             &state) != 0 ||
 531             nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID,
 532             &device_guid) != 0) {
 533                 nvlist_free(label);
 534                 return (B_FALSE);
 535         }
 536
 537         if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
 538             (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_GUID,
 539             &pool_guid) != 0 ||
 540             nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_TXG,
 541             &txg) != 0)) {
 542                 nvlist_free(label);
 543                 return (B_FALSE);
 544         }
 545
 546         nvlist_free(label);
 547
 548         /*
 549          * Check to see if this device indeed belongs to the pool it claims to
 550          * be a part of.  The only way this is allowed is if the device is a hot
 551          * spare (which we check for later on).
 552          */
 553         if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
 554             !spa_guid_exists(pool_guid, device_guid) &&
 555             !spa_spare_exists(device_guid, NULL, NULL) &&
 556             !spa_l2cache_exists(device_guid, NULL))
 557                 return (B_FALSE);
 558
 559         /*
 560          * If the transaction group is zero, then this an initialized (but
 561          * unused) label.  This is only an error if the create transaction
 562          * on-disk is the same as the one we're using now, in which case the
 563          * user has attempted to add the same vdev multiple times in the same
 564          * transaction.
 565          */
 566         if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
 567             txg == 0 && vdtxg == crtxg)
 568                 return (B_TRUE);
 569
 570         /*
 571          * Check to see if this is a spare device.  We do an explicit check for
 572          * spa_has_spare() here because it may be on our pending list of spares
 573          * to add.  We also check if it is an l2cache device.
 574          */
 575         if (spa_spare_exists(device_guid, &spare_pool, NULL) ||
 576             spa_has_spare(spa, device_guid)) {
 577                 if (spare_guid)
 578                         *spare_guid = device_guid;
 579
 580                 switch (reason) {
 581                 case VDEV_LABEL_CREATE:
 582                 case VDEV_LABEL_L2CACHE:
 583                         return (B_TRUE);
 584
 585                 case VDEV_LABEL_REPLACE:
 586                         return (!spa_has_spare(spa, device_guid) ||
 587                             spare_pool != 0ULL);
 588
 589                 case VDEV_LABEL_SPARE:
 590                         return (spa_has_spare(spa, device_guid));
 591                 }
 592         }
 593
 594         /*
 595          * Check to see if this is an l2cache device.
 596          */
 597         if (spa_l2cache_exists(device_guid, NULL))
 598                 return (B_TRUE);
 599
 600         /*
 601          * We can't rely on a pool's state if it's been imported
 602          * read-only.  Instead we look to see if the pools is marked
 603          * read-only in the namespace and set the state to active.
 604          */
 605         if ((spa = spa_by_guid(pool_guid, device_guid)) != NULL &&
 606             spa_mode(spa) == FREAD)
 607                 state = POOL_STATE_ACTIVE;
 608
 609         /*
 610          * If the device is marked ACTIVE, then this device is in use by another
 611          * pool on the system.
 612          */
 613         return (state == POOL_STATE_ACTIVE);
 614 }
 615
 616 /*
 617  * Initialize a vdev label.  We check to make sure each leaf device is not in
 618  * use, and writable.  We put down an initial label which we will later
 619  * overwrite with a complete label.  Note that it's important to do this
 620  * sequentially, not in parallel, so that we catch cases of multiple use of the
 621  * same leaf vdev in the vdev we're creating -- e.g. mirroring a disk with
 622  * itself.
 623  */
 624 int
 625 vdev_label_init(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason)
 626 {
 627         spa_t *spa = vd->vdev_spa;
 628         nvlist_t *label;
 629         vdev_phys_t *vp;
 630         char *pad2;
 631         uberblock_t *ub;
 632         zio_t *zio;
 633         char *buf;
 634         size_t buflen;
 635         int error;
 636         uint64_t spare_guid, l2cache_guid;
 637         int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL;
 638
 639         ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
 640
 641         for (int c = 0; c < vd->vdev_children; c++)
 642                 if ((error = vdev_label_init(vd->vdev_child[c],
 643                     crtxg, reason)) != 0)
 644                         return (error);
 645
 646         /* Track the creation time for this vdev */
 647         vd->vdev_crtxg = crtxg;
 648
 649         if (!vd->vdev_ops->vdev_op_leaf || !spa_writeable(spa))
 650                 return (0);
 651
 652         /*
 653          * Dead vdevs cannot be initialized.
 654          */
 655         if (vdev_is_dead(vd))
 656                 return (SET_ERROR(EIO));
 657
 658         /*
 659          * Determine if the vdev is in use.
 660          */
 661         if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_SPLIT &&
 662             vdev_inuse(vd, crtxg, reason, &spare_guid, &l2cache_guid))
 663                 return (SET_ERROR(EBUSY));
 664
 665         /*
 666          * If this is a request to add or replace a spare or l2cache device
 667          * that is in use elsewhere on the system, then we must update the
 668          * guid (which was initialized to a random value) to reflect the
 669          * actual GUID (which is shared between multiple pools).
 670          */
 671         if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_L2CACHE &&
 672             spare_guid != 0ULL) {
 673                 uint64_t guid_delta = spare_guid - vd->vdev_guid;
 674
 675                 vd->vdev_guid += guid_delta;
 676
 677                 for (vdev_t *pvd = vd; pvd != NULL; pvd = pvd->vdev_parent)
 678                         pvd->vdev_guid_sum += guid_delta;
 679
 680                 /*
 681                  * If this is a replacement, then we want to fallthrough to the
 682                  * rest of the code.  If we're adding a spare, then it's already
 683                  * labeled appropriately and we can just return.
 684                  */
 685                 if (reason == VDEV_LABEL_SPARE)
 686                         return (0);
 687                 ASSERT(reason == VDEV_LABEL_REPLACE ||
 688                     reason == VDEV_LABEL_SPLIT);
 689         }
 690
 691         if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_SPARE &&
 692             l2cache_guid != 0ULL) {
 693                 uint64_t guid_delta = l2cache_guid - vd->vdev_guid;
 694
 695                 vd->vdev_guid += guid_delta;
 696
 697                 for (vdev_t *pvd = vd; pvd != NULL; pvd = pvd->vdev_parent)
 698                         pvd->vdev_guid_sum += guid_delta;
 699
 700                 /*
 701                  * If this is a replacement, then we want to fallthrough to the
 702                  * rest of the code.  If we're adding an l2cache, then it's
 703                  * already labeled appropriately and we can just return.
 704                  */
 705                 if (reason == VDEV_LABEL_L2CACHE)
 706                         return (0);
 707                 ASSERT(reason == VDEV_LABEL_REPLACE);
 708         }
 709
 710         /*
 711          * TRIM the whole thing so that we start with a clean slate.
 712          * It's just an optimization, so we don't care if it fails.
 713          * Don't TRIM if removing so that we don't interfere with zpool
 714          * disaster recovery.
 715          */
 716         if (zfs_trim_enabled && vdev_trim_on_init && !vd->vdev_notrim &&
 717             (reason == VDEV_LABEL_CREATE || reason == VDEV_LABEL_SPARE ||
 718             reason == VDEV_LABEL_L2CACHE))
 719                 zio_wait(zio_trim(NULL, spa, vd, 0, vd->vdev_psize));
 720
 721         /*
 722          * Initialize its label.
 723          */
 724         vp = zio_buf_alloc(sizeof (vdev_phys_t));
 725         bzero(vp, sizeof (vdev_phys_t));
 726
 727         /*
 728          * Generate a label describing the pool and our top-level vdev.
 729          * We mark it as being from txg 0 to indicate that it's not
 730          * really part of an active pool just yet.  The labels will
 731          * be written again with a meaningful txg by spa_sync().
 732          */
 733         if (reason == VDEV_LABEL_SPARE ||
 734             (reason == VDEV_LABEL_REMOVE && vd->vdev_isspare)) {
 735                 /*
 736                  * For inactive hot spares, we generate a special label that
 737                  * identifies as a mutually shared hot spare.  We write the
 738                  * label if we are adding a hot spare, or if we are removing an
 739                  * active hot spare (in which case we want to revert the
 740                  * labels).
 741                  */
 742                 VERIFY(nvlist_alloc(&label, NV_UNIQUE_NAME, KM_SLEEP) == 0);
 743
 744                 VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_VERSION,
 745                     spa_version(spa)) == 0);
 746                 VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_POOL_STATE,
 747                     POOL_STATE_SPARE) == 0);
 748                 VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_GUID,
 749                     vd->vdev_guid) == 0);
 750         } else if (reason == VDEV_LABEL_L2CACHE ||
 751             (reason == VDEV_LABEL_REMOVE && vd->vdev_isl2cache)) {
 752                 /*
 753                  * For level 2 ARC devices, add a special label.
 754                  */
 755                 VERIFY(nvlist_alloc(&label, NV_UNIQUE_NAME, KM_SLEEP) == 0);
 756
 757                 VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_VERSION,
 758                     spa_version(spa)) == 0);
 759                 VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_POOL_STATE,
 760                     POOL_STATE_L2CACHE) == 0);
 761                 VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_GUID,
 762                     vd->vdev_guid) == 0);
 763         } else {
 764                 uint64_t txg = 0ULL;
 765
 766                 if (reason == VDEV_LABEL_SPLIT)
 767                         txg = spa->spa_uberblock.ub_txg;
 768                 label = spa_config_generate(spa, vd, txg, B_FALSE);
 769
 770                 /*
 771                  * Add our creation time.  This allows us to detect multiple
 772                  * vdev uses as described above, and automatically expires if we
 773                  * fail.
 774                  */
 775                 VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_CREATE_TXG,
 776                     crtxg) == 0);
 777         }
 778
 779         buf = vp->vp_nvlist;
 780         buflen = sizeof (vp->vp_nvlist);
 781
 782         error = nvlist_pack(label, &buf, &buflen, NV_ENCODE_XDR, KM_SLEEP);
 783         if (error != 0) {
 784                 nvlist_free(label);
 785                 zio_buf_free(vp, sizeof (vdev_phys_t));
 786                 /* EFAULT means nvlist_pack ran out of room */
 787                 return (error == EFAULT ? ENAMETOOLONG : EINVAL);
 788         }
 789
 790         /*
 791          * Initialize uberblock template.
 792          */
 793         ub = zio_buf_alloc(VDEV_UBERBLOCK_RING);
 794         bzero(ub, VDEV_UBERBLOCK_RING);
 795         *ub = spa->spa_uberblock;
 796         ub->ub_txg = 0;
 797
 798         /* Initialize the 2nd padding area. */
 799         pad2 = zio_buf_alloc(VDEV_PAD_SIZE);
 800         bzero(pad2, VDEV_PAD_SIZE);
 801
 802         /*
 803          * Write everything in parallel.
 804          */
 805 retry:
 806         zio = zio_root(spa, NULL, NULL, flags);
 807
 808         for (int l = 0; l < VDEV_LABELS; l++) {
 809
 810                 vdev_label_write(zio, vd, l, vp,
 811                     offsetof(vdev_label_t, vl_vdev_phys),
 812                     sizeof (vdev_phys_t), NULL, NULL, flags);
 813
 814                 /*
 815                  * Skip the 1st padding area.
 816                  * Zero out the 2nd padding area where it might have
 817                  * left over data from previous filesystem format.
 818                  */
 819                 vdev_label_write(zio, vd, l, pad2,
 820                     offsetof(vdev_label_t, vl_pad2),
 821                     VDEV_PAD_SIZE, NULL, NULL, flags);
 822
 823                 vdev_label_write(zio, vd, l, ub,
 824                     offsetof(vdev_label_t, vl_uberblock),
 825                     VDEV_UBERBLOCK_RING, NULL, NULL, flags);
 826         }
 827
 828         error = zio_wait(zio);
 829
 830         if (error != 0 && !(flags & ZIO_FLAG_TRYHARD)) {
 831                 flags |= ZIO_FLAG_TRYHARD;
 832                 goto retry;
 833         }
 834
 835         nvlist_free(label);
 836         zio_buf_free(pad2, VDEV_PAD_SIZE);
 837         zio_buf_free(ub, VDEV_UBERBLOCK_RING);
 838         zio_buf_free(vp, sizeof (vdev_phys_t));
 839
 840         /*
 841          * If this vdev hasn't been previously identified as a spare, then we
 842          * mark it as such only if a) we are labeling it as a spare, or b) it
 843          * exists as a spare elsewhere in the system.  Do the same for
 844          * level 2 ARC devices.
 845          */
 846         if (error == 0 && !vd->vdev_isspare &&
 847             (reason == VDEV_LABEL_SPARE ||
 848             spa_spare_exists(vd->vdev_guid, NULL, NULL)))
 849                 spa_spare_add(vd);
 850
 851         if (error == 0 && !vd->vdev_isl2cache &&
 852             (reason == VDEV_LABEL_L2CACHE ||
 853             spa_l2cache_exists(vd->vdev_guid, NULL)))
 854                 spa_l2cache_add(vd);
 855
 856         return (error);
 857 }
 858
 859 /*
 860  * ==========================================================================
 861  * uberblock load/sync
 862  * ==========================================================================
 863  */
 864
 865 /*
 866  * Consider the following situation: txg is safely synced to disk.  We've
 867  * written the first uberblock for txg + 1, and then we lose power.  When we
 868  * come back up, we fail to see the uberblock for txg + 1 because, say,
 869  * it was on a mirrored device and the replica to which we wrote txg + 1
 870  * is now offline.  If we then make some changes and sync txg + 1, and then
 871  * the missing replica comes back, then for a few seconds we'll have two
 872  * conflicting uberblocks on disk with the same txg.  The solution is simple:
 873  * among uberblocks with equal txg, choose the one with the latest timestamp.
 874  */
 875 static int
 876 vdev_uberblock_compare(uberblock_t *ub1, uberblock_t *ub2)
 877 {
 878         if (ub1->ub_txg < ub2->ub_txg)
 879                 return (-1);
 880         if (ub1->ub_txg > ub2->ub_txg)
 881                 return (1);
 882
 883         if (ub1->ub_timestamp < ub2->ub_timestamp)
 884                 return (-1);
 885         if (ub1->ub_timestamp > ub2->ub_timestamp)
 886                 return (1);
 887
 888         return (0);
 889 }
 890
 891 struct ubl_cbdata {
 892         uberblock_t     *ubl_ubbest;    /* Best uberblock */
 893         vdev_t          *ubl_vd;        /* vdev associated with the above */
 894 };
 895
 896 static void
 897 vdev_uberblock_load_done(zio_t *zio)
 898 {
 899         vdev_t *vd = zio->io_vd;
 900         spa_t *spa = zio->io_spa;
 901         zio_t *rio = zio->io_private;
 902         uberblock_t *ub = zio->io_data;
 903         struct ubl_cbdata *cbp = rio->io_private;
 904
 905         ASSERT3U(zio->io_size, ==, VDEV_UBERBLOCK_SIZE(vd));
 906
 907         if (zio->io_error == 0 && uberblock_verify(ub) == 0) {
 908                 mutex_enter(&rio->io_lock);
 909                 if (ub->ub_txg <= spa->spa_load_max_txg &&
 910                     vdev_uberblock_compare(ub, cbp->ubl_ubbest) > 0) {
 911                         /*
 912                          * Keep track of the vdev in which this uberblock
 913                          * was found. We will use this information later
 914                          * to obtain the config nvlist associated with
 915                          * this uberblock.
 916                          */
 917                         *cbp->ubl_ubbest = *ub;
 918                         cbp->ubl_vd = vd;
 919                 }
 920                 mutex_exit(&rio->io_lock);
 921         }
 922
 923         zio_buf_free(zio->io_data, zio->io_size);
 924 }
 925
 926 static void
 927 vdev_uberblock_load_impl(zio_t *zio, vdev_t *vd, int flags,
 928     struct ubl_cbdata *cbp)
 929 {
 930         for (int c = 0; c < vd->vdev_children; c++)
 931                 vdev_uberblock_load_impl(zio, vd->vdev_child[c], flags, cbp);
 932
 933         if (vd->vdev_ops->vdev_op_leaf && vdev_readable(vd)) {
 934                 for (int l = 0; l < VDEV_LABELS; l++) {
 935                         for (int n = 0; n < VDEV_UBERBLOCK_COUNT(vd); n++) {
 936                                 vdev_label_read(zio, vd, l,
 937                                     zio_buf_alloc(VDEV_UBERBLOCK_SIZE(vd)),
 938                                     VDEV_UBERBLOCK_OFFSET(vd, n),
 939                                     VDEV_UBERBLOCK_SIZE(vd),
 940                                     vdev_uberblock_load_done, zio, flags);
 941                         }
 942                 }
 943         }
 944 }
 945
 946 /*
 947  * Reads the 'best' uberblock from disk along with its associated
 948  * configuration. First, we read the uberblock array of each label of each
 949  * vdev, keeping track of the uberblock with the highest txg in each array.
 950  * Then, we read the configuration from the same vdev as the best uberblock.
 951  */
 952 void
 953 vdev_uberblock_load(vdev_t *rvd, uberblock_t *ub, nvlist_t **config)
 954 {
 955         zio_t *zio;
 956         spa_t *spa = rvd->vdev_spa;
 957         struct ubl_cbdata cb;
 958         int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL |
 959             ZIO_FLAG_SPECULATIVE | ZIO_FLAG_TRYHARD;
 960
 961         ASSERT(ub);
 962         ASSERT(config);
 963
 964         bzero(ub, sizeof (uberblock_t));
 965         *config = NULL;
 966
 967         cb.ubl_ubbest = ub;
 968         cb.ubl_vd = NULL;
 969
 970         spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
 971         zio = zio_root(spa, NULL, &cb, flags);
 972         vdev_uberblock_load_impl(zio, rvd, flags, &cb);
 973         (void) zio_wait(zio);
 974
 975         /*
 976          * It's possible that the best uberblock was discovered on a label
 977          * that has a configuration which was written in a future txg.
 978          * Search all labels on this vdev to find the configuration that
 979          * matches the txg for our uberblock.
 980          */
 981         if (cb.ubl_vd != NULL)
 982                 *config = vdev_label_read_config(cb.ubl_vd, ub->ub_txg);
 983         spa_config_exit(spa, SCL_ALL, FTAG);
 984 }
 985
 986 /*
 987  * On success, increment root zio's count of good writes.
 988  * We only get credit for writes to known-visible vdevs; see spa_vdev_add().
 989  */
 990 static void
 991 vdev_uberblock_sync_done(zio_t *zio)
 992 {
 993         uint64_t *good_writes = zio->io_private;
 994
 995         if (zio->io_error == 0 && zio->io_vd->vdev_top->vdev_ms_array != 0)
 996                 atomic_inc_64(good_writes);
 997 }
 998
 999 /*
1000  * Write the uberblock to all labels of all leaves of the specified vdev.
1001  */
1002 static void
1003 vdev_uberblock_sync(zio_t *zio, uberblock_t *ub, vdev_t *vd, int flags)
1004 {
1005         uberblock_t *ubbuf;
1006         int n;
1007
1008         for (int c = 0; c < vd->vdev_children; c++)
1009                 vdev_uberblock_sync(zio, ub, vd->vdev_child[c], flags);
1010
1011         if (!vd->vdev_ops->vdev_op_leaf)
1012                 return;
1013
1014         if (!vdev_writeable(vd))
1015                 return;
1016
1017         n = ub->ub_txg & (VDEV_UBERBLOCK_COUNT(vd) - 1);
1018
1019         ubbuf = zio_buf_alloc(VDEV_UBERBLOCK_SIZE(vd));
1020         bzero(ubbuf, VDEV_UBERBLOCK_SIZE(vd));
1021         *ubbuf = *ub;
1022
1023         for (int l = 0; l < VDEV_LABELS; l++)
1024                 vdev_label_write(zio, vd, l, ubbuf,
1025                     VDEV_UBERBLOCK_OFFSET(vd, n), VDEV_UBERBLOCK_SIZE(vd),
1026                     vdev_uberblock_sync_done, zio->io_private,
1027                     flags | ZIO_FLAG_DONT_PROPAGATE);
1028
1029         zio_buf_free(ubbuf, VDEV_UBERBLOCK_SIZE(vd));
1030 }
1031
1032 /* Sync the uberblocks to all vdevs in svd[] */
1033 int
1034 vdev_uberblock_sync_list(vdev_t **svd, int svdcount, uberblock_t *ub, int flags)
1035 {
1036         spa_t *spa = svd[0]->vdev_spa;
1037         zio_t *zio;
1038         uint64_t good_writes = 0;
1039
1040         zio = zio_root(spa, NULL, &good_writes, flags);
1041
1042         for (int v = 0; v < svdcount; v++)
1043                 vdev_uberblock_sync(zio, ub, svd[v], flags);
1044
1045         (void) zio_wait(zio);
1046
1047         /*
1048          * Flush the uberblocks to disk.  This ensures that the odd labels
1049          * are no longer needed (because the new uberblocks and the even
1050          * labels are safely on disk), so it is safe to overwrite them.
1051          */
1052         zio = zio_root(spa, NULL, NULL, flags);
1053
1054         for (int v = 0; v < svdcount; v++)
1055                 zio_flush(zio, svd[v]);
1056
1057         (void) zio_wait(zio);
1058
1059         return (good_writes >= 1 ? 0 : EIO);
1060 }
1061
1062 /*
1063  * On success, increment the count of good writes for our top-level vdev.
1064  */
1065 static void
1066 vdev_label_sync_done(zio_t *zio)
1067 {
1068         uint64_t *good_writes = zio->io_private;
1069
1070         if (zio->io_error == 0)
1071                 atomic_inc_64(good_writes);
1072 }
1073
1074 /*
1075  * If there weren't enough good writes, indicate failure to the parent.
1076  */
1077 static void
1078 vdev_label_sync_top_done(zio_t *zio)
1079 {
1080         uint64_t *good_writes = zio->io_private;
1081
1082         if (*good_writes == 0)
1083                 zio->io_error = SET_ERROR(EIO);
1084
1085         kmem_free(good_writes, sizeof (uint64_t));
1086 }
1087
1088 /*
1089  * We ignore errors for log and cache devices, simply free the private data.
1090  */
1091 static void
1092 vdev_label_sync_ignore_done(zio_t *zio)
1093 {
1094         kmem_free(zio->io_private, sizeof (uint64_t));
1095 }
1096
1097 /*
1098  * Write all even or odd labels to all leaves of the specified vdev.
1099  */
1100 static void
1101 vdev_label_sync(zio_t *zio, vdev_t *vd, int l, uint64_t txg, int flags)
1102 {
1103         nvlist_t *label;
1104         vdev_phys_t *vp;
1105         char *buf;
1106         size_t buflen;
1107
1108         for (int c = 0; c < vd->vdev_children; c++)
1109                 vdev_label_sync(zio, vd->vdev_child[c], l, txg, flags);
1110
1111         if (!vd->vdev_ops->vdev_op_leaf)
1112                 return;
1113
1114         if (!vdev_writeable(vd))
1115                 return;
1116
1117         /*
1118          * Generate a label describing the top-level config to which we belong.
1119          */
1120         label = spa_config_generate(vd->vdev_spa, vd, txg, B_FALSE);
1121
1122         vp = zio_buf_alloc(sizeof (vdev_phys_t));
1123         bzero(vp, sizeof (vdev_phys_t));
1124
1125         buf = vp->vp_nvlist;
1126         buflen = sizeof (vp->vp_nvlist);
1127
1128         if (nvlist_pack(label, &buf, &buflen, NV_ENCODE_XDR, KM_SLEEP) == 0) {
1129                 for (; l < VDEV_LABELS; l += 2) {
1130                         vdev_label_write(zio, vd, l, vp,
1131                             offsetof(vdev_label_t, vl_vdev_phys),
1132                             sizeof (vdev_phys_t),
1133                             vdev_label_sync_done, zio->io_private,
1134                             flags | ZIO_FLAG_DONT_PROPAGATE);
1135                 }
1136         }
1137
1138         zio_buf_free(vp, sizeof (vdev_phys_t));
1139         nvlist_free(label);
1140 }
1141
1142 int
1143 vdev_label_sync_list(spa_t *spa, int l, uint64_t txg, int flags)
1144 {
1145         list_t *dl = &spa->spa_config_dirty_list;
1146         vdev_t *vd;
1147         zio_t *zio;
1148         int error;
1149
1150         /*
1151          * Write the new labels to disk.
1152          */
1153         zio = zio_root(spa, NULL, NULL, flags);
1154
1155         for (vd = list_head(dl); vd != NULL; vd = list_next(dl, vd)) {
1156                 uint64_t *good_writes = kmem_zalloc(sizeof (uint64_t),
1157                     KM_SLEEP);
1158
1159                 ASSERT(!vd->vdev_ishole);
1160
1161                 zio_t *vio = zio_null(zio, spa, NULL,
1162                     (vd->vdev_islog || vd->vdev_aux != NULL) ?
1163                     vdev_label_sync_ignore_done : vdev_label_sync_top_done,
1164                     good_writes, flags);
1165                 vdev_label_sync(vio, vd, l, txg, flags);
1166                 zio_nowait(vio);
1167         }
1168
1169         error = zio_wait(zio);
1170
1171         /*
1172          * Flush the new labels to disk.
1173          */
1174         zio = zio_root(spa, NULL, NULL, flags);
1175
1176         for (vd = list_head(dl); vd != NULL; vd = list_next(dl, vd))
1177                 zio_flush(zio, vd);
1178
1179         (void) zio_wait(zio);
1180
1181         return (error);
1182 }
1183
1184 /*
1185  * Sync the uberblock and any changes to the vdev configuration.
1186  *
1187  * The order of operations is carefully crafted to ensure that
1188  * if the system panics or loses power at any time, the state on disk
1189  * is still transactionally consistent.  The in-line comments below
1190  * describe the failure semantics at each stage.
1191  *
1192  * Moreover, vdev_config_sync() is designed to be idempotent: if it fails
1193  * at any time, you can just call it again, and it will resume its work.
1194  */
1195 int
1196 vdev_config_sync(vdev_t **svd, int svdcount, uint64_t txg, boolean_t tryhard)
1197 {
1198         spa_t *spa = svd[0]->vdev_spa;
1199         uberblock_t *ub = &spa->spa_uberblock;
1200         vdev_t *vd;
1201         zio_t *zio;
1202         int error;
1203         int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL;
1204
1205         /*
1206          * Normally, we don't want to try too hard to write every label and
1207          * uberblock.  If there is a flaky disk, we don't want the rest of the
1208          * sync process to block while we retry.  But if we can't write a
1209          * single label out, we should retry with ZIO_FLAG_TRYHARD before
1210          * bailing out and declaring the pool faulted.
1211          */
1212         if (tryhard)
1213                 flags |= ZIO_FLAG_TRYHARD;
1214
1215         ASSERT(ub->ub_txg <= txg);
1216
1217         /*
1218          * If this isn't a resync due to I/O errors,
1219          * and nothing changed in this transaction group,
1220          * and the vdev configuration hasn't changed,
1221          * then there's nothing to do.
1222          */
1223         if (ub->ub_txg < txg &&
1224             uberblock_update(ub, spa->spa_root_vdev, txg) == B_FALSE &&
1225             list_is_empty(&spa->spa_config_dirty_list))
1226                 return (0);
1227
1228         if (txg > spa_freeze_txg(spa))
1229                 return (0);
1230
1231         ASSERT(txg <= spa->spa_final_txg);
1232
1233         /*
1234          * Flush the write cache of every disk that's been written to
1235          * in this transaction group.  This ensures that all blocks
1236          * written in this txg will be committed to stable storage
1237          * before any uberblock that references them.
1238          */
1239         zio = zio_root(spa, NULL, NULL, flags);
1240
1241         for (vd = txg_list_head(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)); vd;
1242             vd = txg_list_next(&spa->spa_vdev_txg_list, vd, TXG_CLEAN(txg)))
1243                 zio_flush(zio, vd);
1244
1245         (void) zio_wait(zio);
1246
1247         /*
1248          * Sync out the even labels (L0, L2) for every dirty vdev.  If the
1249          * system dies in the middle of this process, that's OK: all of the
1250          * even labels that made it to disk will be newer than any uberblock,
1251          * and will therefore be considered invalid.  The odd labels (L1, L3),
1252          * which have not yet been touched, will still be valid.  We flush
1253          * the new labels to disk to ensure that all even-label updates
1254          * are committed to stable storage before the uberblock update.
1255          */
1256         if ((error = vdev_label_sync_list(spa, 0, txg, flags)) != 0)
1257                 return (error);
1258
1259         /*
1260          * Sync the uberblocks to all vdevs in svd[].
1261          * If the system dies in the middle of this step, there are two cases
1262          * to consider, and the on-disk state is consistent either way:
1263          *
1264          * (1)  If none of the new uberblocks made it to disk, then the
1265          *      previous uberblock will be the newest, and the odd labels
1266          *      (which had not yet been touched) will be valid with respect
1267          *      to that uberblock.
1268          *
1269          * (2)  If one or more new uberblocks made it to disk, then they
1270          *      will be the newest, and the even labels (which had all
1271          *      been successfully committed) will be valid with respect
1272          *      to the new uberblocks.
1273          */
1274         if ((error = vdev_uberblock_sync_list(svd, svdcount, ub, flags)) != 0)
1275                 return (error);
1276
1277         /*
1278          * Sync out odd labels for every dirty vdev.  If the system dies
1279          * in the middle of this process, the even labels and the new
1280          * uberblocks will suffice to open the pool.  The next time
1281          * the pool is opened, the first thing we'll do -- before any
1282          * user data is modified -- is mark every vdev dirty so that
1283          * all labels will be brought up to date.  We flush the new labels
1284          * to disk to ensure that all odd-label updates are committed to
1285          * stable storage before the next transaction group begins.
1286          */
1287         if ((error = vdev_label_sync_list(spa, 1, txg, flags)) != 0)
1288                 return (error);
1289
1290         trim_thread_wakeup(spa);
1291
1292         return (0);
1293 }