sys/cddl/contrib/opensolaris/uts/common/fs/zfs/spa.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 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  * This file contains all the routines used when modifying on-disk SPA state.
  29  * This includes opening, importing, destroying, exporting a pool, and syncing a
  30  * pool.
  31  */
  32
  33 #include <sys/zfs_context.h>
  34 #include <sys/fm/fs/zfs.h>
  35 #include <sys/spa_impl.h>
  36 #include <sys/zio.h>
  37 #include <sys/zio_checksum.h>
  38 #include <sys/zio_compress.h>
  39 #include <sys/dmu.h>
  40 #include <sys/dmu_tx.h>
  41 #include <sys/zap.h>
  42 #include <sys/zil.h>
  43 #include <sys/vdev_impl.h>
  44 #include <sys/metaslab.h>
  45 #include <sys/uberblock_impl.h>
  46 #include <sys/txg.h>
  47 #include <sys/avl.h>
  48 #include <sys/dmu_traverse.h>
  49 #include <sys/dmu_objset.h>
  50 #include <sys/unique.h>
  51 #include <sys/dsl_pool.h>
  52 #include <sys/dsl_dataset.h>
  53 #include <sys/dsl_dir.h>
  54 #include <sys/dsl_prop.h>
  55 #include <sys/dsl_synctask.h>
  56 #include <sys/fs/zfs.h>
  57 #include <sys/arc.h>
  58 #include <sys/callb.h>
  59 #include <sys/sunddi.h>
  60 #include <sys/spa_boot.h>
  61
  62 #include "zfs_prop.h"
  63 #include "zfs_comutil.h"
  64
  65 int zio_taskq_threads[ZIO_TYPES][ZIO_TASKQ_TYPES] = {
  66         /*      ISSUE   INTR                                    */
  67         {       1,      1       },      /* ZIO_TYPE_NULL        */
  68         {       1,      8       },      /* ZIO_TYPE_READ        */
  69         {       8,      1       },      /* ZIO_TYPE_WRITE       */
  70         {       1,      1       },      /* ZIO_TYPE_FREE        */
  71         {       1,      1       },      /* ZIO_TYPE_CLAIM       */
  72         {       1,      1       },      /* ZIO_TYPE_IOCTL       */
  73 };
  74
  75 static void spa_sync_props(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx);
  76 static boolean_t spa_has_active_shared_spare(spa_t *spa);
  77
  78 /*
  79  * ==========================================================================
  80  * SPA properties routines
  81  * ==========================================================================
  82  */
  83
  84 /*
  85  * Add a (source=src, propname=propval) list to an nvlist.
  86  */
  87 static void
  88 spa_prop_add_list(nvlist_t *nvl, zpool_prop_t prop, char *strval,
  89     uint64_t intval, zprop_source_t src)
  90 {
  91         const char *propname = zpool_prop_to_name(prop);
  92         nvlist_t *propval;
  93
  94         VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0);
  95         VERIFY(nvlist_add_uint64(propval, ZPROP_SOURCE, src) == 0);
  96
  97         if (strval != NULL)
  98                 VERIFY(nvlist_add_string(propval, ZPROP_VALUE, strval) == 0);
  99         else
 100                 VERIFY(nvlist_add_uint64(propval, ZPROP_VALUE, intval) == 0);
 101
 102         VERIFY(nvlist_add_nvlist(nvl, propname, propval) == 0);
 103         nvlist_free(propval);
 104 }
 105
 106 /*
 107  * Get property values from the spa configuration.
 108  */
 109 static void
 110 spa_prop_get_config(spa_t *spa, nvlist_t **nvp)
 111 {
 112         uint64_t size = spa_get_space(spa);
 113         uint64_t used = spa_get_alloc(spa);
 114         uint64_t cap, version;
 115         zprop_source_t src = ZPROP_SRC_NONE;
 116         spa_config_dirent_t *dp;
 117
 118         ASSERT(MUTEX_HELD(&spa->spa_props_lock));
 119
 120         /*
 121          * readonly properties
 122          */
 123         spa_prop_add_list(*nvp, ZPOOL_PROP_NAME, spa_name(spa), 0, src);
 124         spa_prop_add_list(*nvp, ZPOOL_PROP_SIZE, NULL, size, src);
 125         spa_prop_add_list(*nvp, ZPOOL_PROP_USED, NULL, used, src);
 126         spa_prop_add_list(*nvp, ZPOOL_PROP_AVAILABLE, NULL, size - used, src);
 127
 128         cap = (size == 0) ? 0 : (used * 100 / size);
 129         spa_prop_add_list(*nvp, ZPOOL_PROP_CAPACITY, NULL, cap, src);
 130
 131         spa_prop_add_list(*nvp, ZPOOL_PROP_GUID, NULL, spa_guid(spa), src);
 132         spa_prop_add_list(*nvp, ZPOOL_PROP_HEALTH, NULL,
 133             spa->spa_root_vdev->vdev_state, src);
 134
 135         /*
 136          * settable properties that are not stored in the pool property object.
 137          */
 138         version = spa_version(spa);
 139         if (version == zpool_prop_default_numeric(ZPOOL_PROP_VERSION))
 140                 src = ZPROP_SRC_DEFAULT;
 141         else
 142                 src = ZPROP_SRC_LOCAL;
 143         spa_prop_add_list(*nvp, ZPOOL_PROP_VERSION, NULL, version, src);
 144
 145         if (spa->spa_root != NULL)
 146                 spa_prop_add_list(*nvp, ZPOOL_PROP_ALTROOT, spa->spa_root,
 147                     0, ZPROP_SRC_LOCAL);
 148
 149         if ((dp = list_head(&spa->spa_config_list)) != NULL) {
 150                 if (dp->scd_path == NULL) {
 151                         spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE,
 152                             "none", 0, ZPROP_SRC_LOCAL);
 153                 } else if (strcmp(dp->scd_path, spa_config_path) != 0) {
 154                         spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE,
 155                             dp->scd_path, 0, ZPROP_SRC_LOCAL);
 156                 }
 157         }
 158 }
 159
 160 /*
 161  * Get zpool property values.
 162  */
 163 int
 164 spa_prop_get(spa_t *spa, nvlist_t **nvp)
 165 {
 166         zap_cursor_t zc;
 167         zap_attribute_t za;
 168         objset_t *mos = spa->spa_meta_objset;
 169         int err;
 170
 171         VERIFY(nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0);
 172
 173         mutex_enter(&spa->spa_props_lock);
 174
 175         /*
 176          * Get properties from the spa config.
 177          */
 178         spa_prop_get_config(spa, nvp);
 179
 180         /* If no pool property object, no more prop to get. */
 181         if (spa->spa_pool_props_object == 0) {
 182                 mutex_exit(&spa->spa_props_lock);
 183                 return (0);
 184         }
 185
 186         /*
 187          * Get properties from the MOS pool property object.
 188          */
 189         for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object);
 190             (err = zap_cursor_retrieve(&zc, &za)) == 0;
 191             zap_cursor_advance(&zc)) {
 192                 uint64_t intval = 0;
 193                 char *strval = NULL;
 194                 zprop_source_t src = ZPROP_SRC_DEFAULT;
 195                 zpool_prop_t prop;
 196
 197                 if ((prop = zpool_name_to_prop(za.za_name)) == ZPROP_INVAL)
 198                         continue;
 199
 200                 switch (za.za_integer_length) {
 201                 case 8:
 202                         /* integer property */
 203                         if (za.za_first_integer !=
 204                             zpool_prop_default_numeric(prop))
 205                                 src = ZPROP_SRC_LOCAL;
 206
 207                         if (prop == ZPOOL_PROP_BOOTFS) {
 208                                 dsl_pool_t *dp;
 209                                 dsl_dataset_t *ds = NULL;
 210
 211                                 dp = spa_get_dsl(spa);
 212                                 rw_enter(&dp->dp_config_rwlock, RW_READER);
 213                                 if (err = dsl_dataset_hold_obj(dp,
 214                                     za.za_first_integer, FTAG, &ds)) {
 215                                         rw_exit(&dp->dp_config_rwlock);
 216                                         break;
 217                                 }
 218
 219                                 strval = kmem_alloc(
 220                                     MAXNAMELEN + strlen(MOS_DIR_NAME) + 1,
 221                                     KM_SLEEP);
 222                                 dsl_dataset_name(ds, strval);
 223                                 dsl_dataset_rele(ds, FTAG);
 224                                 rw_exit(&dp->dp_config_rwlock);
 225                         } else {
 226                                 strval = NULL;
 227                                 intval = za.za_first_integer;
 228                         }
 229
 230                         spa_prop_add_list(*nvp, prop, strval, intval, src);
 231
 232                         if (strval != NULL)
 233                                 kmem_free(strval,
 234                                     MAXNAMELEN + strlen(MOS_DIR_NAME) + 1);
 235
 236                         break;
 237
 238                 case 1:
 239                         /* string property */
 240                         strval = kmem_alloc(za.za_num_integers, KM_SLEEP);
 241                         err = zap_lookup(mos, spa->spa_pool_props_object,
 242                             za.za_name, 1, za.za_num_integers, strval);
 243                         if (err) {
 244                                 kmem_free(strval, za.za_num_integers);
 245                                 break;
 246                         }
 247                         spa_prop_add_list(*nvp, prop, strval, 0, src);
 248                         kmem_free(strval, za.za_num_integers);
 249                         break;
 250
 251                 default:
 252                         break;
 253                 }
 254         }
 255         zap_cursor_fini(&zc);
 256         mutex_exit(&spa->spa_props_lock);
 257 out:
 258         if (err && err != ENOENT) {
 259                 nvlist_free(*nvp);
 260                 *nvp = NULL;
 261                 return (err);
 262         }
 263
 264         return (0);
 265 }
 266
 267 /*
 268  * Validate the given pool properties nvlist and modify the list
 269  * for the property values to be set.
 270  */
 271 static int
 272 spa_prop_validate(spa_t *spa, nvlist_t *props)
 273 {
 274         nvpair_t *elem;
 275         int error = 0, reset_bootfs = 0;
 276         uint64_t objnum;
 277
 278         elem = NULL;
 279         while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
 280                 zpool_prop_t prop;
 281                 char *propname, *strval;
 282                 uint64_t intval;
 283                 objset_t *os;
 284                 char *slash;
 285
 286                 propname = nvpair_name(elem);
 287
 288                 if ((prop = zpool_name_to_prop(propname)) == ZPROP_INVAL)
 289                         return (EINVAL);
 290
 291                 switch (prop) {
 292                 case ZPOOL_PROP_VERSION:
 293                         error = nvpair_value_uint64(elem, &intval);
 294                         if (!error &&
 295                             (intval < spa_version(spa) || intval > SPA_VERSION))
 296                                 error = EINVAL;
 297                         break;
 298
 299                 case ZPOOL_PROP_DELEGATION:
 300                 case ZPOOL_PROP_AUTOREPLACE:
 301                 case ZPOOL_PROP_LISTSNAPS:
 302                         error = nvpair_value_uint64(elem, &intval);
 303                         if (!error && intval > 1)
 304                                 error = EINVAL;
 305                         break;
 306
 307                 case ZPOOL_PROP_BOOTFS:
 308                         if (spa_version(spa) < SPA_VERSION_BOOTFS) {
 309                                 error = ENOTSUP;
 310                                 break;
 311                         }
 312
 313                         /*
 314                          * Make sure the vdev config is bootable
 315                          */
 316                         if (!vdev_is_bootable(spa->spa_root_vdev)) {
 317                                 error = ENOTSUP;
 318                                 break;
 319                         }
 320
 321                         reset_bootfs = 1;
 322
 323                         error = nvpair_value_string(elem, &strval);
 324
 325                         if (!error) {
 326                                 uint64_t compress;
 327
 328                                 if (strval == NULL || strval[0] == '\0') {
 329                                         objnum = zpool_prop_default_numeric(
 330                                             ZPOOL_PROP_BOOTFS);
 331                                         break;
 332                                 }
 333
 334                                 if (error = dmu_objset_open(strval, DMU_OST_ZFS,
 335                                     DS_MODE_USER | DS_MODE_READONLY, &os))
 336                                         break;
 337
 338                                 /* We don't support gzip bootable datasets */
 339                                 if ((error = dsl_prop_get_integer(strval,
 340                                     zfs_prop_to_name(ZFS_PROP_COMPRESSION),
 341                                     &compress, NULL)) == 0 &&
 342                                     !BOOTFS_COMPRESS_VALID(compress)) {
 343                                         error = ENOTSUP;
 344                                 } else {
 345                                         objnum = dmu_objset_id(os);
 346                                 }
 347                                 dmu_objset_close(os);
 348                         }
 349                         break;
 350
 351                 case ZPOOL_PROP_FAILUREMODE:
 352                         error = nvpair_value_uint64(elem, &intval);
 353                         if (!error && (intval < ZIO_FAILURE_MODE_WAIT ||
 354                             intval > ZIO_FAILURE_MODE_PANIC))
 355                                 error = EINVAL;
 356
 357                         /*
 358                          * This is a special case which only occurs when
 359                          * the pool has completely failed. This allows
 360                          * the user to change the in-core failmode property
 361                          * without syncing it out to disk (I/Os might
 362                          * currently be blocked). We do this by returning
 363                          * EIO to the caller (spa_prop_set) to trick it
 364                          * into thinking we encountered a property validation
 365                          * error.
 366                          */
 367                         if (!error && spa_suspended(spa)) {
 368                                 spa->spa_failmode = intval;
 369                                 error = EIO;
 370                         }
 371                         break;
 372
 373                 case ZPOOL_PROP_CACHEFILE:
 374                         if ((error = nvpair_value_string(elem, &strval)) != 0)
 375                                 break;
 376
 377                         if (strval[0] == '\0')
 378                                 break;
 379
 380                         if (strcmp(strval, "none") == 0)
 381                                 break;
 382
 383                         if (strval[0] != '/') {
 384                                 error = EINVAL;
 385                                 break;
 386                         }
 387
 388                         slash = strrchr(strval, '/');
 389                         ASSERT(slash != NULL);
 390
 391                         if (slash[1] == '\0' || strcmp(slash, "/.") == 0 ||
 392                             strcmp(slash, "/..") == 0)
 393                                 error = EINVAL;
 394                         break;
 395                 }
 396
 397                 if (error)
 398                         break;
 399         }
 400
 401         if (!error && reset_bootfs) {
 402                 error = nvlist_remove(props,
 403                     zpool_prop_to_name(ZPOOL_PROP_BOOTFS), DATA_TYPE_STRING);
 404
 405                 if (!error) {
 406                         error = nvlist_add_uint64(props,
 407                             zpool_prop_to_name(ZPOOL_PROP_BOOTFS), objnum);
 408                 }
 409         }
 410
 411         return (error);
 412 }
 413
 414 int
 415 spa_prop_set(spa_t *spa, nvlist_t *nvp)
 416 {
 417         int error;
 418
 419         if ((error = spa_prop_validate(spa, nvp)) != 0)
 420                 return (error);
 421
 422         return (dsl_sync_task_do(spa_get_dsl(spa), NULL, spa_sync_props,
 423             spa, nvp, 3));
 424 }
 425
 426 /*
 427  * If the bootfs property value is dsobj, clear it.
 428  */
 429 void
 430 spa_prop_clear_bootfs(spa_t *spa, uint64_t dsobj, dmu_tx_t *tx)
 431 {
 432         if (spa->spa_bootfs == dsobj && spa->spa_pool_props_object != 0) {
 433                 VERIFY(zap_remove(spa->spa_meta_objset,
 434                     spa->spa_pool_props_object,
 435                     zpool_prop_to_name(ZPOOL_PROP_BOOTFS), tx) == 0);
 436                 spa->spa_bootfs = 0;
 437         }
 438 }
 439
 440 /*
 441  * ==========================================================================
 442  * SPA state manipulation (open/create/destroy/import/export)
 443  * ==========================================================================
 444  */
 445
 446 static int
 447 spa_error_entry_compare(const void *a, const void *b)
 448 {
 449         spa_error_entry_t *sa = (spa_error_entry_t *)a;
 450         spa_error_entry_t *sb = (spa_error_entry_t *)b;
 451         int ret;
 452
 453         ret = bcmp(&sa->se_bookmark, &sb->se_bookmark,
 454             sizeof (zbookmark_t));
 455
 456         if (ret < 0)
 457                 return (-1);
 458         else if (ret > 0)
 459                 return (1);
 460         else
 461                 return (0);
 462 }
 463
 464 /*
 465  * Utility function which retrieves copies of the current logs and
 466  * re-initializes them in the process.
 467  */
 468 void
 469 spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub)
 470 {
 471         ASSERT(MUTEX_HELD(&spa->spa_errlist_lock));
 472
 473         bcopy(&spa->spa_errlist_last, last, sizeof (avl_tree_t));
 474         bcopy(&spa->spa_errlist_scrub, scrub, sizeof (avl_tree_t));
 475
 476         avl_create(&spa->spa_errlist_scrub,
 477             spa_error_entry_compare, sizeof (spa_error_entry_t),
 478             offsetof(spa_error_entry_t, se_avl));
 479         avl_create(&spa->spa_errlist_last,
 480             spa_error_entry_compare, sizeof (spa_error_entry_t),
 481             offsetof(spa_error_entry_t, se_avl));
 482 }
 483
 484 /*
 485  * Activate an uninitialized pool.
 486  */
 487 static void
 488 spa_activate(spa_t *spa)
 489 {
 490
 491         ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED);
 492
 493         spa->spa_state = POOL_STATE_ACTIVE;
 494
 495         spa->spa_normal_class = metaslab_class_create();
 496         spa->spa_log_class = metaslab_class_create();
 497
 498         for (int t = 0; t < ZIO_TYPES; t++) {
 499                 for (int q = 0; q < ZIO_TASKQ_TYPES; q++) {
 500                         spa->spa_zio_taskq[t][q] = taskq_create("spa_zio",
 501                             zio_taskq_threads[t][q], maxclsyspri, 50,
 502                             INT_MAX, TASKQ_PREPOPULATE);
 503                 }
 504         }
 505
 506         list_create(&spa->spa_config_dirty_list, sizeof (vdev_t),
 507             offsetof(vdev_t, vdev_config_dirty_node));
 508         list_create(&spa->spa_state_dirty_list, sizeof (vdev_t),
 509             offsetof(vdev_t, vdev_state_dirty_node));
 510
 511         txg_list_create(&spa->spa_vdev_txg_list,
 512             offsetof(struct vdev, vdev_txg_node));
 513
 514         avl_create(&spa->spa_errlist_scrub,
 515             spa_error_entry_compare, sizeof (spa_error_entry_t),
 516             offsetof(spa_error_entry_t, se_avl));
 517         avl_create(&spa->spa_errlist_last,
 518             spa_error_entry_compare, sizeof (spa_error_entry_t),
 519             offsetof(spa_error_entry_t, se_avl));
 520 }
 521
 522 /*
 523  * Opposite of spa_activate().
 524  */
 525 static void
 526 spa_deactivate(spa_t *spa)
 527 {
 528         ASSERT(spa->spa_sync_on == B_FALSE);
 529         ASSERT(spa->spa_dsl_pool == NULL);
 530         ASSERT(spa->spa_root_vdev == NULL);
 531
 532         ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED);
 533
 534         txg_list_destroy(&spa->spa_vdev_txg_list);
 535
 536         list_destroy(&spa->spa_config_dirty_list);
 537         list_destroy(&spa->spa_state_dirty_list);
 538
 539         for (int t = 0; t < ZIO_TYPES; t++) {
 540                 for (int q = 0; q < ZIO_TASKQ_TYPES; q++) {
 541                         taskq_destroy(spa->spa_zio_taskq[t][q]);
 542                         spa->spa_zio_taskq[t][q] = NULL;
 543                 }
 544         }
 545
 546         metaslab_class_destroy(spa->spa_normal_class);
 547         spa->spa_normal_class = NULL;
 548
 549         metaslab_class_destroy(spa->spa_log_class);
 550         spa->spa_log_class = NULL;
 551
 552         /*
 553          * If this was part of an import or the open otherwise failed, we may
 554          * still have errors left in the queues.  Empty them just in case.
 555          */
 556         spa_errlog_drain(spa);
 557
 558         avl_destroy(&spa->spa_errlist_scrub);
 559         avl_destroy(&spa->spa_errlist_last);
 560
 561         spa->spa_state = POOL_STATE_UNINITIALIZED;
 562 }
 563
 564 /*
 565  * Verify a pool configuration, and construct the vdev tree appropriately.  This
 566  * will create all the necessary vdevs in the appropriate layout, with each vdev
 567  * in the CLOSED state.  This will prep the pool before open/creation/import.
 568  * All vdev validation is done by the vdev_alloc() routine.
 569  */
 570 static int
 571 spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent,
 572     uint_t id, int atype)
 573 {
 574         nvlist_t **child;
 575         uint_t c, children;
 576         int error;
 577
 578         if ((error = vdev_alloc(spa, vdp, nv, parent, id, atype)) != 0)
 579                 return (error);
 580
 581         if ((*vdp)->vdev_ops->vdev_op_leaf)
 582                 return (0);
 583
 584         error = nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
 585             &child, &children);
 586
 587         if (error == ENOENT)
 588                 return (0);
 589
 590         if (error) {
 591                 vdev_free(*vdp);
 592                 *vdp = NULL;
 593                 return (EINVAL);
 594         }
 595
 596         for (c = 0; c < children; c++) {
 597                 vdev_t *vd;
 598                 if ((error = spa_config_parse(spa, &vd, child[c], *vdp, c,
 599                     atype)) != 0) {
 600                         vdev_free(*vdp);
 601                         *vdp = NULL;
 602                         return (error);
 603                 }
 604         }
 605
 606         ASSERT(*vdp != NULL);
 607
 608         return (0);
 609 }
 610
 611 /*
 612  * Opposite of spa_load().
 613  */
 614 static void
 615 spa_unload(spa_t *spa)
 616 {
 617         int i;
 618
 619         ASSERT(MUTEX_HELD(&spa_namespace_lock));
 620
 621         /*
 622          * Stop async tasks.
 623          */
 624         spa_async_suspend(spa);
 625
 626         /*
 627          * Stop syncing.
 628          */
 629         if (spa->spa_sync_on) {
 630                 txg_sync_stop(spa->spa_dsl_pool);
 631                 spa->spa_sync_on = B_FALSE;
 632         }
 633
 634         /*
 635          * Wait for any outstanding async I/O to complete.
 636          */
 637         mutex_enter(&spa->spa_async_root_lock);
 638         while (spa->spa_async_root_count != 0)
 639                 cv_wait(&spa->spa_async_root_cv, &spa->spa_async_root_lock);
 640         mutex_exit(&spa->spa_async_root_lock);
 641
 642         /*
 643          * Drop and purge level 2 cache
 644          */
 645         spa_l2cache_drop(spa);
 646
 647         /*
 648          * Close the dsl pool.
 649          */
 650         if (spa->spa_dsl_pool) {
 651                 dsl_pool_close(spa->spa_dsl_pool);
 652                 spa->spa_dsl_pool = NULL;
 653         }
 654
 655         /*
 656          * Close all vdevs.
 657          */
 658         if (spa->spa_root_vdev)
 659                 vdev_free(spa->spa_root_vdev);
 660         ASSERT(spa->spa_root_vdev == NULL);
 661
 662         for (i = 0; i < spa->spa_spares.sav_count; i++)
 663                 vdev_free(spa->spa_spares.sav_vdevs[i]);
 664         if (spa->spa_spares.sav_vdevs) {
 665                 kmem_free(spa->spa_spares.sav_vdevs,
 666                     spa->spa_spares.sav_count * sizeof (void *));
 667                 spa->spa_spares.sav_vdevs = NULL;
 668         }
 669         if (spa->spa_spares.sav_config) {
 670                 nvlist_free(spa->spa_spares.sav_config);
 671                 spa->spa_spares.sav_config = NULL;
 672         }
 673         spa->spa_spares.sav_count = 0;
 674
 675         for (i = 0; i < spa->spa_l2cache.sav_count; i++)
 676                 vdev_free(spa->spa_l2cache.sav_vdevs[i]);
 677         if (spa->spa_l2cache.sav_vdevs) {
 678                 kmem_free(spa->spa_l2cache.sav_vdevs,
 679                     spa->spa_l2cache.sav_count * sizeof (void *));
 680                 spa->spa_l2cache.sav_vdevs = NULL;
 681         }
 682         if (spa->spa_l2cache.sav_config) {
 683                 nvlist_free(spa->spa_l2cache.sav_config);
 684                 spa->spa_l2cache.sav_config = NULL;
 685         }
 686         spa->spa_l2cache.sav_count = 0;
 687
 688         spa->spa_async_suspended = 0;
 689 }
 690
 691 /*
 692  * Load (or re-load) the current list of vdevs describing the active spares for
 693  * this pool.  When this is called, we have some form of basic information in
 694  * 'spa_spares.sav_config'.  We parse this into vdevs, try to open them, and
 695  * then re-generate a more complete list including status information.
 696  */
 697 static void
 698 spa_load_spares(spa_t *spa)
 699 {
 700         nvlist_t **spares;
 701         uint_t nspares;
 702         int i;
 703         vdev_t *vd, *tvd;
 704
 705         ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
 706
 707         /*
 708          * First, close and free any existing spare vdevs.
 709          */
 710         for (i = 0; i < spa->spa_spares.sav_count; i++) {
 711                 vd = spa->spa_spares.sav_vdevs[i];
 712
 713                 /* Undo the call to spa_activate() below */
 714                 if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
 715                     B_FALSE)) != NULL && tvd->vdev_isspare)
 716                         spa_spare_remove(tvd);
 717                 vdev_close(vd);
 718                 vdev_free(vd);
 719         }
 720
 721         if (spa->spa_spares.sav_vdevs)
 722                 kmem_free(spa->spa_spares.sav_vdevs,
 723                     spa->spa_spares.sav_count * sizeof (void *));
 724
 725         if (spa->spa_spares.sav_config == NULL)
 726                 nspares = 0;
 727         else
 728                 VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
 729                     ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);
 730
 731         spa->spa_spares.sav_count = (int)nspares;
 732         spa->spa_spares.sav_vdevs = NULL;
 733
 734         if (nspares == 0)
 735                 return;
 736
 737         /*
 738          * Construct the array of vdevs, opening them to get status in the
 739          * process.   For each spare, there is potentially two different vdev_t
 740          * structures associated with it: one in the list of spares (used only
 741          * for basic validation purposes) and one in the active vdev
 742          * configuration (if it's spared in).  During this phase we open and
 743          * validate each vdev on the spare list.  If the vdev also exists in the
 744          * active configuration, then we also mark this vdev as an active spare.
 745          */
 746         spa->spa_spares.sav_vdevs = kmem_alloc(nspares * sizeof (void *),
 747             KM_SLEEP);
 748         for (i = 0; i < spa->spa_spares.sav_count; i++) {
 749                 VERIFY(spa_config_parse(spa, &vd, spares[i], NULL, 0,
 750                     VDEV_ALLOC_SPARE) == 0);
 751                 ASSERT(vd != NULL);
 752
 753                 spa->spa_spares.sav_vdevs[i] = vd;
 754
 755                 if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
 756                     B_FALSE)) != NULL) {
 757                         if (!tvd->vdev_isspare)
 758                                 spa_spare_add(tvd);
 759
 760                         /*
 761                          * We only mark the spare active if we were successfully
 762                          * able to load the vdev.  Otherwise, importing a pool
 763                          * with a bad active spare would result in strange
 764                          * behavior, because multiple pool would think the spare
 765                          * is actively in use.
 766                          *
 767                          * There is a vulnerability here to an equally bizarre
 768                          * circumstance, where a dead active spare is later
 769                          * brought back to life (onlined or otherwise).  Given
 770                          * the rarity of this scenario, and the extra complexity
 771                          * it adds, we ignore the possibility.
 772                          */
 773                         if (!vdev_is_dead(tvd))
 774                                 spa_spare_activate(tvd);
 775                 }
 776
 777                 vd->vdev_top = vd;
 778
 779                 if (vdev_open(vd) != 0)
 780                         continue;
 781
 782                 if (vdev_validate_aux(vd) == 0)
 783                         spa_spare_add(vd);
 784         }
 785
 786         /*
 787          * Recompute the stashed list of spares, with status information
 788          * this time.
 789          */
 790         VERIFY(nvlist_remove(spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES,
 791             DATA_TYPE_NVLIST_ARRAY) == 0);
 792
 793         spares = kmem_alloc(spa->spa_spares.sav_count * sizeof (void *),
 794             KM_SLEEP);
 795         for (i = 0; i < spa->spa_spares.sav_count; i++)
 796                 spares[i] = vdev_config_generate(spa,
 797                     spa->spa_spares.sav_vdevs[i], B_TRUE, B_TRUE, B_FALSE);
 798         VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
 799             ZPOOL_CONFIG_SPARES, spares, spa->spa_spares.sav_count) == 0);
 800         for (i = 0; i < spa->spa_spares.sav_count; i++)
 801                 nvlist_free(spares[i]);
 802         kmem_free(spares, spa->spa_spares.sav_count * sizeof (void *));
 803 }
 804
 805 /*
 806  * Load (or re-load) the current list of vdevs describing the active l2cache for
 807  * this pool.  When this is called, we have some form of basic information in
 808  * 'spa_l2cache.sav_config'.  We parse this into vdevs, try to open them, and
 809  * then re-generate a more complete list including status information.
 810  * Devices which are already active have their details maintained, and are
 811  * not re-opened.
 812  */
 813 static void
 814 spa_load_l2cache(spa_t *spa)
 815 {
 816         nvlist_t **l2cache;
 817         uint_t nl2cache;
 818         int i, j, oldnvdevs;
 819         uint64_t guid, size;
 820         vdev_t *vd, **oldvdevs, **newvdevs;
 821         spa_aux_vdev_t *sav = &spa->spa_l2cache;
 822
 823         ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
 824
 825         if (sav->sav_config != NULL) {
 826                 VERIFY(nvlist_lookup_nvlist_array(sav->sav_config,
 827                     ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);
 828                 newvdevs = kmem_alloc(nl2cache * sizeof (void *), KM_SLEEP);
 829         } else {
 830                 nl2cache = 0;
 831         }
 832
 833         oldvdevs = sav->sav_vdevs;
 834         oldnvdevs = sav->sav_count;
 835         sav->sav_vdevs = NULL;
 836         sav->sav_count = 0;
 837
 838         /*
 839          * Process new nvlist of vdevs.
 840          */
 841         for (i = 0; i < nl2cache; i++) {
 842                 VERIFY(nvlist_lookup_uint64(l2cache[i], ZPOOL_CONFIG_GUID,
 843                     &guid) == 0);
 844
 845                 newvdevs[i] = NULL;
 846                 for (j = 0; j < oldnvdevs; j++) {
 847                         vd = oldvdevs[j];
 848                         if (vd != NULL && guid == vd->vdev_guid) {
 849                                 /*
 850                                  * Retain previous vdev for add/remove ops.
 851                                  */
 852                                 newvdevs[i] = vd;
 853                                 oldvdevs[j] = NULL;
 854                                 break;
 855                         }
 856                 }
 857
 858                 if (newvdevs[i] == NULL) {
 859                         /*
 860                          * Create new vdev
 861                          */
 862                         VERIFY(spa_config_parse(spa, &vd, l2cache[i], NULL, 0,
 863                             VDEV_ALLOC_L2CACHE) == 0);
 864                         ASSERT(vd != NULL);
 865                         newvdevs[i] = vd;
 866
 867                         /*
 868                          * Commit this vdev as an l2cache device,
 869                          * even if it fails to open.
 870                          */
 871                         spa_l2cache_add(vd);
 872
 873                         vd->vdev_top = vd;
 874                         vd->vdev_aux = sav;
 875
 876                         spa_l2cache_activate(vd);
 877
 878                         if (vdev_open(vd) != 0)
 879                                 continue;
 880
 881                         (void) vdev_validate_aux(vd);
 882
 883                         if (!vdev_is_dead(vd)) {
 884                                 size = vdev_get_rsize(vd);
 885                                 l2arc_add_vdev(spa, vd,
 886                                     VDEV_LABEL_START_SIZE,
 887                                     size - VDEV_LABEL_START_SIZE);
 888                         }
 889                 }
 890         }
 891
 892         /*
 893          * Purge vdevs that were dropped
 894          */
 895         for (i = 0; i < oldnvdevs; i++) {
 896                 uint64_t pool;
 897
 898                 vd = oldvdevs[i];
 899                 if (vd != NULL) {
 900                         if ((spa_mode & FWRITE) &&
 901                             spa_l2cache_exists(vd->vdev_guid, &pool) &&
 902                             pool != 0ULL &&
 903                             l2arc_vdev_present(vd)) {
 904                                 l2arc_remove_vdev(vd);
 905                         }
 906                         (void) vdev_close(vd);
 907                         spa_l2cache_remove(vd);
 908                 }
 909         }
 910
 911         if (oldvdevs)
 912                 kmem_free(oldvdevs, oldnvdevs * sizeof (void *));
 913
 914         if (sav->sav_config == NULL)
 915                 goto out;
 916
 917         sav->sav_vdevs = newvdevs;
 918         sav->sav_count = (int)nl2cache;
 919
 920         /*
 921          * Recompute the stashed list of l2cache devices, with status
 922          * information this time.
 923          */
 924         VERIFY(nvlist_remove(sav->sav_config, ZPOOL_CONFIG_L2CACHE,
 925             DATA_TYPE_NVLIST_ARRAY) == 0);
 926
 927         l2cache = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP);
 928         for (i = 0; i < sav->sav_count; i++)
 929                 l2cache[i] = vdev_config_generate(spa,
 930                     sav->sav_vdevs[i], B_TRUE, B_FALSE, B_TRUE);
 931         VERIFY(nvlist_add_nvlist_array(sav->sav_config,
 932             ZPOOL_CONFIG_L2CACHE, l2cache, sav->sav_count) == 0);
 933 out:
 934         for (i = 0; i < sav->sav_count; i++)
 935                 nvlist_free(l2cache[i]);
 936         if (sav->sav_count)
 937                 kmem_free(l2cache, sav->sav_count * sizeof (void *));
 938 }
 939
 940 static int
 941 load_nvlist(spa_t *spa, uint64_t obj, nvlist_t **value)
 942 {
 943         dmu_buf_t *db;
 944         char *packed = NULL;
 945         size_t nvsize = 0;
 946         int error;
 947         *value = NULL;
 948
 949         VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db));
 950         nvsize = *(uint64_t *)db->db_data;
 951         dmu_buf_rele(db, FTAG);
 952
 953         packed = kmem_alloc(nvsize, KM_SLEEP);
 954         error = dmu_read(spa->spa_meta_objset, obj, 0, nvsize, packed);
 955         if (error == 0)
 956                 error = nvlist_unpack(packed, nvsize, value, 0);
 957         kmem_free(packed, nvsize);
 958
 959         return (error);
 960 }
 961
 962 /*
 963  * Checks to see if the given vdev could not be opened, in which case we post a
 964  * sysevent to notify the autoreplace code that the device has been removed.
 965  */
 966 static void
 967 spa_check_removed(vdev_t *vd)
 968 {
 969         int c;
 970
 971         for (c = 0; c < vd->vdev_children; c++)
 972                 spa_check_removed(vd->vdev_child[c]);
 973
 974         if (vd->vdev_ops->vdev_op_leaf && vdev_is_dead(vd)) {
 975                 zfs_post_autoreplace(vd->vdev_spa, vd);
 976                 spa_event_notify(vd->vdev_spa, vd, ESC_ZFS_VDEV_CHECK);
 977         }
 978 }
 979
 980 /*
 981  * Check for missing log devices
 982  */
 983 int
 984 spa_check_logs(spa_t *spa)
 985 {
 986         switch (spa->spa_log_state) {
 987         case SPA_LOG_MISSING:
 988                 /* need to recheck in case slog has been restored */
 989         case SPA_LOG_UNKNOWN:
 990                 if (dmu_objset_find(spa->spa_name, zil_check_log_chain, NULL,
 991                     DS_FIND_CHILDREN)) {
 992                         spa->spa_log_state = SPA_LOG_MISSING;
 993                         return (1);
 994                 }
 995                 break;
 996
 997         case SPA_LOG_CLEAR:
 998                 (void) dmu_objset_find(spa->spa_name, zil_clear_log_chain, NULL,
 999                     DS_FIND_CHILDREN);
1000                 break;
1001         }
1002         spa->spa_log_state = SPA_LOG_GOOD;
1003         return (0);
1004 }
1005
1006 /*
1007  * Load an existing storage pool, using the pool's builtin spa_config as a
1008  * source of configuration information.
1009  */
1010 static int
1011 spa_load(spa_t *spa, nvlist_t *config, spa_load_state_t state, int mosconfig)
1012 {
1013         int error = 0;
1014         nvlist_t *nvroot = NULL;
1015         vdev_t *rvd;
1016         uberblock_t *ub = &spa->spa_uberblock;
1017         uint64_t config_cache_txg = spa->spa_config_txg;
1018         uint64_t pool_guid;
1019         uint64_t version;
1020         uint64_t autoreplace = 0;
1021         char *ereport = FM_EREPORT_ZFS_POOL;
1022
1023         ASSERT(MUTEX_HELD(&spa_namespace_lock));
1024
1025         spa->spa_load_state = state;
1026
1027         if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvroot) ||
1028             nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid)) {
1029                 error = EINVAL;
1030                 goto out;
1031         }
1032
1033         /*
1034          * Versioning wasn't explicitly added to the label until later, so if
1035          * it's not present treat it as the initial version.
1036          */
1037         if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, &version) != 0)
1038                 version = SPA_VERSION_INITIAL;
1039
1040         (void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG,
1041             &spa->spa_config_txg);
1042
1043         if ((state == SPA_LOAD_IMPORT || state == SPA_LOAD_TRYIMPORT) &&
1044             spa_guid_exists(pool_guid, 0)) {
1045                 error = EEXIST;
1046                 goto out;
1047         }
1048
1049         spa->spa_load_guid = pool_guid;
1050
1051         /*
1052          * Parse the configuration into a vdev tree.  We explicitly set the
1053          * value that will be returned by spa_version() since parsing the
1054          * configuration requires knowing the version number.
1055          */
1056         spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1057         spa->spa_ubsync.ub_version = version;
1058         error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_LOAD);
1059         spa_config_exit(spa, SCL_ALL, FTAG);
1060
1061         if (error != 0)
1062                 goto out;
1063
1064         ASSERT(spa->spa_root_vdev == rvd);
1065         ASSERT(spa_guid(spa) == pool_guid);
1066
1067         /*
1068          * Try to open all vdevs, loading each label in the process.
1069          */
1070         spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1071         error = vdev_open(rvd);
1072         spa_config_exit(spa, SCL_ALL, FTAG);
1073         if (error != 0)
1074                 goto out;
1075
1076         /*
1077          * Validate the labels for all leaf vdevs.  We need to grab the config
1078          * lock because all label I/O is done with ZIO_FLAG_CONFIG_WRITER.
1079          */
1080         spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1081         error = vdev_validate(rvd);
1082         spa_config_exit(spa, SCL_ALL, FTAG);
1083
1084         if (error != 0)
1085                 goto out;
1086
1087         if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) {
1088                 error = ENXIO;
1089                 goto out;
1090         }
1091
1092         /*
1093          * Find the best uberblock.
1094          */
1095         vdev_uberblock_load(NULL, rvd, ub);
1096
1097         /*
1098          * If we weren't able to find a single valid uberblock, return failure.
1099          */
1100         if (ub->ub_txg == 0) {
1101                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1102                     VDEV_AUX_CORRUPT_DATA);
1103                 error = ENXIO;
1104                 goto out;
1105         }
1106
1107         /*
1108          * If the pool is newer than the code, we can't open it.
1109          */
1110         if (ub->ub_version > SPA_VERSION) {
1111                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1112                     VDEV_AUX_VERSION_NEWER);
1113                 error = ENOTSUP;
1114                 goto out;
1115         }
1116
1117         /*
1118          * If the vdev guid sum doesn't match the uberblock, we have an
1119          * incomplete configuration.
1120          */
1121         if (rvd->vdev_guid_sum != ub->ub_guid_sum && mosconfig) {
1122                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1123                     VDEV_AUX_BAD_GUID_SUM);
1124                 error = ENXIO;
1125                 goto out;
1126         }
1127
1128         /*
1129          * Initialize internal SPA structures.
1130          */
1131         spa->spa_state = POOL_STATE_ACTIVE;
1132         spa->spa_ubsync = spa->spa_uberblock;
1133         spa->spa_first_txg = spa_last_synced_txg(spa) + 1;
1134         error = dsl_pool_open(spa, spa->spa_first_txg, &spa->spa_dsl_pool);
1135         if (error) {
1136                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1137                     VDEV_AUX_CORRUPT_DATA);
1138                 goto out;
1139         }
1140         spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset;
1141
1142         if (zap_lookup(spa->spa_meta_objset,
1143             DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG,
1144             sizeof (uint64_t), 1, &spa->spa_config_object) != 0) {
1145                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1146                     VDEV_AUX_CORRUPT_DATA);
1147                 error = EIO;
1148                 goto out;
1149         }
1150
1151         if (!mosconfig) {
1152                 nvlist_t *newconfig;
1153                 uint64_t hostid;
1154
1155                 if (load_nvlist(spa, spa->spa_config_object, &newconfig) != 0) {
1156                         vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1157                             VDEV_AUX_CORRUPT_DATA);
1158                         error = EIO;
1159                         goto out;
1160                 }
1161
1162                 if (!spa_is_root(spa) && nvlist_lookup_uint64(newconfig,
1163                     ZPOOL_CONFIG_HOSTID, &hostid) == 0) {
1164                         char *hostname;
1165                         unsigned long myhostid = 0;
1166
1167                         VERIFY(nvlist_lookup_string(newconfig,
1168                             ZPOOL_CONFIG_HOSTNAME, &hostname) == 0);
1169
1170                         (void) ddi_strtoul(hw_serial, NULL, 10, &myhostid);
1171                         if (hostid != 0 && myhostid != 0 &&
1172                             (unsigned long)hostid != myhostid) {
1173                                 cmn_err(CE_WARN, "pool '%s' could not be "
1174                                     "loaded as it was last accessed by "
1175                                     "another system (host: %s hostid: 0x%lx). "
1176                                     "See: http://www.sun.com/msg/ZFS-8000-EY",
1177                                     spa_name(spa), hostname,
1178                                     (unsigned long)hostid);
1179                                 error = EBADF;
1180                                 goto out;
1181                         }
1182                 }
1183
1184                 spa_config_set(spa, newconfig);
1185                 spa_unload(spa);
1186                 spa_deactivate(spa);
1187                 spa_activate(spa);
1188
1189                 return (spa_load(spa, newconfig, state, B_TRUE));
1190         }
1191
1192         if (zap_lookup(spa->spa_meta_objset,
1193             DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST,
1194             sizeof (uint64_t), 1, &spa->spa_sync_bplist_obj) != 0) {
1195                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1196                     VDEV_AUX_CORRUPT_DATA);
1197                 error = EIO;
1198                 goto out;
1199         }
1200
1201         /*
1202          * Load the bit that tells us to use the new accounting function
1203          * (raid-z deflation).  If we have an older pool, this will not
1204          * be present.
1205          */
1206         error = zap_lookup(spa->spa_meta_objset,
1207             DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
1208             sizeof (uint64_t), 1, &spa->spa_deflate);
1209         if (error != 0 && error != ENOENT) {
1210                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1211                     VDEV_AUX_CORRUPT_DATA);
1212                 error = EIO;
1213                 goto out;
1214         }
1215
1216         /*
1217          * Load the persistent error log.  If we have an older pool, this will
1218          * not be present.
1219          */
1220         error = zap_lookup(spa->spa_meta_objset,
1221             DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ERRLOG_LAST,
1222             sizeof (uint64_t), 1, &spa->spa_errlog_last);
1223         if (error != 0 && error != ENOENT) {
1224                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1225                     VDEV_AUX_CORRUPT_DATA);
1226                 error = EIO;
1227                 goto out;
1228         }
1229
1230         error = zap_lookup(spa->spa_meta_objset,
1231             DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ERRLOG_SCRUB,
1232             sizeof (uint64_t), 1, &spa->spa_errlog_scrub);
1233         if (error != 0 && error != ENOENT) {
1234                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1235                     VDEV_AUX_CORRUPT_DATA);
1236                 error = EIO;
1237                 goto out;
1238         }
1239
1240         /*
1241          * Load the history object.  If we have an older pool, this
1242          * will not be present.
1243          */
1244         error = zap_lookup(spa->spa_meta_objset,
1245             DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_HISTORY,
1246             sizeof (uint64_t), 1, &spa->spa_history);
1247         if (error != 0 && error != ENOENT) {
1248                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1249                     VDEV_AUX_CORRUPT_DATA);
1250                 error = EIO;
1251                 goto out;
1252         }
1253
1254         /*
1255          * Load any hot spares for this pool.
1256          */
1257         error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
1258             DMU_POOL_SPARES, sizeof (uint64_t), 1, &spa->spa_spares.sav_object);
1259         if (error != 0 && error != ENOENT) {
1260                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1261                     VDEV_AUX_CORRUPT_DATA);
1262                 error = EIO;
1263                 goto out;
1264         }
1265         if (error == 0) {
1266                 ASSERT(spa_version(spa) >= SPA_VERSION_SPARES);
1267                 if (load_nvlist(spa, spa->spa_spares.sav_object,
1268                     &spa->spa_spares.sav_config) != 0) {
1269                         vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1270                             VDEV_AUX_CORRUPT_DATA);
1271                         error = EIO;
1272                         goto out;
1273                 }
1274
1275                 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1276                 spa_load_spares(spa);
1277                 spa_config_exit(spa, SCL_ALL, FTAG);
1278         }
1279
1280         /*
1281          * Load any level 2 ARC devices for this pool.
1282          */
1283         error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
1284             DMU_POOL_L2CACHE, sizeof (uint64_t), 1,
1285             &spa->spa_l2cache.sav_object);
1286         if (error != 0 && error != ENOENT) {
1287                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1288                     VDEV_AUX_CORRUPT_DATA);
1289                 error = EIO;
1290                 goto out;
1291         }
1292         if (error == 0) {
1293                 ASSERT(spa_version(spa) >= SPA_VERSION_L2CACHE);
1294                 if (load_nvlist(spa, spa->spa_l2cache.sav_object,
1295                     &spa->spa_l2cache.sav_config) != 0) {
1296                         vdev_set_state(rvd, B_TRUE,
1297                             VDEV_STATE_CANT_OPEN,
1298                             VDEV_AUX_CORRUPT_DATA);
1299                         error = EIO;
1300                         goto out;
1301                 }
1302
1303                 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1304                 spa_load_l2cache(spa);
1305                 spa_config_exit(spa, SCL_ALL, FTAG);
1306         }
1307
1308         if (spa_check_logs(spa)) {
1309                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1310                     VDEV_AUX_BAD_LOG);
1311                 error = ENXIO;
1312                 ereport = FM_EREPORT_ZFS_LOG_REPLAY;
1313                 goto out;
1314         }
1315
1316
1317         spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);
1318
1319         error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
1320             DMU_POOL_PROPS, sizeof (uint64_t), 1, &spa->spa_pool_props_object);
1321
1322         if (error && error != ENOENT) {
1323                 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1324                     VDEV_AUX_CORRUPT_DATA);
1325                 error = EIO;
1326                 goto out;
1327         }
1328
1329         if (error == 0) {
1330                 (void) zap_lookup(spa->spa_meta_objset,
1331                     spa->spa_pool_props_object,
1332                     zpool_prop_to_name(ZPOOL_PROP_BOOTFS),
1333                     sizeof (uint64_t), 1, &spa->spa_bootfs);
1334                 (void) zap_lookup(spa->spa_meta_objset,
1335                     spa->spa_pool_props_object,
1336                     zpool_prop_to_name(ZPOOL_PROP_AUTOREPLACE),
1337                     sizeof (uint64_t), 1, &autoreplace);
1338                 (void) zap_lookup(spa->spa_meta_objset,
1339                     spa->spa_pool_props_object,
1340                     zpool_prop_to_name(ZPOOL_PROP_DELEGATION),
1341                     sizeof (uint64_t), 1, &spa->spa_delegation);
1342                 (void) zap_lookup(spa->spa_meta_objset,
1343                     spa->spa_pool_props_object,
1344                     zpool_prop_to_name(ZPOOL_PROP_FAILUREMODE),
1345                     sizeof (uint64_t), 1, &spa->spa_failmode);
1346         }
1347
1348         /*
1349          * If the 'autoreplace' property is set, then post a resource notifying
1350          * the ZFS DE that it should not issue any faults for unopenable
1351          * devices.  We also iterate over the vdevs, and post a sysevent for any
1352          * unopenable vdevs so that the normal autoreplace handler can take
1353          * over.
1354          */
1355         if (autoreplace && state != SPA_LOAD_TRYIMPORT)
1356                 spa_check_removed(spa->spa_root_vdev);
1357
1358         /*
1359          * Load the vdev state for all toplevel vdevs.
1360          */
1361         vdev_load(rvd);
1362
1363         /*
1364          * Propagate the leaf DTLs we just loaded all the way up the tree.
1365          */
1366         spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1367         vdev_dtl_reassess(rvd, 0, 0, B_FALSE);
1368         spa_config_exit(spa, SCL_ALL, FTAG);
1369
1370         /*
1371          * Check the state of the root vdev.  If it can't be opened, it
1372          * indicates one or more toplevel vdevs are faulted.
1373          */
1374         if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) {
1375                 error = ENXIO;
1376                 goto out;
1377         }
1378
1379         if ((spa_mode & FWRITE) && state != SPA_LOAD_TRYIMPORT) {
1380                 dmu_tx_t *tx;
1381                 int need_update = B_FALSE;
1382                 int c;
1383
1384                 /*
1385                  * Claim log blocks that haven't been committed yet.
1386                  * This must all happen in a single txg.
1387                  */
1388                 tx = dmu_tx_create_assigned(spa_get_dsl(spa),
1389                     spa_first_txg(spa));
1390                 (void) dmu_objset_find(spa_name(spa),
1391                     zil_claim, tx, DS_FIND_CHILDREN);
1392                 dmu_tx_commit(tx);
1393
1394                 spa->spa_sync_on = B_TRUE;
1395                 txg_sync_start(spa->spa_dsl_pool);
1396
1397                 /*
1398                  * Wait for all claims to sync.
1399                  */
1400                 txg_wait_synced(spa->spa_dsl_pool, 0);
1401
1402                 /*
1403                  * If the config cache is stale, or we have uninitialized
1404                  * metaslabs (see spa_vdev_add()), then update the config.
1405                  */
1406                 if (config_cache_txg != spa->spa_config_txg ||
1407                     state == SPA_LOAD_IMPORT)
1408                         need_update = B_TRUE;
1409
1410                 for (c = 0; c < rvd->vdev_children; c++)
1411                         if (rvd->vdev_child[c]->vdev_ms_array == 0)
1412                                 need_update = B_TRUE;
1413
1414                 /*
1415                  * Update the config cache asychronously in case we're the
1416                  * root pool, in which case the config cache isn't writable yet.
1417                  */
1418                 if (need_update)
1419                         spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
1420         }
1421
1422         error = 0;
1423 out:
1424         spa->spa_minref = refcount_count(&spa->spa_refcount);
1425         if (error && error != EBADF)
1426                 zfs_ereport_post(ereport, spa, NULL, NULL, 0, 0);
1427         spa->spa_load_state = SPA_LOAD_NONE;
1428         spa->spa_ena = 0;
1429
1430         return (error);
1431 }
1432
1433 /*
1434  * Pool Open/Import
1435  *
1436  * The import case is identical to an open except that the configuration is sent
1437  * down from userland, instead of grabbed from the configuration cache.  For the
1438  * case of an open, the pool configuration will exist in the
1439  * POOL_STATE_UNINITIALIZED state.
1440  *
1441  * The stats information (gen/count/ustats) is used to gather vdev statistics at
1442  * the same time open the pool, without having to keep around the spa_t in some
1443  * ambiguous state.
1444  */
1445 static int
1446 spa_open_common(const char *pool, spa_t **spapp, void *tag, nvlist_t **config)
1447 {
1448         spa_t *spa;
1449         int error;
1450         int locked = B_FALSE;
1451
1452         *spapp = NULL;
1453
1454         /*
1455          * As disgusting as this is, we need to support recursive calls to this
1456          * function because dsl_dir_open() is called during spa_load(), and ends
1457          * up calling spa_open() again.  The real fix is to figure out how to
1458          * avoid dsl_dir_open() calling this in the first place.
1459          */
1460         if (mutex_owner(&spa_namespace_lock) != curthread) {
1461                 mutex_enter(&spa_namespace_lock);
1462                 locked = B_TRUE;
1463         }
1464
1465         if ((spa = spa_lookup(pool)) == NULL) {
1466                 if (locked)
1467                         mutex_exit(&spa_namespace_lock);
1468                 return (ENOENT);
1469         }
1470         if (spa->spa_state == POOL_STATE_UNINITIALIZED) {
1471
1472                 spa_activate(spa);
1473
1474                 error = spa_load(spa, spa->spa_config, SPA_LOAD_OPEN, B_FALSE);
1475
1476                 if (error == EBADF) {
1477                         /*
1478                          * If vdev_validate() returns failure (indicated by
1479                          * EBADF), it indicates that one of the vdevs indicates
1480                          * that the pool has been exported or destroyed.  If
1481                          * this is the case, the config cache is out of sync and
1482                          * we should remove the pool from the namespace.
1483                          */
1484                         spa_unload(spa);
1485                         spa_deactivate(spa);
1486                         spa_config_sync(spa, B_TRUE, B_TRUE);
1487                         spa_remove(spa);
1488                         if (locked)
1489                                 mutex_exit(&spa_namespace_lock);
1490                         return (ENOENT);
1491                 }
1492
1493                 if (error) {
1494                         /*
1495                          * We can't open the pool, but we still have useful
1496                          * information: the state of each vdev after the
1497                          * attempted vdev_open().  Return this to the user.
1498                          */
1499                         if (config != NULL && spa->spa_root_vdev != NULL)
1500                                 *config = spa_config_generate(spa, NULL, -1ULL,
1501                                     B_TRUE);
1502                         spa_unload(spa);
1503                         spa_deactivate(spa);
1504                         spa->spa_last_open_failed = B_TRUE;
1505                         if (locked)
1506                                 mutex_exit(&spa_namespace_lock);
1507                         *spapp = NULL;
1508                         return (error);
1509                 } else {
1510                         spa->spa_last_open_failed = B_FALSE;
1511                 }
1512         }
1513
1514         spa_open_ref(spa, tag);
1515
1516         if (locked)
1517                 mutex_exit(&spa_namespace_lock);
1518
1519         *spapp = spa;
1520
1521         if (config != NULL)
1522                 *config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
1523
1524         return (0);
1525 }
1526
1527 int
1528 spa_open(const char *name, spa_t **spapp, void *tag)
1529 {
1530         return (spa_open_common(name, spapp, tag, NULL));
1531 }
1532
1533 /*
1534  * Lookup the given spa_t, incrementing the inject count in the process,
1535  * preventing it from being exported or destroyed.
1536  */
1537 spa_t *
1538 spa_inject_addref(char *name)
1539 {
1540         spa_t *spa;
1541
1542         mutex_enter(&spa_namespace_lock);
1543         if ((spa = spa_lookup(name)) == NULL) {
1544                 mutex_exit(&spa_namespace_lock);
1545                 return (NULL);
1546         }
1547         spa->spa_inject_ref++;
1548         mutex_exit(&spa_namespace_lock);
1549
1550         return (spa);
1551 }
1552
1553 void
1554 spa_inject_delref(spa_t *spa)
1555 {
1556         mutex_enter(&spa_namespace_lock);
1557         spa->spa_inject_ref--;
1558         mutex_exit(&spa_namespace_lock);
1559 }
1560
1561 /*
1562  * Add spares device information to the nvlist.
1563  */
1564 static void
1565 spa_add_spares(spa_t *spa, nvlist_t *config)
1566 {
1567         nvlist_t **spares;
1568         uint_t i, nspares;
1569         nvlist_t *nvroot;
1570         uint64_t guid;
1571         vdev_stat_t *vs;
1572         uint_t vsc;
1573         uint64_t pool;
1574
1575         if (spa->spa_spares.sav_count == 0)
1576                 return;
1577
1578         VERIFY(nvlist_lookup_nvlist(config,
1579             ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
1580         VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
1581             ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);
1582         if (nspares != 0) {
1583                 VERIFY(nvlist_add_nvlist_array(nvroot,
1584                     ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
1585                 VERIFY(nvlist_lookup_nvlist_array(nvroot,
1586                     ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);
1587
1588                 /*
1589                  * Go through and find any spares which have since been
1590                  * repurposed as an active spare.  If this is the case, update
1591                  * their status appropriately.
1592                  */
1593                 for (i = 0; i < nspares; i++) {
1594                         VERIFY(nvlist_lookup_uint64(spares[i],
1595                             ZPOOL_CONFIG_GUID, &guid) == 0);
1596                         if (spa_spare_exists(guid, &pool, NULL) &&
1597                             pool != 0ULL) {
1598                                 VERIFY(nvlist_lookup_uint64_array(
1599                                     spares[i], ZPOOL_CONFIG_STATS,
1600                                     (uint64_t **)&vs, &vsc) == 0);
1601                                 vs->vs_state = VDEV_STATE_CANT_OPEN;
1602                                 vs->vs_aux = VDEV_AUX_SPARED;
1603                         }
1604                 }
1605         }
1606 }
1607
1608 /*
1609  * Add l2cache device information to the nvlist, including vdev stats.
1610  */
1611 static void
1612 spa_add_l2cache(spa_t *spa, nvlist_t *config)
1613 {
1614         nvlist_t **l2cache;
1615         uint_t i, j, nl2cache;
1616         nvlist_t *nvroot;
1617         uint64_t guid;
1618         vdev_t *vd;
1619         vdev_stat_t *vs;
1620         uint_t vsc;
1621
1622         if (spa->spa_l2cache.sav_count == 0)
1623                 return;
1624
1625         spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
1626
1627         VERIFY(nvlist_lookup_nvlist(config,
1628             ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
1629         VERIFY(nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
1630             ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);
1631         if (nl2cache != 0) {
1632                 VERIFY(nvlist_add_nvlist_array(nvroot,
1633                     ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
1634                 VERIFY(nvlist_lookup_nvlist_array(nvroot,
1635                     ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);
1636
1637                 /*
1638                  * Update level 2 cache device stats.
1639                  */
1640
1641                 for (i = 0; i < nl2cache; i++) {
1642                         VERIFY(nvlist_lookup_uint64(l2cache[i],
1643                             ZPOOL_CONFIG_GUID, &guid) == 0);
1644
1645                         vd = NULL;
1646                         for (j = 0; j < spa->spa_l2cache.sav_count; j++) {
1647                                 if (guid ==
1648                                     spa->spa_l2cache.sav_vdevs[j]->vdev_guid) {
1649                                         vd = spa->spa_l2cache.sav_vdevs[j];
1650                                         break;
1651                                 }
1652                         }
1653                         ASSERT(vd != NULL);
1654
1655                         VERIFY(nvlist_lookup_uint64_array(l2cache[i],
1656                             ZPOOL_CONFIG_STATS, (uint64_t **)&vs, &vsc) == 0);
1657                         vdev_get_stats(vd, vs);
1658                 }
1659         }
1660
1661         spa_config_exit(spa, SCL_CONFIG, FTAG);
1662 }
1663
1664 int
1665 spa_get_stats(const char *name, nvlist_t **config, char *altroot, size_t buflen)
1666 {
1667         int error;
1668         spa_t *spa;
1669
1670         *config = NULL;
1671         error = spa_open_common(name, &spa, FTAG, config);
1672
1673         if (spa && *config != NULL) {
1674                 VERIFY(nvlist_add_uint64(*config, ZPOOL_CONFIG_ERRCOUNT,
1675                     spa_get_errlog_size(spa)) == 0);
1676
1677                 if (spa_suspended(spa))
1678                         VERIFY(nvlist_add_uint64(*config,
1679                             ZPOOL_CONFIG_SUSPENDED, spa->spa_failmode) == 0);
1680
1681                 spa_add_spares(spa, *config);
1682                 spa_add_l2cache(spa, *config);
1683         }
1684
1685         /*
1686          * We want to get the alternate root even for faulted pools, so we cheat
1687          * and call spa_lookup() directly.
1688          */
1689         if (altroot) {
1690                 if (spa == NULL) {
1691                         mutex_enter(&spa_namespace_lock);
1692                         spa = spa_lookup(name);
1693                         if (spa)
1694                                 spa_altroot(spa, altroot, buflen);
1695                         else
1696                                 altroot[0] = '\0';
1697                         spa = NULL;
1698                         mutex_exit(&spa_namespace_lock);
1699                 } else {
1700                         spa_altroot(spa, altroot, buflen);
1701                 }
1702         }
1703
1704         if (spa != NULL)
1705                 spa_close(spa, FTAG);
1706
1707         return (error);
1708 }
1709
1710 /*
1711  * Validate that the auxiliary device array is well formed.  We must have an
1712  * array of nvlists, each which describes a valid leaf vdev.  If this is an
1713  * import (mode is VDEV_ALLOC_SPARE), then we allow corrupted spares to be
1714  * specified, as long as they are well-formed.
1715  */
1716 static int
1717 spa_validate_aux_devs(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode,
1718     spa_aux_vdev_t *sav, const char *config, uint64_t version,
1719     vdev_labeltype_t label)
1720 {
1721         nvlist_t **dev;
1722         uint_t i, ndev;
1723         vdev_t *vd;
1724         int error;
1725
1726         ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
1727
1728         /*
1729          * It's acceptable to have no devs specified.
1730          */
1731         if (nvlist_lookup_nvlist_array(nvroot, config, &dev, &ndev) != 0)
1732                 return (0);
1733
1734         if (ndev == 0)
1735                 return (EINVAL);
1736
1737         /*
1738          * Make sure the pool is formatted with a version that supports this
1739          * device type.
1740          */
1741         if (spa_version(spa) < version)
1742                 return (ENOTSUP);
1743
1744         /*
1745          * Set the pending device list so we correctly handle device in-use
1746          * checking.
1747          */
1748         sav->sav_pending = dev;
1749         sav->sav_npending = ndev;
1750
1751         for (i = 0; i < ndev; i++) {
1752                 if ((error = spa_config_parse(spa, &vd, dev[i], NULL, 0,
1753                     mode)) != 0)
1754                         goto out;
1755
1756                 if (!vd->vdev_ops->vdev_op_leaf) {
1757                         vdev_free(vd);
1758                         error = EINVAL;
1759                         goto out;
1760                 }
1761
1762                 /*
1763                  * The L2ARC currently only supports disk devices in
1764                  * kernel context.  For user-level testing, we allow it.
1765                  */
1766 #ifdef _KERNEL
1767                 if ((strcmp(config, ZPOOL_CONFIG_L2CACHE) == 0) &&
1768                     strcmp(vd->vdev_ops->vdev_op_type, VDEV_TYPE_DISK) != 0) {
1769                         error = ENOTBLK;
1770                         goto out;
1771                 }
1772 #endif
1773                 vd->vdev_top = vd;
1774
1775                 if ((error = vdev_open(vd)) == 0 &&
1776                     (error = vdev_label_init(vd, crtxg, label)) == 0) {
1777                         VERIFY(nvlist_add_uint64(dev[i], ZPOOL_CONFIG_GUID,
1778                             vd->vdev_guid) == 0);
1779                 }
1780
1781                 vdev_free(vd);
1782
1783                 if (error &&
1784                     (mode != VDEV_ALLOC_SPARE && mode != VDEV_ALLOC_L2CACHE))
1785                         goto out;
1786                 else
1787                         error = 0;
1788         }
1789
1790 out:
1791         sav->sav_pending = NULL;
1792         sav->sav_npending = 0;
1793         return (error);
1794 }
1795
1796 static int
1797 spa_validate_aux(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode)
1798 {
1799         int error;
1800
1801         ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
1802
1803         if ((error = spa_validate_aux_devs(spa, nvroot, crtxg, mode,
1804             &spa->spa_spares, ZPOOL_CONFIG_SPARES, SPA_VERSION_SPARES,
1805             VDEV_LABEL_SPARE)) != 0) {
1806                 return (error);
1807         }
1808
1809         return (spa_validate_aux_devs(spa, nvroot, crtxg, mode,
1810             &spa->spa_l2cache, ZPOOL_CONFIG_L2CACHE, SPA_VERSION_L2CACHE,
1811             VDEV_LABEL_L2CACHE));
1812 }
1813
1814 static void
1815 spa_set_aux_vdevs(spa_aux_vdev_t *sav, nvlist_t **devs, int ndevs,
1816     const char *config)
1817 {
1818         int i;
1819
1820         if (sav->sav_config != NULL) {
1821                 nvlist_t **olddevs;
1822                 uint_t oldndevs;
1823                 nvlist_t **newdevs;
1824
1825                 /*
1826                  * Generate new dev list by concatentating with the
1827                  * current dev list.
1828                  */
1829                 VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, config,
1830                     &olddevs, &oldndevs) == 0);
1831
1832                 newdevs = kmem_alloc(sizeof (void *) *
1833                     (ndevs + oldndevs), KM_SLEEP);
1834                 for (i = 0; i < oldndevs; i++)
1835                         VERIFY(nvlist_dup(olddevs[i], &newdevs[i],
1836                             KM_SLEEP) == 0);
1837                 for (i = 0; i < ndevs; i++)
1838                         VERIFY(nvlist_dup(devs[i], &newdevs[i + oldndevs],
1839                             KM_SLEEP) == 0);
1840
1841                 VERIFY(nvlist_remove(sav->sav_config, config,
1842                     DATA_TYPE_NVLIST_ARRAY) == 0);
1843
1844                 VERIFY(nvlist_add_nvlist_array(sav->sav_config,
1845                     config, newdevs, ndevs + oldndevs) == 0);
1846                 for (i = 0; i < oldndevs + ndevs; i++)
1847                         nvlist_free(newdevs[i]);
1848                 kmem_free(newdevs, (oldndevs + ndevs) * sizeof (void *));
1849         } else {
1850                 /*
1851                  * Generate a new dev list.
1852                  */
1853                 VERIFY(nvlist_alloc(&sav->sav_config, NV_UNIQUE_NAME,
1854                     KM_SLEEP) == 0);
1855                 VERIFY(nvlist_add_nvlist_array(sav->sav_config, config,
1856                     devs, ndevs) == 0);
1857         }
1858 }
1859
1860 /*
1861  * Stop and drop level 2 ARC devices
1862  */
1863 void
1864 spa_l2cache_drop(spa_t *spa)
1865 {
1866         vdev_t *vd;
1867         int i;
1868         spa_aux_vdev_t *sav = &spa->spa_l2cache;
1869
1870         for (i = 0; i < sav->sav_count; i++) {
1871                 uint64_t pool;
1872
1873                 vd = sav->sav_vdevs[i];
1874                 ASSERT(vd != NULL);
1875
1876                 if ((spa_mode & FWRITE) &&
1877                     spa_l2cache_exists(vd->vdev_guid, &pool) && pool != 0ULL &&
1878                     l2arc_vdev_present(vd)) {
1879                         l2arc_remove_vdev(vd);
1880                 }
1881                 if (vd->vdev_isl2cache)
1882                         spa_l2cache_remove(vd);
1883                 vdev_clear_stats(vd);
1884                 (void) vdev_close(vd);
1885         }
1886 }
1887
1888 /*
1889  * Pool Creation
1890  */
1891 int
1892 spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props,
1893     const char *history_str, nvlist_t *zplprops)
1894 {
1895         spa_t *spa;
1896         char *altroot = NULL;
1897         vdev_t *rvd;
1898         dsl_pool_t *dp;
1899         dmu_tx_t *tx;
1900         int c, error = 0;
1901         uint64_t txg = TXG_INITIAL;
1902         nvlist_t **spares, **l2cache;
1903         uint_t nspares, nl2cache;
1904         uint64_t version;
1905
1906         /*
1907          * If this pool already exists, return failure.
1908          */
1909         mutex_enter(&spa_namespace_lock);
1910         if (spa_lookup(pool) != NULL) {
1911                 mutex_exit(&spa_namespace_lock);
1912                 return (EEXIST);
1913         }
1914
1915         /*
1916          * Allocate a new spa_t structure.
1917          */
1918         (void) nvlist_lookup_string(props,
1919             zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot);
1920         spa = spa_add(pool, altroot);
1921         spa_activate(spa);
1922
1923         spa->spa_uberblock.ub_txg = txg - 1;
1924
1925         if (props && (error = spa_prop_validate(spa, props))) {
1926                 spa_unload(spa);
1927                 spa_deactivate(spa);
1928                 spa_remove(spa);
1929                 mutex_exit(&spa_namespace_lock);
1930                 return (error);
1931         }
1932
1933         if (nvlist_lookup_uint64(props, zpool_prop_to_name(ZPOOL_PROP_VERSION),
1934             &version) != 0)
1935                 version = SPA_VERSION;
1936         ASSERT(version <= SPA_VERSION);
1937         spa->spa_uberblock.ub_version = version;
1938         spa->spa_ubsync = spa->spa_uberblock;
1939
1940         /*
1941          * Create the root vdev.
1942          */
1943         spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1944
1945         error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_ADD);
1946
1947         ASSERT(error != 0 || rvd != NULL);
1948         ASSERT(error != 0 || spa->spa_root_vdev == rvd);
1949
1950         if (error == 0 && !zfs_allocatable_devs(nvroot))
1951                 error = EINVAL;
1952
1953         if (error == 0 &&
1954             (error = vdev_create(rvd, txg, B_FALSE)) == 0 &&
1955             (error = spa_validate_aux(spa, nvroot, txg,
1956             VDEV_ALLOC_ADD)) == 0) {
1957                 for (c = 0; c < rvd->vdev_children; c++)
1958                         vdev_init(rvd->vdev_child[c], txg);
1959                 vdev_config_dirty(rvd);
1960         }
1961
1962         spa_config_exit(spa, SCL_ALL, FTAG);
1963
1964         if (error != 0) {
1965                 spa_unload(spa);
1966                 spa_deactivate(spa);
1967                 spa_remove(spa);
1968                 mutex_exit(&spa_namespace_lock);
1969                 return (error);
1970         }
1971
1972         /*
1973          * Get the list of spares, if specified.
1974          */
1975         if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
1976             &spares, &nspares) == 0) {
1977                 VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, NV_UNIQUE_NAME,
1978                     KM_SLEEP) == 0);
1979                 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
1980                     ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
1981                 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1982                 spa_load_spares(spa);
1983                 spa_config_exit(spa, SCL_ALL, FTAG);
1984                 spa->spa_spares.sav_sync = B_TRUE;
1985         }
1986
1987         /*
1988          * Get the list of level 2 cache devices, if specified.
1989          */
1990         if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
1991             &l2cache, &nl2cache) == 0) {
1992                 VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config,
1993                     NV_UNIQUE_NAME, KM_SLEEP) == 0);
1994                 VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
1995                     ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
1996                 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1997                 spa_load_l2cache(spa);
1998                 spa_config_exit(spa, SCL_ALL, FTAG);
1999                 spa->spa_l2cache.sav_sync = B_TRUE;
2000         }
2001
2002         spa->spa_dsl_pool = dp = dsl_pool_create(spa, zplprops, txg);
2003         spa->spa_meta_objset = dp->dp_meta_objset;
2004
2005         tx = dmu_tx_create_assigned(dp, txg);
2006
2007         /*
2008          * Create the pool config object.
2009          */
2010         spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset,
2011             DMU_OT_PACKED_NVLIST, SPA_CONFIG_BLOCKSIZE,
2012             DMU_OT_PACKED_NVLIST_SIZE, sizeof (uint64_t), tx);
2013
2014         if (zap_add(spa->spa_meta_objset,
2015             DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG,
2016             sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) {
2017                 cmn_err(CE_PANIC, "failed to add pool config");
2018         }
2019
2020         /* Newly created pools with the right version are always deflated. */
2021         if (version >= SPA_VERSION_RAIDZ_DEFLATE) {
2022                 spa->spa_deflate = TRUE;
2023                 if (zap_add(spa->spa_meta_objset,
2024                     DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
2025                     sizeof (uint64_t), 1, &spa->spa_deflate, tx) != 0) {
2026                         cmn_err(CE_PANIC, "failed to add deflate");
2027                 }
2028         }
2029
2030         /*
2031          * Create the deferred-free bplist object.  Turn off compression
2032          * because sync-to-convergence takes longer if the blocksize
2033          * keeps changing.
2034          */
2035         spa->spa_sync_bplist_obj = bplist_create(spa->spa_meta_objset,
2036             1 << 14, tx);
2037         dmu_object_set_compress(spa->spa_meta_objset, spa->spa_sync_bplist_obj,
2038             ZIO_COMPRESS_OFF, tx);
2039
2040         if (zap_add(spa->spa_meta_objset,
2041             DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST,
2042             sizeof (uint64_t), 1, &spa->spa_sync_bplist_obj, tx) != 0) {
2043                 cmn_err(CE_PANIC, "failed to add bplist");
2044         }
2045
2046         /*
2047          * Create the pool's history object.
2048          */
2049         if (version >= SPA_VERSION_ZPOOL_HISTORY)
2050                 spa_history_create_obj(spa, tx);
2051
2052         /*
2053          * Set pool properties.
2054          */
2055         spa->spa_bootfs = zpool_prop_default_numeric(ZPOOL_PROP_BOOTFS);
2056         spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);
2057         spa->spa_failmode = zpool_prop_default_numeric(ZPOOL_PROP_FAILUREMODE);
2058         if (props)
2059                 spa_sync_props(spa, props, CRED(), tx);
2060
2061         dmu_tx_commit(tx);
2062
2063         spa->spa_sync_on = B_TRUE;
2064         txg_sync_start(spa->spa_dsl_pool);
2065
2066         /*
2067          * We explicitly wait for the first transaction to complete so that our
2068          * bean counters are appropriately updated.
2069          */
2070         txg_wait_synced(spa->spa_dsl_pool, txg);
2071
2072         spa_config_sync(spa, B_FALSE, B_TRUE);
2073
2074         if (version >= SPA_VERSION_ZPOOL_HISTORY && history_str != NULL)
2075                 (void) spa_history_log(spa, history_str, LOG_CMD_POOL_CREATE);
2076
2077         mutex_exit(&spa_namespace_lock);
2078
2079         spa->spa_minref = refcount_count(&spa->spa_refcount);
2080
2081         return (0);
2082 }
2083
2084 /*
2085  * Import the given pool into the system.  We set up the necessary spa_t and
2086  * then call spa_load() to do the dirty work.
2087  */
2088 static int
2089 spa_import_common(const char *pool, nvlist_t *config, nvlist_t *props,
2090     boolean_t isroot, boolean_t allowfaulted)
2091 {
2092         spa_t *spa;
2093         char *altroot = NULL;
2094         int error, loaderr;
2095         nvlist_t *nvroot;
2096         nvlist_t **spares, **l2cache;
2097         uint_t nspares, nl2cache;
2098
2099         /*
2100          * If a pool with this name exists, return failure.
2101          */
2102         mutex_enter(&spa_namespace_lock);
2103         if (spa_lookup(pool) != NULL) {
2104                 mutex_exit(&spa_namespace_lock);
2105                 return (EEXIST);
2106         }
2107
2108         /*
2109          * Create and initialize the spa structure.
2110          */
2111         (void) nvlist_lookup_string(props,
2112             zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot);
2113         spa = spa_add(pool, altroot);
2114         spa_activate(spa);
2115
2116         if (allowfaulted)
2117                 spa->spa_import_faulted = B_TRUE;
2118         spa->spa_is_root = isroot;
2119
2120         /*
2121          * Pass off the heavy lifting to spa_load().
2122          * Pass TRUE for mosconfig (unless this is a root pool) because
2123          * the user-supplied config is actually the one to trust when
2124          * doing an import.
2125          */
2126         loaderr = error = spa_load(spa, config, SPA_LOAD_IMPORT, !isroot);
2127
2128         spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2129         /*
2130          * Toss any existing sparelist, as it doesn't have any validity anymore,
2131          * and conflicts with spa_has_spare().
2132          */
2133         if (!isroot && spa->spa_spares.sav_config) {
2134                 nvlist_free(spa->spa_spares.sav_config);
2135                 spa->spa_spares.sav_config = NULL;
2136                 spa_load_spares(spa);
2137         }
2138         if (!isroot && spa->spa_l2cache.sav_config) {
2139                 nvlist_free(spa->spa_l2cache.sav_config);
2140                 spa->spa_l2cache.sav_config = NULL;
2141                 spa_load_l2cache(spa);
2142         }
2143
2144         VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
2145             &nvroot) == 0);
2146         if (error == 0)
2147                 error = spa_validate_aux(spa, nvroot, -1ULL, VDEV_ALLOC_SPARE);
2148         if (error == 0)
2149                 error = spa_validate_aux(spa, nvroot, -1ULL,
2150                     VDEV_ALLOC_L2CACHE);
2151         spa_config_exit(spa, SCL_ALL, FTAG);
2152
2153         if (error != 0 || (props && (error = spa_prop_set(spa, props)))) {
2154                 if (loaderr != 0 && loaderr != EINVAL && allowfaulted) {
2155                         /*
2156                          * If we failed to load the pool, but 'allowfaulted' is
2157                          * set, then manually set the config as if the config
2158                          * passed in was specified in the cache file.
2159                          */
2160                         error = 0;
2161                         spa->spa_import_faulted = B_FALSE;
2162                         if (spa->spa_config == NULL)
2163                                 spa->spa_config = spa_config_generate(spa,
2164                                     NULL, -1ULL, B_TRUE);
2165                         spa_unload(spa);
2166                         spa_deactivate(spa);
2167                         spa_config_sync(spa, B_FALSE, B_TRUE);
2168                 } else {
2169                         spa_unload(spa);
2170                         spa_deactivate(spa);
2171                         spa_remove(spa);
2172                 }
2173                 mutex_exit(&spa_namespace_lock);
2174                 return (error);
2175         }
2176
2177         /*
2178          * Override any spares and level 2 cache devices as specified by
2179          * the user, as these may have correct device names/devids, etc.
2180          */
2181         if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
2182             &spares, &nspares) == 0) {
2183                 if (spa->spa_spares.sav_config)
2184                         VERIFY(nvlist_remove(spa->spa_spares.sav_config,
2185                             ZPOOL_CONFIG_SPARES, DATA_TYPE_NVLIST_ARRAY) == 0);
2186                 else
2187                         VERIFY(nvlist_alloc(&spa->spa_spares.sav_config,
2188                             NV_UNIQUE_NAME, KM_SLEEP) == 0);
2189                 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
2190                     ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
2191                 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2192                 spa_load_spares(spa);
2193                 spa_config_exit(spa, SCL_ALL, FTAG);
2194                 spa->spa_spares.sav_sync = B_TRUE;
2195         }
2196         if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
2197             &l2cache, &nl2cache) == 0) {
2198                 if (spa->spa_l2cache.sav_config)
2199                         VERIFY(nvlist_remove(spa->spa_l2cache.sav_config,
2200                             ZPOOL_CONFIG_L2CACHE, DATA_TYPE_NVLIST_ARRAY) == 0);
2201                 else
2202                         VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config,
2203                             NV_UNIQUE_NAME, KM_SLEEP) == 0);
2204                 VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
2205                     ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
2206                 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2207                 spa_load_l2cache(spa);
2208                 spa_config_exit(spa, SCL_ALL, FTAG);
2209                 spa->spa_l2cache.sav_sync = B_TRUE;
2210         }
2211
2212         if (spa_mode & FWRITE) {
2213                 /*
2214                  * Update the config cache to include the newly-imported pool.
2215                  */
2216                 spa_config_update_common(spa, SPA_CONFIG_UPDATE_POOL, isroot);
2217         }
2218
2219         spa->spa_import_faulted = B_FALSE;
2220         mutex_exit(&spa_namespace_lock);
2221
2222         return (0);
2223 }
2224
2225 #if defined(sun)
2226 #ifdef _KERNEL
2227 /*
2228  * Build a "root" vdev for a top level vdev read in from a rootpool
2229  * device label.
2230  */
2231 static void
2232 spa_build_rootpool_config(nvlist_t *config)
2233 {
2234         nvlist_t *nvtop, *nvroot;
2235         uint64_t pgid;
2236
2237         /*
2238          * Add this top-level vdev to the child array.
2239          */
2240         VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvtop)
2241             == 0);
2242         VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pgid)
2243             == 0);
2244
2245         /*
2246          * Put this pool's top-level vdevs into a root vdev.
2247          */
2248         VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2249         VERIFY(nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT)
2250             == 0);
2251         VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_ID, 0ULL) == 0);
2252         VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_GUID, pgid) == 0);
2253         VERIFY(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
2254             &nvtop, 1) == 0);
2255
2256         /*
2257          * Replace the existing vdev_tree with the new root vdev in
2258          * this pool's configuration (remove the old, add the new).
2259          */
2260         VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, nvroot) == 0);
2261         nvlist_free(nvroot);
2262 }
2263
2264 /*
2265  * Get the root pool information from the root disk, then import the root pool
2266  * during the system boot up time.
2267  */
2268 extern int vdev_disk_read_rootlabel(char *, char *, nvlist_t **);
2269
2270 int
2271 spa_check_rootconf(char *devpath, char *devid, nvlist_t **bestconf,
2272     uint64_t *besttxg)
2273 {
2274         nvlist_t *config;
2275         uint64_t txg;
2276         int error;
2277
2278         if (error = vdev_disk_read_rootlabel(devpath, devid, &config))
2279                 return (error);
2280
2281         VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, &txg) == 0);
2282
2283         if (bestconf != NULL)
2284                 *bestconf = config;
2285         else
2286                 nvlist_free(config);
2287         *besttxg = txg;
2288         return (0);
2289 }
2290
2291 boolean_t
2292 spa_rootdev_validate(nvlist_t *nv)
2293 {
2294         uint64_t ival;
2295
2296         if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE, &ival) == 0 ||
2297             nvlist_lookup_uint64(nv, ZPOOL_CONFIG_FAULTED, &ival) == 0 ||
2298             nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVED, &ival) == 0)
2299                 return (B_FALSE);
2300
2301         return (B_TRUE);
2302 }
2303
2304
2305 /*
2306  * Given the boot device's physical path or devid, check if the device
2307  * is in a valid state.  If so, return the configuration from the vdev
2308  * label.
2309  */
2310 int
2311 spa_get_rootconf(char *devpath, char *devid, nvlist_t **bestconf)
2312 {
2313         nvlist_t *conf = NULL;
2314         uint64_t txg = 0;
2315         nvlist_t *nvtop, **child;
2316         char *type;
2317         char *bootpath = NULL;
2318         uint_t children, c;
2319         char *tmp;
2320         int error;
2321
2322         if (devpath && ((tmp = strchr(devpath, ' ')) != NULL))
2323                 *tmp = '\0';
2324         if (error = spa_check_rootconf(devpath, devid, &conf, &txg)) {
2325                 cmn_err(CE_NOTE, "error reading device label");
2326                 return (error);
2327         }
2328         if (txg == 0) {
2329                 cmn_err(CE_NOTE, "this device is detached");
2330                 nvlist_free(conf);
2331                 return (EINVAL);
2332         }
2333
2334         VERIFY(nvlist_lookup_nvlist(conf, ZPOOL_CONFIG_VDEV_TREE,
2335             &nvtop) == 0);
2336         VERIFY(nvlist_lookup_string(nvtop, ZPOOL_CONFIG_TYPE, &type) == 0);
2337
2338         if (strcmp(type, VDEV_TYPE_DISK) == 0) {
2339                 if (spa_rootdev_validate(nvtop)) {
2340                         goto out;
2341                 } else {
2342                         nvlist_free(conf);
2343                         return (EINVAL);
2344                 }
2345         }
2346
2347         ASSERT(strcmp(type, VDEV_TYPE_MIRROR) == 0);
2348
2349         VERIFY(nvlist_lookup_nvlist_array(nvtop, ZPOOL_CONFIG_CHILDREN,
2350             &child, &children) == 0);
2351
2352         /*
2353          * Go thru vdevs in the mirror to see if the given device
2354          * has the most recent txg. Only the device with the most
2355          * recent txg has valid information and should be booted.
2356          */
2357         for (c = 0; c < children; c++) {
2358                 char *cdevid, *cpath;
2359                 uint64_t tmptxg;
2360
2361                 if (nvlist_lookup_string(child[c], ZPOOL_CONFIG_PHYS_PATH,
2362                     &cpath) != 0)
2363                         return (EINVAL);
2364                 if (nvlist_lookup_string(child[c], ZPOOL_CONFIG_DEVID,
2365                     &cdevid) != 0)
2366                         return (EINVAL);
2367                 if ((spa_check_rootconf(cpath, cdevid, NULL,
2368                     &tmptxg) == 0) && (tmptxg > txg)) {
2369                         txg = tmptxg;
2370                         VERIFY(nvlist_lookup_string(child[c],
2371                             ZPOOL_CONFIG_PATH, &bootpath) == 0);
2372                 }
2373         }
2374
2375         /* Does the best device match the one we've booted from? */
2376         if (bootpath) {
2377                 cmn_err(CE_NOTE, "try booting from '%s'", bootpath);
2378                 return (EINVAL);
2379         }
2380 out:
2381         *bestconf = conf;
2382         return (0);
2383 }
2384
2385 /*
2386  * Import a root pool.
2387  *
2388  * For x86. devpath_list will consist of devid and/or physpath name of
2389  * the vdev (e.g. "id1,sd@SSEAGATE..." or "/pci@1f,0/ide@d/disk@0,0:a").
2390  * The GRUB "findroot" command will return the vdev we should boot.
2391  *
2392  * For Sparc, devpath_list consists the physpath name of the booting device
2393  * no matter the rootpool is a single device pool or a mirrored pool.
2394  * e.g.
2395  *      "/pci@1f,0/ide@d/disk@0,0:a"
2396  */
2397 int
2398 spa_import_rootpool(char *devpath, char *devid)
2399 {
2400         nvlist_t *conf = NULL;
2401         char *pname;
2402         int error;
2403
2404         /*
2405          * Get the vdev pathname and configuation from the most
2406          * recently updated vdev (highest txg).
2407          */
2408         if (error = spa_get_rootconf(devpath, devid, &conf))
2409                 goto msg_out;
2410
2411         /*
2412          * Add type "root" vdev to the config.
2413          */
2414         spa_build_rootpool_config(conf);
2415
2416         VERIFY(nvlist_lookup_string(conf, ZPOOL_CONFIG_POOL_NAME, &pname) == 0);
2417
2418         /*
2419          * We specify 'allowfaulted' for this to be treated like spa_open()
2420          * instead of spa_import().  This prevents us from marking vdevs as
2421          * persistently unavailable, and generates FMA ereports as if it were a
2422          * pool open, not import.
2423          */
2424         error = spa_import_common(pname, conf, NULL, B_TRUE, B_TRUE);
2425         if (error == EEXIST)
2426                 error = 0;
2427
2428         nvlist_free(conf);
2429         return (error);
2430
2431 msg_out:
2432         cmn_err(CE_NOTE, "\n"
2433             "  ***************************************************  \n"
2434             "  *  This device is not bootable!                   *  \n"
2435             "  *  It is either offlined or detached or faulted.  *  \n"
2436             "  *  Please try to boot from a different device.    *  \n"
2437             "  ***************************************************  ");
2438
2439         return (error);
2440 }
2441 #endif
2442 #endif
2443
2444 /*
2445  * Import a non-root pool into the system.
2446  */
2447 int
2448 spa_import(const char *pool, nvlist_t *config, nvlist_t *props)
2449 {
2450         return (spa_import_common(pool, config, props, B_FALSE, B_FALSE));
2451 }
2452
2453 int
2454 spa_import_faulted(const char *pool, nvlist_t *config, nvlist_t *props)
2455 {
2456         return (spa_import_common(pool, config, props, B_FALSE, B_TRUE));
2457 }
2458
2459
2460 /*
2461  * This (illegal) pool name is used when temporarily importing a spa_t in order
2462  * to get the vdev stats associated with the imported devices.
2463  */
2464 #define TRYIMPORT_NAME  "$import"
2465
2466 nvlist_t *
2467 spa_tryimport(nvlist_t *tryconfig)
2468 {
2469         nvlist_t *config = NULL;
2470         char *poolname;
2471         spa_t *spa;
2472         uint64_t state;
2473
2474         if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname))
2475                 return (NULL);
2476
2477         if (nvlist_lookup_uint64(tryconfig, ZPOOL_CONFIG_POOL_STATE, &state))
2478                 return (NULL);
2479
2480         /*
2481          * Create and initialize the spa structure.
2482          */
2483         mutex_enter(&spa_namespace_lock);
2484         spa = spa_add(TRYIMPORT_NAME, NULL);
2485         spa_activate(spa);
2486
2487         /*
2488          * Pass off the heavy lifting to spa_load().
2489          * Pass TRUE for mosconfig because the user-supplied config
2490          * is actually the one to trust when doing an import.
2491          */
2492         (void) spa_load(spa, tryconfig, SPA_LOAD_TRYIMPORT, B_TRUE);
2493
2494         /*
2495          * If 'tryconfig' was at least parsable, return the current config.
2496          */
2497         if (spa->spa_root_vdev != NULL) {
2498                 config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
2499                 VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME,
2500                     poolname) == 0);
2501                 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE,
2502                     state) == 0);
2503                 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_TIMESTAMP,
2504                     spa->spa_uberblock.ub_timestamp) == 0);
2505
2506                 /*
2507                  * If the bootfs property exists on this pool then we
2508                  * copy it out so that external consumers can tell which
2509                  * pools are bootable.
2510                  */
2511                 if (spa->spa_bootfs) {
2512                         char *tmpname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2513
2514                         /*
2515                          * We have to play games with the name since the
2516                          * pool was opened as TRYIMPORT_NAME.
2517                          */
2518                         if (dsl_dsobj_to_dsname(spa_name(spa),
2519                             spa->spa_bootfs, tmpname) == 0) {
2520                                 char *cp;
2521                                 char *dsname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2522
2523                                 cp = strchr(tmpname, '/');
2524                                 if (cp == NULL) {
2525                                         (void) strlcpy(dsname, tmpname,
2526                                             MAXPATHLEN);
2527                                 } else {
2528                                         (void) snprintf(dsname, MAXPATHLEN,
2529                                             "%s/%s", poolname, ++cp);
2530                                 }
2531                                 VERIFY(nvlist_add_string(config,
2532                                     ZPOOL_CONFIG_BOOTFS, dsname) == 0);
2533                                 kmem_free(dsname, MAXPATHLEN);
2534                         }
2535                         kmem_free(tmpname, MAXPATHLEN);
2536                 }
2537
2538                 /*
2539                  * Add the list of hot spares and level 2 cache devices.
2540                  */
2541                 spa_add_spares(spa, config);
2542                 spa_add_l2cache(spa, config);
2543         }
2544
2545         spa_unload(spa);
2546         spa_deactivate(spa);
2547         spa_remove(spa);
2548         mutex_exit(&spa_namespace_lock);
2549
2550         return (config);
2551 }
2552
2553 /*
2554  * Pool export/destroy
2555  *
2556  * The act of destroying or exporting a pool is very simple.  We make sure there
2557  * is no more pending I/O and any references to the pool are gone.  Then, we
2558  * update the pool state and sync all the labels to disk, removing the
2559  * configuration from the cache afterwards.
2560  */
2561 static int
2562 spa_export_common(char *pool, int new_state, nvlist_t **oldconfig,
2563     boolean_t force)
2564 {
2565         spa_t *spa;
2566
2567         if (oldconfig)
2568                 *oldconfig = NULL;
2569
2570         if (!(spa_mode & FWRITE))
2571                 return (EROFS);
2572
2573         mutex_enter(&spa_namespace_lock);
2574         if ((spa = spa_lookup(pool)) == NULL) {
2575                 mutex_exit(&spa_namespace_lock);
2576                 return (ENOENT);
2577         }
2578
2579         /*
2580          * Put a hold on the pool, drop the namespace lock, stop async tasks,
2581          * reacquire the namespace lock, and see if we can export.
2582          */
2583         spa_open_ref(spa, FTAG);
2584         mutex_exit(&spa_namespace_lock);
2585         spa_async_suspend(spa);
2586         mutex_enter(&spa_namespace_lock);
2587         spa_close(spa, FTAG);
2588
2589         /*
2590          * The pool will be in core if it's openable,
2591          * in which case we can modify its state.
2592          */
2593         if (spa->spa_state != POOL_STATE_UNINITIALIZED && spa->spa_sync_on) {
2594                 /*
2595                  * Objsets may be open only because they're dirty, so we
2596                  * have to force it to sync before checking spa_refcnt.
2597                  */
2598                 txg_wait_synced(spa->spa_dsl_pool, 0);
2599
2600                 /*
2601                  * A pool cannot be exported or destroyed if there are active
2602                  * references.  If we are resetting a pool, allow references by
2603                  * fault injection handlers.
2604                  */
2605                 if (!spa_refcount_zero(spa) ||
2606                     (spa->spa_inject_ref != 0 &&
2607                     new_state != POOL_STATE_UNINITIALIZED)) {
2608                         spa_async_resume(spa);
2609                         mutex_exit(&spa_namespace_lock);
2610                         return (EBUSY);
2611                 }
2612
2613                 /*
2614                  * A pool cannot be exported if it has an active shared spare.
2615                  * This is to prevent other pools stealing the active spare
2616                  * from an exported pool. At user's own will, such pool can
2617                  * be forcedly exported.
2618                  */
2619                 if (!force && new_state == POOL_STATE_EXPORTED &&
2620                     spa_has_active_shared_spare(spa)) {
2621                         spa_async_resume(spa);
2622                         mutex_exit(&spa_namespace_lock);
2623                         return (EXDEV);
2624                 }
2625
2626                 /*
2627                  * We want this to be reflected on every label,
2628                  * so mark them all dirty.  spa_unload() will do the
2629                  * final sync that pushes these changes out.
2630                  */
2631                 if (new_state != POOL_STATE_UNINITIALIZED) {
2632                         spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2633                         spa->spa_state = new_state;
2634                         spa->spa_final_txg = spa_last_synced_txg(spa) + 1;
2635                         vdev_config_dirty(spa->spa_root_vdev);
2636                         spa_config_exit(spa, SCL_ALL, FTAG);
2637                 }
2638         }
2639
2640         spa_event_notify(spa, NULL, ESC_ZFS_POOL_DESTROY);
2641
2642         if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
2643                 spa_unload(spa);
2644                 spa_deactivate(spa);
2645         }
2646
2647         if (oldconfig && spa->spa_config)
2648                 VERIFY(nvlist_dup(spa->spa_config, oldconfig, 0) == 0);
2649
2650         if (new_state != POOL_STATE_UNINITIALIZED) {
2651                 spa_config_sync(spa, B_TRUE, B_TRUE);
2652                 spa_remove(spa);
2653         }
2654         mutex_exit(&spa_namespace_lock);
2655
2656         return (0);
2657 }
2658
2659 /*
2660  * Destroy a storage pool.
2661  */
2662 int
2663 spa_destroy(char *pool)
2664 {
2665         return (spa_export_common(pool, POOL_STATE_DESTROYED, NULL, B_FALSE));
2666 }
2667
2668 /*
2669  * Export a storage pool.
2670  */
2671 int
2672 spa_export(char *pool, nvlist_t **oldconfig, boolean_t force)
2673 {
2674         return (spa_export_common(pool, POOL_STATE_EXPORTED, oldconfig, force));
2675 }
2676
2677 /*
2678  * Similar to spa_export(), this unloads the spa_t without actually removing it
2679  * from the namespace in any way.
2680  */
2681 int
2682 spa_reset(char *pool)
2683 {
2684         return (spa_export_common(pool, POOL_STATE_UNINITIALIZED, NULL,
2685             B_FALSE));
2686 }
2687
2688 /*
2689  * ==========================================================================
2690  * Device manipulation
2691  * ==========================================================================
2692  */
2693
2694 /*
2695  * Add a device to a storage pool.
2696  */
2697 int
2698 spa_vdev_add(spa_t *spa, nvlist_t *nvroot)
2699 {
2700         uint64_t txg;
2701         int c, error;
2702         vdev_t *rvd = spa->spa_root_vdev;
2703         vdev_t *vd, *tvd;
2704         nvlist_t **spares, **l2cache;
2705         uint_t nspares, nl2cache;
2706
2707         txg = spa_vdev_enter(spa);
2708
2709         if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0,
2710             VDEV_ALLOC_ADD)) != 0)
2711                 return (spa_vdev_exit(spa, NULL, txg, error));
2712
2713         spa->spa_pending_vdev = vd;     /* spa_vdev_exit() will clear this */
2714
2715         if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, &spares,
2716             &nspares) != 0)
2717                 nspares = 0;
2718
2719         if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, &l2cache,
2720             &nl2cache) != 0)
2721                 nl2cache = 0;
2722
2723         if (vd->vdev_children == 0 && nspares == 0 && nl2cache == 0)
2724                 return (spa_vdev_exit(spa, vd, txg, EINVAL));
2725
2726         if (vd->vdev_children != 0 &&
2727             (error = vdev_create(vd, txg, B_FALSE)) != 0)
2728                 return (spa_vdev_exit(spa, vd, txg, error));
2729
2730         /*
2731          * We must validate the spares and l2cache devices after checking the
2732          * children.  Otherwise, vdev_inuse() will blindly overwrite the spare.
2733          */
2734         if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0)
2735                 return (spa_vdev_exit(spa, vd, txg, error));
2736
2737         /*
2738          * Transfer each new top-level vdev from vd to rvd.
2739          */
2740         for (c = 0; c < vd->vdev_children; c++) {
2741                 tvd = vd->vdev_child[c];
2742                 vdev_remove_child(vd, tvd);
2743                 tvd->vdev_id = rvd->vdev_children;
2744                 vdev_add_child(rvd, tvd);
2745                 vdev_config_dirty(tvd);
2746         }
2747
2748         if (nspares != 0) {
2749                 spa_set_aux_vdevs(&spa->spa_spares, spares, nspares,
2750                     ZPOOL_CONFIG_SPARES);
2751                 spa_load_spares(spa);
2752                 spa->spa_spares.sav_sync = B_TRUE;
2753         }
2754
2755         if (nl2cache != 0) {
2756                 spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache,
2757                     ZPOOL_CONFIG_L2CACHE);
2758                 spa_load_l2cache(spa);
2759                 spa->spa_l2cache.sav_sync = B_TRUE;
2760         }
2761
2762         /*
2763          * We have to be careful when adding new vdevs to an existing pool.
2764          * If other threads start allocating from these vdevs before we
2765          * sync the config cache, and we lose power, then upon reboot we may
2766          * fail to open the pool because there are DVAs that the config cache
2767          * can't translate.  Therefore, we first add the vdevs without
2768          * initializing metaslabs; sync the config cache (via spa_vdev_exit());
2769          * and then let spa_config_update() initialize the new metaslabs.
2770          *
2771          * spa_load() checks for added-but-not-initialized vdevs, so that
2772          * if we lose power at any point in this sequence, the remaining
2773          * steps will be completed the next time we load the pool.
2774          */
2775         (void) spa_vdev_exit(spa, vd, txg, 0);
2776
2777         mutex_enter(&spa_namespace_lock);
2778         spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
2779         mutex_exit(&spa_namespace_lock);
2780
2781         return (0);
2782 }
2783
2784 /*
2785  * Attach a device to a mirror.  The arguments are the path to any device
2786  * in the mirror, and the nvroot for the new device.  If the path specifies
2787  * a device that is not mirrored, we automatically insert the mirror vdev.
2788  *
2789  * If 'replacing' is specified, the new device is intended to replace the
2790  * existing device; in this case the two devices are made into their own
2791  * mirror using the 'replacing' vdev, which is functionally identical to
2792  * the mirror vdev (it actually reuses all the same ops) but has a few
2793  * extra rules: you can't attach to it after it's been created, and upon
2794  * completion of resilvering, the first disk (the one being replaced)
2795  * is automatically detached.
2796  */
2797 int
2798 spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing)
2799 {
2800         uint64_t txg, open_txg;
2801         vdev_t *rvd = spa->spa_root_vdev;
2802         vdev_t *oldvd, *newvd, *newrootvd, *pvd, *tvd;
2803         vdev_ops_t *pvops;
2804         dmu_tx_t *tx;
2805         char *oldvdpath, *newvdpath;
2806         int newvd_isspare;
2807         int error;
2808
2809         txg = spa_vdev_enter(spa);
2810
2811         oldvd = spa_lookup_by_guid(spa, guid, B_FALSE);
2812
2813         if (oldvd == NULL)
2814                 return (spa_vdev_exit(spa, NULL, txg, ENODEV));
2815
2816         if (!oldvd->vdev_ops->vdev_op_leaf)
2817                 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
2818
2819         pvd = oldvd->vdev_parent;
2820
2821         if ((error = spa_config_parse(spa, &newrootvd, nvroot, NULL, 0,
2822             VDEV_ALLOC_ADD)) != 0)
2823                 return (spa_vdev_exit(spa, NULL, txg, EINVAL));
2824
2825         if (newrootvd->vdev_children != 1)
2826                 return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
2827
2828         newvd = newrootvd->vdev_child[0];
2829
2830         if (!newvd->vdev_ops->vdev_op_leaf)
2831                 return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
2832
2833         if ((error = vdev_create(newrootvd, txg, replacing)) != 0)
2834                 return (spa_vdev_exit(spa, newrootvd, txg, error));
2835
2836         /*
2837          * Spares can't replace logs
2838          */
2839         if (oldvd->vdev_top->vdev_islog && newvd->vdev_isspare)
2840                 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2841
2842         if (!replacing) {
2843                 /*
2844                  * For attach, the only allowable parent is a mirror or the root
2845                  * vdev.
2846                  */
2847                 if (pvd->vdev_ops != &vdev_mirror_ops &&
2848                     pvd->vdev_ops != &vdev_root_ops)
2849                         return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2850
2851                 pvops = &vdev_mirror_ops;
2852         } else {
2853                 /*
2854                  * Active hot spares can only be replaced by inactive hot
2855                  * spares.
2856                  */
2857                 if (pvd->vdev_ops == &vdev_spare_ops &&
2858                     pvd->vdev_child[1] == oldvd &&
2859                     !spa_has_spare(spa, newvd->vdev_guid))
2860                         return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2861
2862                 /*
2863                  * If the source is a hot spare, and the parent isn't already a
2864                  * spare, then we want to create a new hot spare.  Otherwise, we
2865                  * want to create a replacing vdev.  The user is not allowed to
2866                  * attach to a spared vdev child unless the 'isspare' state is
2867                  * the same (spare replaces spare, non-spare replaces
2868                  * non-spare).
2869                  */
2870                 if (pvd->vdev_ops == &vdev_replacing_ops)
2871                         return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2872                 else if (pvd->vdev_ops == &vdev_spare_ops &&
2873                     newvd->vdev_isspare != oldvd->vdev_isspare)
2874                         return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2875                 else if (pvd->vdev_ops != &vdev_spare_ops &&
2876                     newvd->vdev_isspare)
2877                         pvops = &vdev_spare_ops;
2878                 else
2879                         pvops = &vdev_replacing_ops;
2880         }
2881
2882         /*
2883          * Compare the new device size with the replaceable/attachable
2884          * device size.
2885          */
2886         if (newvd->vdev_psize < vdev_get_rsize(oldvd))
2887                 return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW));
2888
2889         /*
2890          * The new device cannot have a higher alignment requirement
2891          * than the top-level vdev.
2892          */
2893         if (newvd->vdev_ashift > oldvd->vdev_top->vdev_ashift)
2894                 return (spa_vdev_exit(spa, newrootvd, txg, EDOM));
2895
2896         /*
2897          * If this is an in-place replacement, update oldvd's path and devid
2898          * to make it distinguishable from newvd, and unopenable from now on.
2899          */
2900         if (strcmp(oldvd->vdev_path, newvd->vdev_path) == 0) {
2901                 spa_strfree(oldvd->vdev_path);
2902                 oldvd->vdev_path = kmem_alloc(strlen(newvd->vdev_path) + 5,
2903                     KM_SLEEP);
2904                 (void) sprintf(oldvd->vdev_path, "%s/%s",
2905                     newvd->vdev_path, "old");
2906                 if (oldvd->vdev_devid != NULL) {
2907                         spa_strfree(oldvd->vdev_devid);
2908                         oldvd->vdev_devid = NULL;
2909                 }
2910         }
2911
2912         /*
2913          * If the parent is not a mirror, or if we're replacing, insert the new
2914          * mirror/replacing/spare vdev above oldvd.
2915          */
2916         if (pvd->vdev_ops != pvops)
2917                 pvd = vdev_add_parent(oldvd, pvops);
2918
2919         ASSERT(pvd->vdev_top->vdev_parent == rvd);
2920         ASSERT(pvd->vdev_ops == pvops);
2921         ASSERT(oldvd->vdev_parent == pvd);
2922
2923         /*
2924          * Extract the new device from its root and add it to pvd.
2925          */
2926         vdev_remove_child(newrootvd, newvd);
2927         newvd->vdev_id = pvd->vdev_children;
2928         vdev_add_child(pvd, newvd);
2929
2930         /*
2931          * If newvd is smaller than oldvd, but larger than its rsize,
2932          * the addition of newvd may have decreased our parent's asize.
2933          */
2934         pvd->vdev_asize = MIN(pvd->vdev_asize, newvd->vdev_asize);
2935
2936         tvd = newvd->vdev_top;
2937         ASSERT(pvd->vdev_top == tvd);
2938         ASSERT(tvd->vdev_parent == rvd);
2939
2940         vdev_config_dirty(tvd);
2941
2942         /*
2943          * Set newvd's DTL to [TXG_INITIAL, open_txg].  It will propagate
2944          * upward when spa_vdev_exit() calls vdev_dtl_reassess().
2945          */
2946         open_txg = txg + TXG_CONCURRENT_STATES - 1;
2947
2948         mutex_enter(&newvd->vdev_dtl_lock);
2949         space_map_add(&newvd->vdev_dtl_map, TXG_INITIAL,
2950             open_txg - TXG_INITIAL + 1);
2951         mutex_exit(&newvd->vdev_dtl_lock);
2952
2953         if (newvd->vdev_isspare)
2954                 spa_spare_activate(newvd);
2955         oldvdpath = spa_strdup(oldvd->vdev_path);
2956         newvdpath = spa_strdup(newvd->vdev_path);
2957         newvd_isspare = newvd->vdev_isspare;
2958
2959         /*
2960          * Mark newvd's DTL dirty in this txg.
2961          */
2962         vdev_dirty(tvd, VDD_DTL, newvd, txg);
2963
2964         (void) spa_vdev_exit(spa, newrootvd, open_txg, 0);
2965
2966         tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
2967         if (dmu_tx_assign(tx, TXG_WAIT) == 0) {
2968                 spa_history_internal_log(LOG_POOL_VDEV_ATTACH, spa, tx,
2969                     CRED(),  "%s vdev=%s %s vdev=%s",
2970                     replacing && newvd_isspare ? "spare in" :
2971                     replacing ? "replace" : "attach", newvdpath,
2972                     replacing ? "for" : "to", oldvdpath);
2973                 dmu_tx_commit(tx);
2974         } else {
2975                 dmu_tx_abort(tx);
2976         }
2977
2978         spa_strfree(oldvdpath);
2979         spa_strfree(newvdpath);
2980
2981         /*
2982          * Kick off a resilver to update newvd.
2983          */
2984         VERIFY3U(spa_scrub(spa, POOL_SCRUB_RESILVER), ==, 0);
2985
2986         return (0);
2987 }
2988
2989 /*
2990  * Detach a device from a mirror or replacing vdev.
2991  * If 'replace_done' is specified, only detach if the parent
2992  * is a replacing vdev.
2993  */
2994 int
2995 spa_vdev_detach(spa_t *spa, uint64_t guid, int replace_done)
2996 {
2997         uint64_t txg;
2998         int c, t, error;
2999         vdev_t *rvd = spa->spa_root_vdev;
3000         vdev_t *vd, *pvd, *cvd, *tvd;
3001         boolean_t unspare = B_FALSE;
3002         uint64_t unspare_guid;
3003         size_t len;
3004
3005         txg = spa_vdev_enter(spa);
3006
3007         vd = spa_lookup_by_guid(spa, guid, B_FALSE);
3008
3009         if (vd == NULL)
3010                 return (spa_vdev_exit(spa, NULL, txg, ENODEV));
3011
3012         if (!vd->vdev_ops->vdev_op_leaf)
3013                 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
3014
3015         pvd = vd->vdev_parent;
3016
3017         /*
3018          * If replace_done is specified, only remove this device if it's
3019          * the first child of a replacing vdev.  For the 'spare' vdev, either
3020          * disk can be removed.
3021          */
3022         if (replace_done) {
3023                 if (pvd->vdev_ops == &vdev_replacing_ops) {
3024                         if (vd->vdev_id != 0)
3025                                 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
3026                 } else if (pvd->vdev_ops != &vdev_spare_ops) {
3027                         return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
3028                 }
3029         }
3030
3031         ASSERT(pvd->vdev_ops != &vdev_spare_ops ||
3032             spa_version(spa) >= SPA_VERSION_SPARES);
3033
3034         /*
3035          * Only mirror, replacing, and spare vdevs support detach.
3036          */
3037         if (pvd->vdev_ops != &vdev_replacing_ops &&
3038             pvd->vdev_ops != &vdev_mirror_ops &&
3039             pvd->vdev_ops != &vdev_spare_ops)
3040                 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
3041
3042         /*
3043          * If there's only one replica, you can't detach it.
3044          */
3045         if (pvd->vdev_children <= 1)
3046                 return (spa_vdev_exit(spa, NULL, txg, EBUSY));
3047
3048         /*
3049          * If all siblings have non-empty DTLs, this device may have the only
3050          * valid copy of the data, which means we cannot safely detach it.
3051          *
3052          * XXX -- as in the vdev_offline() case, we really want a more
3053          * precise DTL check.
3054          */
3055         for (c = 0; c < pvd->vdev_children; c++) {
3056                 uint64_t dirty;
3057
3058                 cvd = pvd->vdev_child[c];
3059                 if (cvd == vd)
3060                         continue;
3061                 if (vdev_is_dead(cvd))
3062                         continue;
3063                 mutex_enter(&cvd->vdev_dtl_lock);
3064                 dirty = cvd->vdev_dtl_map.sm_space |
3065                     cvd->vdev_dtl_scrub.sm_space;
3066                 mutex_exit(&cvd->vdev_dtl_lock);
3067                 if (!dirty)
3068                         break;
3069         }
3070
3071         if (c == pvd->vdev_children)
3072                 return (spa_vdev_exit(spa, NULL, txg, EBUSY));
3073
3074         /*
3075          * If we are detaching the second disk from a replacing vdev, then
3076          * check to see if we changed the original vdev's path to have "/old"
3077          * at the end in spa_vdev_attach().  If so, undo that change now.
3078          */
3079         if (pvd->vdev_ops == &vdev_replacing_ops && vd->vdev_id == 1 &&
3080             pvd->vdev_child[0]->vdev_path != NULL &&
3081             pvd->vdev_child[1]->vdev_path != NULL) {
3082                 ASSERT(pvd->vdev_child[1] == vd);
3083                 cvd = pvd->vdev_child[0];
3084                 len = strlen(vd->vdev_path);
3085                 if (strncmp(cvd->vdev_path, vd->vdev_path, len) == 0 &&
3086                     strcmp(cvd->vdev_path + len, "/old") == 0) {
3087                         spa_strfree(cvd->vdev_path);
3088                         cvd->vdev_path = spa_strdup(vd->vdev_path);
3089                 }
3090         }
3091
3092         /*
3093          * If we are detaching the original disk from a spare, then it implies
3094          * that the spare should become a real disk, and be removed from the
3095          * active spare list for the pool.
3096          */
3097         if (pvd->vdev_ops == &vdev_spare_ops &&
3098             vd->vdev_id == 0)
3099                 unspare = B_TRUE;
3100
3101         /*
3102          * Erase the disk labels so the disk can be used for other things.
3103          * This must be done after all other error cases are handled,
3104          * but before we disembowel vd (so we can still do I/O to it).
3105          * But if we can't do it, don't treat the error as fatal --
3106          * it may be that the unwritability of the disk is the reason
3107          * it's being detached!
3108          */
3109         error = vdev_label_init(vd, 0, VDEV_LABEL_REMOVE);
3110
3111         /*
3112          * Remove vd from its parent and compact the parent's children.
3113          */
3114         vdev_remove_child(pvd, vd);
3115         vdev_compact_children(pvd);
3116
3117         /*
3118          * Remember one of the remaining children so we can get tvd below.
3119          */
3120         cvd = pvd->vdev_child[0];
3121
3122         /*
3123          * If we need to remove the remaining child from the list of hot spares,
3124          * do it now, marking the vdev as no longer a spare in the process.  We
3125          * must do this before vdev_remove_parent(), because that can change the
3126          * GUID if it creates a new toplevel GUID.
3127          */
3128         if (unspare) {
3129                 ASSERT(cvd->vdev_isspare);
3130                 spa_spare_remove(cvd);
3131                 unspare_guid = cvd->vdev_guid;
3132         }
3133
3134         /*
3135          * If the parent mirror/replacing vdev only has one child,
3136          * the parent is no longer needed.  Remove it from the tree.
3137          */
3138         if (pvd->vdev_children == 1)
3139                 vdev_remove_parent(cvd);
3140
3141         /*
3142          * We don't set tvd until now because the parent we just removed
3143          * may have been the previous top-level vdev.
3144          */
3145         tvd = cvd->vdev_top;
3146         ASSERT(tvd->vdev_parent == rvd);
3147
3148         /*
3149          * Reevaluate the parent vdev state.
3150          */
3151         vdev_propagate_state(cvd);
3152
3153         /*
3154          * If the device we just detached was smaller than the others, it may be
3155          * possible to add metaslabs (i.e. grow the pool).  vdev_metaslab_init()
3156          * can't fail because the existing metaslabs are already in core, so
3157          * there's nothing to read from disk.
3158          */
3159         VERIFY(vdev_metaslab_init(tvd, txg) == 0);
3160
3161         vdev_config_dirty(tvd);
3162
3163         /*
3164          * Mark vd's DTL as dirty in this txg.  vdev_dtl_sync() will see that
3165          * vd->vdev_detached is set and free vd's DTL object in syncing context.
3166          * But first make sure we're not on any *other* txg's DTL list, to
3167          * prevent vd from being accessed after it's freed.
3168          */
3169         for (t = 0; t < TXG_SIZE; t++)
3170                 (void) txg_list_remove_this(&tvd->vdev_dtl_list, vd, t);
3171         vd->vdev_detached = B_TRUE;
3172         vdev_dirty(tvd, VDD_DTL, vd, txg);
3173
3174         spa_event_notify(spa, vd, ESC_ZFS_VDEV_REMOVE);
3175
3176         error = spa_vdev_exit(spa, vd, txg, 0);
3177
3178         /*
3179          * If this was the removal of the original device in a hot spare vdev,
3180          * then we want to go through and remove the device from the hot spare
3181          * list of every other pool.
3182          */
3183         if (unspare) {
3184                 spa = NULL;
3185                 mutex_enter(&spa_namespace_lock);
3186                 while ((spa = spa_next(spa)) != NULL) {
3187                         if (spa->spa_state != POOL_STATE_ACTIVE)
3188                                 continue;
3189                         spa_open_ref(spa, FTAG);
3190                         mutex_exit(&spa_namespace_lock);
3191                         (void) spa_vdev_remove(spa, unspare_guid, B_TRUE);
3192                         mutex_enter(&spa_namespace_lock);
3193                         spa_close(spa, FTAG);
3194                 }
3195                 mutex_exit(&spa_namespace_lock);
3196         }
3197
3198         return (error);
3199 }
3200
3201 static nvlist_t *
3202 spa_nvlist_lookup_by_guid(nvlist_t **nvpp, int count, uint64_t target_guid)
3203 {
3204         for (int i = 0; i < count; i++) {
3205                 uint64_t guid;
3206
3207                 VERIFY(nvlist_lookup_uint64(nvpp[i], ZPOOL_CONFIG_GUID,
3208                     &guid) == 0);
3209
3210                 if (guid == target_guid)
3211                         return (nvpp[i]);
3212         }
3213
3214         return (NULL);
3215 }
3216
3217 static void
3218 spa_vdev_remove_aux(nvlist_t *config, char *name, nvlist_t **dev, int count,
3219         nvlist_t *dev_to_remove)
3220 {
3221         nvlist_t **newdev = NULL;
3222
3223         if (count > 1)
3224                 newdev = kmem_alloc((count - 1) * sizeof (void *), KM_SLEEP);
3225
3226         for (int i = 0, j = 0; i < count; i++) {
3227                 if (dev[i] == dev_to_remove)
3228                         continue;
3229                 VERIFY(nvlist_dup(dev[i], &newdev[j++], KM_SLEEP) == 0);
3230         }
3231
3232         VERIFY(nvlist_remove(config, name, DATA_TYPE_NVLIST_ARRAY) == 0);
3233         VERIFY(nvlist_add_nvlist_array(config, name, newdev, count - 1) == 0);
3234
3235         for (int i = 0; i < count - 1; i++)
3236                 nvlist_free(newdev[i]);
3237
3238         if (count > 1)
3239                 kmem_free(newdev, (count - 1) * sizeof (void *));
3240 }
3241
3242 /*
3243  * Remove a device from the pool.  Currently, this supports removing only hot
3244  * spares and level 2 ARC devices.
3245  */
3246 int
3247 spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare)
3248 {
3249         vdev_t *vd;
3250         nvlist_t **spares, **l2cache, *nv;
3251         uint_t nspares, nl2cache;
3252         uint64_t txg;
3253         int error = 0;
3254
3255         txg = spa_vdev_enter(spa);
3256
3257         vd = spa_lookup_by_guid(spa, guid, B_FALSE);
3258
3259         if (spa->spa_spares.sav_vdevs != NULL &&
3260             nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
3261             ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0 &&
3262             (nv = spa_nvlist_lookup_by_guid(spares, nspares, guid)) != NULL) {
3263                 /*
3264                  * Only remove the hot spare if it's not currently in use
3265                  * in this pool.
3266                  */
3267                 if (vd == NULL || unspare) {
3268                         spa_vdev_remove_aux(spa->spa_spares.sav_config,
3269                             ZPOOL_CONFIG_SPARES, spares, nspares, nv);
3270                         spa_load_spares(spa);
3271                         spa->spa_spares.sav_sync = B_TRUE;
3272                 } else {
3273                         error = EBUSY;
3274                 }
3275         } else if (spa->spa_l2cache.sav_vdevs != NULL &&
3276             nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
3277             ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0 &&
3278             (nv = spa_nvlist_lookup_by_guid(l2cache, nl2cache, guid)) != NULL) {
3279                 /*
3280                  * Cache devices can always be removed.
3281                  */
3282                 spa_vdev_remove_aux(spa->spa_l2cache.sav_config,
3283                     ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache, nv);
3284                 spa_load_l2cache(spa);
3285                 spa->spa_l2cache.sav_sync = B_TRUE;
3286         } else if (vd != NULL) {
3287                 /*
3288                  * Normal vdevs cannot be removed (yet).
3289                  */
3290                 error = ENOTSUP;
3291         } else {
3292                 /*
3293                  * There is no vdev of any kind with the specified guid.
3294                  */
3295                 error = ENOENT;
3296         }
3297
3298         return (spa_vdev_exit(spa, NULL, txg, error));
3299 }
3300
3301 /*
3302  * Find any device that's done replacing, or a vdev marked 'unspare' that's
3303  * current spared, so we can detach it.
3304  */
3305 static vdev_t *
3306 spa_vdev_resilver_done_hunt(vdev_t *vd)
3307 {
3308         vdev_t *newvd, *oldvd;
3309         int c;
3310
3311         for (c = 0; c < vd->vdev_children; c++) {
3312                 oldvd = spa_vdev_resilver_done_hunt(vd->vdev_child[c]);
3313                 if (oldvd != NULL)
3314                         return (oldvd);
3315         }
3316
3317         /*
3318          * Check for a completed replacement.
3319          */
3320         if (vd->vdev_ops == &vdev_replacing_ops && vd->vdev_children == 2) {
3321                 oldvd = vd->vdev_child[0];
3322                 newvd = vd->vdev_child[1];
3323
3324                 mutex_enter(&newvd->vdev_dtl_lock);
3325                 if (newvd->vdev_dtl_map.sm_space == 0 &&
3326                     newvd->vdev_dtl_scrub.sm_space == 0) {
3327                         mutex_exit(&newvd->vdev_dtl_lock);
3328                         return (oldvd);
3329                 }
3330                 mutex_exit(&newvd->vdev_dtl_lock);
3331         }
3332
3333         /*
3334          * Check for a completed resilver with the 'unspare' flag set.
3335          */
3336         if (vd->vdev_ops == &vdev_spare_ops && vd->vdev_children == 2) {
3337                 newvd = vd->vdev_child[0];
3338                 oldvd = vd->vdev_child[1];
3339
3340                 mutex_enter(&newvd->vdev_dtl_lock);
3341                 if (newvd->vdev_unspare &&
3342                     newvd->vdev_dtl_map.sm_space == 0 &&
3343                     newvd->vdev_dtl_scrub.sm_space == 0) {
3344                         newvd->vdev_unspare = 0;
3345                         mutex_exit(&newvd->vdev_dtl_lock);
3346                         return (oldvd);
3347                 }
3348                 mutex_exit(&newvd->vdev_dtl_lock);
3349         }
3350
3351         return (NULL);
3352 }
3353
3354 static void
3355 spa_vdev_resilver_done(spa_t *spa)
3356 {
3357         vdev_t *vd;
3358         vdev_t *pvd;
3359         uint64_t guid;
3360         uint64_t pguid = 0;
3361
3362         spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
3363
3364         while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) {
3365                 guid = vd->vdev_guid;
3366                 /*
3367                  * If we have just finished replacing a hot spared device, then
3368                  * we need to detach the parent's first child (the original hot
3369                  * spare) as well.
3370                  */
3371                 pvd = vd->vdev_parent;
3372                 if (pvd->vdev_parent->vdev_ops == &vdev_spare_ops &&
3373                     pvd->vdev_id == 0) {
3374                         ASSERT(pvd->vdev_ops == &vdev_replacing_ops);
3375                         ASSERT(pvd->vdev_parent->vdev_children == 2);
3376                         pguid = pvd->vdev_parent->vdev_child[1]->vdev_guid;
3377                 }
3378                 spa_config_exit(spa, SCL_CONFIG, FTAG);
3379                 if (spa_vdev_detach(spa, guid, B_TRUE) != 0)
3380                         return;
3381                 if (pguid != 0 && spa_vdev_detach(spa, pguid, B_TRUE) != 0)
3382                         return;
3383                 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
3384         }
3385
3386         spa_config_exit(spa, SCL_CONFIG, FTAG);
3387 }
3388
3389 /*
3390  * Update the stored path for this vdev.  Dirty the vdev configuration, relying
3391  * on spa_vdev_enter/exit() to synchronize the labels and cache.
3392  */
3393 int
3394 spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath)
3395 {
3396         vdev_t *vd;
3397         uint64_t txg;
3398
3399         txg = spa_vdev_enter(spa);
3400
3401         if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) {
3402                 /*
3403                  * Determine if this is a reference to a hot spare device.  If
3404                  * it is, update the path manually as there is no associated
3405                  * vdev_t that can be synced to disk.
3406                  */
3407                 nvlist_t **spares;
3408                 uint_t i, nspares;
3409
3410                 if (spa->spa_spares.sav_config != NULL) {
3411                         VERIFY(nvlist_lookup_nvlist_array(
3412                             spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES,
3413                             &spares, &nspares) == 0);
3414                         for (i = 0; i < nspares; i++) {
3415                                 uint64_t theguid;
3416                                 VERIFY(nvlist_lookup_uint64(spares[i],
3417                                     ZPOOL_CONFIG_GUID, &theguid) == 0);
3418                                 if (theguid == guid) {
3419                                         VERIFY(nvlist_add_string(spares[i],
3420                                             ZPOOL_CONFIG_PATH, newpath) == 0);
3421                                         spa_load_spares(spa);
3422                                         spa->spa_spares.sav_sync = B_TRUE;
3423                                         return (spa_vdev_exit(spa, NULL, txg,
3424                                             0));
3425                                 }
3426                         }
3427                 }
3428
3429                 return (spa_vdev_exit(spa, NULL, txg, ENOENT));
3430         }
3431
3432         if (!vd->vdev_ops->vdev_op_leaf)
3433                 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
3434
3435         spa_strfree(vd->vdev_path);
3436         vd->vdev_path = spa_strdup(newpath);
3437
3438         vdev_config_dirty(vd->vdev_top);
3439
3440         return (spa_vdev_exit(spa, NULL, txg, 0));
3441 }
3442
3443 /*
3444  * ==========================================================================
3445  * SPA Scrubbing
3446  * ==========================================================================
3447  */
3448
3449 int
3450 spa_scrub(spa_t *spa, pool_scrub_type_t type)
3451 {
3452         ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
3453
3454         if ((uint_t)type >= POOL_SCRUB_TYPES)
3455                 return (ENOTSUP);
3456
3457         /*
3458          * If a resilver was requested, but there is no DTL on a
3459          * writeable leaf device, we have nothing to do.
3460          */
3461         if (type == POOL_SCRUB_RESILVER &&
3462             !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) {
3463                 spa_async_request(spa, SPA_ASYNC_RESILVER_DONE);
3464                 return (0);
3465         }
3466
3467         if (type == POOL_SCRUB_EVERYTHING &&
3468             spa->spa_dsl_pool->dp_scrub_func != SCRUB_FUNC_NONE &&
3469             spa->spa_dsl_pool->dp_scrub_isresilver)
3470                 return (EBUSY);
3471
3472         if (type == POOL_SCRUB_EVERYTHING || type == POOL_SCRUB_RESILVER) {
3473                 return (dsl_pool_scrub_clean(spa->spa_dsl_pool));
3474         } else if (type == POOL_SCRUB_NONE) {
3475                 return (dsl_pool_scrub_cancel(spa->spa_dsl_pool));
3476         } else {
3477                 return (EINVAL);
3478         }
3479 }
3480
3481 /*
3482  * ==========================================================================
3483  * SPA async task processing
3484  * ==========================================================================
3485  */
3486
3487 static void
3488 spa_async_remove(spa_t *spa, vdev_t *vd)
3489 {
3490         if (vd->vdev_remove_wanted) {
3491                 vd->vdev_remove_wanted = 0;
3492                 vdev_set_state(vd, B_FALSE, VDEV_STATE_REMOVED, VDEV_AUX_NONE);
3493                 vdev_clear(spa, vd);
3494                 vdev_state_dirty(vd->vdev_top);
3495         }
3496
3497         for (int c = 0; c < vd->vdev_children; c++)
3498                 spa_async_remove(spa, vd->vdev_child[c]);
3499 }
3500
3501 static void
3502 spa_async_probe(spa_t *spa, vdev_t *vd)
3503 {
3504         if (vd->vdev_probe_wanted) {
3505                 vd->vdev_probe_wanted = 0;
3506                 vdev_reopen(vd);        /* vdev_open() does the actual probe */
3507         }
3508
3509         for (int c = 0; c < vd->vdev_children; c++)
3510                 spa_async_probe(spa, vd->vdev_child[c]);
3511 }
3512
3513 static void
3514 spa_async_thread(void *arg)
3515 {
3516         spa_t *spa = arg;
3517         int tasks;
3518
3519         ASSERT(spa->spa_sync_on);
3520
3521         mutex_enter(&spa->spa_async_lock);
3522         tasks = spa->spa_async_tasks;
3523         spa->spa_async_tasks = 0;
3524         mutex_exit(&spa->spa_async_lock);
3525
3526         /*
3527          * See if the config needs to be updated.
3528          */
3529         if (tasks & SPA_ASYNC_CONFIG_UPDATE) {
3530                 mutex_enter(&spa_namespace_lock);
3531                 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
3532                 mutex_exit(&spa_namespace_lock);
3533         }
3534
3535         /*
3536          * See if any devices need to be marked REMOVED.
3537          */
3538         if (tasks & SPA_ASYNC_REMOVE) {
3539                 spa_vdev_state_enter(spa);
3540                 spa_async_remove(spa, spa->spa_root_vdev);
3541                 for (int i = 0; i < spa->spa_l2cache.sav_count; i++)
3542                         spa_async_remove(spa, spa->spa_l2cache.sav_vdevs[i]);
3543                 for (int i = 0; i < spa->spa_spares.sav_count; i++)
3544                         spa_async_remove(spa, spa->spa_spares.sav_vdevs[i]);
3545                 (void) spa_vdev_state_exit(spa, NULL, 0);
3546         }
3547
3548         /*
3549          * See if any devices need to be probed.
3550          */
3551         if (tasks & SPA_ASYNC_PROBE) {
3552                 spa_vdev_state_enter(spa);
3553                 spa_async_probe(spa, spa->spa_root_vdev);
3554                 (void) spa_vdev_state_exit(spa, NULL, 0);
3555         }
3556
3557         /*
3558          * If any devices are done replacing, detach them.
3559          */
3560         if (tasks & SPA_ASYNC_RESILVER_DONE)
3561                 spa_vdev_resilver_done(spa);
3562
3563         /*
3564          * Kick off a resilver.
3565          */
3566         if (tasks & SPA_ASYNC_RESILVER)
3567                 VERIFY(spa_scrub(spa, POOL_SCRUB_RESILVER) == 0);
3568
3569         /*
3570          * Let the world know that we're done.
3571          */
3572         mutex_enter(&spa->spa_async_lock);
3573         spa->spa_async_thread = NULL;
3574         cv_broadcast(&spa->spa_async_cv);
3575         mutex_exit(&spa->spa_async_lock);
3576         thread_exit();
3577 }
3578
3579 void
3580 spa_async_suspend(spa_t *spa)
3581 {
3582         mutex_enter(&spa->spa_async_lock);
3583         spa->spa_async_suspended++;
3584         while (spa->spa_async_thread != NULL)
3585                 cv_wait(&spa->spa_async_cv, &spa->spa_async_lock);
3586         mutex_exit(&spa->spa_async_lock);
3587 }
3588
3589 void
3590 spa_async_resume(spa_t *spa)
3591 {
3592         mutex_enter(&spa->spa_async_lock);
3593         ASSERT(spa->spa_async_suspended != 0);
3594         spa->spa_async_suspended--;
3595         mutex_exit(&spa->spa_async_lock);
3596 }
3597
3598 static void
3599 spa_async_dispatch(spa_t *spa)
3600 {
3601         mutex_enter(&spa->spa_async_lock);
3602         if (spa->spa_async_tasks && !spa->spa_async_suspended &&
3603             spa->spa_async_thread == NULL &&
3604             rootdir != NULL && !vn_is_readonly(rootdir))
3605                 spa->spa_async_thread = thread_create(NULL, 0,
3606                     spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri);
3607         mutex_exit(&spa->spa_async_lock);
3608 }
3609
3610 void
3611 spa_async_request(spa_t *spa, int task)
3612 {
3613         mutex_enter(&spa->spa_async_lock);
3614         spa->spa_async_tasks |= task;
3615         mutex_exit(&spa->spa_async_lock);
3616 }
3617
3618 /*
3619  * ==========================================================================
3620  * SPA syncing routines
3621  * ==========================================================================
3622  */
3623
3624 static void
3625 spa_sync_deferred_frees(spa_t *spa, uint64_t txg)
3626 {
3627         bplist_t *bpl = &spa->spa_sync_bplist;
3628         dmu_tx_t *tx;
3629         blkptr_t blk;
3630         uint64_t itor = 0;
3631         zio_t *zio;
3632         int error;
3633         uint8_t c = 1;
3634
3635         zio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
3636
3637         while (bplist_iterate(bpl, &itor, &blk) == 0) {
3638                 ASSERT(blk.blk_birth < txg);
3639                 zio_nowait(zio_free(zio, spa, txg, &blk, NULL, NULL,
3640                     ZIO_FLAG_MUSTSUCCEED));
3641         }
3642
3643         error = zio_wait(zio);
3644         ASSERT3U(error, ==, 0);
3645
3646         tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg);
3647         bplist_vacate(bpl, tx);
3648
3649         /*
3650          * Pre-dirty the first block so we sync to convergence faster.
3651          * (Usually only the first block is needed.)
3652          */
3653         dmu_write(spa->spa_meta_objset, spa->spa_sync_bplist_obj, 0, 1, &c, tx);
3654         dmu_tx_commit(tx);
3655 }
3656
3657 static void
3658 spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx)
3659 {
3660         char *packed = NULL;
3661         size_t bufsize;
3662         size_t nvsize = 0;
3663         dmu_buf_t *db;
3664
3665         VERIFY(nvlist_size(nv, &nvsize, NV_ENCODE_XDR) == 0);
3666
3667         /*
3668          * Write full (SPA_CONFIG_BLOCKSIZE) blocks of configuration
3669          * information.  This avoids the dbuf_will_dirty() path and
3670          * saves us a pre-read to get data we don't actually care about.
3671          */
3672         bufsize = P2ROUNDUP(nvsize, SPA_CONFIG_BLOCKSIZE);
3673         packed = kmem_alloc(bufsize, KM_SLEEP);
3674
3675         VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR,
3676             KM_SLEEP) == 0);
3677         bzero(packed + nvsize, bufsize - nvsize);
3678
3679         dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx);
3680
3681         kmem_free(packed, bufsize);
3682
3683         VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db));
3684         dmu_buf_will_dirty(db, tx);
3685         *(uint64_t *)db->db_data = nvsize;
3686         dmu_buf_rele(db, FTAG);
3687 }
3688
3689 static void
3690 spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx,
3691     const char *config, const char *entry)
3692 {
3693         nvlist_t *nvroot;
3694         nvlist_t **list;
3695         int i;
3696
3697         if (!sav->sav_sync)
3698                 return;
3699
3700         /*
3701          * Update the MOS nvlist describing the list of available devices.
3702          * spa_validate_aux() will have already made sure this nvlist is
3703          * valid and the vdevs are labeled appropriately.
3704          */
3705         if (sav->sav_object == 0) {
3706                 sav->sav_object = dmu_object_alloc(spa->spa_meta_objset,
3707                     DMU_OT_PACKED_NVLIST, 1 << 14, DMU_OT_PACKED_NVLIST_SIZE,
3708                     sizeof (uint64_t), tx);
3709                 VERIFY(zap_update(spa->spa_meta_objset,
3710                     DMU_POOL_DIRECTORY_OBJECT, entry, sizeof (uint64_t), 1,
3711                     &sav->sav_object, tx) == 0);
3712         }
3713
3714         VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0);
3715         if (sav->sav_count == 0) {
3716                 VERIFY(nvlist_add_nvlist_array(nvroot, config, NULL, 0) == 0);
3717         } else {
3718                 list = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP);
3719                 for (i = 0; i < sav->sav_count; i++)
3720                         list[i] = vdev_config_generate(spa, sav->sav_vdevs[i],
3721                             B_FALSE, B_FALSE, B_TRUE);
3722                 VERIFY(nvlist_add_nvlist_array(nvroot, config, list,
3723                     sav->sav_count) == 0);
3724                 for (i = 0; i < sav->sav_count; i++)
3725                         nvlist_free(list[i]);
3726                 kmem_free(list, sav->sav_count * sizeof (void *));
3727         }
3728
3729         spa_sync_nvlist(spa, sav->sav_object, nvroot, tx);
3730         nvlist_free(nvroot);
3731
3732         sav->sav_sync = B_FALSE;
3733 }
3734
3735 static void
3736 spa_sync_config_object(spa_t *spa, dmu_tx_t *tx)
3737 {
3738         nvlist_t *config;
3739
3740         if (list_is_empty(&spa->spa_config_dirty_list))
3741                 return;
3742
3743         spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
3744
3745         config = spa_config_generate(spa, spa->spa_root_vdev,
3746             dmu_tx_get_txg(tx), B_FALSE);
3747
3748         spa_config_exit(spa, SCL_STATE, FTAG);
3749
3750         if (spa->spa_config_syncing)
3751                 nvlist_free(spa->spa_config_syncing);
3752         spa->spa_config_syncing = config;
3753
3754         spa_sync_nvlist(spa, spa->spa_config_object, config, tx);
3755 }
3756
3757 /*
3758  * Set zpool properties.
3759  */
3760 static void
3761 spa_sync_props(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
3762 {
3763         spa_t *spa = arg1;
3764         objset_t *mos = spa->spa_meta_objset;
3765         nvlist_t *nvp = arg2;
3766         nvpair_t *elem;
3767         uint64_t intval;
3768         char *strval;
3769         zpool_prop_t prop;
3770         const char *propname;
3771         zprop_type_t proptype;
3772         spa_config_dirent_t *dp;
3773
3774         mutex_enter(&spa->spa_props_lock);
3775
3776         elem = NULL;
3777         while ((elem = nvlist_next_nvpair(nvp, elem))) {
3778                 switch (prop = zpool_name_to_prop(nvpair_name(elem))) {
3779                 case ZPOOL_PROP_VERSION:
3780                         /*
3781                          * Only set version for non-zpool-creation cases
3782                          * (set/import). spa_create() needs special care
3783                          * for version setting.
3784                          */
3785                         if (tx->tx_txg != TXG_INITIAL) {
3786                                 VERIFY(nvpair_value_uint64(elem,
3787                                     &intval) == 0);
3788                                 ASSERT(intval <= SPA_VERSION);
3789                                 ASSERT(intval >= spa_version(spa));
3790                                 spa->spa_uberblock.ub_version = intval;
3791                                 vdev_config_dirty(spa->spa_root_vdev);
3792                         }
3793                         break;
3794
3795                 case ZPOOL_PROP_ALTROOT:
3796                         /*
3797                          * 'altroot' is a non-persistent property. It should
3798                          * have been set temporarily at creation or import time.
3799                          */
3800                         ASSERT(spa->spa_root != NULL);
3801                         break;
3802
3803                 case ZPOOL_PROP_CACHEFILE:
3804                         /*
3805                          * 'cachefile' is a non-persistent property, but note
3806                          * an async request that the config cache needs to be
3807                          * udpated.
3808                          */
3809                         VERIFY(nvpair_value_string(elem, &strval) == 0);
3810
3811                         dp = kmem_alloc(sizeof (spa_config_dirent_t), KM_SLEEP);
3812
3813                         if (strval[0] == '\0')
3814                                 dp->scd_path = spa_strdup(spa_config_path);
3815                         else if (strcmp(strval, "none") == 0)
3816                                 dp->scd_path = NULL;
3817                         else
3818                                 dp->scd_path = spa_strdup(strval);
3819
3820                         list_insert_head(&spa->spa_config_list, dp);
3821                         spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
3822                         break;
3823                 default:
3824                         /*
3825                          * Set pool property values in the poolprops mos object.
3826                          */
3827                         if (spa->spa_pool_props_object == 0) {
3828                                 objset_t *mos = spa->spa_meta_objset;
3829
3830                                 VERIFY((spa->spa_pool_props_object =
3831                                     zap_create(mos, DMU_OT_POOL_PROPS,
3832                                     DMU_OT_NONE, 0, tx)) > 0);
3833
3834                                 VERIFY(zap_update(mos,
3835                                     DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_PROPS,
3836                                     8, 1, &spa->spa_pool_props_object, tx)
3837                                     == 0);
3838                         }
3839
3840                         /* normalize the property name */
3841                         propname = zpool_prop_to_name(prop);
3842                         proptype = zpool_prop_get_type(prop);
3843
3844                         if (nvpair_type(elem) == DATA_TYPE_STRING) {
3845                                 ASSERT(proptype == PROP_TYPE_STRING);
3846                                 VERIFY(nvpair_value_string(elem, &strval) == 0);
3847                                 VERIFY(zap_update(mos,
3848                                     spa->spa_pool_props_object, propname,
3849                                     1, strlen(strval) + 1, strval, tx) == 0);
3850
3851                         } else if (nvpair_type(elem) == DATA_TYPE_UINT64) {
3852                                 VERIFY(nvpair_value_uint64(elem, &intval) == 0);
3853
3854                                 if (proptype == PROP_TYPE_INDEX) {
3855                                         const char *unused;
3856                                         VERIFY(zpool_prop_index_to_string(
3857                                             prop, intval, &unused) == 0);
3858                                 }
3859                                 VERIFY(zap_update(mos,
3860                                     spa->spa_pool_props_object, propname,
3861                                     8, 1, &intval, tx) == 0);
3862                         } else {
3863                                 ASSERT(0); /* not allowed */
3864                         }
3865
3866                         switch (prop) {
3867                         case ZPOOL_PROP_DELEGATION:
3868                                 spa->spa_delegation = intval;
3869                                 break;
3870                         case ZPOOL_PROP_BOOTFS:
3871                                 spa->spa_bootfs = intval;
3872                                 break;
3873                         case ZPOOL_PROP_FAILUREMODE:
3874                                 spa->spa_failmode = intval;
3875                                 break;
3876                         default:
3877                                 break;
3878                         }
3879                 }
3880
3881                 /* log internal history if this is not a zpool create */
3882                 if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY &&
3883                     tx->tx_txg != TXG_INITIAL) {
3884                         spa_history_internal_log(LOG_POOL_PROPSET,
3885                             spa, tx, cr, "%s %lld %s",
3886                             nvpair_name(elem), intval, spa_name(spa));
3887                 }
3888         }
3889
3890         mutex_exit(&spa->spa_props_lock);
3891 }
3892
3893 /*
3894  * Sync the specified transaction group.  New blocks may be dirtied as
3895  * part of the process, so we iterate until it converges.
3896  */
3897 void
3898 spa_sync(spa_t *spa, uint64_t txg)
3899 {
3900         dsl_pool_t *dp = spa->spa_dsl_pool;
3901         objset_t *mos = spa->spa_meta_objset;
3902         bplist_t *bpl = &spa->spa_sync_bplist;
3903         vdev_t *rvd = spa->spa_root_vdev;
3904         vdev_t *vd;
3905         dmu_tx_t *tx;
3906         int dirty_vdevs;
3907         int error;
3908
3909         /*
3910          * Lock out configuration changes.
3911          */
3912         spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
3913
3914         spa->spa_syncing_txg = txg;
3915         spa->spa_sync_pass = 0;
3916
3917         /*
3918          * If there are any pending vdev state changes, convert them
3919          * into config changes that go out with this transaction group.
3920          */
3921         spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
3922         while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) {
3923                 vdev_state_clean(vd);
3924                 vdev_config_dirty(vd);
3925         }
3926         spa_config_exit(spa, SCL_STATE, FTAG);
3927
3928         VERIFY(0 == bplist_open(bpl, mos, spa->spa_sync_bplist_obj));
3929
3930         tx = dmu_tx_create_assigned(dp, txg);
3931
3932         /*
3933          * If we are upgrading to SPA_VERSION_RAIDZ_DEFLATE this txg,
3934          * set spa_deflate if we have no raid-z vdevs.
3935          */
3936         if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE &&
3937             spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) {
3938                 int i;
3939
3940                 for (i = 0; i < rvd->vdev_children; i++) {
3941                         vd = rvd->vdev_child[i];
3942                         if (vd->vdev_deflate_ratio != SPA_MINBLOCKSIZE)
3943                                 break;
3944                 }
3945                 if (i == rvd->vdev_children) {
3946                         spa->spa_deflate = TRUE;
3947                         VERIFY(0 == zap_add(spa->spa_meta_objset,
3948                             DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
3949                             sizeof (uint64_t), 1, &spa->spa_deflate, tx));
3950                 }
3951         }
3952
3953         if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN &&
3954             spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) {
3955                 dsl_pool_create_origin(dp, tx);
3956
3957                 /* Keeping the origin open increases spa_minref */
3958                 spa->spa_minref += 3;
3959         }
3960
3961         if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES &&
3962             spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) {
3963                 dsl_pool_upgrade_clones(dp, tx);
3964         }
3965
3966         /*
3967          * If anything has changed in this txg, push the deferred frees
3968          * from the previous txg.  If not, leave them alone so that we
3969          * don't generate work on an otherwise idle system.
3970          */
3971         if (!txg_list_empty(&dp->dp_dirty_datasets, txg) ||
3972             !txg_list_empty(&dp->dp_dirty_dirs, txg) ||
3973             !txg_list_empty(&dp->dp_sync_tasks, txg))
3974                 spa_sync_deferred_frees(spa, txg);
3975
3976         /*
3977          * Iterate to convergence.
3978          */
3979         do {
3980                 spa->spa_sync_pass++;
3981
3982                 spa_sync_config_object(spa, tx);
3983                 spa_sync_aux_dev(spa, &spa->spa_spares, tx,
3984                     ZPOOL_CONFIG_SPARES, DMU_POOL_SPARES);
3985                 spa_sync_aux_dev(spa, &spa->spa_l2cache, tx,
3986                     ZPOOL_CONFIG_L2CACHE, DMU_POOL_L2CACHE);
3987                 spa_errlog_sync(spa, txg);
3988                 dsl_pool_sync(dp, txg);
3989
3990                 dirty_vdevs = 0;
3991                 while (vd = txg_list_remove(&spa->spa_vdev_txg_list, txg)) {
3992                         vdev_sync(vd, txg);
3993                         dirty_vdevs++;
3994                 }
3995
3996                 bplist_sync(bpl, tx);
3997         } while (dirty_vdevs);
3998
3999         bplist_close(bpl);
4000
4001         dprintf("txg %llu passes %d\n", txg, spa->spa_sync_pass);
4002
4003         /*
4004          * Rewrite the vdev configuration (which includes the uberblock)
4005          * to commit the transaction group.
4006          *
4007          * If there are no dirty vdevs, we sync the uberblock to a few
4008          * random top-level vdevs that are known to be visible in the
4009          * config cache (see spa_vdev_add() for a complete description).
4010          * If there *are* dirty vdevs, sync the uberblock to all vdevs.
4011          */
4012         for (;;) {
4013                 /*
4014                  * We hold SCL_STATE to prevent vdev open/close/etc.
4015                  * while we're attempting to write the vdev labels.
4016                  */
4017                 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
4018
4019                 if (list_is_empty(&spa->spa_config_dirty_list)) {
4020                         vdev_t *svd[SPA_DVAS_PER_BP];
4021                         int svdcount = 0;
4022                         int children = rvd->vdev_children;
4023                         int c0 = spa_get_random(children);
4024                         int c;
4025
4026                         for (c = 0; c < children; c++) {
4027                                 vd = rvd->vdev_child[(c0 + c) % children];
4028                                 if (vd->vdev_ms_array == 0 || vd->vdev_islog)
4029                                         continue;
4030                                 svd[svdcount++] = vd;
4031                                 if (svdcount == SPA_DVAS_PER_BP)
4032                                         break;
4033                         }
4034                         error = vdev_config_sync(svd, svdcount, txg);
4035                 } else {
4036                         error = vdev_config_sync(rvd->vdev_child,
4037                             rvd->vdev_children, txg);
4038                 }
4039
4040                 spa_config_exit(spa, SCL_STATE, FTAG);
4041
4042                 if (error == 0)
4043                         break;
4044                 zio_suspend(spa, NULL);
4045                 zio_resume_wait(spa);
4046         }
4047         dmu_tx_commit(tx);
4048
4049         /*
4050          * Clear the dirty config list.
4051          */
4052         while ((vd = list_head(&spa->spa_config_dirty_list)) != NULL)
4053                 vdev_config_clean(vd);
4054
4055         /*
4056          * Now that the new config has synced transactionally,
4057          * let it become visible to the config cache.
4058          */
4059         if (spa->spa_config_syncing != NULL) {
4060                 spa_config_set(spa, spa->spa_config_syncing);
4061                 spa->spa_config_txg = txg;
4062                 spa->spa_config_syncing = NULL;
4063         }
4064
4065         spa->spa_traverse_wanted = B_TRUE;
4066         rw_enter(&spa->spa_traverse_lock, RW_WRITER);
4067         spa->spa_traverse_wanted = B_FALSE;
4068         spa->spa_ubsync = spa->spa_uberblock;
4069         rw_exit(&spa->spa_traverse_lock);
4070
4071         /*
4072          * Clean up the ZIL records for the synced txg.
4073          */
4074         dsl_pool_zil_clean(dp);
4075
4076         /*
4077          * Update usable space statistics.
4078          */
4079         while (vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)))
4080                 vdev_sync_done(vd, txg);
4081
4082         /*
4083          * It had better be the case that we didn't dirty anything
4084          * since vdev_config_sync().
4085          */
4086         ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg));
4087         ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg));
4088         ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg));
4089         ASSERT(bpl->bpl_queue == NULL);
4090
4091         spa_config_exit(spa, SCL_CONFIG, FTAG);
4092
4093         /*
4094          * If any async tasks have been requested, kick them off.
4095          */
4096         spa_async_dispatch(spa);
4097 }
4098
4099 /*
4100  * Sync all pools.  We don't want to hold the namespace lock across these
4101  * operations, so we take a reference on the spa_t and drop the lock during the
4102  * sync.
4103  */
4104 void
4105 spa_sync_allpools(void)
4106 {
4107         spa_t *spa = NULL;
4108         mutex_enter(&spa_namespace_lock);
4109         while ((spa = spa_next(spa)) != NULL) {
4110                 if (spa_state(spa) != POOL_STATE_ACTIVE || spa_suspended(spa))
4111                         continue;
4112                 spa_open_ref(spa, FTAG);
4113                 mutex_exit(&spa_namespace_lock);
4114                 txg_wait_synced(spa_get_dsl(spa), 0);
4115                 mutex_enter(&spa_namespace_lock);
4116                 spa_close(spa, FTAG);
4117         }
4118         mutex_exit(&spa_namespace_lock);
4119 }
4120
4121 /*
4122  * ==========================================================================
4123  * Miscellaneous routines
4124  * ==========================================================================
4125  */
4126
4127 /*
4128  * Remove all pools in the system.
4129  */
4130 void
4131 spa_evict_all(void)
4132 {
4133         spa_t *spa;
4134
4135         /*
4136          * Remove all cached state.  All pools should be closed now,
4137          * so every spa in the AVL tree should be unreferenced.
4138          */
4139         mutex_enter(&spa_namespace_lock);
4140         while ((spa = spa_next(NULL)) != NULL) {
4141                 /*
4142                  * Stop async tasks.  The async thread may need to detach
4143                  * a device that's been replaced, which requires grabbing
4144                  * spa_namespace_lock, so we must drop it here.
4145                  */
4146                 spa_open_ref(spa, FTAG);
4147                 mutex_exit(&spa_namespace_lock);
4148                 spa_async_suspend(spa);
4149                 mutex_enter(&spa_namespace_lock);
4150                 spa_close(spa, FTAG);
4151
4152                 if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
4153                         spa_unload(spa);
4154                         spa_deactivate(spa);
4155                 }
4156                 spa_remove(spa);
4157         }
4158         mutex_exit(&spa_namespace_lock);
4159 }
4160
4161 vdev_t *
4162 spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t l2cache)
4163 {
4164         vdev_t *vd;
4165         int i;
4166
4167         if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL)
4168                 return (vd);
4169
4170         if (l2cache) {
4171                 for (i = 0; i < spa->spa_l2cache.sav_count; i++) {
4172                         vd = spa->spa_l2cache.sav_vdevs[i];
4173                         if (vd->vdev_guid == guid)
4174                                 return (vd);
4175                 }
4176         }
4177
4178         return (NULL);
4179 }
4180
4181 void
4182 spa_upgrade(spa_t *spa, uint64_t version)
4183 {
4184         spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4185
4186         /*
4187          * This should only be called for a non-faulted pool, and since a
4188          * future version would result in an unopenable pool, this shouldn't be
4189          * possible.
4190          */
4191         ASSERT(spa->spa_uberblock.ub_version <= SPA_VERSION);
4192         ASSERT(version >= spa->spa_uberblock.ub_version);
4193
4194         spa->spa_uberblock.ub_version = version;
4195         vdev_config_dirty(spa->spa_root_vdev);
4196
4197         spa_config_exit(spa, SCL_ALL, FTAG);
4198
4199         txg_wait_synced(spa_get_dsl(spa), 0);
4200 }
4201
4202 boolean_t
4203 spa_has_spare(spa_t *spa, uint64_t guid)
4204 {
4205         int i;
4206         uint64_t spareguid;
4207         spa_aux_vdev_t *sav = &spa->spa_spares;
4208
4209         for (i = 0; i < sav->sav_count; i++)
4210                 if (sav->sav_vdevs[i]->vdev_guid == guid)
4211                         return (B_TRUE);
4212
4213         for (i = 0; i < sav->sav_npending; i++) {
4214                 if (nvlist_lookup_uint64(sav->sav_pending[i], ZPOOL_CONFIG_GUID,
4215                     &spareguid) == 0 && spareguid == guid)
4216                         return (B_TRUE);
4217         }
4218
4219         return (B_FALSE);
4220 }
4221
4222 /*
4223  * Check if a pool has an active shared spare device.
4224  * Note: reference count of an active spare is 2, as a spare and as a replace
4225  */
4226 static boolean_t
4227 spa_has_active_shared_spare(spa_t *spa)
4228 {
4229         int i, refcnt;
4230         uint64_t pool;
4231         spa_aux_vdev_t *sav = &spa->spa_spares;
4232
4233         for (i = 0; i < sav->sav_count; i++) {
4234                 if (spa_spare_exists(sav->sav_vdevs[i]->vdev_guid, &pool,
4235                     &refcnt) && pool != 0ULL && pool == spa_guid(spa) &&
4236                     refcnt > 2)
4237                         return (B_TRUE);
4238         }
4239
4240         return (B_FALSE);
4241 }
4242
4243 /*
4244  * Post a sysevent corresponding to the given event.  The 'name' must be one of
4245  * the event definitions in sys/sysevent/eventdefs.h.  The payload will be
4246  * filled in from the spa and (optionally) the vdev.  This doesn't do anything
4247  * in the userland libzpool, as we don't want consumers to misinterpret ztest
4248  * or zdb as real changes.
4249  */
4250 void
4251 spa_event_notify(spa_t *spa, vdev_t *vd, const char *name)
4252 {
4253 #if 0
4254 #ifdef _KERNEL
4255         sysevent_t              *ev;
4256         sysevent_attr_list_t    *attr = NULL;
4257         sysevent_value_t        value;
4258         sysevent_id_t           eid;
4259
4260         ev = sysevent_alloc(EC_ZFS, (char *)name, SUNW_KERN_PUB "zfs",
4261             SE_SLEEP);
4262
4263         value.value_type = SE_DATA_TYPE_STRING;
4264         value.value.sv_string = spa_name(spa);
4265         if (sysevent_add_attr(&attr, ZFS_EV_POOL_NAME, &value, SE_SLEEP) != 0)
4266                 goto done;
4267
4268         value.value_type = SE_DATA_TYPE_UINT64;
4269         value.value.sv_uint64 = spa_guid(spa);
4270         if (sysevent_add_attr(&attr, ZFS_EV_POOL_GUID, &value, SE_SLEEP) != 0)
4271                 goto done;
4272
4273         if (vd) {
4274                 value.value_type = SE_DATA_TYPE_UINT64;
4275                 value.value.sv_uint64 = vd->vdev_guid;
4276                 if (sysevent_add_attr(&attr, ZFS_EV_VDEV_GUID, &value,
4277                     SE_SLEEP) != 0)
4278                         goto done;
4279
4280                 if (vd->vdev_path) {
4281                         value.value_type = SE_DATA_TYPE_STRING;
4282                         value.value.sv_string = vd->vdev_path;
4283                         if (sysevent_add_attr(&attr, ZFS_EV_VDEV_PATH,
4284                             &value, SE_SLEEP) != 0)
4285                                 goto done;
4286                 }
4287         }
4288
4289         if (sysevent_attach_attributes(ev, attr) != 0)
4290                 goto done;
4291         attr = NULL;
4292
4293         (void) log_sysevent(ev, SE_SLEEP, &eid);
4294
4295 done:
4296         if (attr)
4297                 sysevent_free_attr(attr);
4298         sysevent_free(ev);
4299 #endif
4300 #endif
4301 }