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