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 2010 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/dmu.h> 39 #include <sys/dmu_tx.h> 40 #include <sys/zap.h> 41 #include <sys/zil.h> 42 #include <sys/ddt.h> 43 #include <sys/vdev_impl.h> 44 #include <sys/metaslab.h> 45 #include <sys/metaslab_impl.h> 46 #include <sys/uberblock_impl.h> 47 #include <sys/txg.h> 48 #include <sys/avl.h> 49 #include <sys/dmu_traverse.h> 50 #include <sys/dmu_objset.h> 51 #include <sys/unique.h> 52 #include <sys/dsl_pool.h> 53 #include <sys/dsl_dataset.h> 54 #include <sys/dsl_dir.h> 55 #include <sys/dsl_prop.h> 56 #include <sys/dsl_synctask.h> 57 #include <sys/fs/zfs.h> 58 #include <sys/arc.h> 59 #include <sys/callb.h> 60 #include <sys/systeminfo.h> 61 #include <sys/spa_boot.h> 62 #include <sys/zfs_ioctl.h> 63 64 #ifdef _KERNEL 65 #include <sys/bootprops.h> 66 #include <sys/callb.h> 67 #include <sys/cpupart.h> 68 #include <sys/pool.h> 69 #include <sys/sysdc.h> 70 #include <sys/zone.h> 71 #endif /* _KERNEL */ 72 73 #include "zfs_prop.h" 74 #include "zfs_comutil.h" 75 76 typedef enum zti_modes { 77 zti_mode_fixed, /* value is # of threads (min 1) */ 78 zti_mode_online_percent, /* value is % of online CPUs */ 79 zti_mode_batch, /* cpu-intensive; value is ignored */ 80 zti_mode_null, /* don't create a taskq */ 81 zti_nmodes 82 } zti_modes_t; 83 84 #define ZTI_FIX(n) { zti_mode_fixed, (n) } 85 #define ZTI_PCT(n) { zti_mode_online_percent, (n) } 86 #define ZTI_BATCH { zti_mode_batch, 0 } 87 #define ZTI_NULL { zti_mode_null, 0 } 88 89 #define ZTI_ONE ZTI_FIX(1) 90 91 typedef struct zio_taskq_info { 92 enum zti_modes zti_mode; 93 uint_t zti_value; 94 } zio_taskq_info_t; 95 96 static const char *const zio_taskq_types[ZIO_TASKQ_TYPES] = { 97 "issue", "issue_high", "intr", "intr_high" 98 }; 99 100 /* 101 * Define the taskq threads for the following I/O types: 102 * NULL, READ, WRITE, FREE, CLAIM, and IOCTL 103 */ 104 const zio_taskq_info_t zio_taskqs[ZIO_TYPES][ZIO_TASKQ_TYPES] = { 105 /* ISSUE ISSUE_HIGH INTR INTR_HIGH */ 106 { ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, 107 { ZTI_FIX(8), ZTI_NULL, ZTI_BATCH, ZTI_NULL }, 108 { ZTI_BATCH, ZTI_FIX(5), ZTI_FIX(8), ZTI_FIX(5) }, 109 { ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, 110 { ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, 111 { ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, 112 }; 113 114 static void spa_sync_props(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx); 115 static boolean_t spa_has_active_shared_spare(spa_t *spa); 116 static int spa_load_impl(spa_t *spa, uint64_t, nvlist_t *config, 117 spa_load_state_t state, spa_import_type_t type, boolean_t mosconfig, 118 char **ereport); 119 120 uint_t zio_taskq_batch_pct = 100; /* 1 thread per cpu in pset */ 121 id_t zio_taskq_psrset_bind = PS_NONE; 122 boolean_t zio_taskq_sysdc = B_TRUE; /* use SDC scheduling class */ 123 uint_t zio_taskq_basedc = 80; /* base duty cycle */ 124 125 boolean_t spa_create_process = B_TRUE; /* no process ==> no sysdc */ 126 127 /* 128 * This (illegal) pool name is used when temporarily importing a spa_t in order 129 * to get the vdev stats associated with the imported devices. 130 */ 131 #define TRYIMPORT_NAME "$import" 132 133 /* 134 * ========================================================================== 135 * SPA properties routines 136 * ========================================================================== 137 */ 138 139 /* 140 * Add a (source=src, propname=propval) list to an nvlist. 141 */ 142 static void 143 spa_prop_add_list(nvlist_t *nvl, zpool_prop_t prop, char *strval, 144 uint64_t intval, zprop_source_t src) 145 { 146 const char *propname = zpool_prop_to_name(prop); 147 nvlist_t *propval; 148 149 VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0); 150 VERIFY(nvlist_add_uint64(propval, ZPROP_SOURCE, src) == 0); 151 152 if (strval != NULL) 153 VERIFY(nvlist_add_string(propval, ZPROP_VALUE, strval) == 0); 154 else 155 VERIFY(nvlist_add_uint64(propval, ZPROP_VALUE, intval) == 0); 156 157 VERIFY(nvlist_add_nvlist(nvl, propname, propval) == 0); 158 nvlist_free(propval); 159 } 160 161 /* 162 * Get property values from the spa configuration. 163 */ 164 static void 165 spa_prop_get_config(spa_t *spa, nvlist_t **nvp) 166 { 167 uint64_t size; 168 uint64_t alloc; 169 uint64_t cap, version; 170 zprop_source_t src = ZPROP_SRC_NONE; 171 spa_config_dirent_t *dp; 172 173 ASSERT(MUTEX_HELD(&spa->spa_props_lock)); 174 175 if (spa->spa_root_vdev != NULL) { 176 alloc = metaslab_class_get_alloc(spa_normal_class(spa)); 177 size = metaslab_class_get_space(spa_normal_class(spa)); 178 spa_prop_add_list(*nvp, ZPOOL_PROP_NAME, spa_name(spa), 0, src); 179 spa_prop_add_list(*nvp, ZPOOL_PROP_SIZE, NULL, size, src); 180 spa_prop_add_list(*nvp, ZPOOL_PROP_ALLOCATED, NULL, alloc, src); 181 spa_prop_add_list(*nvp, ZPOOL_PROP_FREE, NULL, 182 size - alloc, src); 183 184 cap = (size == 0) ? 0 : (alloc * 100 / size); 185 spa_prop_add_list(*nvp, ZPOOL_PROP_CAPACITY, NULL, cap, src); 186 187 spa_prop_add_list(*nvp, ZPOOL_PROP_DEDUPRATIO, NULL, 188 ddt_get_pool_dedup_ratio(spa), src); 189 190 spa_prop_add_list(*nvp, ZPOOL_PROP_HEALTH, NULL, 191 spa->spa_root_vdev->vdev_state, src); 192 193 version = spa_version(spa); 194 if (version == zpool_prop_default_numeric(ZPOOL_PROP_VERSION)) 195 src = ZPROP_SRC_DEFAULT; 196 else 197 src = ZPROP_SRC_LOCAL; 198 spa_prop_add_list(*nvp, ZPOOL_PROP_VERSION, NULL, version, src); 199 } 200 201 spa_prop_add_list(*nvp, ZPOOL_PROP_GUID, NULL, spa_guid(spa), src); 202 203 if (spa->spa_root != NULL) 204 spa_prop_add_list(*nvp, ZPOOL_PROP_ALTROOT, spa->spa_root, 205 0, ZPROP_SRC_LOCAL); 206 207 if ((dp = list_head(&spa->spa_config_list)) != NULL) { 208 if (dp->scd_path == NULL) { 209 spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE, 210 "none", 0, ZPROP_SRC_LOCAL); 211 } else if (strcmp(dp->scd_path, spa_config_path) != 0) { 212 spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE, 213 dp->scd_path, 0, ZPROP_SRC_LOCAL); 214 } 215 } 216 } 217 218 /* 219 * Get zpool property values. 220 */ 221 int 222 spa_prop_get(spa_t *spa, nvlist_t **nvp) 223 { 224 objset_t *mos = spa->spa_meta_objset; 225 zap_cursor_t zc; 226 zap_attribute_t za; 227 int err; 228 229 VERIFY(nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0); 230 231 mutex_enter(&spa->spa_props_lock); 232 233 /* 234 * Get properties from the spa config. 235 */ 236 spa_prop_get_config(spa, nvp); 237 238 /* If no pool property object, no more prop to get. */ 239 if (mos == NULL || spa->spa_pool_props_object == 0) { 240 mutex_exit(&spa->spa_props_lock); 241 return (0); 242 } 243 244 /* 245 * Get properties from the MOS pool property object. 246 */ 247 for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object); 248 (err = zap_cursor_retrieve(&zc, &za)) == 0; 249 zap_cursor_advance(&zc)) { 250 uint64_t intval = 0; 251 char *strval = NULL; 252 zprop_source_t src = ZPROP_SRC_DEFAULT; 253 zpool_prop_t prop; 254 255 if ((prop = zpool_name_to_prop(za.za_name)) == ZPROP_INVAL) 256 continue; 257 258 switch (za.za_integer_length) { 259 case 8: 260 /* integer property */ 261 if (za.za_first_integer != 262 zpool_prop_default_numeric(prop)) 263 src = ZPROP_SRC_LOCAL; 264 265 if (prop == ZPOOL_PROP_BOOTFS) { 266 dsl_pool_t *dp; 267 dsl_dataset_t *ds = NULL; 268 269 dp = spa_get_dsl(spa); 270 rw_enter(&dp->dp_config_rwlock, RW_READER); 271 if (err = dsl_dataset_hold_obj(dp, 272 za.za_first_integer, FTAG, &ds)) { 273 rw_exit(&dp->dp_config_rwlock); 274 break; 275 } 276 277 strval = kmem_alloc( 278 MAXNAMELEN + strlen(MOS_DIR_NAME) + 1, 279 KM_SLEEP); 280 dsl_dataset_name(ds, strval); 281 dsl_dataset_rele(ds, FTAG); 282 rw_exit(&dp->dp_config_rwlock); 283 } else { 284 strval = NULL; 285 intval = za.za_first_integer; 286 } 287 288 spa_prop_add_list(*nvp, prop, strval, intval, src); 289 290 if (strval != NULL) 291 kmem_free(strval, 292 MAXNAMELEN + strlen(MOS_DIR_NAME) + 1); 293 294 break; 295 296 case 1: 297 /* string property */ 298 strval = kmem_alloc(za.za_num_integers, KM_SLEEP); 299 err = zap_lookup(mos, spa->spa_pool_props_object, 300 za.za_name, 1, za.za_num_integers, strval); 301 if (err) { 302 kmem_free(strval, za.za_num_integers); 303 break; 304 } 305 spa_prop_add_list(*nvp, prop, strval, 0, src); 306 kmem_free(strval, za.za_num_integers); 307 break; 308 309 default: 310 break; 311 } 312 } 313 zap_cursor_fini(&zc); 314 mutex_exit(&spa->spa_props_lock); 315 out: 316 if (err && err != ENOENT) { 317 nvlist_free(*nvp); 318 *nvp = NULL; 319 return (err); 320 } 321 322 return (0); 323 } 324 325 /* 326 * Validate the given pool properties nvlist and modify the list 327 * for the property values to be set. 328 */ 329 static int 330 spa_prop_validate(spa_t *spa, nvlist_t *props) 331 { 332 nvpair_t *elem; 333 int error = 0, reset_bootfs = 0; 334 uint64_t objnum; 335 336 elem = NULL; 337 while ((elem = nvlist_next_nvpair(props, elem)) != NULL) { 338 zpool_prop_t prop; 339 char *propname, *strval; 340 uint64_t intval; 341 objset_t *os; 342 char *slash; 343 344 propname = nvpair_name(elem); 345 346 if ((prop = zpool_name_to_prop(propname)) == ZPROP_INVAL) 347 return (EINVAL); 348 349 switch (prop) { 350 case ZPOOL_PROP_VERSION: 351 error = nvpair_value_uint64(elem, &intval); 352 if (!error && 353 (intval < spa_version(spa) || intval > SPA_VERSION)) 354 error = EINVAL; 355 break; 356 357 case ZPOOL_PROP_DELEGATION: 358 case ZPOOL_PROP_AUTOREPLACE: 359 case ZPOOL_PROP_LISTSNAPS: 360 case ZPOOL_PROP_AUTOEXPAND: 361 error = nvpair_value_uint64(elem, &intval); 362 if (!error && intval > 1) 363 error = EINVAL; 364 break; 365 366 case ZPOOL_PROP_BOOTFS: 367 /* 368 * If the pool version is less than SPA_VERSION_BOOTFS, 369 * or the pool is still being created (version == 0), 370 * the bootfs property cannot be set. 371 */ 372 if (spa_version(spa) < SPA_VERSION_BOOTFS) { 373 error = ENOTSUP; 374 break; 375 } 376 377 /* 378 * Make sure the vdev config is bootable 379 */ 380 if (!vdev_is_bootable(spa->spa_root_vdev)) { 381 error = ENOTSUP; 382 break; 383 } 384 385 reset_bootfs = 1; 386 387 error = nvpair_value_string(elem, &strval); 388 389 if (!error) { 390 uint64_t compress; 391 392 if (strval == NULL || strval[0] == '\0') { 393 objnum = zpool_prop_default_numeric( 394 ZPOOL_PROP_BOOTFS); 395 break; 396 } 397 398 if (error = dmu_objset_hold(strval, FTAG, &os)) 399 break; 400 401 /* Must be ZPL and not gzip compressed. */ 402 403 if (dmu_objset_type(os) != DMU_OST_ZFS) { 404 error = ENOTSUP; 405 } else if ((error = dsl_prop_get_integer(strval, 406 zfs_prop_to_name(ZFS_PROP_COMPRESSION), 407 &compress, NULL)) == 0 && 408 !BOOTFS_COMPRESS_VALID(compress)) { 409 error = ENOTSUP; 410 } else { 411 objnum = dmu_objset_id(os); 412 } 413 dmu_objset_rele(os, FTAG); 414 } 415 break; 416 417 case ZPOOL_PROP_FAILUREMODE: 418 error = nvpair_value_uint64(elem, &intval); 419 if (!error && (intval < ZIO_FAILURE_MODE_WAIT || 420 intval > ZIO_FAILURE_MODE_PANIC)) 421 error = EINVAL; 422 423 /* 424 * This is a special case which only occurs when 425 * the pool has completely failed. This allows 426 * the user to change the in-core failmode property 427 * without syncing it out to disk (I/Os might 428 * currently be blocked). We do this by returning 429 * EIO to the caller (spa_prop_set) to trick it 430 * into thinking we encountered a property validation 431 * error. 432 */ 433 if (!error && spa_suspended(spa)) { 434 spa->spa_failmode = intval; 435 error = EIO; 436 } 437 break; 438 439 case ZPOOL_PROP_CACHEFILE: 440 if ((error = nvpair_value_string(elem, &strval)) != 0) 441 break; 442 443 if (strval[0] == '\0') 444 break; 445 446 if (strcmp(strval, "none") == 0) 447 break; 448 449 if (strval[0] != '/') { 450 error = EINVAL; 451 break; 452 } 453 454 slash = strrchr(strval, '/'); 455 ASSERT(slash != NULL); 456 457 if (slash[1] == '\0' || strcmp(slash, "/.") == 0 || 458 strcmp(slash, "/..") == 0) 459 error = EINVAL; 460 break; 461 462 case ZPOOL_PROP_DEDUPDITTO: 463 if (spa_version(spa) < SPA_VERSION_DEDUP) 464 error = ENOTSUP; 465 else 466 error = nvpair_value_uint64(elem, &intval); 467 if (error == 0 && 468 intval != 0 && intval < ZIO_DEDUPDITTO_MIN) 469 error = EINVAL; 470 break; 471 } 472 473 if (error) 474 break; 475 } 476 477 if (!error && reset_bootfs) { 478 error = nvlist_remove(props, 479 zpool_prop_to_name(ZPOOL_PROP_BOOTFS), DATA_TYPE_STRING); 480 481 if (!error) { 482 error = nvlist_add_uint64(props, 483 zpool_prop_to_name(ZPOOL_PROP_BOOTFS), objnum); 484 } 485 } 486 487 return (error); 488 } 489 490 void 491 spa_configfile_set(spa_t *spa, nvlist_t *nvp, boolean_t need_sync) 492 { 493 char *cachefile; 494 spa_config_dirent_t *dp; 495 496 if (nvlist_lookup_string(nvp, zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), 497 &cachefile) != 0) 498 return; 499 500 dp = kmem_alloc(sizeof (spa_config_dirent_t), 501 KM_SLEEP); 502 503 if (cachefile[0] == '\0') 504 dp->scd_path = spa_strdup(spa_config_path); 505 else if (strcmp(cachefile, "none") == 0) 506 dp->scd_path = NULL; 507 else 508 dp->scd_path = spa_strdup(cachefile); 509 510 list_insert_head(&spa->spa_config_list, dp); 511 if (need_sync) 512 spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); 513 } 514 515 int 516 spa_prop_set(spa_t *spa, nvlist_t *nvp) 517 { 518 int error; 519 nvpair_t *elem; 520 boolean_t need_sync = B_FALSE; 521 zpool_prop_t prop; 522 523 if ((error = spa_prop_validate(spa, nvp)) != 0) 524 return (error); 525 526 elem = NULL; 527 while ((elem = nvlist_next_nvpair(nvp, elem)) != NULL) { 528 if ((prop = zpool_name_to_prop( 529 nvpair_name(elem))) == ZPROP_INVAL) 530 return (EINVAL); 531 532 if (prop == ZPOOL_PROP_CACHEFILE || prop == ZPOOL_PROP_ALTROOT) 533 continue; 534 535 need_sync = B_TRUE; 536 break; 537 } 538 539 if (need_sync) 540 return (dsl_sync_task_do(spa_get_dsl(spa), NULL, spa_sync_props, 541 spa, nvp, 3)); 542 else 543 return (0); 544 } 545 546 /* 547 * If the bootfs property value is dsobj, clear it. 548 */ 549 void 550 spa_prop_clear_bootfs(spa_t *spa, uint64_t dsobj, dmu_tx_t *tx) 551 { 552 if (spa->spa_bootfs == dsobj && spa->spa_pool_props_object != 0) { 553 VERIFY(zap_remove(spa->spa_meta_objset, 554 spa->spa_pool_props_object, 555 zpool_prop_to_name(ZPOOL_PROP_BOOTFS), tx) == 0); 556 spa->spa_bootfs = 0; 557 } 558 } 559 560 /* 561 * ========================================================================== 562 * SPA state manipulation (open/create/destroy/import/export) 563 * ========================================================================== 564 */ 565 566 static int 567 spa_error_entry_compare(const void *a, const void *b) 568 { 569 spa_error_entry_t *sa = (spa_error_entry_t *)a; 570 spa_error_entry_t *sb = (spa_error_entry_t *)b; 571 int ret; 572 573 ret = bcmp(&sa->se_bookmark, &sb->se_bookmark, 574 sizeof (zbookmark_t)); 575 576 if (ret < 0) 577 return (-1); 578 else if (ret > 0) 579 return (1); 580 else 581 return (0); 582 } 583 584 /* 585 * Utility function which retrieves copies of the current logs and 586 * re-initializes them in the process. 587 */ 588 void 589 spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub) 590 { 591 ASSERT(MUTEX_HELD(&spa->spa_errlist_lock)); 592 593 bcopy(&spa->spa_errlist_last, last, sizeof (avl_tree_t)); 594 bcopy(&spa->spa_errlist_scrub, scrub, sizeof (avl_tree_t)); 595 596 avl_create(&spa->spa_errlist_scrub, 597 spa_error_entry_compare, sizeof (spa_error_entry_t), 598 offsetof(spa_error_entry_t, se_avl)); 599 avl_create(&spa->spa_errlist_last, 600 spa_error_entry_compare, sizeof (spa_error_entry_t), 601 offsetof(spa_error_entry_t, se_avl)); 602 } 603 604 static taskq_t * 605 spa_taskq_create(spa_t *spa, const char *name, enum zti_modes mode, 606 uint_t value) 607 { 608 uint_t flags = TASKQ_PREPOPULATE; 609 boolean_t batch = B_FALSE; 610 611 switch (mode) { 612 case zti_mode_null: 613 return (NULL); /* no taskq needed */ 614 615 case zti_mode_fixed: 616 ASSERT3U(value, >=, 1); 617 value = MAX(value, 1); 618 break; 619 620 case zti_mode_batch: 621 batch = B_TRUE; 622 flags |= TASKQ_THREADS_CPU_PCT; 623 value = zio_taskq_batch_pct; 624 break; 625 626 case zti_mode_online_percent: 627 flags |= TASKQ_THREADS_CPU_PCT; 628 break; 629 630 default: 631 panic("unrecognized mode for %s taskq (%u:%u) in " 632 "spa_activate()", 633 name, mode, value); 634 break; 635 } 636 637 if (zio_taskq_sysdc && spa->spa_proc != &p0) { 638 if (batch) 639 flags |= TASKQ_DC_BATCH; 640 641 return (taskq_create_sysdc(name, value, 50, INT_MAX, 642 spa->spa_proc, zio_taskq_basedc, flags)); 643 } 644 return (taskq_create_proc(name, value, maxclsyspri, 50, INT_MAX, 645 spa->spa_proc, flags)); 646 } 647 648 static void 649 spa_create_zio_taskqs(spa_t *spa) 650 { 651 for (int t = 0; t < ZIO_TYPES; t++) { 652 for (int q = 0; q < ZIO_TASKQ_TYPES; q++) { 653 const zio_taskq_info_t *ztip = &zio_taskqs[t][q]; 654 enum zti_modes mode = ztip->zti_mode; 655 uint_t value = ztip->zti_value; 656 char name[32]; 657 658 (void) snprintf(name, sizeof (name), 659 "%s_%s", zio_type_name[t], zio_taskq_types[q]); 660 661 spa->spa_zio_taskq[t][q] = 662 spa_taskq_create(spa, name, mode, value); 663 } 664 } 665 } 666 667 #ifdef _KERNEL 668 static void 669 spa_thread(void *arg) 670 { 671 callb_cpr_t cprinfo; 672 673 spa_t *spa = arg; 674 user_t *pu = PTOU(curproc); 675 676 CALLB_CPR_INIT(&cprinfo, &spa->spa_proc_lock, callb_generic_cpr, 677 spa->spa_name); 678 679 ASSERT(curproc != &p0); 680 (void) snprintf(pu->u_psargs, sizeof (pu->u_psargs), 681 "zpool-%s", spa->spa_name); 682 (void) strlcpy(pu->u_comm, pu->u_psargs, sizeof (pu->u_comm)); 683 684 /* bind this thread to the requested psrset */ 685 if (zio_taskq_psrset_bind != PS_NONE) { 686 pool_lock(); 687 mutex_enter(&cpu_lock); 688 mutex_enter(&pidlock); 689 mutex_enter(&curproc->p_lock); 690 691 if (cpupart_bind_thread(curthread, zio_taskq_psrset_bind, 692 0, NULL, NULL) == 0) { 693 curthread->t_bind_pset = zio_taskq_psrset_bind; 694 } else { 695 cmn_err(CE_WARN, 696 "Couldn't bind process for zfs pool \"%s\" to " 697 "pset %d\n", spa->spa_name, zio_taskq_psrset_bind); 698 } 699 700 mutex_exit(&curproc->p_lock); 701 mutex_exit(&pidlock); 702 mutex_exit(&cpu_lock); 703 pool_unlock(); 704 } 705 706 if (zio_taskq_sysdc) { 707 sysdc_thread_enter(curthread, 100, 0); 708 } 709 710 spa->spa_proc = curproc; 711 spa->spa_did = curthread->t_did; 712 713 spa_create_zio_taskqs(spa); 714 715 mutex_enter(&spa->spa_proc_lock); 716 ASSERT(spa->spa_proc_state == SPA_PROC_CREATED); 717 718 spa->spa_proc_state = SPA_PROC_ACTIVE; 719 cv_broadcast(&spa->spa_proc_cv); 720 721 CALLB_CPR_SAFE_BEGIN(&cprinfo); 722 while (spa->spa_proc_state == SPA_PROC_ACTIVE) 723 cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock); 724 CALLB_CPR_SAFE_END(&cprinfo, &spa->spa_proc_lock); 725 726 ASSERT(spa->spa_proc_state == SPA_PROC_DEACTIVATE); 727 spa->spa_proc_state = SPA_PROC_GONE; 728 spa->spa_proc = &p0; 729 cv_broadcast(&spa->spa_proc_cv); 730 CALLB_CPR_EXIT(&cprinfo); /* drops spa_proc_lock */ 731 732 mutex_enter(&curproc->p_lock); 733 lwp_exit(); 734 } 735 #endif 736 737 /* 738 * Activate an uninitialized pool. 739 */ 740 static void 741 spa_activate(spa_t *spa, int mode) 742 { 743 ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED); 744 745 spa->spa_state = POOL_STATE_ACTIVE; 746 spa->spa_mode = mode; 747 748 spa->spa_normal_class = metaslab_class_create(spa, zfs_metaslab_ops); 749 spa->spa_log_class = metaslab_class_create(spa, zfs_metaslab_ops); 750 751 /* Try to create a covering process */ 752 mutex_enter(&spa->spa_proc_lock); 753 ASSERT(spa->spa_proc_state == SPA_PROC_NONE); 754 ASSERT(spa->spa_proc == &p0); 755 spa->spa_did = 0; 756 757 /* Only create a process if we're going to be around a while. */ 758 if (spa_create_process && strcmp(spa->spa_name, TRYIMPORT_NAME) != 0) { 759 if (newproc(spa_thread, (caddr_t)spa, syscid, maxclsyspri, 760 NULL, 0) == 0) { 761 spa->spa_proc_state = SPA_PROC_CREATED; 762 while (spa->spa_proc_state == SPA_PROC_CREATED) { 763 cv_wait(&spa->spa_proc_cv, 764 &spa->spa_proc_lock); 765 } 766 ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE); 767 ASSERT(spa->spa_proc != &p0); 768 ASSERT(spa->spa_did != 0); 769 } else { 770 #ifdef _KERNEL 771 cmn_err(CE_WARN, 772 "Couldn't create process for zfs pool \"%s\"\n", 773 spa->spa_name); 774 #endif 775 } 776 } 777 mutex_exit(&spa->spa_proc_lock); 778 779 /* If we didn't create a process, we need to create our taskqs. */ 780 if (spa->spa_proc == &p0) { 781 spa_create_zio_taskqs(spa); 782 } 783 784 list_create(&spa->spa_config_dirty_list, sizeof (vdev_t), 785 offsetof(vdev_t, vdev_config_dirty_node)); 786 list_create(&spa->spa_state_dirty_list, sizeof (vdev_t), 787 offsetof(vdev_t, vdev_state_dirty_node)); 788 789 txg_list_create(&spa->spa_vdev_txg_list, 790 offsetof(struct vdev, vdev_txg_node)); 791 792 avl_create(&spa->spa_errlist_scrub, 793 spa_error_entry_compare, sizeof (spa_error_entry_t), 794 offsetof(spa_error_entry_t, se_avl)); 795 avl_create(&spa->spa_errlist_last, 796 spa_error_entry_compare, sizeof (spa_error_entry_t), 797 offsetof(spa_error_entry_t, se_avl)); 798 } 799 800 /* 801 * Opposite of spa_activate(). 802 */ 803 static void 804 spa_deactivate(spa_t *spa) 805 { 806 ASSERT(spa->spa_sync_on == B_FALSE); 807 ASSERT(spa->spa_dsl_pool == NULL); 808 ASSERT(spa->spa_root_vdev == NULL); 809 ASSERT(spa->spa_async_zio_root == NULL); 810 ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED); 811 812 txg_list_destroy(&spa->spa_vdev_txg_list); 813 814 list_destroy(&spa->spa_config_dirty_list); 815 list_destroy(&spa->spa_state_dirty_list); 816 817 for (int t = 0; t < ZIO_TYPES; t++) { 818 for (int q = 0; q < ZIO_TASKQ_TYPES; q++) { 819 if (spa->spa_zio_taskq[t][q] != NULL) 820 taskq_destroy(spa->spa_zio_taskq[t][q]); 821 spa->spa_zio_taskq[t][q] = NULL; 822 } 823 } 824 825 metaslab_class_destroy(spa->spa_normal_class); 826 spa->spa_normal_class = NULL; 827 828 metaslab_class_destroy(spa->spa_log_class); 829 spa->spa_log_class = NULL; 830 831 /* 832 * If this was part of an import or the open otherwise failed, we may 833 * still have errors left in the queues. Empty them just in case. 834 */ 835 spa_errlog_drain(spa); 836 837 avl_destroy(&spa->spa_errlist_scrub); 838 avl_destroy(&spa->spa_errlist_last); 839 840 spa->spa_state = POOL_STATE_UNINITIALIZED; 841 842 mutex_enter(&spa->spa_proc_lock); 843 if (spa->spa_proc_state != SPA_PROC_NONE) { 844 ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE); 845 spa->spa_proc_state = SPA_PROC_DEACTIVATE; 846 cv_broadcast(&spa->spa_proc_cv); 847 while (spa->spa_proc_state == SPA_PROC_DEACTIVATE) { 848 ASSERT(spa->spa_proc != &p0); 849 cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock); 850 } 851 ASSERT(spa->spa_proc_state == SPA_PROC_GONE); 852 spa->spa_proc_state = SPA_PROC_NONE; 853 } 854 ASSERT(spa->spa_proc == &p0); 855 mutex_exit(&spa->spa_proc_lock); 856 857 /* 858 * We want to make sure spa_thread() has actually exited the ZFS 859 * module, so that the module can't be unloaded out from underneath 860 * it. 861 */ 862 if (spa->spa_did != 0) { 863 thread_join(spa->spa_did); 864 spa->spa_did = 0; 865 } 866 } 867 868 /* 869 * Verify a pool configuration, and construct the vdev tree appropriately. This 870 * will create all the necessary vdevs in the appropriate layout, with each vdev 871 * in the CLOSED state. This will prep the pool before open/creation/import. 872 * All vdev validation is done by the vdev_alloc() routine. 873 */ 874 static int 875 spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent, 876 uint_t id, int atype) 877 { 878 nvlist_t **child; 879 uint_t children; 880 int error; 881 882 if ((error = vdev_alloc(spa, vdp, nv, parent, id, atype)) != 0) 883 return (error); 884 885 if ((*vdp)->vdev_ops->vdev_op_leaf) 886 return (0); 887 888 error = nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 889 &child, &children); 890 891 if (error == ENOENT) 892 return (0); 893 894 if (error) { 895 vdev_free(*vdp); 896 *vdp = NULL; 897 return (EINVAL); 898 } 899 900 for (int c = 0; c < children; c++) { 901 vdev_t *vd; 902 if ((error = spa_config_parse(spa, &vd, child[c], *vdp, c, 903 atype)) != 0) { 904 vdev_free(*vdp); 905 *vdp = NULL; 906 return (error); 907 } 908 } 909 910 ASSERT(*vdp != NULL); 911 912 return (0); 913 } 914 915 /* 916 * Opposite of spa_load(). 917 */ 918 static void 919 spa_unload(spa_t *spa) 920 { 921 int i; 922 923 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 924 925 /* 926 * Stop async tasks. 927 */ 928 spa_async_suspend(spa); 929 930 /* 931 * Stop syncing. 932 */ 933 if (spa->spa_sync_on) { 934 txg_sync_stop(spa->spa_dsl_pool); 935 spa->spa_sync_on = B_FALSE; 936 } 937 938 /* 939 * Wait for any outstanding async I/O to complete. 940 */ 941 if (spa->spa_async_zio_root != NULL) { 942 (void) zio_wait(spa->spa_async_zio_root); 943 spa->spa_async_zio_root = NULL; 944 } 945 946 /* 947 * Close the dsl pool. 948 */ 949 if (spa->spa_dsl_pool) { 950 dsl_pool_close(spa->spa_dsl_pool); 951 spa->spa_dsl_pool = NULL; 952 spa->spa_meta_objset = NULL; 953 } 954 955 ddt_unload(spa); 956 957 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 958 959 /* 960 * Drop and purge level 2 cache 961 */ 962 spa_l2cache_drop(spa); 963 964 /* 965 * Close all vdevs. 966 */ 967 if (spa->spa_root_vdev) 968 vdev_free(spa->spa_root_vdev); 969 ASSERT(spa->spa_root_vdev == NULL); 970 971 for (i = 0; i < spa->spa_spares.sav_count; i++) 972 vdev_free(spa->spa_spares.sav_vdevs[i]); 973 if (spa->spa_spares.sav_vdevs) { 974 kmem_free(spa->spa_spares.sav_vdevs, 975 spa->spa_spares.sav_count * sizeof (void *)); 976 spa->spa_spares.sav_vdevs = NULL; 977 } 978 if (spa->spa_spares.sav_config) { 979 nvlist_free(spa->spa_spares.sav_config); 980 spa->spa_spares.sav_config = NULL; 981 } 982 spa->spa_spares.sav_count = 0; 983 984 for (i = 0; i < spa->spa_l2cache.sav_count; i++) 985 vdev_free(spa->spa_l2cache.sav_vdevs[i]); 986 if (spa->spa_l2cache.sav_vdevs) { 987 kmem_free(spa->spa_l2cache.sav_vdevs, 988 spa->spa_l2cache.sav_count * sizeof (void *)); 989 spa->spa_l2cache.sav_vdevs = NULL; 990 } 991 if (spa->spa_l2cache.sav_config) { 992 nvlist_free(spa->spa_l2cache.sav_config); 993 spa->spa_l2cache.sav_config = NULL; 994 } 995 spa->spa_l2cache.sav_count = 0; 996 997 spa->spa_async_suspended = 0; 998 999 spa_config_exit(spa, SCL_ALL, FTAG); 1000 } 1001 1002 /* 1003 * Load (or re-load) the current list of vdevs describing the active spares for 1004 * this pool. When this is called, we have some form of basic information in 1005 * 'spa_spares.sav_config'. We parse this into vdevs, try to open them, and 1006 * then re-generate a more complete list including status information. 1007 */ 1008 static void 1009 spa_load_spares(spa_t *spa) 1010 { 1011 nvlist_t **spares; 1012 uint_t nspares; 1013 int i; 1014 vdev_t *vd, *tvd; 1015 1016 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 1017 1018 /* 1019 * First, close and free any existing spare vdevs. 1020 */ 1021 for (i = 0; i < spa->spa_spares.sav_count; i++) { 1022 vd = spa->spa_spares.sav_vdevs[i]; 1023 1024 /* Undo the call to spa_activate() below */ 1025 if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid, 1026 B_FALSE)) != NULL && tvd->vdev_isspare) 1027 spa_spare_remove(tvd); 1028 vdev_close(vd); 1029 vdev_free(vd); 1030 } 1031 1032 if (spa->spa_spares.sav_vdevs) 1033 kmem_free(spa->spa_spares.sav_vdevs, 1034 spa->spa_spares.sav_count * sizeof (void *)); 1035 1036 if (spa->spa_spares.sav_config == NULL) 1037 nspares = 0; 1038 else 1039 VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, 1040 ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0); 1041 1042 spa->spa_spares.sav_count = (int)nspares; 1043 spa->spa_spares.sav_vdevs = NULL; 1044 1045 if (nspares == 0) 1046 return; 1047 1048 /* 1049 * Construct the array of vdevs, opening them to get status in the 1050 * process. For each spare, there is potentially two different vdev_t 1051 * structures associated with it: one in the list of spares (used only 1052 * for basic validation purposes) and one in the active vdev 1053 * configuration (if it's spared in). During this phase we open and 1054 * validate each vdev on the spare list. If the vdev also exists in the 1055 * active configuration, then we also mark this vdev as an active spare. 1056 */ 1057 spa->spa_spares.sav_vdevs = kmem_alloc(nspares * sizeof (void *), 1058 KM_SLEEP); 1059 for (i = 0; i < spa->spa_spares.sav_count; i++) { 1060 VERIFY(spa_config_parse(spa, &vd, spares[i], NULL, 0, 1061 VDEV_ALLOC_SPARE) == 0); 1062 ASSERT(vd != NULL); 1063 1064 spa->spa_spares.sav_vdevs[i] = vd; 1065 1066 if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid, 1067 B_FALSE)) != NULL) { 1068 if (!tvd->vdev_isspare) 1069 spa_spare_add(tvd); 1070 1071 /* 1072 * We only mark the spare active if we were successfully 1073 * able to load the vdev. Otherwise, importing a pool 1074 * with a bad active spare would result in strange 1075 * behavior, because multiple pool would think the spare 1076 * is actively in use. 1077 * 1078 * There is a vulnerability here to an equally bizarre 1079 * circumstance, where a dead active spare is later 1080 * brought back to life (onlined or otherwise). Given 1081 * the rarity of this scenario, and the extra complexity 1082 * it adds, we ignore the possibility. 1083 */ 1084 if (!vdev_is_dead(tvd)) 1085 spa_spare_activate(tvd); 1086 } 1087 1088 vd->vdev_top = vd; 1089 vd->vdev_aux = &spa->spa_spares; 1090 1091 if (vdev_open(vd) != 0) 1092 continue; 1093 1094 if (vdev_validate_aux(vd) == 0) 1095 spa_spare_add(vd); 1096 } 1097 1098 /* 1099 * Recompute the stashed list of spares, with status information 1100 * this time. 1101 */ 1102 VERIFY(nvlist_remove(spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES, 1103 DATA_TYPE_NVLIST_ARRAY) == 0); 1104 1105 spares = kmem_alloc(spa->spa_spares.sav_count * sizeof (void *), 1106 KM_SLEEP); 1107 for (i = 0; i < spa->spa_spares.sav_count; i++) 1108 spares[i] = vdev_config_generate(spa, 1109 spa->spa_spares.sav_vdevs[i], B_TRUE, B_TRUE, B_FALSE); 1110 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config, 1111 ZPOOL_CONFIG_SPARES, spares, spa->spa_spares.sav_count) == 0); 1112 for (i = 0; i < spa->spa_spares.sav_count; i++) 1113 nvlist_free(spares[i]); 1114 kmem_free(spares, spa->spa_spares.sav_count * sizeof (void *)); 1115 } 1116 1117 /* 1118 * Load (or re-load) the current list of vdevs describing the active l2cache for 1119 * this pool. When this is called, we have some form of basic information in 1120 * 'spa_l2cache.sav_config'. We parse this into vdevs, try to open them, and 1121 * then re-generate a more complete list including status information. 1122 * Devices which are already active have their details maintained, and are 1123 * not re-opened. 1124 */ 1125 static void 1126 spa_load_l2cache(spa_t *spa) 1127 { 1128 nvlist_t **l2cache; 1129 uint_t nl2cache; 1130 int i, j, oldnvdevs; 1131 uint64_t guid; 1132 vdev_t *vd, **oldvdevs, **newvdevs; 1133 spa_aux_vdev_t *sav = &spa->spa_l2cache; 1134 1135 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 1136 1137 if (sav->sav_config != NULL) { 1138 VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, 1139 ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0); 1140 newvdevs = kmem_alloc(nl2cache * sizeof (void *), KM_SLEEP); 1141 } else { 1142 nl2cache = 0; 1143 } 1144 1145 oldvdevs = sav->sav_vdevs; 1146 oldnvdevs = sav->sav_count; 1147 sav->sav_vdevs = NULL; 1148 sav->sav_count = 0; 1149 1150 /* 1151 * Process new nvlist of vdevs. 1152 */ 1153 for (i = 0; i < nl2cache; i++) { 1154 VERIFY(nvlist_lookup_uint64(l2cache[i], ZPOOL_CONFIG_GUID, 1155 &guid) == 0); 1156 1157 newvdevs[i] = NULL; 1158 for (j = 0; j < oldnvdevs; j++) { 1159 vd = oldvdevs[j]; 1160 if (vd != NULL && guid == vd->vdev_guid) { 1161 /* 1162 * Retain previous vdev for add/remove ops. 1163 */ 1164 newvdevs[i] = vd; 1165 oldvdevs[j] = NULL; 1166 break; 1167 } 1168 } 1169 1170 if (newvdevs[i] == NULL) { 1171 /* 1172 * Create new vdev 1173 */ 1174 VERIFY(spa_config_parse(spa, &vd, l2cache[i], NULL, 0, 1175 VDEV_ALLOC_L2CACHE) == 0); 1176 ASSERT(vd != NULL); 1177 newvdevs[i] = vd; 1178 1179 /* 1180 * Commit this vdev as an l2cache device, 1181 * even if it fails to open. 1182 */ 1183 spa_l2cache_add(vd); 1184 1185 vd->vdev_top = vd; 1186 vd->vdev_aux = sav; 1187 1188 spa_l2cache_activate(vd); 1189 1190 if (vdev_open(vd) != 0) 1191 continue; 1192 1193 (void) vdev_validate_aux(vd); 1194 1195 if (!vdev_is_dead(vd)) 1196 l2arc_add_vdev(spa, vd); 1197 } 1198 } 1199 1200 /* 1201 * Purge vdevs that were dropped 1202 */ 1203 for (i = 0; i < oldnvdevs; i++) { 1204 uint64_t pool; 1205 1206 vd = oldvdevs[i]; 1207 if (vd != NULL) { 1208 if (spa_l2cache_exists(vd->vdev_guid, &pool) && 1209 pool != 0ULL && l2arc_vdev_present(vd)) 1210 l2arc_remove_vdev(vd); 1211 (void) vdev_close(vd); 1212 spa_l2cache_remove(vd); 1213 } 1214 } 1215 1216 if (oldvdevs) 1217 kmem_free(oldvdevs, oldnvdevs * sizeof (void *)); 1218 1219 if (sav->sav_config == NULL) 1220 goto out; 1221 1222 sav->sav_vdevs = newvdevs; 1223 sav->sav_count = (int)nl2cache; 1224 1225 /* 1226 * Recompute the stashed list of l2cache devices, with status 1227 * information this time. 1228 */ 1229 VERIFY(nvlist_remove(sav->sav_config, ZPOOL_CONFIG_L2CACHE, 1230 DATA_TYPE_NVLIST_ARRAY) == 0); 1231 1232 l2cache = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP); 1233 for (i = 0; i < sav->sav_count; i++) 1234 l2cache[i] = vdev_config_generate(spa, 1235 sav->sav_vdevs[i], B_TRUE, B_FALSE, B_TRUE); 1236 VERIFY(nvlist_add_nvlist_array(sav->sav_config, 1237 ZPOOL_CONFIG_L2CACHE, l2cache, sav->sav_count) == 0); 1238 out: 1239 for (i = 0; i < sav->sav_count; i++) 1240 nvlist_free(l2cache[i]); 1241 if (sav->sav_count) 1242 kmem_free(l2cache, sav->sav_count * sizeof (void *)); 1243 } 1244 1245 static int 1246 load_nvlist(spa_t *spa, uint64_t obj, nvlist_t **value) 1247 { 1248 dmu_buf_t *db; 1249 char *packed = NULL; 1250 size_t nvsize = 0; 1251 int error; 1252 *value = NULL; 1253 1254 VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db)); 1255 nvsize = *(uint64_t *)db->db_data; 1256 dmu_buf_rele(db, FTAG); 1257 1258 packed = kmem_alloc(nvsize, KM_SLEEP); 1259 error = dmu_read(spa->spa_meta_objset, obj, 0, nvsize, packed, 1260 DMU_READ_PREFETCH); 1261 if (error == 0) 1262 error = nvlist_unpack(packed, nvsize, value, 0); 1263 kmem_free(packed, nvsize); 1264 1265 return (error); 1266 } 1267 1268 /* 1269 * Checks to see if the given vdev could not be opened, in which case we post a 1270 * sysevent to notify the autoreplace code that the device has been removed. 1271 */ 1272 static void 1273 spa_check_removed(vdev_t *vd) 1274 { 1275 for (int c = 0; c < vd->vdev_children; c++) 1276 spa_check_removed(vd->vdev_child[c]); 1277 1278 if (vd->vdev_ops->vdev_op_leaf && vdev_is_dead(vd)) { 1279 zfs_post_autoreplace(vd->vdev_spa, vd); 1280 spa_event_notify(vd->vdev_spa, vd, ESC_ZFS_VDEV_CHECK); 1281 } 1282 } 1283 1284 /* 1285 * Load the slog device state from the config object since it's possible 1286 * that the label does not contain the most up-to-date information. 1287 */ 1288 void 1289 spa_load_log_state(spa_t *spa, nvlist_t *nv) 1290 { 1291 vdev_t *ovd, *rvd = spa->spa_root_vdev; 1292 1293 /* 1294 * Load the original root vdev tree from the passed config. 1295 */ 1296 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1297 VERIFY(spa_config_parse(spa, &ovd, nv, NULL, 0, VDEV_ALLOC_LOAD) == 0); 1298 1299 for (int c = 0; c < rvd->vdev_children; c++) { 1300 vdev_t *cvd = rvd->vdev_child[c]; 1301 if (cvd->vdev_islog) 1302 vdev_load_log_state(cvd, ovd->vdev_child[c]); 1303 } 1304 vdev_free(ovd); 1305 spa_config_exit(spa, SCL_ALL, FTAG); 1306 } 1307 1308 /* 1309 * Check for missing log devices 1310 */ 1311 int 1312 spa_check_logs(spa_t *spa) 1313 { 1314 switch (spa->spa_log_state) { 1315 case SPA_LOG_MISSING: 1316 /* need to recheck in case slog has been restored */ 1317 case SPA_LOG_UNKNOWN: 1318 if (dmu_objset_find(spa->spa_name, zil_check_log_chain, NULL, 1319 DS_FIND_CHILDREN)) { 1320 spa_set_log_state(spa, SPA_LOG_MISSING); 1321 return (1); 1322 } 1323 break; 1324 } 1325 return (0); 1326 } 1327 1328 static boolean_t 1329 spa_passivate_log(spa_t *spa) 1330 { 1331 vdev_t *rvd = spa->spa_root_vdev; 1332 boolean_t slog_found = B_FALSE; 1333 1334 ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER)); 1335 1336 if (!spa_has_slogs(spa)) 1337 return (B_FALSE); 1338 1339 for (int c = 0; c < rvd->vdev_children; c++) { 1340 vdev_t *tvd = rvd->vdev_child[c]; 1341 metaslab_group_t *mg = tvd->vdev_mg; 1342 1343 if (tvd->vdev_islog) { 1344 metaslab_group_passivate(mg); 1345 slog_found = B_TRUE; 1346 } 1347 } 1348 1349 return (slog_found); 1350 } 1351 1352 static void 1353 spa_activate_log(spa_t *spa) 1354 { 1355 vdev_t *rvd = spa->spa_root_vdev; 1356 1357 ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER)); 1358 1359 for (int c = 0; c < rvd->vdev_children; c++) { 1360 vdev_t *tvd = rvd->vdev_child[c]; 1361 metaslab_group_t *mg = tvd->vdev_mg; 1362 1363 if (tvd->vdev_islog) 1364 metaslab_group_activate(mg); 1365 } 1366 } 1367 1368 int 1369 spa_offline_log(spa_t *spa) 1370 { 1371 int error = 0; 1372 1373 if ((error = dmu_objset_find(spa_name(spa), zil_vdev_offline, 1374 NULL, DS_FIND_CHILDREN)) == 0) { 1375 1376 /* 1377 * We successfully offlined the log device, sync out the 1378 * current txg so that the "stubby" block can be removed 1379 * by zil_sync(). 1380 */ 1381 txg_wait_synced(spa->spa_dsl_pool, 0); 1382 } 1383 return (error); 1384 } 1385 1386 static void 1387 spa_aux_check_removed(spa_aux_vdev_t *sav) 1388 { 1389 for (int i = 0; i < sav->sav_count; i++) 1390 spa_check_removed(sav->sav_vdevs[i]); 1391 } 1392 1393 void 1394 spa_claim_notify(zio_t *zio) 1395 { 1396 spa_t *spa = zio->io_spa; 1397 1398 if (zio->io_error) 1399 return; 1400 1401 mutex_enter(&spa->spa_props_lock); /* any mutex will do */ 1402 if (spa->spa_claim_max_txg < zio->io_bp->blk_birth) 1403 spa->spa_claim_max_txg = zio->io_bp->blk_birth; 1404 mutex_exit(&spa->spa_props_lock); 1405 } 1406 1407 typedef struct spa_load_error { 1408 uint64_t sle_metadata_count; 1409 uint64_t sle_data_count; 1410 } spa_load_error_t; 1411 1412 static void 1413 spa_load_verify_done(zio_t *zio) 1414 { 1415 blkptr_t *bp = zio->io_bp; 1416 spa_load_error_t *sle = zio->io_private; 1417 dmu_object_type_t type = BP_GET_TYPE(bp); 1418 int error = zio->io_error; 1419 1420 if (error) { 1421 if ((BP_GET_LEVEL(bp) != 0 || dmu_ot[type].ot_metadata) && 1422 type != DMU_OT_INTENT_LOG) 1423 atomic_add_64(&sle->sle_metadata_count, 1); 1424 else 1425 atomic_add_64(&sle->sle_data_count, 1); 1426 } 1427 zio_data_buf_free(zio->io_data, zio->io_size); 1428 } 1429 1430 /*ARGSUSED*/ 1431 static int 1432 spa_load_verify_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, 1433 const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg) 1434 { 1435 if (bp != NULL) { 1436 zio_t *rio = arg; 1437 size_t size = BP_GET_PSIZE(bp); 1438 void *data = zio_data_buf_alloc(size); 1439 1440 zio_nowait(zio_read(rio, spa, bp, data, size, 1441 spa_load_verify_done, rio->io_private, ZIO_PRIORITY_SCRUB, 1442 ZIO_FLAG_SPECULATIVE | ZIO_FLAG_CANFAIL | 1443 ZIO_FLAG_SCRUB | ZIO_FLAG_RAW, zb)); 1444 } 1445 return (0); 1446 } 1447 1448 static int 1449 spa_load_verify(spa_t *spa) 1450 { 1451 zio_t *rio; 1452 spa_load_error_t sle = { 0 }; 1453 zpool_rewind_policy_t policy; 1454 boolean_t verify_ok = B_FALSE; 1455 int error; 1456 1457 rio = zio_root(spa, NULL, &sle, 1458 ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE); 1459 1460 error = traverse_pool(spa, spa->spa_verify_min_txg, 1461 TRAVERSE_PRE | TRAVERSE_PREFETCH, spa_load_verify_cb, rio); 1462 1463 (void) zio_wait(rio); 1464 1465 zpool_get_rewind_policy(spa->spa_config, &policy); 1466 1467 spa->spa_load_meta_errors = sle.sle_metadata_count; 1468 spa->spa_load_data_errors = sle.sle_data_count; 1469 1470 if (!error && sle.sle_metadata_count <= policy.zrp_maxmeta && 1471 sle.sle_data_count <= policy.zrp_maxdata) { 1472 verify_ok = B_TRUE; 1473 spa->spa_load_txg = spa->spa_uberblock.ub_txg; 1474 spa->spa_load_txg_ts = spa->spa_uberblock.ub_timestamp; 1475 } else { 1476 spa->spa_load_max_txg = spa->spa_uberblock.ub_txg; 1477 } 1478 1479 if (error) { 1480 if (error != ENXIO && error != EIO) 1481 error = EIO; 1482 return (error); 1483 } 1484 1485 return (verify_ok ? 0 : EIO); 1486 } 1487 1488 /* 1489 * Find a value in the pool props object. 1490 */ 1491 static void 1492 spa_prop_find(spa_t *spa, zpool_prop_t prop, uint64_t *val) 1493 { 1494 (void) zap_lookup(spa->spa_meta_objset, spa->spa_pool_props_object, 1495 zpool_prop_to_name(prop), sizeof (uint64_t), 1, val); 1496 } 1497 1498 /* 1499 * Find a value in the pool directory object. 1500 */ 1501 static int 1502 spa_dir_prop(spa_t *spa, const char *name, uint64_t *val) 1503 { 1504 return (zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 1505 name, sizeof (uint64_t), 1, val)); 1506 } 1507 1508 static int 1509 spa_vdev_err(vdev_t *vdev, vdev_aux_t aux, int err) 1510 { 1511 vdev_set_state(vdev, B_TRUE, VDEV_STATE_CANT_OPEN, aux); 1512 return (err); 1513 } 1514 1515 /* 1516 * Fix up config after a partly-completed split. This is done with the 1517 * ZPOOL_CONFIG_SPLIT nvlist. Both the splitting pool and the split-off 1518 * pool have that entry in their config, but only the splitting one contains 1519 * a list of all the guids of the vdevs that are being split off. 1520 * 1521 * This function determines what to do with that list: either rejoin 1522 * all the disks to the pool, or complete the splitting process. To attempt 1523 * the rejoin, each disk that is offlined is marked online again, and 1524 * we do a reopen() call. If the vdev label for every disk that was 1525 * marked online indicates it was successfully split off (VDEV_AUX_SPLIT_POOL) 1526 * then we call vdev_split() on each disk, and complete the split. 1527 * 1528 * Otherwise we leave the config alone, with all the vdevs in place in 1529 * the original pool. 1530 */ 1531 static void 1532 spa_try_repair(spa_t *spa, nvlist_t *config) 1533 { 1534 uint_t extracted; 1535 uint64_t *glist; 1536 uint_t i, gcount; 1537 nvlist_t *nvl; 1538 vdev_t **vd; 1539 boolean_t attempt_reopen; 1540 1541 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT, &nvl) != 0) 1542 return; 1543 1544 /* check that the config is complete */ 1545 if (nvlist_lookup_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST, 1546 &glist, &gcount) != 0) 1547 return; 1548 1549 vd = kmem_zalloc(gcount * sizeof (vdev_t *), KM_SLEEP); 1550 1551 /* attempt to online all the vdevs & validate */ 1552 attempt_reopen = B_TRUE; 1553 for (i = 0; i < gcount; i++) { 1554 if (glist[i] == 0) /* vdev is hole */ 1555 continue; 1556 1557 vd[i] = spa_lookup_by_guid(spa, glist[i], B_FALSE); 1558 if (vd[i] == NULL) { 1559 /* 1560 * Don't bother attempting to reopen the disks; 1561 * just do the split. 1562 */ 1563 attempt_reopen = B_FALSE; 1564 } else { 1565 /* attempt to re-online it */ 1566 vd[i]->vdev_offline = B_FALSE; 1567 } 1568 } 1569 1570 if (attempt_reopen) { 1571 vdev_reopen(spa->spa_root_vdev); 1572 1573 /* check each device to see what state it's in */ 1574 for (extracted = 0, i = 0; i < gcount; i++) { 1575 if (vd[i] != NULL && 1576 vd[i]->vdev_stat.vs_aux != VDEV_AUX_SPLIT_POOL) 1577 break; 1578 ++extracted; 1579 } 1580 } 1581 1582 /* 1583 * If every disk has been moved to the new pool, or if we never 1584 * even attempted to look at them, then we split them off for 1585 * good. 1586 */ 1587 if (!attempt_reopen || gcount == extracted) { 1588 for (i = 0; i < gcount; i++) 1589 if (vd[i] != NULL) 1590 vdev_split(vd[i]); 1591 vdev_reopen(spa->spa_root_vdev); 1592 } 1593 1594 kmem_free(vd, gcount * sizeof (vdev_t *)); 1595 } 1596 1597 static int 1598 spa_load(spa_t *spa, spa_load_state_t state, spa_import_type_t type, 1599 boolean_t mosconfig) 1600 { 1601 nvlist_t *config = spa->spa_config; 1602 char *ereport = FM_EREPORT_ZFS_POOL; 1603 int error; 1604 uint64_t pool_guid; 1605 nvlist_t *nvl; 1606 1607 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid)) 1608 return (EINVAL); 1609 1610 /* 1611 * Versioning wasn't explicitly added to the label until later, so if 1612 * it's not present treat it as the initial version. 1613 */ 1614 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 1615 &spa->spa_ubsync.ub_version) != 0) 1616 spa->spa_ubsync.ub_version = SPA_VERSION_INITIAL; 1617 1618 (void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, 1619 &spa->spa_config_txg); 1620 1621 if ((state == SPA_LOAD_IMPORT || state == SPA_LOAD_TRYIMPORT) && 1622 spa_guid_exists(pool_guid, 0)) { 1623 error = EEXIST; 1624 } else { 1625 spa->spa_load_guid = pool_guid; 1626 1627 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT, 1628 &nvl) == 0) { 1629 VERIFY(nvlist_dup(nvl, &spa->spa_config_splitting, 1630 KM_SLEEP) == 0); 1631 } 1632 1633 error = spa_load_impl(spa, pool_guid, config, state, type, 1634 mosconfig, &ereport); 1635 } 1636 1637 spa->spa_minref = refcount_count(&spa->spa_refcount); 1638 if (error && error != EBADF) 1639 zfs_ereport_post(ereport, spa, NULL, NULL, 0, 0); 1640 spa->spa_load_state = error ? SPA_LOAD_ERROR : SPA_LOAD_NONE; 1641 spa->spa_ena = 0; 1642 1643 return (error); 1644 } 1645 1646 /* 1647 * Load an existing storage pool, using the pool's builtin spa_config as a 1648 * source of configuration information. 1649 */ 1650 static int 1651 spa_load_impl(spa_t *spa, uint64_t pool_guid, nvlist_t *config, 1652 spa_load_state_t state, spa_import_type_t type, boolean_t mosconfig, 1653 char **ereport) 1654 { 1655 int error = 0; 1656 nvlist_t *nvconfig, *nvroot = NULL; 1657 vdev_t *rvd; 1658 uberblock_t *ub = &spa->spa_uberblock; 1659 uint64_t config_cache_txg = spa->spa_config_txg; 1660 int orig_mode = spa->spa_mode; 1661 int parse; 1662 1663 /* 1664 * If this is an untrusted config, access the pool in read-only mode. 1665 * This prevents things like resilvering recently removed devices. 1666 */ 1667 if (!mosconfig) 1668 spa->spa_mode = FREAD; 1669 1670 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 1671 1672 spa->spa_load_state = state; 1673 1674 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvroot)) 1675 return (EINVAL); 1676 1677 parse = (type == SPA_IMPORT_EXISTING ? 1678 VDEV_ALLOC_LOAD : VDEV_ALLOC_SPLIT); 1679 1680 /* 1681 * Create "The Godfather" zio to hold all async IOs 1682 */ 1683 spa->spa_async_zio_root = zio_root(spa, NULL, NULL, 1684 ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE | ZIO_FLAG_GODFATHER); 1685 1686 /* 1687 * Parse the configuration into a vdev tree. We explicitly set the 1688 * value that will be returned by spa_version() since parsing the 1689 * configuration requires knowing the version number. 1690 */ 1691 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1692 error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, parse); 1693 spa_config_exit(spa, SCL_ALL, FTAG); 1694 1695 if (error != 0) 1696 return (error); 1697 1698 ASSERT(spa->spa_root_vdev == rvd); 1699 1700 if (type != SPA_IMPORT_ASSEMBLE) { 1701 ASSERT(spa_guid(spa) == pool_guid); 1702 } 1703 1704 /* 1705 * Try to open all vdevs, loading each label in the process. 1706 */ 1707 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1708 error = vdev_open(rvd); 1709 spa_config_exit(spa, SCL_ALL, FTAG); 1710 if (error != 0) 1711 return (error); 1712 1713 /* 1714 * We need to validate the vdev labels against the configuration that 1715 * we have in hand, which is dependent on the setting of mosconfig. If 1716 * mosconfig is true then we're validating the vdev labels based on 1717 * that config. Otherwise, we're validating against the cached config 1718 * (zpool.cache) that was read when we loaded the zfs module, and then 1719 * later we will recursively call spa_load() and validate against 1720 * the vdev config. 1721 * 1722 * If we're assembling a new pool that's been split off from an 1723 * existing pool, the labels haven't yet been updated so we skip 1724 * validation for now. 1725 */ 1726 if (type != SPA_IMPORT_ASSEMBLE) { 1727 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1728 error = vdev_validate(rvd); 1729 spa_config_exit(spa, SCL_ALL, FTAG); 1730 1731 if (error != 0) 1732 return (error); 1733 1734 if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) 1735 return (ENXIO); 1736 } 1737 1738 /* 1739 * Find the best uberblock. 1740 */ 1741 vdev_uberblock_load(NULL, rvd, ub); 1742 1743 /* 1744 * If we weren't able to find a single valid uberblock, return failure. 1745 */ 1746 if (ub->ub_txg == 0) 1747 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, ENXIO)); 1748 1749 /* 1750 * If the pool is newer than the code, we can't open it. 1751 */ 1752 if (ub->ub_version > SPA_VERSION) 1753 return (spa_vdev_err(rvd, VDEV_AUX_VERSION_NEWER, ENOTSUP)); 1754 1755 /* 1756 * If the vdev guid sum doesn't match the uberblock, we have an 1757 * incomplete configuration. 1758 */ 1759 if (mosconfig && type != SPA_IMPORT_ASSEMBLE && 1760 rvd->vdev_guid_sum != ub->ub_guid_sum) 1761 return (spa_vdev_err(rvd, VDEV_AUX_BAD_GUID_SUM, ENXIO)); 1762 1763 if (type != SPA_IMPORT_ASSEMBLE && spa->spa_config_splitting) { 1764 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1765 spa_try_repair(spa, config); 1766 spa_config_exit(spa, SCL_ALL, FTAG); 1767 nvlist_free(spa->spa_config_splitting); 1768 spa->spa_config_splitting = NULL; 1769 } 1770 1771 /* 1772 * Initialize internal SPA structures. 1773 */ 1774 spa->spa_state = POOL_STATE_ACTIVE; 1775 spa->spa_ubsync = spa->spa_uberblock; 1776 spa->spa_verify_min_txg = spa->spa_extreme_rewind ? 1777 TXG_INITIAL : spa_last_synced_txg(spa) - TXG_DEFER_SIZE; 1778 spa->spa_first_txg = spa->spa_last_ubsync_txg ? 1779 spa->spa_last_ubsync_txg : spa_last_synced_txg(spa) + 1; 1780 spa->spa_claim_max_txg = spa->spa_first_txg; 1781 1782 error = dsl_pool_open(spa, spa->spa_first_txg, &spa->spa_dsl_pool); 1783 if (error) 1784 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1785 spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset; 1786 1787 if (spa_dir_prop(spa, DMU_POOL_CONFIG, &spa->spa_config_object) != 0) 1788 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1789 1790 if (load_nvlist(spa, spa->spa_config_object, &nvconfig) != 0) 1791 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1792 1793 if (!mosconfig) { 1794 uint64_t hostid; 1795 1796 if (!spa_is_root(spa) && nvlist_lookup_uint64(nvconfig, 1797 ZPOOL_CONFIG_HOSTID, &hostid) == 0) { 1798 char *hostname; 1799 unsigned long myhostid = 0; 1800 1801 VERIFY(nvlist_lookup_string(nvconfig, 1802 ZPOOL_CONFIG_HOSTNAME, &hostname) == 0); 1803 1804 #ifdef _KERNEL 1805 myhostid = zone_get_hostid(NULL); 1806 #else /* _KERNEL */ 1807 /* 1808 * We're emulating the system's hostid in userland, so 1809 * we can't use zone_get_hostid(). 1810 */ 1811 (void) ddi_strtoul(hw_serial, NULL, 10, &myhostid); 1812 #endif /* _KERNEL */ 1813 if (hostid != 0 && myhostid != 0 && 1814 hostid != myhostid) { 1815 cmn_err(CE_WARN, "pool '%s' could not be " 1816 "loaded as it was last accessed by " 1817 "another system (host: %s hostid: 0x%lx). " 1818 "See: http://www.sun.com/msg/ZFS-8000-EY", 1819 spa_name(spa), hostname, 1820 (unsigned long)hostid); 1821 return (EBADF); 1822 } 1823 } 1824 1825 spa_config_set(spa, nvconfig); 1826 spa_unload(spa); 1827 spa_deactivate(spa); 1828 spa_activate(spa, orig_mode); 1829 1830 return (spa_load(spa, state, SPA_IMPORT_EXISTING, B_TRUE)); 1831 } 1832 1833 if (spa_dir_prop(spa, DMU_POOL_SYNC_BPLIST, 1834 &spa->spa_deferred_bplist_obj) != 0) 1835 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1836 1837 /* 1838 * Load the bit that tells us to use the new accounting function 1839 * (raid-z deflation). If we have an older pool, this will not 1840 * be present. 1841 */ 1842 error = spa_dir_prop(spa, DMU_POOL_DEFLATE, &spa->spa_deflate); 1843 if (error != 0 && error != ENOENT) 1844 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1845 1846 /* 1847 * Load the persistent error log. If we have an older pool, this will 1848 * not be present. 1849 */ 1850 error = spa_dir_prop(spa, DMU_POOL_ERRLOG_LAST, &spa->spa_errlog_last); 1851 if (error != 0 && error != ENOENT) 1852 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1853 1854 error = spa_dir_prop(spa, DMU_POOL_ERRLOG_SCRUB, 1855 &spa->spa_errlog_scrub); 1856 if (error != 0 && error != ENOENT) 1857 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1858 1859 /* 1860 * Load the history object. If we have an older pool, this 1861 * will not be present. 1862 */ 1863 error = spa_dir_prop(spa, DMU_POOL_HISTORY, &spa->spa_history); 1864 if (error != 0 && error != ENOENT) 1865 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1866 1867 /* 1868 * If we're assembling the pool from the split-off vdevs of 1869 * an existing pool, we don't want to attach the spares & cache 1870 * devices. 1871 */ 1872 1873 /* 1874 * Load any hot spares for this pool. 1875 */ 1876 error = spa_dir_prop(spa, DMU_POOL_SPARES, &spa->spa_spares.sav_object); 1877 if (error != 0 && error != ENOENT) 1878 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1879 if (error == 0 && type != SPA_IMPORT_ASSEMBLE) { 1880 ASSERT(spa_version(spa) >= SPA_VERSION_SPARES); 1881 if (load_nvlist(spa, spa->spa_spares.sav_object, 1882 &spa->spa_spares.sav_config) != 0) 1883 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1884 1885 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1886 spa_load_spares(spa); 1887 spa_config_exit(spa, SCL_ALL, FTAG); 1888 } else if (error == 0) { 1889 spa->spa_spares.sav_sync = B_TRUE; 1890 } 1891 1892 /* 1893 * Load any level 2 ARC devices for this pool. 1894 */ 1895 error = spa_dir_prop(spa, DMU_POOL_L2CACHE, 1896 &spa->spa_l2cache.sav_object); 1897 if (error != 0 && error != ENOENT) 1898 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1899 if (error == 0 && type != SPA_IMPORT_ASSEMBLE) { 1900 ASSERT(spa_version(spa) >= SPA_VERSION_L2CACHE); 1901 if (load_nvlist(spa, spa->spa_l2cache.sav_object, 1902 &spa->spa_l2cache.sav_config) != 0) 1903 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1904 1905 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1906 spa_load_l2cache(spa); 1907 spa_config_exit(spa, SCL_ALL, FTAG); 1908 } else if (error == 0) { 1909 spa->spa_l2cache.sav_sync = B_TRUE; 1910 } 1911 1912 spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION); 1913 1914 error = spa_dir_prop(spa, DMU_POOL_PROPS, &spa->spa_pool_props_object); 1915 if (error && error != ENOENT) 1916 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1917 1918 if (error == 0) { 1919 uint64_t autoreplace; 1920 1921 spa_prop_find(spa, ZPOOL_PROP_BOOTFS, &spa->spa_bootfs); 1922 spa_prop_find(spa, ZPOOL_PROP_AUTOREPLACE, &autoreplace); 1923 spa_prop_find(spa, ZPOOL_PROP_DELEGATION, &spa->spa_delegation); 1924 spa_prop_find(spa, ZPOOL_PROP_FAILUREMODE, &spa->spa_failmode); 1925 spa_prop_find(spa, ZPOOL_PROP_AUTOEXPAND, &spa->spa_autoexpand); 1926 spa_prop_find(spa, ZPOOL_PROP_DEDUPDITTO, 1927 &spa->spa_dedup_ditto); 1928 1929 spa->spa_autoreplace = (autoreplace != 0); 1930 } 1931 1932 /* 1933 * If the 'autoreplace' property is set, then post a resource notifying 1934 * the ZFS DE that it should not issue any faults for unopenable 1935 * devices. We also iterate over the vdevs, and post a sysevent for any 1936 * unopenable vdevs so that the normal autoreplace handler can take 1937 * over. 1938 */ 1939 if (spa->spa_autoreplace && state != SPA_LOAD_TRYIMPORT) { 1940 spa_check_removed(spa->spa_root_vdev); 1941 /* 1942 * For the import case, this is done in spa_import(), because 1943 * at this point we're using the spare definitions from 1944 * the MOS config, not necessarily from the userland config. 1945 */ 1946 if (state != SPA_LOAD_IMPORT) { 1947 spa_aux_check_removed(&spa->spa_spares); 1948 spa_aux_check_removed(&spa->spa_l2cache); 1949 } 1950 } 1951 1952 /* 1953 * Load the vdev state for all toplevel vdevs. 1954 */ 1955 vdev_load(rvd); 1956 1957 /* 1958 * Propagate the leaf DTLs we just loaded all the way up the tree. 1959 */ 1960 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1961 vdev_dtl_reassess(rvd, 0, 0, B_FALSE); 1962 spa_config_exit(spa, SCL_ALL, FTAG); 1963 1964 /* 1965 * Check the state of the root vdev. If it can't be opened, it 1966 * indicates one or more toplevel vdevs are faulted. 1967 */ 1968 if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) 1969 return (ENXIO); 1970 1971 /* 1972 * Load the DDTs (dedup tables). 1973 */ 1974 error = ddt_load(spa); 1975 if (error != 0) 1976 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1977 1978 spa_update_dspace(spa); 1979 1980 if (state != SPA_LOAD_TRYIMPORT) { 1981 error = spa_load_verify(spa); 1982 if (error) 1983 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, 1984 error)); 1985 } 1986 1987 /* 1988 * Load the intent log state and check log integrity. If we're 1989 * assembling a pool from a split, the log is not transferred over. 1990 */ 1991 if (type != SPA_IMPORT_ASSEMBLE) { 1992 VERIFY(nvlist_lookup_nvlist(nvconfig, ZPOOL_CONFIG_VDEV_TREE, 1993 &nvroot) == 0); 1994 spa_load_log_state(spa, nvroot); 1995 nvlist_free(nvconfig); 1996 1997 if (spa_check_logs(spa)) { 1998 *ereport = FM_EREPORT_ZFS_LOG_REPLAY; 1999 return (spa_vdev_err(rvd, VDEV_AUX_BAD_LOG, ENXIO)); 2000 } 2001 } 2002 2003 if (spa_writeable(spa) && (state == SPA_LOAD_RECOVER || 2004 spa->spa_load_max_txg == UINT64_MAX)) { 2005 dmu_tx_t *tx; 2006 int need_update = B_FALSE; 2007 2008 ASSERT(state != SPA_LOAD_TRYIMPORT); 2009 2010 /* 2011 * Claim log blocks that haven't been committed yet. 2012 * This must all happen in a single txg. 2013 * Note: spa_claim_max_txg is updated by spa_claim_notify(), 2014 * invoked from zil_claim_log_block()'s i/o done callback. 2015 * Price of rollback is that we abandon the log. 2016 */ 2017 spa->spa_claiming = B_TRUE; 2018 2019 tx = dmu_tx_create_assigned(spa_get_dsl(spa), 2020 spa_first_txg(spa)); 2021 (void) dmu_objset_find(spa_name(spa), 2022 zil_claim, tx, DS_FIND_CHILDREN); 2023 dmu_tx_commit(tx); 2024 2025 spa->spa_claiming = B_FALSE; 2026 2027 spa_set_log_state(spa, SPA_LOG_GOOD); 2028 spa->spa_sync_on = B_TRUE; 2029 txg_sync_start(spa->spa_dsl_pool); 2030 2031 /* 2032 * Wait for all claims to sync. We sync up to the highest 2033 * claimed log block birth time so that claimed log blocks 2034 * don't appear to be from the future. spa_claim_max_txg 2035 * will have been set for us by either zil_check_log_chain() 2036 * (invoked from spa_check_logs()) or zil_claim() above. 2037 */ 2038 txg_wait_synced(spa->spa_dsl_pool, spa->spa_claim_max_txg); 2039 2040 /* 2041 * If the config cache is stale, or we have uninitialized 2042 * metaslabs (see spa_vdev_add()), then update the config. 2043 * 2044 * If spa_load_verbatim is true, trust the current 2045 * in-core spa_config and update the disk labels. 2046 */ 2047 if (config_cache_txg != spa->spa_config_txg || 2048 state == SPA_LOAD_IMPORT || spa->spa_load_verbatim || 2049 state == SPA_LOAD_RECOVER) 2050 need_update = B_TRUE; 2051 2052 for (int c = 0; c < rvd->vdev_children; c++) 2053 if (rvd->vdev_child[c]->vdev_ms_array == 0) 2054 need_update = B_TRUE; 2055 2056 /* 2057 * Update the config cache asychronously in case we're the 2058 * root pool, in which case the config cache isn't writable yet. 2059 */ 2060 if (need_update) 2061 spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); 2062 2063 /* 2064 * Check all DTLs to see if anything needs resilvering. 2065 */ 2066 if (vdev_resilver_needed(rvd, NULL, NULL)) 2067 spa_async_request(spa, SPA_ASYNC_RESILVER); 2068 2069 /* 2070 * Delete any inconsistent datasets. 2071 */ 2072 (void) dmu_objset_find(spa_name(spa), 2073 dsl_destroy_inconsistent, NULL, DS_FIND_CHILDREN); 2074 2075 /* 2076 * Clean up any stale temporary dataset userrefs. 2077 */ 2078 dsl_pool_clean_tmp_userrefs(spa->spa_dsl_pool); 2079 } 2080 2081 return (0); 2082 } 2083 2084 static int 2085 spa_load_retry(spa_t *spa, spa_load_state_t state, int mosconfig) 2086 { 2087 spa_unload(spa); 2088 spa_deactivate(spa); 2089 2090 spa->spa_load_max_txg--; 2091 2092 spa_activate(spa, spa_mode_global); 2093 spa_async_suspend(spa); 2094 2095 return (spa_load(spa, state, SPA_IMPORT_EXISTING, mosconfig)); 2096 } 2097 2098 static int 2099 spa_load_best(spa_t *spa, spa_load_state_t state, int mosconfig, 2100 uint64_t max_request, boolean_t extreme) 2101 { 2102 nvlist_t *config = NULL; 2103 int load_error, rewind_error; 2104 uint64_t safe_rollback_txg; 2105 uint64_t min_txg; 2106 2107 if (spa->spa_load_txg && state == SPA_LOAD_RECOVER) { 2108 spa->spa_load_max_txg = spa->spa_load_txg; 2109 spa_set_log_state(spa, SPA_LOG_CLEAR); 2110 } else { 2111 spa->spa_load_max_txg = max_request; 2112 } 2113 2114 load_error = rewind_error = spa_load(spa, state, SPA_IMPORT_EXISTING, 2115 mosconfig); 2116 if (load_error == 0) 2117 return (0); 2118 2119 if (spa->spa_root_vdev != NULL) 2120 config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 2121 2122 spa->spa_last_ubsync_txg = spa->spa_uberblock.ub_txg; 2123 spa->spa_last_ubsync_txg_ts = spa->spa_uberblock.ub_timestamp; 2124 2125 /* specific txg requested */ 2126 if (spa->spa_load_max_txg != UINT64_MAX && !extreme) { 2127 nvlist_free(config); 2128 return (load_error); 2129 } 2130 2131 /* Price of rolling back is discarding txgs, including log */ 2132 if (state == SPA_LOAD_RECOVER) 2133 spa_set_log_state(spa, SPA_LOG_CLEAR); 2134 2135 spa->spa_load_max_txg = spa->spa_uberblock.ub_txg; 2136 safe_rollback_txg = spa->spa_uberblock.ub_txg - TXG_DEFER_SIZE; 2137 2138 min_txg = extreme ? TXG_INITIAL : safe_rollback_txg; 2139 while (rewind_error && (spa->spa_uberblock.ub_txg >= min_txg)) { 2140 if (spa->spa_load_max_txg < safe_rollback_txg) 2141 spa->spa_extreme_rewind = B_TRUE; 2142 rewind_error = spa_load_retry(spa, state, mosconfig); 2143 } 2144 2145 if (config) 2146 spa_rewind_data_to_nvlist(spa, config); 2147 2148 spa->spa_extreme_rewind = B_FALSE; 2149 spa->spa_load_max_txg = UINT64_MAX; 2150 2151 if (config && (rewind_error || state != SPA_LOAD_RECOVER)) 2152 spa_config_set(spa, config); 2153 2154 return (state == SPA_LOAD_RECOVER ? rewind_error : load_error); 2155 } 2156 2157 /* 2158 * Pool Open/Import 2159 * 2160 * The import case is identical to an open except that the configuration is sent 2161 * down from userland, instead of grabbed from the configuration cache. For the 2162 * case of an open, the pool configuration will exist in the 2163 * POOL_STATE_UNINITIALIZED state. 2164 * 2165 * The stats information (gen/count/ustats) is used to gather vdev statistics at 2166 * the same time open the pool, without having to keep around the spa_t in some 2167 * ambiguous state. 2168 */ 2169 static int 2170 spa_open_common(const char *pool, spa_t **spapp, void *tag, nvlist_t *nvpolicy, 2171 nvlist_t **config) 2172 { 2173 spa_t *spa; 2174 boolean_t norewind; 2175 boolean_t extreme; 2176 zpool_rewind_policy_t policy; 2177 spa_load_state_t state = SPA_LOAD_OPEN; 2178 int error; 2179 int locked = B_FALSE; 2180 2181 *spapp = NULL; 2182 2183 zpool_get_rewind_policy(nvpolicy, &policy); 2184 if (policy.zrp_request & ZPOOL_DO_REWIND) 2185 state = SPA_LOAD_RECOVER; 2186 norewind = (policy.zrp_request == ZPOOL_NO_REWIND); 2187 extreme = ((policy.zrp_request & ZPOOL_EXTREME_REWIND) != 0); 2188 2189 /* 2190 * As disgusting as this is, we need to support recursive calls to this 2191 * function because dsl_dir_open() is called during spa_load(), and ends 2192 * up calling spa_open() again. The real fix is to figure out how to 2193 * avoid dsl_dir_open() calling this in the first place. 2194 */ 2195 if (mutex_owner(&spa_namespace_lock) != curthread) { 2196 mutex_enter(&spa_namespace_lock); 2197 locked = B_TRUE; 2198 } 2199 2200 if ((spa = spa_lookup(pool)) == NULL) { 2201 if (locked) 2202 mutex_exit(&spa_namespace_lock); 2203 return (ENOENT); 2204 } 2205 2206 if (spa->spa_state == POOL_STATE_UNINITIALIZED) { 2207 2208 spa_activate(spa, spa_mode_global); 2209 2210 if (spa->spa_last_open_failed && norewind) { 2211 if (config != NULL && spa->spa_config) 2212 VERIFY(nvlist_dup(spa->spa_config, 2213 config, KM_SLEEP) == 0); 2214 spa_deactivate(spa); 2215 if (locked) 2216 mutex_exit(&spa_namespace_lock); 2217 return (spa->spa_last_open_failed); 2218 } 2219 2220 if (state != SPA_LOAD_RECOVER) 2221 spa->spa_last_ubsync_txg = spa->spa_load_txg = 0; 2222 2223 error = spa_load_best(spa, state, B_FALSE, policy.zrp_txg, 2224 extreme); 2225 2226 if (error == EBADF) { 2227 /* 2228 * If vdev_validate() returns failure (indicated by 2229 * EBADF), it indicates that one of the vdevs indicates 2230 * that the pool has been exported or destroyed. If 2231 * this is the case, the config cache is out of sync and 2232 * we should remove the pool from the namespace. 2233 */ 2234 spa_unload(spa); 2235 spa_deactivate(spa); 2236 spa_config_sync(spa, B_TRUE, B_TRUE); 2237 spa_remove(spa); 2238 if (locked) 2239 mutex_exit(&spa_namespace_lock); 2240 return (ENOENT); 2241 } 2242 2243 if (error) { 2244 /* 2245 * We can't open the pool, but we still have useful 2246 * information: the state of each vdev after the 2247 * attempted vdev_open(). Return this to the user. 2248 */ 2249 if (config != NULL && spa->spa_config) 2250 VERIFY(nvlist_dup(spa->spa_config, config, 2251 KM_SLEEP) == 0); 2252 spa_unload(spa); 2253 spa_deactivate(spa); 2254 spa->spa_last_open_failed = error; 2255 if (locked) 2256 mutex_exit(&spa_namespace_lock); 2257 *spapp = NULL; 2258 return (error); 2259 } 2260 2261 } 2262 2263 spa_open_ref(spa, tag); 2264 2265 2266 if (config != NULL) 2267 *config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 2268 2269 if (locked) { 2270 spa->spa_last_open_failed = 0; 2271 spa->spa_last_ubsync_txg = 0; 2272 spa->spa_load_txg = 0; 2273 mutex_exit(&spa_namespace_lock); 2274 } 2275 2276 *spapp = spa; 2277 2278 return (0); 2279 } 2280 2281 int 2282 spa_open_rewind(const char *name, spa_t **spapp, void *tag, nvlist_t *policy, 2283 nvlist_t **config) 2284 { 2285 return (spa_open_common(name, spapp, tag, policy, config)); 2286 } 2287 2288 int 2289 spa_open(const char *name, spa_t **spapp, void *tag) 2290 { 2291 return (spa_open_common(name, spapp, tag, NULL, NULL)); 2292 } 2293 2294 /* 2295 * Lookup the given spa_t, incrementing the inject count in the process, 2296 * preventing it from being exported or destroyed. 2297 */ 2298 spa_t * 2299 spa_inject_addref(char *name) 2300 { 2301 spa_t *spa; 2302 2303 mutex_enter(&spa_namespace_lock); 2304 if ((spa = spa_lookup(name)) == NULL) { 2305 mutex_exit(&spa_namespace_lock); 2306 return (NULL); 2307 } 2308 spa->spa_inject_ref++; 2309 mutex_exit(&spa_namespace_lock); 2310 2311 return (spa); 2312 } 2313 2314 void 2315 spa_inject_delref(spa_t *spa) 2316 { 2317 mutex_enter(&spa_namespace_lock); 2318 spa->spa_inject_ref--; 2319 mutex_exit(&spa_namespace_lock); 2320 } 2321 2322 /* 2323 * Add spares device information to the nvlist. 2324 */ 2325 static void 2326 spa_add_spares(spa_t *spa, nvlist_t *config) 2327 { 2328 nvlist_t **spares; 2329 uint_t i, nspares; 2330 nvlist_t *nvroot; 2331 uint64_t guid; 2332 vdev_stat_t *vs; 2333 uint_t vsc; 2334 uint64_t pool; 2335 2336 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); 2337 2338 if (spa->spa_spares.sav_count == 0) 2339 return; 2340 2341 VERIFY(nvlist_lookup_nvlist(config, 2342 ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); 2343 VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, 2344 ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0); 2345 if (nspares != 0) { 2346 VERIFY(nvlist_add_nvlist_array(nvroot, 2347 ZPOOL_CONFIG_SPARES, spares, nspares) == 0); 2348 VERIFY(nvlist_lookup_nvlist_array(nvroot, 2349 ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0); 2350 2351 /* 2352 * Go through and find any spares which have since been 2353 * repurposed as an active spare. If this is the case, update 2354 * their status appropriately. 2355 */ 2356 for (i = 0; i < nspares; i++) { 2357 VERIFY(nvlist_lookup_uint64(spares[i], 2358 ZPOOL_CONFIG_GUID, &guid) == 0); 2359 if (spa_spare_exists(guid, &pool, NULL) && 2360 pool != 0ULL) { 2361 VERIFY(nvlist_lookup_uint64_array( 2362 spares[i], ZPOOL_CONFIG_STATS, 2363 (uint64_t **)&vs, &vsc) == 0); 2364 vs->vs_state = VDEV_STATE_CANT_OPEN; 2365 vs->vs_aux = VDEV_AUX_SPARED; 2366 } 2367 } 2368 } 2369 } 2370 2371 /* 2372 * Add l2cache device information to the nvlist, including vdev stats. 2373 */ 2374 static void 2375 spa_add_l2cache(spa_t *spa, nvlist_t *config) 2376 { 2377 nvlist_t **l2cache; 2378 uint_t i, j, nl2cache; 2379 nvlist_t *nvroot; 2380 uint64_t guid; 2381 vdev_t *vd; 2382 vdev_stat_t *vs; 2383 uint_t vsc; 2384 2385 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); 2386 2387 if (spa->spa_l2cache.sav_count == 0) 2388 return; 2389 2390 VERIFY(nvlist_lookup_nvlist(config, 2391 ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); 2392 VERIFY(nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config, 2393 ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0); 2394 if (nl2cache != 0) { 2395 VERIFY(nvlist_add_nvlist_array(nvroot, 2396 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); 2397 VERIFY(nvlist_lookup_nvlist_array(nvroot, 2398 ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0); 2399 2400 /* 2401 * Update level 2 cache device stats. 2402 */ 2403 2404 for (i = 0; i < nl2cache; i++) { 2405 VERIFY(nvlist_lookup_uint64(l2cache[i], 2406 ZPOOL_CONFIG_GUID, &guid) == 0); 2407 2408 vd = NULL; 2409 for (j = 0; j < spa->spa_l2cache.sav_count; j++) { 2410 if (guid == 2411 spa->spa_l2cache.sav_vdevs[j]->vdev_guid) { 2412 vd = spa->spa_l2cache.sav_vdevs[j]; 2413 break; 2414 } 2415 } 2416 ASSERT(vd != NULL); 2417 2418 VERIFY(nvlist_lookup_uint64_array(l2cache[i], 2419 ZPOOL_CONFIG_STATS, (uint64_t **)&vs, &vsc) == 0); 2420 vdev_get_stats(vd, vs); 2421 } 2422 } 2423 } 2424 2425 int 2426 spa_get_stats(const char *name, nvlist_t **config, char *altroot, size_t buflen) 2427 { 2428 int error; 2429 spa_t *spa; 2430 2431 *config = NULL; 2432 error = spa_open_common(name, &spa, FTAG, NULL, config); 2433 2434 if (spa != NULL) { 2435 /* 2436 * This still leaves a window of inconsistency where the spares 2437 * or l2cache devices could change and the config would be 2438 * self-inconsistent. 2439 */ 2440 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 2441 2442 if (*config != NULL) { 2443 VERIFY(nvlist_add_uint64(*config, 2444 ZPOOL_CONFIG_ERRCOUNT, 2445 spa_get_errlog_size(spa)) == 0); 2446 2447 if (spa_suspended(spa)) 2448 VERIFY(nvlist_add_uint64(*config, 2449 ZPOOL_CONFIG_SUSPENDED, 2450 spa->spa_failmode) == 0); 2451 2452 spa_add_spares(spa, *config); 2453 spa_add_l2cache(spa, *config); 2454 } 2455 } 2456 2457 /* 2458 * We want to get the alternate root even for faulted pools, so we cheat 2459 * and call spa_lookup() directly. 2460 */ 2461 if (altroot) { 2462 if (spa == NULL) { 2463 mutex_enter(&spa_namespace_lock); 2464 spa = spa_lookup(name); 2465 if (spa) 2466 spa_altroot(spa, altroot, buflen); 2467 else 2468 altroot[0] = '\0'; 2469 spa = NULL; 2470 mutex_exit(&spa_namespace_lock); 2471 } else { 2472 spa_altroot(spa, altroot, buflen); 2473 } 2474 } 2475 2476 if (spa != NULL) { 2477 spa_config_exit(spa, SCL_CONFIG, FTAG); 2478 spa_close(spa, FTAG); 2479 } 2480 2481 return (error); 2482 } 2483 2484 /* 2485 * Validate that the auxiliary device array is well formed. We must have an 2486 * array of nvlists, each which describes a valid leaf vdev. If this is an 2487 * import (mode is VDEV_ALLOC_SPARE), then we allow corrupted spares to be 2488 * specified, as long as they are well-formed. 2489 */ 2490 static int 2491 spa_validate_aux_devs(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode, 2492 spa_aux_vdev_t *sav, const char *config, uint64_t version, 2493 vdev_labeltype_t label) 2494 { 2495 nvlist_t **dev; 2496 uint_t i, ndev; 2497 vdev_t *vd; 2498 int error; 2499 2500 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 2501 2502 /* 2503 * It's acceptable to have no devs specified. 2504 */ 2505 if (nvlist_lookup_nvlist_array(nvroot, config, &dev, &ndev) != 0) 2506 return (0); 2507 2508 if (ndev == 0) 2509 return (EINVAL); 2510 2511 /* 2512 * Make sure the pool is formatted with a version that supports this 2513 * device type. 2514 */ 2515 if (spa_version(spa) < version) 2516 return (ENOTSUP); 2517 2518 /* 2519 * Set the pending device list so we correctly handle device in-use 2520 * checking. 2521 */ 2522 sav->sav_pending = dev; 2523 sav->sav_npending = ndev; 2524 2525 for (i = 0; i < ndev; i++) { 2526 if ((error = spa_config_parse(spa, &vd, dev[i], NULL, 0, 2527 mode)) != 0) 2528 goto out; 2529 2530 if (!vd->vdev_ops->vdev_op_leaf) { 2531 vdev_free(vd); 2532 error = EINVAL; 2533 goto out; 2534 } 2535 2536 /* 2537 * The L2ARC currently only supports disk devices in 2538 * kernel context. For user-level testing, we allow it. 2539 */ 2540 #ifdef _KERNEL 2541 if ((strcmp(config, ZPOOL_CONFIG_L2CACHE) == 0) && 2542 strcmp(vd->vdev_ops->vdev_op_type, VDEV_TYPE_DISK) != 0) { 2543 error = ENOTBLK; 2544 goto out; 2545 } 2546 #endif 2547 vd->vdev_top = vd; 2548 2549 if ((error = vdev_open(vd)) == 0 && 2550 (error = vdev_label_init(vd, crtxg, label)) == 0) { 2551 VERIFY(nvlist_add_uint64(dev[i], ZPOOL_CONFIG_GUID, 2552 vd->vdev_guid) == 0); 2553 } 2554 2555 vdev_free(vd); 2556 2557 if (error && 2558 (mode != VDEV_ALLOC_SPARE && mode != VDEV_ALLOC_L2CACHE)) 2559 goto out; 2560 else 2561 error = 0; 2562 } 2563 2564 out: 2565 sav->sav_pending = NULL; 2566 sav->sav_npending = 0; 2567 return (error); 2568 } 2569 2570 static int 2571 spa_validate_aux(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode) 2572 { 2573 int error; 2574 2575 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 2576 2577 if ((error = spa_validate_aux_devs(spa, nvroot, crtxg, mode, 2578 &spa->spa_spares, ZPOOL_CONFIG_SPARES, SPA_VERSION_SPARES, 2579 VDEV_LABEL_SPARE)) != 0) { 2580 return (error); 2581 } 2582 2583 return (spa_validate_aux_devs(spa, nvroot, crtxg, mode, 2584 &spa->spa_l2cache, ZPOOL_CONFIG_L2CACHE, SPA_VERSION_L2CACHE, 2585 VDEV_LABEL_L2CACHE)); 2586 } 2587 2588 static void 2589 spa_set_aux_vdevs(spa_aux_vdev_t *sav, nvlist_t **devs, int ndevs, 2590 const char *config) 2591 { 2592 int i; 2593 2594 if (sav->sav_config != NULL) { 2595 nvlist_t **olddevs; 2596 uint_t oldndevs; 2597 nvlist_t **newdevs; 2598 2599 /* 2600 * Generate new dev list by concatentating with the 2601 * current dev list. 2602 */ 2603 VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, config, 2604 &olddevs, &oldndevs) == 0); 2605 2606 newdevs = kmem_alloc(sizeof (void *) * 2607 (ndevs + oldndevs), KM_SLEEP); 2608 for (i = 0; i < oldndevs; i++) 2609 VERIFY(nvlist_dup(olddevs[i], &newdevs[i], 2610 KM_SLEEP) == 0); 2611 for (i = 0; i < ndevs; i++) 2612 VERIFY(nvlist_dup(devs[i], &newdevs[i + oldndevs], 2613 KM_SLEEP) == 0); 2614 2615 VERIFY(nvlist_remove(sav->sav_config, config, 2616 DATA_TYPE_NVLIST_ARRAY) == 0); 2617 2618 VERIFY(nvlist_add_nvlist_array(sav->sav_config, 2619 config, newdevs, ndevs + oldndevs) == 0); 2620 for (i = 0; i < oldndevs + ndevs; i++) 2621 nvlist_free(newdevs[i]); 2622 kmem_free(newdevs, (oldndevs + ndevs) * sizeof (void *)); 2623 } else { 2624 /* 2625 * Generate a new dev list. 2626 */ 2627 VERIFY(nvlist_alloc(&sav->sav_config, NV_UNIQUE_NAME, 2628 KM_SLEEP) == 0); 2629 VERIFY(nvlist_add_nvlist_array(sav->sav_config, config, 2630 devs, ndevs) == 0); 2631 } 2632 } 2633 2634 /* 2635 * Stop and drop level 2 ARC devices 2636 */ 2637 void 2638 spa_l2cache_drop(spa_t *spa) 2639 { 2640 vdev_t *vd; 2641 int i; 2642 spa_aux_vdev_t *sav = &spa->spa_l2cache; 2643 2644 for (i = 0; i < sav->sav_count; i++) { 2645 uint64_t pool; 2646 2647 vd = sav->sav_vdevs[i]; 2648 ASSERT(vd != NULL); 2649 2650 if (spa_l2cache_exists(vd->vdev_guid, &pool) && 2651 pool != 0ULL && l2arc_vdev_present(vd)) 2652 l2arc_remove_vdev(vd); 2653 if (vd->vdev_isl2cache) 2654 spa_l2cache_remove(vd); 2655 vdev_clear_stats(vd); 2656 (void) vdev_close(vd); 2657 } 2658 } 2659 2660 /* 2661 * Pool Creation 2662 */ 2663 int 2664 spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props, 2665 const char *history_str, nvlist_t *zplprops) 2666 { 2667 spa_t *spa; 2668 char *altroot = NULL; 2669 vdev_t *rvd; 2670 dsl_pool_t *dp; 2671 dmu_tx_t *tx; 2672 int error = 0; 2673 uint64_t txg = TXG_INITIAL; 2674 nvlist_t **spares, **l2cache; 2675 uint_t nspares, nl2cache; 2676 uint64_t version; 2677 2678 /* 2679 * If this pool already exists, return failure. 2680 */ 2681 mutex_enter(&spa_namespace_lock); 2682 if (spa_lookup(pool) != NULL) { 2683 mutex_exit(&spa_namespace_lock); 2684 return (EEXIST); 2685 } 2686 2687 /* 2688 * Allocate a new spa_t structure. 2689 */ 2690 (void) nvlist_lookup_string(props, 2691 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 2692 spa = spa_add(pool, NULL, altroot); 2693 spa_activate(spa, spa_mode_global); 2694 2695 if (props && (error = spa_prop_validate(spa, props))) { 2696 spa_deactivate(spa); 2697 spa_remove(spa); 2698 mutex_exit(&spa_namespace_lock); 2699 return (error); 2700 } 2701 2702 if (nvlist_lookup_uint64(props, zpool_prop_to_name(ZPOOL_PROP_VERSION), 2703 &version) != 0) 2704 version = SPA_VERSION; 2705 ASSERT(version <= SPA_VERSION); 2706 2707 spa->spa_first_txg = txg; 2708 spa->spa_uberblock.ub_txg = txg - 1; 2709 spa->spa_uberblock.ub_version = version; 2710 spa->spa_ubsync = spa->spa_uberblock; 2711 2712 /* 2713 * Create "The Godfather" zio to hold all async IOs 2714 */ 2715 spa->spa_async_zio_root = zio_root(spa, NULL, NULL, 2716 ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE | ZIO_FLAG_GODFATHER); 2717 2718 /* 2719 * Create the root vdev. 2720 */ 2721 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 2722 2723 error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_ADD); 2724 2725 ASSERT(error != 0 || rvd != NULL); 2726 ASSERT(error != 0 || spa->spa_root_vdev == rvd); 2727 2728 if (error == 0 && !zfs_allocatable_devs(nvroot)) 2729 error = EINVAL; 2730 2731 if (error == 0 && 2732 (error = vdev_create(rvd, txg, B_FALSE)) == 0 && 2733 (error = spa_validate_aux(spa, nvroot, txg, 2734 VDEV_ALLOC_ADD)) == 0) { 2735 for (int c = 0; c < rvd->vdev_children; c++) { 2736 vdev_metaslab_set_size(rvd->vdev_child[c]); 2737 vdev_expand(rvd->vdev_child[c], txg); 2738 } 2739 } 2740 2741 spa_config_exit(spa, SCL_ALL, FTAG); 2742 2743 if (error != 0) { 2744 spa_unload(spa); 2745 spa_deactivate(spa); 2746 spa_remove(spa); 2747 mutex_exit(&spa_namespace_lock); 2748 return (error); 2749 } 2750 2751 /* 2752 * Get the list of spares, if specified. 2753 */ 2754 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 2755 &spares, &nspares) == 0) { 2756 VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, NV_UNIQUE_NAME, 2757 KM_SLEEP) == 0); 2758 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config, 2759 ZPOOL_CONFIG_SPARES, spares, nspares) == 0); 2760 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 2761 spa_load_spares(spa); 2762 spa_config_exit(spa, SCL_ALL, FTAG); 2763 spa->spa_spares.sav_sync = B_TRUE; 2764 } 2765 2766 /* 2767 * Get the list of level 2 cache devices, if specified. 2768 */ 2769 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 2770 &l2cache, &nl2cache) == 0) { 2771 VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config, 2772 NV_UNIQUE_NAME, KM_SLEEP) == 0); 2773 VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config, 2774 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); 2775 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 2776 spa_load_l2cache(spa); 2777 spa_config_exit(spa, SCL_ALL, FTAG); 2778 spa->spa_l2cache.sav_sync = B_TRUE; 2779 } 2780 2781 spa->spa_dsl_pool = dp = dsl_pool_create(spa, zplprops, txg); 2782 spa->spa_meta_objset = dp->dp_meta_objset; 2783 2784 /* 2785 * Create DDTs (dedup tables). 2786 */ 2787 ddt_create(spa); 2788 2789 spa_update_dspace(spa); 2790 2791 tx = dmu_tx_create_assigned(dp, txg); 2792 2793 /* 2794 * Create the pool config object. 2795 */ 2796 spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset, 2797 DMU_OT_PACKED_NVLIST, SPA_CONFIG_BLOCKSIZE, 2798 DMU_OT_PACKED_NVLIST_SIZE, sizeof (uint64_t), tx); 2799 2800 if (zap_add(spa->spa_meta_objset, 2801 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG, 2802 sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) { 2803 cmn_err(CE_PANIC, "failed to add pool config"); 2804 } 2805 2806 /* Newly created pools with the right version are always deflated. */ 2807 if (version >= SPA_VERSION_RAIDZ_DEFLATE) { 2808 spa->spa_deflate = TRUE; 2809 if (zap_add(spa->spa_meta_objset, 2810 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE, 2811 sizeof (uint64_t), 1, &spa->spa_deflate, tx) != 0) { 2812 cmn_err(CE_PANIC, "failed to add deflate"); 2813 } 2814 } 2815 2816 /* 2817 * Create the deferred-free bplist object. Turn off compression 2818 * because sync-to-convergence takes longer if the blocksize 2819 * keeps changing. 2820 */ 2821 spa->spa_deferred_bplist_obj = bplist_create(spa->spa_meta_objset, 2822 1 << 14, tx); 2823 dmu_object_set_compress(spa->spa_meta_objset, 2824 spa->spa_deferred_bplist_obj, ZIO_COMPRESS_OFF, tx); 2825 2826 if (zap_add(spa->spa_meta_objset, 2827 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST, 2828 sizeof (uint64_t), 1, &spa->spa_deferred_bplist_obj, tx) != 0) { 2829 cmn_err(CE_PANIC, "failed to add bplist"); 2830 } 2831 2832 /* 2833 * Create the pool's history object. 2834 */ 2835 if (version >= SPA_VERSION_ZPOOL_HISTORY) 2836 spa_history_create_obj(spa, tx); 2837 2838 /* 2839 * Set pool properties. 2840 */ 2841 spa->spa_bootfs = zpool_prop_default_numeric(ZPOOL_PROP_BOOTFS); 2842 spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION); 2843 spa->spa_failmode = zpool_prop_default_numeric(ZPOOL_PROP_FAILUREMODE); 2844 spa->spa_autoexpand = zpool_prop_default_numeric(ZPOOL_PROP_AUTOEXPAND); 2845 2846 if (props != NULL) { 2847 spa_configfile_set(spa, props, B_FALSE); 2848 spa_sync_props(spa, props, CRED(), tx); 2849 } 2850 2851 dmu_tx_commit(tx); 2852 2853 spa->spa_sync_on = B_TRUE; 2854 txg_sync_start(spa->spa_dsl_pool); 2855 2856 /* 2857 * We explicitly wait for the first transaction to complete so that our 2858 * bean counters are appropriately updated. 2859 */ 2860 txg_wait_synced(spa->spa_dsl_pool, txg); 2861 2862 spa_config_sync(spa, B_FALSE, B_TRUE); 2863 2864 if (version >= SPA_VERSION_ZPOOL_HISTORY && history_str != NULL) 2865 (void) spa_history_log(spa, history_str, LOG_CMD_POOL_CREATE); 2866 spa_history_log_version(spa, LOG_POOL_CREATE); 2867 2868 spa->spa_minref = refcount_count(&spa->spa_refcount); 2869 2870 mutex_exit(&spa_namespace_lock); 2871 2872 return (0); 2873 } 2874 2875 #ifdef _KERNEL 2876 /* 2877 * Get the root pool information from the root disk, then import the root pool 2878 * during the system boot up time. 2879 */ 2880 extern int vdev_disk_read_rootlabel(char *, char *, nvlist_t **); 2881 2882 static nvlist_t * 2883 spa_generate_rootconf(char *devpath, char *devid, uint64_t *guid) 2884 { 2885 nvlist_t *config; 2886 nvlist_t *nvtop, *nvroot; 2887 uint64_t pgid; 2888 2889 if (vdev_disk_read_rootlabel(devpath, devid, &config) != 0) 2890 return (NULL); 2891 2892 /* 2893 * Add this top-level vdev to the child array. 2894 */ 2895 VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 2896 &nvtop) == 0); 2897 VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 2898 &pgid) == 0); 2899 VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, guid) == 0); 2900 2901 /* 2902 * Put this pool's top-level vdevs into a root vdev. 2903 */ 2904 VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0); 2905 VERIFY(nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE, 2906 VDEV_TYPE_ROOT) == 0); 2907 VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_ID, 0ULL) == 0); 2908 VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_GUID, pgid) == 0); 2909 VERIFY(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 2910 &nvtop, 1) == 0); 2911 2912 /* 2913 * Replace the existing vdev_tree with the new root vdev in 2914 * this pool's configuration (remove the old, add the new). 2915 */ 2916 VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, nvroot) == 0); 2917 nvlist_free(nvroot); 2918 return (config); 2919 } 2920 2921 /* 2922 * Walk the vdev tree and see if we can find a device with "better" 2923 * configuration. A configuration is "better" if the label on that 2924 * device has a more recent txg. 2925 */ 2926 static void 2927 spa_alt_rootvdev(vdev_t *vd, vdev_t **avd, uint64_t *txg) 2928 { 2929 for (int c = 0; c < vd->vdev_children; c++) 2930 spa_alt_rootvdev(vd->vdev_child[c], avd, txg); 2931 2932 if (vd->vdev_ops->vdev_op_leaf) { 2933 nvlist_t *label; 2934 uint64_t label_txg; 2935 2936 if (vdev_disk_read_rootlabel(vd->vdev_physpath, vd->vdev_devid, 2937 &label) != 0) 2938 return; 2939 2940 VERIFY(nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_TXG, 2941 &label_txg) == 0); 2942 2943 /* 2944 * Do we have a better boot device? 2945 */ 2946 if (label_txg > *txg) { 2947 *txg = label_txg; 2948 *avd = vd; 2949 } 2950 nvlist_free(label); 2951 } 2952 } 2953 2954 /* 2955 * Import a root pool. 2956 * 2957 * For x86. devpath_list will consist of devid and/or physpath name of 2958 * the vdev (e.g. "id1,sd@SSEAGATE..." or "/pci@1f,0/ide@d/disk@0,0:a"). 2959 * The GRUB "findroot" command will return the vdev we should boot. 2960 * 2961 * For Sparc, devpath_list consists the physpath name of the booting device 2962 * no matter the rootpool is a single device pool or a mirrored pool. 2963 * e.g. 2964 * "/pci@1f,0/ide@d/disk@0,0:a" 2965 */ 2966 int 2967 spa_import_rootpool(char *devpath, char *devid) 2968 { 2969 spa_t *spa; 2970 vdev_t *rvd, *bvd, *avd = NULL; 2971 nvlist_t *config, *nvtop; 2972 uint64_t guid, txg; 2973 char *pname; 2974 int error; 2975 2976 /* 2977 * Read the label from the boot device and generate a configuration. 2978 */ 2979 config = spa_generate_rootconf(devpath, devid, &guid); 2980 #if defined(_OBP) && defined(_KERNEL) 2981 if (config == NULL) { 2982 if (strstr(devpath, "/iscsi/ssd") != NULL) { 2983 /* iscsi boot */ 2984 get_iscsi_bootpath_phy(devpath); 2985 config = spa_generate_rootconf(devpath, devid, &guid); 2986 } 2987 } 2988 #endif 2989 if (config == NULL) { 2990 cmn_err(CE_NOTE, "Can not read the pool label from '%s'", 2991 devpath); 2992 return (EIO); 2993 } 2994 2995 VERIFY(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 2996 &pname) == 0); 2997 VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, &txg) == 0); 2998 2999 mutex_enter(&spa_namespace_lock); 3000 if ((spa = spa_lookup(pname)) != NULL) { 3001 /* 3002 * Remove the existing root pool from the namespace so that we 3003 * can replace it with the correct config we just read in. 3004 */ 3005 spa_remove(spa); 3006 } 3007 3008 spa = spa_add(pname, config, NULL); 3009 spa->spa_is_root = B_TRUE; 3010 spa->spa_load_verbatim = B_TRUE; 3011 3012 /* 3013 * Build up a vdev tree based on the boot device's label config. 3014 */ 3015 VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 3016 &nvtop) == 0); 3017 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3018 error = spa_config_parse(spa, &rvd, nvtop, NULL, 0, 3019 VDEV_ALLOC_ROOTPOOL); 3020 spa_config_exit(spa, SCL_ALL, FTAG); 3021 if (error) { 3022 mutex_exit(&spa_namespace_lock); 3023 nvlist_free(config); 3024 cmn_err(CE_NOTE, "Can not parse the config for pool '%s'", 3025 pname); 3026 return (error); 3027 } 3028 3029 /* 3030 * Get the boot vdev. 3031 */ 3032 if ((bvd = vdev_lookup_by_guid(rvd, guid)) == NULL) { 3033 cmn_err(CE_NOTE, "Can not find the boot vdev for guid %llu", 3034 (u_longlong_t)guid); 3035 error = ENOENT; 3036 goto out; 3037 } 3038 3039 /* 3040 * Determine if there is a better boot device. 3041 */ 3042 avd = bvd; 3043 spa_alt_rootvdev(rvd, &avd, &txg); 3044 if (avd != bvd) { 3045 cmn_err(CE_NOTE, "The boot device is 'degraded'. Please " 3046 "try booting from '%s'", avd->vdev_path); 3047 error = EINVAL; 3048 goto out; 3049 } 3050 3051 /* 3052 * If the boot device is part of a spare vdev then ensure that 3053 * we're booting off the active spare. 3054 */ 3055 if (bvd->vdev_parent->vdev_ops == &vdev_spare_ops && 3056 !bvd->vdev_isspare) { 3057 cmn_err(CE_NOTE, "The boot device is currently spared. Please " 3058 "try booting from '%s'", 3059 bvd->vdev_parent->vdev_child[1]->vdev_path); 3060 error = EINVAL; 3061 goto out; 3062 } 3063 3064 error = 0; 3065 spa_history_log_version(spa, LOG_POOL_IMPORT); 3066 out: 3067 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3068 vdev_free(rvd); 3069 spa_config_exit(spa, SCL_ALL, FTAG); 3070 mutex_exit(&spa_namespace_lock); 3071 3072 nvlist_free(config); 3073 return (error); 3074 } 3075 3076 #endif 3077 3078 /* 3079 * Take a pool and insert it into the namespace as if it had been loaded at 3080 * boot. 3081 */ 3082 int 3083 spa_import_verbatim(const char *pool, nvlist_t *config, nvlist_t *props) 3084 { 3085 spa_t *spa; 3086 zpool_rewind_policy_t policy; 3087 char *altroot = NULL; 3088 3089 mutex_enter(&spa_namespace_lock); 3090 if (spa_lookup(pool) != NULL) { 3091 mutex_exit(&spa_namespace_lock); 3092 return (EEXIST); 3093 } 3094 3095 (void) nvlist_lookup_string(props, 3096 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 3097 spa = spa_add(pool, config, altroot); 3098 3099 zpool_get_rewind_policy(config, &policy); 3100 spa->spa_load_max_txg = policy.zrp_txg; 3101 3102 spa->spa_load_verbatim = B_TRUE; 3103 3104 if (props != NULL) 3105 spa_configfile_set(spa, props, B_FALSE); 3106 3107 spa_config_sync(spa, B_FALSE, B_TRUE); 3108 3109 mutex_exit(&spa_namespace_lock); 3110 spa_history_log_version(spa, LOG_POOL_IMPORT); 3111 3112 return (0); 3113 } 3114 3115 /* 3116 * Import a non-root pool into the system. 3117 */ 3118 int 3119 spa_import(const char *pool, nvlist_t *config, nvlist_t *props) 3120 { 3121 spa_t *spa; 3122 char *altroot = NULL; 3123 spa_load_state_t state = SPA_LOAD_IMPORT; 3124 zpool_rewind_policy_t policy; 3125 int error; 3126 nvlist_t *nvroot; 3127 nvlist_t **spares, **l2cache; 3128 uint_t nspares, nl2cache; 3129 3130 /* 3131 * If a pool with this name exists, return failure. 3132 */ 3133 mutex_enter(&spa_namespace_lock); 3134 if (spa_lookup(pool) != NULL) { 3135 mutex_exit(&spa_namespace_lock); 3136 return (EEXIST); 3137 } 3138 3139 zpool_get_rewind_policy(config, &policy); 3140 if (policy.zrp_request & ZPOOL_DO_REWIND) 3141 state = SPA_LOAD_RECOVER; 3142 3143 /* 3144 * Create and initialize the spa structure. 3145 */ 3146 (void) nvlist_lookup_string(props, 3147 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 3148 spa = spa_add(pool, config, altroot); 3149 spa_activate(spa, spa_mode_global); 3150 3151 /* 3152 * Don't start async tasks until we know everything is healthy. 3153 */ 3154 spa_async_suspend(spa); 3155 3156 /* 3157 * Pass off the heavy lifting to spa_load(). Pass TRUE for mosconfig 3158 * because the user-supplied config is actually the one to trust when 3159 * doing an import. 3160 */ 3161 if (state != SPA_LOAD_RECOVER) 3162 spa->spa_last_ubsync_txg = spa->spa_load_txg = 0; 3163 error = spa_load_best(spa, state, B_TRUE, policy.zrp_txg, 3164 ((policy.zrp_request & ZPOOL_EXTREME_REWIND) != 0)); 3165 3166 /* 3167 * Propagate anything learned about failing or best txgs 3168 * back to caller 3169 */ 3170 spa_rewind_data_to_nvlist(spa, config); 3171 3172 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3173 /* 3174 * Toss any existing sparelist, as it doesn't have any validity 3175 * anymore, and conflicts with spa_has_spare(). 3176 */ 3177 if (spa->spa_spares.sav_config) { 3178 nvlist_free(spa->spa_spares.sav_config); 3179 spa->spa_spares.sav_config = NULL; 3180 spa_load_spares(spa); 3181 } 3182 if (spa->spa_l2cache.sav_config) { 3183 nvlist_free(spa->spa_l2cache.sav_config); 3184 spa->spa_l2cache.sav_config = NULL; 3185 spa_load_l2cache(spa); 3186 } 3187 3188 VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 3189 &nvroot) == 0); 3190 if (error == 0) 3191 error = spa_validate_aux(spa, nvroot, -1ULL, 3192 VDEV_ALLOC_SPARE); 3193 if (error == 0) 3194 error = spa_validate_aux(spa, nvroot, -1ULL, 3195 VDEV_ALLOC_L2CACHE); 3196 spa_config_exit(spa, SCL_ALL, FTAG); 3197 3198 if (props != NULL) 3199 spa_configfile_set(spa, props, B_FALSE); 3200 3201 if (error != 0 || (props && spa_writeable(spa) && 3202 (error = spa_prop_set(spa, props)))) { 3203 spa_unload(spa); 3204 spa_deactivate(spa); 3205 spa_remove(spa); 3206 mutex_exit(&spa_namespace_lock); 3207 return (error); 3208 } 3209 3210 spa_async_resume(spa); 3211 3212 /* 3213 * Override any spares and level 2 cache devices as specified by 3214 * the user, as these may have correct device names/devids, etc. 3215 */ 3216 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 3217 &spares, &nspares) == 0) { 3218 if (spa->spa_spares.sav_config) 3219 VERIFY(nvlist_remove(spa->spa_spares.sav_config, 3220 ZPOOL_CONFIG_SPARES, DATA_TYPE_NVLIST_ARRAY) == 0); 3221 else 3222 VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, 3223 NV_UNIQUE_NAME, KM_SLEEP) == 0); 3224 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config, 3225 ZPOOL_CONFIG_SPARES, spares, nspares) == 0); 3226 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3227 spa_load_spares(spa); 3228 spa_config_exit(spa, SCL_ALL, FTAG); 3229 spa->spa_spares.sav_sync = B_TRUE; 3230 } 3231 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 3232 &l2cache, &nl2cache) == 0) { 3233 if (spa->spa_l2cache.sav_config) 3234 VERIFY(nvlist_remove(spa->spa_l2cache.sav_config, 3235 ZPOOL_CONFIG_L2CACHE, DATA_TYPE_NVLIST_ARRAY) == 0); 3236 else 3237 VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config, 3238 NV_UNIQUE_NAME, KM_SLEEP) == 0); 3239 VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config, 3240 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); 3241 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3242 spa_load_l2cache(spa); 3243 spa_config_exit(spa, SCL_ALL, FTAG); 3244 spa->spa_l2cache.sav_sync = B_TRUE; 3245 } 3246 3247 /* 3248 * Check for any removed devices. 3249 */ 3250 if (spa->spa_autoreplace) { 3251 spa_aux_check_removed(&spa->spa_spares); 3252 spa_aux_check_removed(&spa->spa_l2cache); 3253 } 3254 3255 if (spa_writeable(spa)) { 3256 /* 3257 * Update the config cache to include the newly-imported pool. 3258 */ 3259 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 3260 } 3261 3262 /* 3263 * It's possible that the pool was expanded while it was exported. 3264 * We kick off an async task to handle this for us. 3265 */ 3266 spa_async_request(spa, SPA_ASYNC_AUTOEXPAND); 3267 3268 mutex_exit(&spa_namespace_lock); 3269 spa_history_log_version(spa, LOG_POOL_IMPORT); 3270 3271 return (0); 3272 } 3273 3274 nvlist_t * 3275 spa_tryimport(nvlist_t *tryconfig) 3276 { 3277 nvlist_t *config = NULL; 3278 char *poolname; 3279 spa_t *spa; 3280 uint64_t state; 3281 int error; 3282 3283 if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname)) 3284 return (NULL); 3285 3286 if (nvlist_lookup_uint64(tryconfig, ZPOOL_CONFIG_POOL_STATE, &state)) 3287 return (NULL); 3288 3289 /* 3290 * Create and initialize the spa structure. 3291 */ 3292 mutex_enter(&spa_namespace_lock); 3293 spa = spa_add(TRYIMPORT_NAME, tryconfig, NULL); 3294 spa_activate(spa, FREAD); 3295 3296 /* 3297 * Pass off the heavy lifting to spa_load(). 3298 * Pass TRUE for mosconfig because the user-supplied config 3299 * is actually the one to trust when doing an import. 3300 */ 3301 error = spa_load(spa, SPA_LOAD_TRYIMPORT, SPA_IMPORT_EXISTING, B_TRUE); 3302 3303 /* 3304 * If 'tryconfig' was at least parsable, return the current config. 3305 */ 3306 if (spa->spa_root_vdev != NULL) { 3307 config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 3308 VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, 3309 poolname) == 0); 3310 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE, 3311 state) == 0); 3312 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_TIMESTAMP, 3313 spa->spa_uberblock.ub_timestamp) == 0); 3314 3315 /* 3316 * If the bootfs property exists on this pool then we 3317 * copy it out so that external consumers can tell which 3318 * pools are bootable. 3319 */ 3320 if ((!error || error == EEXIST) && spa->spa_bootfs) { 3321 char *tmpname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 3322 3323 /* 3324 * We have to play games with the name since the 3325 * pool was opened as TRYIMPORT_NAME. 3326 */ 3327 if (dsl_dsobj_to_dsname(spa_name(spa), 3328 spa->spa_bootfs, tmpname) == 0) { 3329 char *cp; 3330 char *dsname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 3331 3332 cp = strchr(tmpname, '/'); 3333 if (cp == NULL) { 3334 (void) strlcpy(dsname, tmpname, 3335 MAXPATHLEN); 3336 } else { 3337 (void) snprintf(dsname, MAXPATHLEN, 3338 "%s/%s", poolname, ++cp); 3339 } 3340 VERIFY(nvlist_add_string(config, 3341 ZPOOL_CONFIG_BOOTFS, dsname) == 0); 3342 kmem_free(dsname, MAXPATHLEN); 3343 } 3344 kmem_free(tmpname, MAXPATHLEN); 3345 } 3346 3347 /* 3348 * Add the list of hot spares and level 2 cache devices. 3349 */ 3350 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 3351 spa_add_spares(spa, config); 3352 spa_add_l2cache(spa, config); 3353 spa_config_exit(spa, SCL_CONFIG, FTAG); 3354 } 3355 3356 spa_unload(spa); 3357 spa_deactivate(spa); 3358 spa_remove(spa); 3359 mutex_exit(&spa_namespace_lock); 3360 3361 return (config); 3362 } 3363 3364 /* 3365 * Pool export/destroy 3366 * 3367 * The act of destroying or exporting a pool is very simple. We make sure there 3368 * is no more pending I/O and any references to the pool are gone. Then, we 3369 * update the pool state and sync all the labels to disk, removing the 3370 * configuration from the cache afterwards. If the 'hardforce' flag is set, then 3371 * we don't sync the labels or remove the configuration cache. 3372 */ 3373 static int 3374 spa_export_common(char *pool, int new_state, nvlist_t **oldconfig, 3375 boolean_t force, boolean_t hardforce) 3376 { 3377 spa_t *spa; 3378 3379 if (oldconfig) 3380 *oldconfig = NULL; 3381 3382 if (!(spa_mode_global & FWRITE)) 3383 return (EROFS); 3384 3385 mutex_enter(&spa_namespace_lock); 3386 if ((spa = spa_lookup(pool)) == NULL) { 3387 mutex_exit(&spa_namespace_lock); 3388 return (ENOENT); 3389 } 3390 3391 /* 3392 * Put a hold on the pool, drop the namespace lock, stop async tasks, 3393 * reacquire the namespace lock, and see if we can export. 3394 */ 3395 spa_open_ref(spa, FTAG); 3396 mutex_exit(&spa_namespace_lock); 3397 spa_async_suspend(spa); 3398 mutex_enter(&spa_namespace_lock); 3399 spa_close(spa, FTAG); 3400 3401 /* 3402 * The pool will be in core if it's openable, 3403 * in which case we can modify its state. 3404 */ 3405 if (spa->spa_state != POOL_STATE_UNINITIALIZED && spa->spa_sync_on) { 3406 /* 3407 * Objsets may be open only because they're dirty, so we 3408 * have to force it to sync before checking spa_refcnt. 3409 */ 3410 txg_wait_synced(spa->spa_dsl_pool, 0); 3411 3412 /* 3413 * A pool cannot be exported or destroyed if there are active 3414 * references. If we are resetting a pool, allow references by 3415 * fault injection handlers. 3416 */ 3417 if (!spa_refcount_zero(spa) || 3418 (spa->spa_inject_ref != 0 && 3419 new_state != POOL_STATE_UNINITIALIZED)) { 3420 spa_async_resume(spa); 3421 mutex_exit(&spa_namespace_lock); 3422 return (EBUSY); 3423 } 3424 3425 /* 3426 * A pool cannot be exported if it has an active shared spare. 3427 * This is to prevent other pools stealing the active spare 3428 * from an exported pool. At user's own will, such pool can 3429 * be forcedly exported. 3430 */ 3431 if (!force && new_state == POOL_STATE_EXPORTED && 3432 spa_has_active_shared_spare(spa)) { 3433 spa_async_resume(spa); 3434 mutex_exit(&spa_namespace_lock); 3435 return (EXDEV); 3436 } 3437 3438 /* 3439 * We want this to be reflected on every label, 3440 * so mark them all dirty. spa_unload() will do the 3441 * final sync that pushes these changes out. 3442 */ 3443 if (new_state != POOL_STATE_UNINITIALIZED && !hardforce) { 3444 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3445 spa->spa_state = new_state; 3446 spa->spa_final_txg = spa_last_synced_txg(spa) + 1; 3447 vdev_config_dirty(spa->spa_root_vdev); 3448 spa_config_exit(spa, SCL_ALL, FTAG); 3449 } 3450 } 3451 3452 spa_event_notify(spa, NULL, ESC_ZFS_POOL_DESTROY); 3453 3454 if (spa->spa_state != POOL_STATE_UNINITIALIZED) { 3455 spa_unload(spa); 3456 spa_deactivate(spa); 3457 } 3458 3459 if (oldconfig && spa->spa_config) 3460 VERIFY(nvlist_dup(spa->spa_config, oldconfig, 0) == 0); 3461 3462 if (new_state != POOL_STATE_UNINITIALIZED) { 3463 if (!hardforce) 3464 spa_config_sync(spa, B_TRUE, B_TRUE); 3465 spa_remove(spa); 3466 } 3467 mutex_exit(&spa_namespace_lock); 3468 3469 return (0); 3470 } 3471 3472 /* 3473 * Destroy a storage pool. 3474 */ 3475 int 3476 spa_destroy(char *pool) 3477 { 3478 return (spa_export_common(pool, POOL_STATE_DESTROYED, NULL, 3479 B_FALSE, B_FALSE)); 3480 } 3481 3482 /* 3483 * Export a storage pool. 3484 */ 3485 int 3486 spa_export(char *pool, nvlist_t **oldconfig, boolean_t force, 3487 boolean_t hardforce) 3488 { 3489 return (spa_export_common(pool, POOL_STATE_EXPORTED, oldconfig, 3490 force, hardforce)); 3491 } 3492 3493 /* 3494 * Similar to spa_export(), this unloads the spa_t without actually removing it 3495 * from the namespace in any way. 3496 */ 3497 int 3498 spa_reset(char *pool) 3499 { 3500 return (spa_export_common(pool, POOL_STATE_UNINITIALIZED, NULL, 3501 B_FALSE, B_FALSE)); 3502 } 3503 3504 /* 3505 * ========================================================================== 3506 * Device manipulation 3507 * ========================================================================== 3508 */ 3509 3510 /* 3511 * Add a device to a storage pool. 3512 */ 3513 int 3514 spa_vdev_add(spa_t *spa, nvlist_t *nvroot) 3515 { 3516 uint64_t txg, id; 3517 int error; 3518 vdev_t *rvd = spa->spa_root_vdev; 3519 vdev_t *vd, *tvd; 3520 nvlist_t **spares, **l2cache; 3521 uint_t nspares, nl2cache; 3522 3523 txg = spa_vdev_enter(spa); 3524 3525 if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0, 3526 VDEV_ALLOC_ADD)) != 0) 3527 return (spa_vdev_exit(spa, NULL, txg, error)); 3528 3529 spa->spa_pending_vdev = vd; /* spa_vdev_exit() will clear this */ 3530 3531 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, &spares, 3532 &nspares) != 0) 3533 nspares = 0; 3534 3535 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, &l2cache, 3536 &nl2cache) != 0) 3537 nl2cache = 0; 3538 3539 if (vd->vdev_children == 0 && nspares == 0 && nl2cache == 0) 3540 return (spa_vdev_exit(spa, vd, txg, EINVAL)); 3541 3542 if (vd->vdev_children != 0 && 3543 (error = vdev_create(vd, txg, B_FALSE)) != 0) 3544 return (spa_vdev_exit(spa, vd, txg, error)); 3545 3546 /* 3547 * We must validate the spares and l2cache devices after checking the 3548 * children. Otherwise, vdev_inuse() will blindly overwrite the spare. 3549 */ 3550 if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0) 3551 return (spa_vdev_exit(spa, vd, txg, error)); 3552 3553 /* 3554 * Transfer each new top-level vdev from vd to rvd. 3555 */ 3556 for (int c = 0; c < vd->vdev_children; c++) { 3557 3558 /* 3559 * Set the vdev id to the first hole, if one exists. 3560 */ 3561 for (id = 0; id < rvd->vdev_children; id++) { 3562 if (rvd->vdev_child[id]->vdev_ishole) { 3563 vdev_free(rvd->vdev_child[id]); 3564 break; 3565 } 3566 } 3567 tvd = vd->vdev_child[c]; 3568 vdev_remove_child(vd, tvd); 3569 tvd->vdev_id = id; 3570 vdev_add_child(rvd, tvd); 3571 vdev_config_dirty(tvd); 3572 } 3573 3574 if (nspares != 0) { 3575 spa_set_aux_vdevs(&spa->spa_spares, spares, nspares, 3576 ZPOOL_CONFIG_SPARES); 3577 spa_load_spares(spa); 3578 spa->spa_spares.sav_sync = B_TRUE; 3579 } 3580 3581 if (nl2cache != 0) { 3582 spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache, 3583 ZPOOL_CONFIG_L2CACHE); 3584 spa_load_l2cache(spa); 3585 spa->spa_l2cache.sav_sync = B_TRUE; 3586 } 3587 3588 /* 3589 * We have to be careful when adding new vdevs to an existing pool. 3590 * If other threads start allocating from these vdevs before we 3591 * sync the config cache, and we lose power, then upon reboot we may 3592 * fail to open the pool because there are DVAs that the config cache 3593 * can't translate. Therefore, we first add the vdevs without 3594 * initializing metaslabs; sync the config cache (via spa_vdev_exit()); 3595 * and then let spa_config_update() initialize the new metaslabs. 3596 * 3597 * spa_load() checks for added-but-not-initialized vdevs, so that 3598 * if we lose power at any point in this sequence, the remaining 3599 * steps will be completed the next time we load the pool. 3600 */ 3601 (void) spa_vdev_exit(spa, vd, txg, 0); 3602 3603 mutex_enter(&spa_namespace_lock); 3604 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 3605 mutex_exit(&spa_namespace_lock); 3606 3607 return (0); 3608 } 3609 3610 /* 3611 * Attach a device to a mirror. The arguments are the path to any device 3612 * in the mirror, and the nvroot for the new device. If the path specifies 3613 * a device that is not mirrored, we automatically insert the mirror vdev. 3614 * 3615 * If 'replacing' is specified, the new device is intended to replace the 3616 * existing device; in this case the two devices are made into their own 3617 * mirror using the 'replacing' vdev, which is functionally identical to 3618 * the mirror vdev (it actually reuses all the same ops) but has a few 3619 * extra rules: you can't attach to it after it's been created, and upon 3620 * completion of resilvering, the first disk (the one being replaced) 3621 * is automatically detached. 3622 */ 3623 int 3624 spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing) 3625 { 3626 uint64_t txg, open_txg; 3627 vdev_t *rvd = spa->spa_root_vdev; 3628 vdev_t *oldvd, *newvd, *newrootvd, *pvd, *tvd; 3629 vdev_ops_t *pvops; 3630 char *oldvdpath, *newvdpath; 3631 int newvd_isspare; 3632 int error; 3633 3634 txg = spa_vdev_enter(spa); 3635 3636 oldvd = spa_lookup_by_guid(spa, guid, B_FALSE); 3637 3638 if (oldvd == NULL) 3639 return (spa_vdev_exit(spa, NULL, txg, ENODEV)); 3640 3641 if (!oldvd->vdev_ops->vdev_op_leaf) 3642 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 3643 3644 pvd = oldvd->vdev_parent; 3645 3646 if ((error = spa_config_parse(spa, &newrootvd, nvroot, NULL, 0, 3647 VDEV_ALLOC_ADD)) != 0) 3648 return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 3649 3650 if (newrootvd->vdev_children != 1) 3651 return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); 3652 3653 newvd = newrootvd->vdev_child[0]; 3654 3655 if (!newvd->vdev_ops->vdev_op_leaf) 3656 return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); 3657 3658 if ((error = vdev_create(newrootvd, txg, replacing)) != 0) 3659 return (spa_vdev_exit(spa, newrootvd, txg, error)); 3660 3661 /* 3662 * Spares can't replace logs 3663 */ 3664 if (oldvd->vdev_top->vdev_islog && newvd->vdev_isspare) 3665 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 3666 3667 if (!replacing) { 3668 /* 3669 * For attach, the only allowable parent is a mirror or the root 3670 * vdev. 3671 */ 3672 if (pvd->vdev_ops != &vdev_mirror_ops && 3673 pvd->vdev_ops != &vdev_root_ops) 3674 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 3675 3676 pvops = &vdev_mirror_ops; 3677 } else { 3678 /* 3679 * Active hot spares can only be replaced by inactive hot 3680 * spares. 3681 */ 3682 if (pvd->vdev_ops == &vdev_spare_ops && 3683 pvd->vdev_child[1] == oldvd && 3684 !spa_has_spare(spa, newvd->vdev_guid)) 3685 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 3686 3687 /* 3688 * If the source is a hot spare, and the parent isn't already a 3689 * spare, then we want to create a new hot spare. Otherwise, we 3690 * want to create a replacing vdev. The user is not allowed to 3691 * attach to a spared vdev child unless the 'isspare' state is 3692 * the same (spare replaces spare, non-spare replaces 3693 * non-spare). 3694 */ 3695 if (pvd->vdev_ops == &vdev_replacing_ops) 3696 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 3697 else if (pvd->vdev_ops == &vdev_spare_ops && 3698 newvd->vdev_isspare != oldvd->vdev_isspare) 3699 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 3700 else if (pvd->vdev_ops != &vdev_spare_ops && 3701 newvd->vdev_isspare) 3702 pvops = &vdev_spare_ops; 3703 else 3704 pvops = &vdev_replacing_ops; 3705 } 3706 3707 /* 3708 * Make sure the new device is big enough. 3709 */ 3710 if (newvd->vdev_asize < vdev_get_min_asize(oldvd)) 3711 return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW)); 3712 3713 /* 3714 * The new device cannot have a higher alignment requirement 3715 * than the top-level vdev. 3716 */ 3717 if (newvd->vdev_ashift > oldvd->vdev_top->vdev_ashift) 3718 return (spa_vdev_exit(spa, newrootvd, txg, EDOM)); 3719 3720 /* 3721 * If this is an in-place replacement, update oldvd's path and devid 3722 * to make it distinguishable from newvd, and unopenable from now on. 3723 */ 3724 if (strcmp(oldvd->vdev_path, newvd->vdev_path) == 0) { 3725 spa_strfree(oldvd->vdev_path); 3726 oldvd->vdev_path = kmem_alloc(strlen(newvd->vdev_path) + 5, 3727 KM_SLEEP); 3728 (void) sprintf(oldvd->vdev_path, "%s/%s", 3729 newvd->vdev_path, "old"); 3730 if (oldvd->vdev_devid != NULL) { 3731 spa_strfree(oldvd->vdev_devid); 3732 oldvd->vdev_devid = NULL; 3733 } 3734 } 3735 3736 /* 3737 * If the parent is not a mirror, or if we're replacing, insert the new 3738 * mirror/replacing/spare vdev above oldvd. 3739 */ 3740 if (pvd->vdev_ops != pvops) 3741 pvd = vdev_add_parent(oldvd, pvops); 3742 3743 ASSERT(pvd->vdev_top->vdev_parent == rvd); 3744 ASSERT(pvd->vdev_ops == pvops); 3745 ASSERT(oldvd->vdev_parent == pvd); 3746 3747 /* 3748 * Extract the new device from its root and add it to pvd. 3749 */ 3750 vdev_remove_child(newrootvd, newvd); 3751 newvd->vdev_id = pvd->vdev_children; 3752 newvd->vdev_crtxg = oldvd->vdev_crtxg; 3753 vdev_add_child(pvd, newvd); 3754 3755 tvd = newvd->vdev_top; 3756 ASSERT(pvd->vdev_top == tvd); 3757 ASSERT(tvd->vdev_parent == rvd); 3758 3759 vdev_config_dirty(tvd); 3760 3761 /* 3762 * Set newvd's DTL to [TXG_INITIAL, open_txg]. It will propagate 3763 * upward when spa_vdev_exit() calls vdev_dtl_reassess(). 3764 */ 3765 open_txg = txg + TXG_CONCURRENT_STATES - 1; 3766 3767 vdev_dtl_dirty(newvd, DTL_MISSING, 3768 TXG_INITIAL, open_txg - TXG_INITIAL + 1); 3769 3770 if (newvd->vdev_isspare) { 3771 spa_spare_activate(newvd); 3772 spa_event_notify(spa, newvd, ESC_ZFS_VDEV_SPARE); 3773 } 3774 3775 oldvdpath = spa_strdup(oldvd->vdev_path); 3776 newvdpath = spa_strdup(newvd->vdev_path); 3777 newvd_isspare = newvd->vdev_isspare; 3778 3779 /* 3780 * Mark newvd's DTL dirty in this txg. 3781 */ 3782 vdev_dirty(tvd, VDD_DTL, newvd, txg); 3783 3784 (void) spa_vdev_exit(spa, newrootvd, open_txg, 0); 3785 3786 spa_history_internal_log(LOG_POOL_VDEV_ATTACH, spa, NULL, 3787 CRED(), "%s vdev=%s %s vdev=%s", 3788 replacing && newvd_isspare ? "spare in" : 3789 replacing ? "replace" : "attach", newvdpath, 3790 replacing ? "for" : "to", oldvdpath); 3791 3792 spa_strfree(oldvdpath); 3793 spa_strfree(newvdpath); 3794 3795 /* 3796 * Kick off a resilver to update newvd. 3797 */ 3798 VERIFY3U(spa_scrub(spa, POOL_SCRUB_RESILVER), ==, 0); 3799 3800 return (0); 3801 } 3802 3803 /* 3804 * Detach a device from a mirror or replacing vdev. 3805 * If 'replace_done' is specified, only detach if the parent 3806 * is a replacing vdev. 3807 */ 3808 int 3809 spa_vdev_detach(spa_t *spa, uint64_t guid, uint64_t pguid, int replace_done) 3810 { 3811 uint64_t txg; 3812 int error; 3813 vdev_t *rvd = spa->spa_root_vdev; 3814 vdev_t *vd, *pvd, *cvd, *tvd; 3815 boolean_t unspare = B_FALSE; 3816 uint64_t unspare_guid; 3817 size_t len; 3818 char *vdpath; 3819 3820 txg = spa_vdev_enter(spa); 3821 3822 vd = spa_lookup_by_guid(spa, guid, B_FALSE); 3823 3824 if (vd == NULL) 3825 return (spa_vdev_exit(spa, NULL, txg, ENODEV)); 3826 3827 if (!vd->vdev_ops->vdev_op_leaf) 3828 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 3829 3830 pvd = vd->vdev_parent; 3831 3832 /* 3833 * If the parent/child relationship is not as expected, don't do it. 3834 * Consider M(A,R(B,C)) -- that is, a mirror of A with a replacing 3835 * vdev that's replacing B with C. The user's intent in replacing 3836 * is to go from M(A,B) to M(A,C). If the user decides to cancel 3837 * the replace by detaching C, the expected behavior is to end up 3838 * M(A,B). But suppose that right after deciding to detach C, 3839 * the replacement of B completes. We would have M(A,C), and then 3840 * ask to detach C, which would leave us with just A -- not what 3841 * the user wanted. To prevent this, we make sure that the 3842 * parent/child relationship hasn't changed -- in this example, 3843 * that C's parent is still the replacing vdev R. 3844 */ 3845 if (pvd->vdev_guid != pguid && pguid != 0) 3846 return (spa_vdev_exit(spa, NULL, txg, EBUSY)); 3847 3848 /* 3849 * If replace_done is specified, only remove this device if it's 3850 * the first child of a replacing vdev. For the 'spare' vdev, either 3851 * disk can be removed. 3852 */ 3853 if (replace_done) { 3854 if (pvd->vdev_ops == &vdev_replacing_ops) { 3855 if (vd->vdev_id != 0) 3856 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 3857 } else if (pvd->vdev_ops != &vdev_spare_ops) { 3858 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 3859 } 3860 } 3861 3862 ASSERT(pvd->vdev_ops != &vdev_spare_ops || 3863 spa_version(spa) >= SPA_VERSION_SPARES); 3864 3865 /* 3866 * Only mirror, replacing, and spare vdevs support detach. 3867 */ 3868 if (pvd->vdev_ops != &vdev_replacing_ops && 3869 pvd->vdev_ops != &vdev_mirror_ops && 3870 pvd->vdev_ops != &vdev_spare_ops) 3871 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 3872 3873 /* 3874 * If this device has the only valid copy of some data, 3875 * we cannot safely detach it. 3876 */ 3877 if (vdev_dtl_required(vd)) 3878 return (spa_vdev_exit(spa, NULL, txg, EBUSY)); 3879 3880 ASSERT(pvd->vdev_children >= 2); 3881 3882 /* 3883 * If we are detaching the second disk from a replacing vdev, then 3884 * check to see if we changed the original vdev's path to have "/old" 3885 * at the end in spa_vdev_attach(). If so, undo that change now. 3886 */ 3887 if (pvd->vdev_ops == &vdev_replacing_ops && vd->vdev_id == 1 && 3888 pvd->vdev_child[0]->vdev_path != NULL && 3889 pvd->vdev_child[1]->vdev_path != NULL) { 3890 ASSERT(pvd->vdev_child[1] == vd); 3891 cvd = pvd->vdev_child[0]; 3892 len = strlen(vd->vdev_path); 3893 if (strncmp(cvd->vdev_path, vd->vdev_path, len) == 0 && 3894 strcmp(cvd->vdev_path + len, "/old") == 0) { 3895 spa_strfree(cvd->vdev_path); 3896 cvd->vdev_path = spa_strdup(vd->vdev_path); 3897 } 3898 } 3899 3900 /* 3901 * If we are detaching the original disk from a spare, then it implies 3902 * that the spare should become a real disk, and be removed from the 3903 * active spare list for the pool. 3904 */ 3905 if (pvd->vdev_ops == &vdev_spare_ops && 3906 vd->vdev_id == 0 && pvd->vdev_child[1]->vdev_isspare) 3907 unspare = B_TRUE; 3908 3909 /* 3910 * Erase the disk labels so the disk can be used for other things. 3911 * This must be done after all other error cases are handled, 3912 * but before we disembowel vd (so we can still do I/O to it). 3913 * But if we can't do it, don't treat the error as fatal -- 3914 * it may be that the unwritability of the disk is the reason 3915 * it's being detached! 3916 */ 3917 error = vdev_label_init(vd, 0, VDEV_LABEL_REMOVE); 3918 3919 /* 3920 * Remove vd from its parent and compact the parent's children. 3921 */ 3922 vdev_remove_child(pvd, vd); 3923 vdev_compact_children(pvd); 3924 3925 /* 3926 * Remember one of the remaining children so we can get tvd below. 3927 */ 3928 cvd = pvd->vdev_child[0]; 3929 3930 /* 3931 * If we need to remove the remaining child from the list of hot spares, 3932 * do it now, marking the vdev as no longer a spare in the process. 3933 * We must do this before vdev_remove_parent(), because that can 3934 * change the GUID if it creates a new toplevel GUID. For a similar 3935 * reason, we must remove the spare now, in the same txg as the detach; 3936 * otherwise someone could attach a new sibling, change the GUID, and 3937 * the subsequent attempt to spa_vdev_remove(unspare_guid) would fail. 3938 */ 3939 if (unspare) { 3940 ASSERT(cvd->vdev_isspare); 3941 spa_spare_remove(cvd); 3942 unspare_guid = cvd->vdev_guid; 3943 (void) spa_vdev_remove(spa, unspare_guid, B_TRUE); 3944 } 3945 3946 /* 3947 * If the parent mirror/replacing vdev only has one child, 3948 * the parent is no longer needed. Remove it from the tree. 3949 */ 3950 if (pvd->vdev_children == 1) 3951 vdev_remove_parent(cvd); 3952 3953 /* 3954 * We don't set tvd until now because the parent we just removed 3955 * may have been the previous top-level vdev. 3956 */ 3957 tvd = cvd->vdev_top; 3958 ASSERT(tvd->vdev_parent == rvd); 3959 3960 /* 3961 * Reevaluate the parent vdev state. 3962 */ 3963 vdev_propagate_state(cvd); 3964 3965 /* 3966 * If the 'autoexpand' property is set on the pool then automatically 3967 * try to expand the size of the pool. For example if the device we 3968 * just detached was smaller than the others, it may be possible to 3969 * add metaslabs (i.e. grow the pool). We need to reopen the vdev 3970 * first so that we can obtain the updated sizes of the leaf vdevs. 3971 */ 3972 if (spa->spa_autoexpand) { 3973 vdev_reopen(tvd); 3974 vdev_expand(tvd, txg); 3975 } 3976 3977 vdev_config_dirty(tvd); 3978 3979 /* 3980 * Mark vd's DTL as dirty in this txg. vdev_dtl_sync() will see that 3981 * vd->vdev_detached is set and free vd's DTL object in syncing context. 3982 * But first make sure we're not on any *other* txg's DTL list, to 3983 * prevent vd from being accessed after it's freed. 3984 */ 3985 vdpath = spa_strdup(vd->vdev_path); 3986 for (int t = 0; t < TXG_SIZE; t++) 3987 (void) txg_list_remove_this(&tvd->vdev_dtl_list, vd, t); 3988 vd->vdev_detached = B_TRUE; 3989 vdev_dirty(tvd, VDD_DTL, vd, txg); 3990 3991 spa_event_notify(spa, vd, ESC_ZFS_VDEV_REMOVE); 3992 3993 error = spa_vdev_exit(spa, vd, txg, 0); 3994 3995 spa_history_internal_log(LOG_POOL_VDEV_DETACH, spa, NULL, CRED(), 3996 "vdev=%s", vdpath); 3997 spa_strfree(vdpath); 3998 3999 /* 4000 * If this was the removal of the original device in a hot spare vdev, 4001 * then we want to go through and remove the device from the hot spare 4002 * list of every other pool. 4003 */ 4004 if (unspare) { 4005 spa_t *myspa = spa; 4006 spa = NULL; 4007 mutex_enter(&spa_namespace_lock); 4008 while ((spa = spa_next(spa)) != NULL) { 4009 if (spa->spa_state != POOL_STATE_ACTIVE) 4010 continue; 4011 if (spa == myspa) 4012 continue; 4013 spa_open_ref(spa, FTAG); 4014 mutex_exit(&spa_namespace_lock); 4015 (void) spa_vdev_remove(spa, unspare_guid, B_TRUE); 4016 mutex_enter(&spa_namespace_lock); 4017 spa_close(spa, FTAG); 4018 } 4019 mutex_exit(&spa_namespace_lock); 4020 } 4021 4022 return (error); 4023 } 4024 4025 /* 4026 * Split a set of devices from their mirrors, and create a new pool from them. 4027 */ 4028 int 4029 spa_vdev_split_mirror(spa_t *spa, char *newname, nvlist_t *config, 4030 nvlist_t *props, boolean_t exp) 4031 { 4032 int error = 0; 4033 uint64_t txg, *glist; 4034 spa_t *newspa; 4035 uint_t c, children, lastlog; 4036 nvlist_t **child, *nvl, *tmp; 4037 dmu_tx_t *tx; 4038 char *altroot = NULL; 4039 vdev_t *rvd, **vml = NULL; /* vdev modify list */ 4040 boolean_t activate_slog; 4041 4042 if (!spa_writeable(spa)) 4043 return (EROFS); 4044 4045 txg = spa_vdev_enter(spa); 4046 4047 /* clear the log and flush everything up to now */ 4048 activate_slog = spa_passivate_log(spa); 4049 (void) spa_vdev_config_exit(spa, NULL, txg, 0, FTAG); 4050 error = spa_offline_log(spa); 4051 txg = spa_vdev_config_enter(spa); 4052 4053 if (activate_slog) 4054 spa_activate_log(spa); 4055 4056 if (error != 0) 4057 return (spa_vdev_exit(spa, NULL, txg, error)); 4058 4059 /* check new spa name before going any further */ 4060 if (spa_lookup(newname) != NULL) 4061 return (spa_vdev_exit(spa, NULL, txg, EEXIST)); 4062 4063 /* 4064 * scan through all the children to ensure they're all mirrors 4065 */ 4066 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvl) != 0 || 4067 nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_CHILDREN, &child, 4068 &children) != 0) 4069 return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 4070 4071 /* first, check to ensure we've got the right child count */ 4072 rvd = spa->spa_root_vdev; 4073 lastlog = 0; 4074 for (c = 0; c < rvd->vdev_children; c++) { 4075 vdev_t *vd = rvd->vdev_child[c]; 4076 4077 /* don't count the holes & logs as children */ 4078 if (vd->vdev_islog || vd->vdev_ishole) { 4079 if (lastlog == 0) 4080 lastlog = c; 4081 continue; 4082 } 4083 4084 lastlog = 0; 4085 } 4086 if (children != (lastlog != 0 ? lastlog : rvd->vdev_children)) 4087 return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 4088 4089 /* next, ensure no spare or cache devices are part of the split */ 4090 if (nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_SPARES, &tmp) == 0 || 4091 nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_L2CACHE, &tmp) == 0) 4092 return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 4093 4094 vml = kmem_zalloc(children * sizeof (vdev_t *), KM_SLEEP); 4095 glist = kmem_zalloc(children * sizeof (uint64_t), KM_SLEEP); 4096 4097 /* then, loop over each vdev and validate it */ 4098 for (c = 0; c < children; c++) { 4099 uint64_t is_hole = 0; 4100 4101 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE, 4102 &is_hole); 4103 4104 if (is_hole != 0) { 4105 if (spa->spa_root_vdev->vdev_child[c]->vdev_ishole || 4106 spa->spa_root_vdev->vdev_child[c]->vdev_islog) { 4107 continue; 4108 } else { 4109 error = EINVAL; 4110 break; 4111 } 4112 } 4113 4114 /* which disk is going to be split? */ 4115 if (nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_GUID, 4116 &glist[c]) != 0) { 4117 error = EINVAL; 4118 break; 4119 } 4120 4121 /* look it up in the spa */ 4122 vml[c] = spa_lookup_by_guid(spa, glist[c], B_FALSE); 4123 if (vml[c] == NULL) { 4124 error = ENODEV; 4125 break; 4126 } 4127 4128 /* make sure there's nothing stopping the split */ 4129 if (vml[c]->vdev_parent->vdev_ops != &vdev_mirror_ops || 4130 vml[c]->vdev_islog || 4131 vml[c]->vdev_ishole || 4132 vml[c]->vdev_isspare || 4133 vml[c]->vdev_isl2cache || 4134 !vdev_writeable(vml[c]) || 4135 vml[c]->vdev_children != 0 || 4136 vml[c]->vdev_state != VDEV_STATE_HEALTHY || 4137 c != spa->spa_root_vdev->vdev_child[c]->vdev_id) { 4138 error = EINVAL; 4139 break; 4140 } 4141 4142 if (vdev_dtl_required(vml[c])) { 4143 error = EBUSY; 4144 break; 4145 } 4146 4147 /* we need certain info from the top level */ 4148 VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_ARRAY, 4149 vml[c]->vdev_top->vdev_ms_array) == 0); 4150 VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_SHIFT, 4151 vml[c]->vdev_top->vdev_ms_shift) == 0); 4152 VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASIZE, 4153 vml[c]->vdev_top->vdev_asize) == 0); 4154 VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASHIFT, 4155 vml[c]->vdev_top->vdev_ashift) == 0); 4156 } 4157 4158 if (error != 0) { 4159 kmem_free(vml, children * sizeof (vdev_t *)); 4160 kmem_free(glist, children * sizeof (uint64_t)); 4161 return (spa_vdev_exit(spa, NULL, txg, error)); 4162 } 4163 4164 /* stop writers from using the disks */ 4165 for (c = 0; c < children; c++) { 4166 if (vml[c] != NULL) 4167 vml[c]->vdev_offline = B_TRUE; 4168 } 4169 vdev_reopen(spa->spa_root_vdev); 4170 4171 /* 4172 * Temporarily record the splitting vdevs in the spa config. This 4173 * will disappear once the config is regenerated. 4174 */ 4175 VERIFY(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP) == 0); 4176 VERIFY(nvlist_add_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST, 4177 glist, children) == 0); 4178 kmem_free(glist, children * sizeof (uint64_t)); 4179 4180 VERIFY(nvlist_add_nvlist(spa->spa_config, ZPOOL_CONFIG_SPLIT, 4181 nvl) == 0); 4182 spa->spa_config_splitting = nvl; 4183 vdev_config_dirty(spa->spa_root_vdev); 4184 4185 /* configure and create the new pool */ 4186 VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, newname) == 0); 4187 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE, 4188 exp ? POOL_STATE_EXPORTED : POOL_STATE_ACTIVE) == 0); 4189 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VERSION, 4190 spa_version(spa)) == 0); 4191 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_TXG, 4192 spa->spa_config_txg) == 0); 4193 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_GUID, 4194 spa_generate_guid(NULL)) == 0); 4195 (void) nvlist_lookup_string(props, 4196 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 4197 4198 /* add the new pool to the namespace */ 4199 newspa = spa_add(newname, config, altroot); 4200 newspa->spa_config_txg = spa->spa_config_txg; 4201 spa_set_log_state(newspa, SPA_LOG_CLEAR); 4202 4203 /* release the spa config lock, retaining the namespace lock */ 4204 spa_vdev_config_exit(spa, NULL, txg, 0, FTAG); 4205 4206 if (zio_injection_enabled) 4207 zio_handle_panic_injection(spa, FTAG, 1); 4208 4209 spa_activate(newspa, spa_mode_global); 4210 spa_async_suspend(newspa); 4211 4212 /* create the new pool from the disks of the original pool */ 4213 error = spa_load(newspa, SPA_LOAD_IMPORT, SPA_IMPORT_ASSEMBLE, B_TRUE); 4214 if (error) 4215 goto out; 4216 4217 /* if that worked, generate a real config for the new pool */ 4218 if (newspa->spa_root_vdev != NULL) { 4219 VERIFY(nvlist_alloc(&newspa->spa_config_splitting, 4220 NV_UNIQUE_NAME, KM_SLEEP) == 0); 4221 VERIFY(nvlist_add_uint64(newspa->spa_config_splitting, 4222 ZPOOL_CONFIG_SPLIT_GUID, spa_guid(spa)) == 0); 4223 spa_config_set(newspa, spa_config_generate(newspa, NULL, -1ULL, 4224 B_TRUE)); 4225 } 4226 4227 /* set the props */ 4228 if (props != NULL) { 4229 spa_configfile_set(newspa, props, B_FALSE); 4230 error = spa_prop_set(newspa, props); 4231 if (error) 4232 goto out; 4233 } 4234 4235 /* flush everything */ 4236 txg = spa_vdev_config_enter(newspa); 4237 vdev_config_dirty(newspa->spa_root_vdev); 4238 (void) spa_vdev_config_exit(newspa, NULL, txg, 0, FTAG); 4239 4240 if (zio_injection_enabled) 4241 zio_handle_panic_injection(spa, FTAG, 2); 4242 4243 spa_async_resume(newspa); 4244 4245 /* finally, update the original pool's config */ 4246 txg = spa_vdev_config_enter(spa); 4247 tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir); 4248 error = dmu_tx_assign(tx, TXG_WAIT); 4249 if (error != 0) 4250 dmu_tx_abort(tx); 4251 for (c = 0; c < children; c++) { 4252 if (vml[c] != NULL) { 4253 vdev_split(vml[c]); 4254 if (error == 0) 4255 spa_history_internal_log(LOG_POOL_VDEV_DETACH, 4256 spa, tx, CRED(), "vdev=%s", 4257 vml[c]->vdev_path); 4258 vdev_free(vml[c]); 4259 } 4260 } 4261 vdev_config_dirty(spa->spa_root_vdev); 4262 spa->spa_config_splitting = NULL; 4263 nvlist_free(nvl); 4264 if (error == 0) 4265 dmu_tx_commit(tx); 4266 (void) spa_vdev_exit(spa, NULL, txg, 0); 4267 4268 if (zio_injection_enabled) 4269 zio_handle_panic_injection(spa, FTAG, 3); 4270 4271 /* split is complete; log a history record */ 4272 spa_history_internal_log(LOG_POOL_SPLIT, newspa, NULL, CRED(), 4273 "split new pool %s from pool %s", newname, spa_name(spa)); 4274 4275 kmem_free(vml, children * sizeof (vdev_t *)); 4276 4277 /* if we're not going to mount the filesystems in userland, export */ 4278 if (exp) 4279 error = spa_export_common(newname, POOL_STATE_EXPORTED, NULL, 4280 B_FALSE, B_FALSE); 4281 4282 return (error); 4283 4284 out: 4285 spa_unload(newspa); 4286 spa_deactivate(newspa); 4287 spa_remove(newspa); 4288 4289 txg = spa_vdev_config_enter(spa); 4290 nvlist_free(spa->spa_config_splitting); 4291 spa->spa_config_splitting = NULL; 4292 (void) spa_vdev_exit(spa, NULL, txg, error); 4293 4294 kmem_free(vml, children * sizeof (vdev_t *)); 4295 return (error); 4296 } 4297 4298 static nvlist_t * 4299 spa_nvlist_lookup_by_guid(nvlist_t **nvpp, int count, uint64_t target_guid) 4300 { 4301 for (int i = 0; i < count; i++) { 4302 uint64_t guid; 4303 4304 VERIFY(nvlist_lookup_uint64(nvpp[i], ZPOOL_CONFIG_GUID, 4305 &guid) == 0); 4306 4307 if (guid == target_guid) 4308 return (nvpp[i]); 4309 } 4310 4311 return (NULL); 4312 } 4313 4314 static void 4315 spa_vdev_remove_aux(nvlist_t *config, char *name, nvlist_t **dev, int count, 4316 nvlist_t *dev_to_remove) 4317 { 4318 nvlist_t **newdev = NULL; 4319 4320 if (count > 1) 4321 newdev = kmem_alloc((count - 1) * sizeof (void *), KM_SLEEP); 4322 4323 for (int i = 0, j = 0; i < count; i++) { 4324 if (dev[i] == dev_to_remove) 4325 continue; 4326 VERIFY(nvlist_dup(dev[i], &newdev[j++], KM_SLEEP) == 0); 4327 } 4328 4329 VERIFY(nvlist_remove(config, name, DATA_TYPE_NVLIST_ARRAY) == 0); 4330 VERIFY(nvlist_add_nvlist_array(config, name, newdev, count - 1) == 0); 4331 4332 for (int i = 0; i < count - 1; i++) 4333 nvlist_free(newdev[i]); 4334 4335 if (count > 1) 4336 kmem_free(newdev, (count - 1) * sizeof (void *)); 4337 } 4338 4339 /* 4340 * Removing a device from the vdev namespace requires several steps 4341 * and can take a significant amount of time. As a result we use 4342 * the spa_vdev_config_[enter/exit] functions which allow us to 4343 * grab and release the spa_config_lock while still holding the namespace 4344 * lock. During each step the configuration is synced out. 4345 */ 4346 4347 /* 4348 * Evacuate the device. 4349 */ 4350 int 4351 spa_vdev_remove_evacuate(spa_t *spa, vdev_t *vd) 4352 { 4353 int error = 0; 4354 uint64_t txg; 4355 4356 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 4357 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0); 4358 ASSERT(vd == vd->vdev_top); 4359 4360 /* 4361 * Evacuate the device. We don't hold the config lock as writer 4362 * since we need to do I/O but we do keep the 4363 * spa_namespace_lock held. Once this completes the device 4364 * should no longer have any blocks allocated on it. 4365 */ 4366 if (vd->vdev_islog) { 4367 error = dmu_objset_find(spa_name(spa), zil_vdev_offline, 4368 NULL, DS_FIND_CHILDREN); 4369 } else { 4370 error = ENOTSUP; /* until we have bp rewrite */ 4371 } 4372 4373 txg_wait_synced(spa_get_dsl(spa), 0); 4374 4375 if (error) 4376 return (error); 4377 4378 /* 4379 * The evacuation succeeded. Remove any remaining MOS metadata 4380 * associated with this vdev, and wait for these changes to sync. 4381 */ 4382 txg = spa_vdev_config_enter(spa); 4383 vd->vdev_removing = B_TRUE; 4384 vdev_dirty(vd, 0, NULL, txg); 4385 vdev_config_dirty(vd); 4386 spa_vdev_config_exit(spa, NULL, txg, 0, FTAG); 4387 4388 return (0); 4389 } 4390 4391 /* 4392 * Complete the removal by cleaning up the namespace. 4393 */ 4394 void 4395 spa_vdev_remove_from_namespace(spa_t *spa, vdev_t *vd) 4396 { 4397 vdev_t *rvd = spa->spa_root_vdev; 4398 uint64_t id = vd->vdev_id; 4399 boolean_t last_vdev = (id == (rvd->vdev_children - 1)); 4400 4401 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 4402 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 4403 ASSERT(vd == vd->vdev_top); 4404 4405 (void) vdev_label_init(vd, 0, VDEV_LABEL_REMOVE); 4406 4407 if (list_link_active(&vd->vdev_state_dirty_node)) 4408 vdev_state_clean(vd); 4409 if (list_link_active(&vd->vdev_config_dirty_node)) 4410 vdev_config_clean(vd); 4411 4412 vdev_free(vd); 4413 4414 if (last_vdev) { 4415 vdev_compact_children(rvd); 4416 } else { 4417 vd = vdev_alloc_common(spa, id, 0, &vdev_hole_ops); 4418 vdev_add_child(rvd, vd); 4419 } 4420 vdev_config_dirty(rvd); 4421 4422 /* 4423 * Reassess the health of our root vdev. 4424 */ 4425 vdev_reopen(rvd); 4426 } 4427 4428 /* 4429 * Remove a device from the pool. Currently, this supports removing only hot 4430 * spares, slogs, and level 2 ARC devices. 4431 */ 4432 int 4433 spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare) 4434 { 4435 vdev_t *vd; 4436 metaslab_group_t *mg; 4437 nvlist_t **spares, **l2cache, *nv; 4438 uint64_t txg = 0; 4439 uint_t nspares, nl2cache; 4440 int error = 0; 4441 boolean_t locked = MUTEX_HELD(&spa_namespace_lock); 4442 4443 if (!locked) 4444 txg = spa_vdev_enter(spa); 4445 4446 vd = spa_lookup_by_guid(spa, guid, B_FALSE); 4447 4448 if (spa->spa_spares.sav_vdevs != NULL && 4449 nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, 4450 ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0 && 4451 (nv = spa_nvlist_lookup_by_guid(spares, nspares, guid)) != NULL) { 4452 /* 4453 * Only remove the hot spare if it's not currently in use 4454 * in this pool. 4455 */ 4456 if (vd == NULL || unspare) { 4457 spa_vdev_remove_aux(spa->spa_spares.sav_config, 4458 ZPOOL_CONFIG_SPARES, spares, nspares, nv); 4459 spa_load_spares(spa); 4460 spa->spa_spares.sav_sync = B_TRUE; 4461 } else { 4462 error = EBUSY; 4463 } 4464 } else if (spa->spa_l2cache.sav_vdevs != NULL && 4465 nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config, 4466 ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0 && 4467 (nv = spa_nvlist_lookup_by_guid(l2cache, nl2cache, guid)) != NULL) { 4468 /* 4469 * Cache devices can always be removed. 4470 */ 4471 spa_vdev_remove_aux(spa->spa_l2cache.sav_config, 4472 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache, nv); 4473 spa_load_l2cache(spa); 4474 spa->spa_l2cache.sav_sync = B_TRUE; 4475 } else if (vd != NULL && vd->vdev_islog) { 4476 ASSERT(!locked); 4477 ASSERT(vd == vd->vdev_top); 4478 4479 /* 4480 * XXX - Once we have bp-rewrite this should 4481 * become the common case. 4482 */ 4483 4484 mg = vd->vdev_mg; 4485 4486 /* 4487 * Stop allocating from this vdev. 4488 */ 4489 metaslab_group_passivate(mg); 4490 4491 /* 4492 * Wait for the youngest allocations and frees to sync, 4493 * and then wait for the deferral of those frees to finish. 4494 */ 4495 spa_vdev_config_exit(spa, NULL, 4496 txg + TXG_CONCURRENT_STATES + TXG_DEFER_SIZE, 0, FTAG); 4497 4498 /* 4499 * Attempt to evacuate the vdev. 4500 */ 4501 error = spa_vdev_remove_evacuate(spa, vd); 4502 4503 txg = spa_vdev_config_enter(spa); 4504 4505 /* 4506 * If we couldn't evacuate the vdev, unwind. 4507 */ 4508 if (error) { 4509 metaslab_group_activate(mg); 4510 return (spa_vdev_exit(spa, NULL, txg, error)); 4511 } 4512 4513 /* 4514 * Clean up the vdev namespace. 4515 */ 4516 spa_vdev_remove_from_namespace(spa, vd); 4517 4518 } else if (vd != NULL) { 4519 /* 4520 * Normal vdevs cannot be removed (yet). 4521 */ 4522 error = ENOTSUP; 4523 } else { 4524 /* 4525 * There is no vdev of any kind with the specified guid. 4526 */ 4527 error = ENOENT; 4528 } 4529 4530 if (!locked) 4531 return (spa_vdev_exit(spa, NULL, txg, error)); 4532 4533 return (error); 4534 } 4535 4536 /* 4537 * Find any device that's done replacing, or a vdev marked 'unspare' that's 4538 * current spared, so we can detach it. 4539 */ 4540 static vdev_t * 4541 spa_vdev_resilver_done_hunt(vdev_t *vd) 4542 { 4543 vdev_t *newvd, *oldvd; 4544 4545 for (int c = 0; c < vd->vdev_children; c++) { 4546 oldvd = spa_vdev_resilver_done_hunt(vd->vdev_child[c]); 4547 if (oldvd != NULL) 4548 return (oldvd); 4549 } 4550 4551 /* 4552 * Check for a completed replacement. 4553 */ 4554 if (vd->vdev_ops == &vdev_replacing_ops && vd->vdev_children == 2) { 4555 oldvd = vd->vdev_child[0]; 4556 newvd = vd->vdev_child[1]; 4557 4558 if (vdev_dtl_empty(newvd, DTL_MISSING) && 4559 !vdev_dtl_required(oldvd)) 4560 return (oldvd); 4561 } 4562 4563 /* 4564 * Check for a completed resilver with the 'unspare' flag set. 4565 */ 4566 if (vd->vdev_ops == &vdev_spare_ops && vd->vdev_children == 2) { 4567 newvd = vd->vdev_child[0]; 4568 oldvd = vd->vdev_child[1]; 4569 4570 if (newvd->vdev_unspare && 4571 vdev_dtl_empty(newvd, DTL_MISSING) && 4572 !vdev_dtl_required(oldvd)) { 4573 newvd->vdev_unspare = 0; 4574 return (oldvd); 4575 } 4576 } 4577 4578 return (NULL); 4579 } 4580 4581 static void 4582 spa_vdev_resilver_done(spa_t *spa) 4583 { 4584 vdev_t *vd, *pvd, *ppvd; 4585 uint64_t guid, sguid, pguid, ppguid; 4586 4587 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 4588 4589 while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) { 4590 pvd = vd->vdev_parent; 4591 ppvd = pvd->vdev_parent; 4592 guid = vd->vdev_guid; 4593 pguid = pvd->vdev_guid; 4594 ppguid = ppvd->vdev_guid; 4595 sguid = 0; 4596 /* 4597 * If we have just finished replacing a hot spared device, then 4598 * we need to detach the parent's first child (the original hot 4599 * spare) as well. 4600 */ 4601 if (ppvd->vdev_ops == &vdev_spare_ops && pvd->vdev_id == 0) { 4602 ASSERT(pvd->vdev_ops == &vdev_replacing_ops); 4603 ASSERT(ppvd->vdev_children == 2); 4604 sguid = ppvd->vdev_child[1]->vdev_guid; 4605 } 4606 spa_config_exit(spa, SCL_ALL, FTAG); 4607 if (spa_vdev_detach(spa, guid, pguid, B_TRUE) != 0) 4608 return; 4609 if (sguid && spa_vdev_detach(spa, sguid, ppguid, B_TRUE) != 0) 4610 return; 4611 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 4612 } 4613 4614 spa_config_exit(spa, SCL_ALL, FTAG); 4615 } 4616 4617 /* 4618 * Update the stored path or FRU for this vdev. 4619 */ 4620 int 4621 spa_vdev_set_common(spa_t *spa, uint64_t guid, const char *value, 4622 boolean_t ispath) 4623 { 4624 vdev_t *vd; 4625 4626 spa_vdev_state_enter(spa, SCL_ALL); 4627 4628 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) 4629 return (spa_vdev_state_exit(spa, NULL, ENOENT)); 4630 4631 if (!vd->vdev_ops->vdev_op_leaf) 4632 return (spa_vdev_state_exit(spa, NULL, ENOTSUP)); 4633 4634 if (ispath) { 4635 spa_strfree(vd->vdev_path); 4636 vd->vdev_path = spa_strdup(value); 4637 } else { 4638 if (vd->vdev_fru != NULL) 4639 spa_strfree(vd->vdev_fru); 4640 vd->vdev_fru = spa_strdup(value); 4641 } 4642 4643 return (spa_vdev_state_exit(spa, vd, 0)); 4644 } 4645 4646 int 4647 spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath) 4648 { 4649 return (spa_vdev_set_common(spa, guid, newpath, B_TRUE)); 4650 } 4651 4652 int 4653 spa_vdev_setfru(spa_t *spa, uint64_t guid, const char *newfru) 4654 { 4655 return (spa_vdev_set_common(spa, guid, newfru, B_FALSE)); 4656 } 4657 4658 /* 4659 * ========================================================================== 4660 * SPA Scrubbing 4661 * ========================================================================== 4662 */ 4663 4664 int 4665 spa_scrub(spa_t *spa, pool_scrub_type_t type) 4666 { 4667 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0); 4668 4669 if ((uint_t)type >= POOL_SCRUB_TYPES) 4670 return (ENOTSUP); 4671 4672 /* 4673 * If a resilver was requested, but there is no DTL on a 4674 * writeable leaf device, we have nothing to do. 4675 */ 4676 if (type == POOL_SCRUB_RESILVER && 4677 !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) { 4678 spa_async_request(spa, SPA_ASYNC_RESILVER_DONE); 4679 return (0); 4680 } 4681 4682 if (type == POOL_SCRUB_EVERYTHING && 4683 spa->spa_dsl_pool->dp_scrub_func != SCRUB_FUNC_NONE && 4684 spa->spa_dsl_pool->dp_scrub_isresilver) 4685 return (EBUSY); 4686 4687 if (type == POOL_SCRUB_EVERYTHING || type == POOL_SCRUB_RESILVER) { 4688 return (dsl_pool_scrub_clean(spa->spa_dsl_pool)); 4689 } else if (type == POOL_SCRUB_NONE) { 4690 return (dsl_pool_scrub_cancel(spa->spa_dsl_pool)); 4691 } else { 4692 return (EINVAL); 4693 } 4694 } 4695 4696 /* 4697 * ========================================================================== 4698 * SPA async task processing 4699 * ========================================================================== 4700 */ 4701 4702 static void 4703 spa_async_remove(spa_t *spa, vdev_t *vd) 4704 { 4705 if (vd->vdev_remove_wanted) { 4706 vd->vdev_remove_wanted = 0; 4707 vdev_set_state(vd, B_FALSE, VDEV_STATE_REMOVED, VDEV_AUX_NONE); 4708 4709 /* 4710 * We want to clear the stats, but we don't want to do a full 4711 * vdev_clear() as that will cause us to throw away 4712 * degraded/faulted state as well as attempt to reopen the 4713 * device, all of which is a waste. 4714 */ 4715 vd->vdev_stat.vs_read_errors = 0; 4716 vd->vdev_stat.vs_write_errors = 0; 4717 vd->vdev_stat.vs_checksum_errors = 0; 4718 4719 vdev_state_dirty(vd->vdev_top); 4720 } 4721 4722 for (int c = 0; c < vd->vdev_children; c++) 4723 spa_async_remove(spa, vd->vdev_child[c]); 4724 } 4725 4726 static void 4727 spa_async_probe(spa_t *spa, vdev_t *vd) 4728 { 4729 if (vd->vdev_probe_wanted) { 4730 vd->vdev_probe_wanted = 0; 4731 vdev_reopen(vd); /* vdev_open() does the actual probe */ 4732 } 4733 4734 for (int c = 0; c < vd->vdev_children; c++) 4735 spa_async_probe(spa, vd->vdev_child[c]); 4736 } 4737 4738 static void 4739 spa_async_autoexpand(spa_t *spa, vdev_t *vd) 4740 { 4741 sysevent_id_t eid; 4742 nvlist_t *attr; 4743 char *physpath; 4744 4745 if (!spa->spa_autoexpand) 4746 return; 4747 4748 for (int c = 0; c < vd->vdev_children; c++) { 4749 vdev_t *cvd = vd->vdev_child[c]; 4750 spa_async_autoexpand(spa, cvd); 4751 } 4752 4753 if (!vd->vdev_ops->vdev_op_leaf || vd->vdev_physpath == NULL) 4754 return; 4755 4756 physpath = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 4757 (void) snprintf(physpath, MAXPATHLEN, "/devices%s", vd->vdev_physpath); 4758 4759 VERIFY(nvlist_alloc(&attr, NV_UNIQUE_NAME, KM_SLEEP) == 0); 4760 VERIFY(nvlist_add_string(attr, DEV_PHYS_PATH, physpath) == 0); 4761 4762 (void) ddi_log_sysevent(zfs_dip, SUNW_VENDOR, EC_DEV_STATUS, 4763 ESC_DEV_DLE, attr, &eid, DDI_SLEEP); 4764 4765 nvlist_free(attr); 4766 kmem_free(physpath, MAXPATHLEN); 4767 } 4768 4769 static void 4770 spa_async_thread(spa_t *spa) 4771 { 4772 int tasks; 4773 4774 ASSERT(spa->spa_sync_on); 4775 4776 mutex_enter(&spa->spa_async_lock); 4777 tasks = spa->spa_async_tasks; 4778 spa->spa_async_tasks = 0; 4779 mutex_exit(&spa->spa_async_lock); 4780 4781 /* 4782 * See if the config needs to be updated. 4783 */ 4784 if (tasks & SPA_ASYNC_CONFIG_UPDATE) { 4785 uint64_t old_space, new_space; 4786 4787 mutex_enter(&spa_namespace_lock); 4788 old_space = metaslab_class_get_space(spa_normal_class(spa)); 4789 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 4790 new_space = metaslab_class_get_space(spa_normal_class(spa)); 4791 mutex_exit(&spa_namespace_lock); 4792 4793 /* 4794 * If the pool grew as a result of the config update, 4795 * then log an internal history event. 4796 */ 4797 if (new_space != old_space) { 4798 spa_history_internal_log(LOG_POOL_VDEV_ONLINE, 4799 spa, NULL, CRED(), 4800 "pool '%s' size: %llu(+%llu)", 4801 spa_name(spa), new_space, new_space - old_space); 4802 } 4803 } 4804 4805 /* 4806 * See if any devices need to be marked REMOVED. 4807 */ 4808 if (tasks & SPA_ASYNC_REMOVE) { 4809 spa_vdev_state_enter(spa, SCL_NONE); 4810 spa_async_remove(spa, spa->spa_root_vdev); 4811 for (int i = 0; i < spa->spa_l2cache.sav_count; i++) 4812 spa_async_remove(spa, spa->spa_l2cache.sav_vdevs[i]); 4813 for (int i = 0; i < spa->spa_spares.sav_count; i++) 4814 spa_async_remove(spa, spa->spa_spares.sav_vdevs[i]); 4815 (void) spa_vdev_state_exit(spa, NULL, 0); 4816 } 4817 4818 if ((tasks & SPA_ASYNC_AUTOEXPAND) && !spa_suspended(spa)) { 4819 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 4820 spa_async_autoexpand(spa, spa->spa_root_vdev); 4821 spa_config_exit(spa, SCL_CONFIG, FTAG); 4822 } 4823 4824 /* 4825 * See if any devices need to be probed. 4826 */ 4827 if (tasks & SPA_ASYNC_PROBE) { 4828 spa_vdev_state_enter(spa, SCL_NONE); 4829 spa_async_probe(spa, spa->spa_root_vdev); 4830 (void) spa_vdev_state_exit(spa, NULL, 0); 4831 } 4832 4833 /* 4834 * If any devices are done replacing, detach them. 4835 */ 4836 if (tasks & SPA_ASYNC_RESILVER_DONE) 4837 spa_vdev_resilver_done(spa); 4838 4839 /* 4840 * Kick off a resilver. 4841 */ 4842 if (tasks & SPA_ASYNC_RESILVER) 4843 VERIFY(spa_scrub(spa, POOL_SCRUB_RESILVER) == 0); 4844 4845 /* 4846 * Let the world know that we're done. 4847 */ 4848 mutex_enter(&spa->spa_async_lock); 4849 spa->spa_async_thread = NULL; 4850 cv_broadcast(&spa->spa_async_cv); 4851 mutex_exit(&spa->spa_async_lock); 4852 thread_exit(); 4853 } 4854 4855 void 4856 spa_async_suspend(spa_t *spa) 4857 { 4858 mutex_enter(&spa->spa_async_lock); 4859 spa->spa_async_suspended++; 4860 while (spa->spa_async_thread != NULL) 4861 cv_wait(&spa->spa_async_cv, &spa->spa_async_lock); 4862 mutex_exit(&spa->spa_async_lock); 4863 } 4864 4865 void 4866 spa_async_resume(spa_t *spa) 4867 { 4868 mutex_enter(&spa->spa_async_lock); 4869 ASSERT(spa->spa_async_suspended != 0); 4870 spa->spa_async_suspended--; 4871 mutex_exit(&spa->spa_async_lock); 4872 } 4873 4874 static void 4875 spa_async_dispatch(spa_t *spa) 4876 { 4877 mutex_enter(&spa->spa_async_lock); 4878 if (spa->spa_async_tasks && !spa->spa_async_suspended && 4879 spa->spa_async_thread == NULL && 4880 rootdir != NULL && !vn_is_readonly(rootdir)) 4881 spa->spa_async_thread = thread_create(NULL, 0, 4882 spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri); 4883 mutex_exit(&spa->spa_async_lock); 4884 } 4885 4886 void 4887 spa_async_request(spa_t *spa, int task) 4888 { 4889 mutex_enter(&spa->spa_async_lock); 4890 spa->spa_async_tasks |= task; 4891 mutex_exit(&spa->spa_async_lock); 4892 } 4893 4894 /* 4895 * ========================================================================== 4896 * SPA syncing routines 4897 * ========================================================================== 4898 */ 4899 static void 4900 spa_sync_deferred_bplist(spa_t *spa, bplist_t *bpl, dmu_tx_t *tx, uint64_t txg) 4901 { 4902 blkptr_t blk; 4903 uint64_t itor = 0; 4904 uint8_t c = 1; 4905 4906 while (bplist_iterate(bpl, &itor, &blk) == 0) { 4907 ASSERT(blk.blk_birth < txg); 4908 zio_free(spa, txg, &blk); 4909 } 4910 4911 bplist_vacate(bpl, tx); 4912 4913 /* 4914 * Pre-dirty the first block so we sync to convergence faster. 4915 * (Usually only the first block is needed.) 4916 */ 4917 dmu_write(bpl->bpl_mos, spa->spa_deferred_bplist_obj, 0, 1, &c, tx); 4918 } 4919 4920 static void 4921 spa_sync_free(void *arg, const blkptr_t *bp, dmu_tx_t *tx) 4922 { 4923 zio_t *zio = arg; 4924 4925 zio_nowait(zio_free_sync(zio, zio->io_spa, dmu_tx_get_txg(tx), bp, 4926 zio->io_flags)); 4927 } 4928 4929 static void 4930 spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx) 4931 { 4932 char *packed = NULL; 4933 size_t bufsize; 4934 size_t nvsize = 0; 4935 dmu_buf_t *db; 4936 4937 VERIFY(nvlist_size(nv, &nvsize, NV_ENCODE_XDR) == 0); 4938 4939 /* 4940 * Write full (SPA_CONFIG_BLOCKSIZE) blocks of configuration 4941 * information. This avoids the dbuf_will_dirty() path and 4942 * saves us a pre-read to get data we don't actually care about. 4943 */ 4944 bufsize = P2ROUNDUP(nvsize, SPA_CONFIG_BLOCKSIZE); 4945 packed = kmem_alloc(bufsize, KM_SLEEP); 4946 4947 VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR, 4948 KM_SLEEP) == 0); 4949 bzero(packed + nvsize, bufsize - nvsize); 4950 4951 dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx); 4952 4953 kmem_free(packed, bufsize); 4954 4955 VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db)); 4956 dmu_buf_will_dirty(db, tx); 4957 *(uint64_t *)db->db_data = nvsize; 4958 dmu_buf_rele(db, FTAG); 4959 } 4960 4961 static void 4962 spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx, 4963 const char *config, const char *entry) 4964 { 4965 nvlist_t *nvroot; 4966 nvlist_t **list; 4967 int i; 4968 4969 if (!sav->sav_sync) 4970 return; 4971 4972 /* 4973 * Update the MOS nvlist describing the list of available devices. 4974 * spa_validate_aux() will have already made sure this nvlist is 4975 * valid and the vdevs are labeled appropriately. 4976 */ 4977 if (sav->sav_object == 0) { 4978 sav->sav_object = dmu_object_alloc(spa->spa_meta_objset, 4979 DMU_OT_PACKED_NVLIST, 1 << 14, DMU_OT_PACKED_NVLIST_SIZE, 4980 sizeof (uint64_t), tx); 4981 VERIFY(zap_update(spa->spa_meta_objset, 4982 DMU_POOL_DIRECTORY_OBJECT, entry, sizeof (uint64_t), 1, 4983 &sav->sav_object, tx) == 0); 4984 } 4985 4986 VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0); 4987 if (sav->sav_count == 0) { 4988 VERIFY(nvlist_add_nvlist_array(nvroot, config, NULL, 0) == 0); 4989 } else { 4990 list = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP); 4991 for (i = 0; i < sav->sav_count; i++) 4992 list[i] = vdev_config_generate(spa, sav->sav_vdevs[i], 4993 B_FALSE, B_FALSE, B_TRUE); 4994 VERIFY(nvlist_add_nvlist_array(nvroot, config, list, 4995 sav->sav_count) == 0); 4996 for (i = 0; i < sav->sav_count; i++) 4997 nvlist_free(list[i]); 4998 kmem_free(list, sav->sav_count * sizeof (void *)); 4999 } 5000 5001 spa_sync_nvlist(spa, sav->sav_object, nvroot, tx); 5002 nvlist_free(nvroot); 5003 5004 sav->sav_sync = B_FALSE; 5005 } 5006 5007 static void 5008 spa_sync_config_object(spa_t *spa, dmu_tx_t *tx) 5009 { 5010 nvlist_t *config; 5011 5012 if (list_is_empty(&spa->spa_config_dirty_list)) 5013 return; 5014 5015 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 5016 5017 config = spa_config_generate(spa, spa->spa_root_vdev, 5018 dmu_tx_get_txg(tx), B_FALSE); 5019 5020 spa_config_exit(spa, SCL_STATE, FTAG); 5021 5022 if (spa->spa_config_syncing) 5023 nvlist_free(spa->spa_config_syncing); 5024 spa->spa_config_syncing = config; 5025 5026 spa_sync_nvlist(spa, spa->spa_config_object, config, tx); 5027 } 5028 5029 /* 5030 * Set zpool properties. 5031 */ 5032 static void 5033 spa_sync_props(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 5034 { 5035 spa_t *spa = arg1; 5036 objset_t *mos = spa->spa_meta_objset; 5037 nvlist_t *nvp = arg2; 5038 nvpair_t *elem; 5039 uint64_t intval; 5040 char *strval; 5041 zpool_prop_t prop; 5042 const char *propname; 5043 zprop_type_t proptype; 5044 5045 mutex_enter(&spa->spa_props_lock); 5046 5047 elem = NULL; 5048 while ((elem = nvlist_next_nvpair(nvp, elem))) { 5049 switch (prop = zpool_name_to_prop(nvpair_name(elem))) { 5050 case ZPOOL_PROP_VERSION: 5051 /* 5052 * Only set version for non-zpool-creation cases 5053 * (set/import). spa_create() needs special care 5054 * for version setting. 5055 */ 5056 if (tx->tx_txg != TXG_INITIAL) { 5057 VERIFY(nvpair_value_uint64(elem, 5058 &intval) == 0); 5059 ASSERT(intval <= SPA_VERSION); 5060 ASSERT(intval >= spa_version(spa)); 5061 spa->spa_uberblock.ub_version = intval; 5062 vdev_config_dirty(spa->spa_root_vdev); 5063 } 5064 break; 5065 5066 case ZPOOL_PROP_ALTROOT: 5067 /* 5068 * 'altroot' is a non-persistent property. It should 5069 * have been set temporarily at creation or import time. 5070 */ 5071 ASSERT(spa->spa_root != NULL); 5072 break; 5073 5074 case ZPOOL_PROP_CACHEFILE: 5075 /* 5076 * 'cachefile' is also a non-persisitent property. 5077 */ 5078 break; 5079 default: 5080 /* 5081 * Set pool property values in the poolprops mos object. 5082 */ 5083 if (spa->spa_pool_props_object == 0) { 5084 VERIFY((spa->spa_pool_props_object = 5085 zap_create(mos, DMU_OT_POOL_PROPS, 5086 DMU_OT_NONE, 0, tx)) > 0); 5087 5088 VERIFY(zap_update(mos, 5089 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_PROPS, 5090 8, 1, &spa->spa_pool_props_object, tx) 5091 == 0); 5092 } 5093 5094 /* normalize the property name */ 5095 propname = zpool_prop_to_name(prop); 5096 proptype = zpool_prop_get_type(prop); 5097 5098 if (nvpair_type(elem) == DATA_TYPE_STRING) { 5099 ASSERT(proptype == PROP_TYPE_STRING); 5100 VERIFY(nvpair_value_string(elem, &strval) == 0); 5101 VERIFY(zap_update(mos, 5102 spa->spa_pool_props_object, propname, 5103 1, strlen(strval) + 1, strval, tx) == 0); 5104 5105 } else if (nvpair_type(elem) == DATA_TYPE_UINT64) { 5106 VERIFY(nvpair_value_uint64(elem, &intval) == 0); 5107 5108 if (proptype == PROP_TYPE_INDEX) { 5109 const char *unused; 5110 VERIFY(zpool_prop_index_to_string( 5111 prop, intval, &unused) == 0); 5112 } 5113 VERIFY(zap_update(mos, 5114 spa->spa_pool_props_object, propname, 5115 8, 1, &intval, tx) == 0); 5116 } else { 5117 ASSERT(0); /* not allowed */ 5118 } 5119 5120 switch (prop) { 5121 case ZPOOL_PROP_DELEGATION: 5122 spa->spa_delegation = intval; 5123 break; 5124 case ZPOOL_PROP_BOOTFS: 5125 spa->spa_bootfs = intval; 5126 break; 5127 case ZPOOL_PROP_FAILUREMODE: 5128 spa->spa_failmode = intval; 5129 break; 5130 case ZPOOL_PROP_AUTOEXPAND: 5131 spa->spa_autoexpand = intval; 5132 spa_async_request(spa, SPA_ASYNC_AUTOEXPAND); 5133 break; 5134 case ZPOOL_PROP_DEDUPDITTO: 5135 spa->spa_dedup_ditto = intval; 5136 break; 5137 default: 5138 break; 5139 } 5140 } 5141 5142 /* log internal history if this is not a zpool create */ 5143 if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY && 5144 tx->tx_txg != TXG_INITIAL) { 5145 spa_history_internal_log(LOG_POOL_PROPSET, 5146 spa, tx, cr, "%s %lld %s", 5147 nvpair_name(elem), intval, spa_name(spa)); 5148 } 5149 } 5150 5151 mutex_exit(&spa->spa_props_lock); 5152 } 5153 5154 /* 5155 * Sync the specified transaction group. New blocks may be dirtied as 5156 * part of the process, so we iterate until it converges. 5157 */ 5158 void 5159 spa_sync(spa_t *spa, uint64_t txg) 5160 { 5161 dsl_pool_t *dp = spa->spa_dsl_pool; 5162 objset_t *mos = spa->spa_meta_objset; 5163 bplist_t *defer_bpl = &spa->spa_deferred_bplist; 5164 bplist_t *free_bpl = &spa->spa_free_bplist[txg & TXG_MASK]; 5165 vdev_t *rvd = spa->spa_root_vdev; 5166 vdev_t *vd; 5167 dmu_tx_t *tx; 5168 int error; 5169 5170 /* 5171 * Lock out configuration changes. 5172 */ 5173 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 5174 5175 spa->spa_syncing_txg = txg; 5176 spa->spa_sync_pass = 0; 5177 5178 /* 5179 * If there are any pending vdev state changes, convert them 5180 * into config changes that go out with this transaction group. 5181 */ 5182 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 5183 while (list_head(&spa->spa_state_dirty_list) != NULL) { 5184 /* 5185 * We need the write lock here because, for aux vdevs, 5186 * calling vdev_config_dirty() modifies sav_config. 5187 * This is ugly and will become unnecessary when we 5188 * eliminate the aux vdev wart by integrating all vdevs 5189 * into the root vdev tree. 5190 */ 5191 spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 5192 spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_WRITER); 5193 while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) { 5194 vdev_state_clean(vd); 5195 vdev_config_dirty(vd); 5196 } 5197 spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 5198 spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER); 5199 } 5200 spa_config_exit(spa, SCL_STATE, FTAG); 5201 5202 VERIFY(0 == bplist_open(defer_bpl, mos, spa->spa_deferred_bplist_obj)); 5203 5204 tx = dmu_tx_create_assigned(dp, txg); 5205 5206 /* 5207 * If we are upgrading to SPA_VERSION_RAIDZ_DEFLATE this txg, 5208 * set spa_deflate if we have no raid-z vdevs. 5209 */ 5210 if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE && 5211 spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) { 5212 int i; 5213 5214 for (i = 0; i < rvd->vdev_children; i++) { 5215 vd = rvd->vdev_child[i]; 5216 if (vd->vdev_deflate_ratio != SPA_MINBLOCKSIZE) 5217 break; 5218 } 5219 if (i == rvd->vdev_children) { 5220 spa->spa_deflate = TRUE; 5221 VERIFY(0 == zap_add(spa->spa_meta_objset, 5222 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE, 5223 sizeof (uint64_t), 1, &spa->spa_deflate, tx)); 5224 } 5225 } 5226 5227 if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN && 5228 spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) { 5229 dsl_pool_create_origin(dp, tx); 5230 5231 /* Keeping the origin open increases spa_minref */ 5232 spa->spa_minref += 3; 5233 } 5234 5235 if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES && 5236 spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) { 5237 dsl_pool_upgrade_clones(dp, tx); 5238 } 5239 5240 /* 5241 * If anything has changed in this txg, push the deferred frees 5242 * from the previous txg. If not, leave them alone so that we 5243 * don't generate work on an otherwise idle system. 5244 */ 5245 if (!txg_list_empty(&dp->dp_dirty_datasets, txg) || 5246 !txg_list_empty(&dp->dp_dirty_dirs, txg) || 5247 !txg_list_empty(&dp->dp_sync_tasks, txg)) 5248 spa_sync_deferred_bplist(spa, defer_bpl, tx, txg); 5249 5250 /* 5251 * Iterate to convergence. 5252 */ 5253 do { 5254 int pass = ++spa->spa_sync_pass; 5255 5256 spa_sync_config_object(spa, tx); 5257 spa_sync_aux_dev(spa, &spa->spa_spares, tx, 5258 ZPOOL_CONFIG_SPARES, DMU_POOL_SPARES); 5259 spa_sync_aux_dev(spa, &spa->spa_l2cache, tx, 5260 ZPOOL_CONFIG_L2CACHE, DMU_POOL_L2CACHE); 5261 spa_errlog_sync(spa, txg); 5262 dsl_pool_sync(dp, txg); 5263 5264 if (pass <= SYNC_PASS_DEFERRED_FREE) { 5265 zio_t *zio = zio_root(spa, NULL, NULL, 0); 5266 bplist_sync(free_bpl, spa_sync_free, zio, tx); 5267 VERIFY(zio_wait(zio) == 0); 5268 } else { 5269 bplist_sync(free_bpl, bplist_enqueue_cb, defer_bpl, tx); 5270 } 5271 5272 ddt_sync(spa, txg); 5273 5274 mutex_enter(&spa->spa_scrub_lock); 5275 while (spa->spa_scrub_inflight > 0) 5276 cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock); 5277 mutex_exit(&spa->spa_scrub_lock); 5278 5279 while (vd = txg_list_remove(&spa->spa_vdev_txg_list, txg)) 5280 vdev_sync(vd, txg); 5281 5282 } while (dmu_objset_is_dirty(mos, txg)); 5283 5284 ASSERT(free_bpl->bpl_queue == NULL); 5285 5286 bplist_close(defer_bpl); 5287 5288 /* 5289 * Rewrite the vdev configuration (which includes the uberblock) 5290 * to commit the transaction group. 5291 * 5292 * If there are no dirty vdevs, we sync the uberblock to a few 5293 * random top-level vdevs that are known to be visible in the 5294 * config cache (see spa_vdev_add() for a complete description). 5295 * If there *are* dirty vdevs, sync the uberblock to all vdevs. 5296 */ 5297 for (;;) { 5298 /* 5299 * We hold SCL_STATE to prevent vdev open/close/etc. 5300 * while we're attempting to write the vdev labels. 5301 */ 5302 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 5303 5304 if (list_is_empty(&spa->spa_config_dirty_list)) { 5305 vdev_t *svd[SPA_DVAS_PER_BP]; 5306 int svdcount = 0; 5307 int children = rvd->vdev_children; 5308 int c0 = spa_get_random(children); 5309 5310 for (int c = 0; c < children; c++) { 5311 vd = rvd->vdev_child[(c0 + c) % children]; 5312 if (vd->vdev_ms_array == 0 || vd->vdev_islog) 5313 continue; 5314 svd[svdcount++] = vd; 5315 if (svdcount == SPA_DVAS_PER_BP) 5316 break; 5317 } 5318 error = vdev_config_sync(svd, svdcount, txg, B_FALSE); 5319 if (error != 0) 5320 error = vdev_config_sync(svd, svdcount, txg, 5321 B_TRUE); 5322 } else { 5323 error = vdev_config_sync(rvd->vdev_child, 5324 rvd->vdev_children, txg, B_FALSE); 5325 if (error != 0) 5326 error = vdev_config_sync(rvd->vdev_child, 5327 rvd->vdev_children, txg, B_TRUE); 5328 } 5329 5330 spa_config_exit(spa, SCL_STATE, FTAG); 5331 5332 if (error == 0) 5333 break; 5334 zio_suspend(spa, NULL); 5335 zio_resume_wait(spa); 5336 } 5337 dmu_tx_commit(tx); 5338 5339 /* 5340 * Clear the dirty config list. 5341 */ 5342 while ((vd = list_head(&spa->spa_config_dirty_list)) != NULL) 5343 vdev_config_clean(vd); 5344 5345 /* 5346 * Now that the new config has synced transactionally, 5347 * let it become visible to the config cache. 5348 */ 5349 if (spa->spa_config_syncing != NULL) { 5350 spa_config_set(spa, spa->spa_config_syncing); 5351 spa->spa_config_txg = txg; 5352 spa->spa_config_syncing = NULL; 5353 } 5354 5355 spa->spa_ubsync = spa->spa_uberblock; 5356 5357 dsl_pool_sync_done(dp, txg); 5358 5359 /* 5360 * Update usable space statistics. 5361 */ 5362 while (vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg))) 5363 vdev_sync_done(vd, txg); 5364 5365 spa_update_dspace(spa); 5366 5367 /* 5368 * It had better be the case that we didn't dirty anything 5369 * since vdev_config_sync(). 5370 */ 5371 ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg)); 5372 ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg)); 5373 ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg)); 5374 ASSERT(defer_bpl->bpl_queue == NULL); 5375 ASSERT(free_bpl->bpl_queue == NULL); 5376 5377 spa->spa_sync_pass = 0; 5378 5379 spa_config_exit(spa, SCL_CONFIG, FTAG); 5380 5381 spa_handle_ignored_writes(spa); 5382 5383 /* 5384 * If any async tasks have been requested, kick them off. 5385 */ 5386 spa_async_dispatch(spa); 5387 } 5388 5389 /* 5390 * Sync all pools. We don't want to hold the namespace lock across these 5391 * operations, so we take a reference on the spa_t and drop the lock during the 5392 * sync. 5393 */ 5394 void 5395 spa_sync_allpools(void) 5396 { 5397 spa_t *spa = NULL; 5398 mutex_enter(&spa_namespace_lock); 5399 while ((spa = spa_next(spa)) != NULL) { 5400 if (spa_state(spa) != POOL_STATE_ACTIVE || spa_suspended(spa)) 5401 continue; 5402 spa_open_ref(spa, FTAG); 5403 mutex_exit(&spa_namespace_lock); 5404 txg_wait_synced(spa_get_dsl(spa), 0); 5405 mutex_enter(&spa_namespace_lock); 5406 spa_close(spa, FTAG); 5407 } 5408 mutex_exit(&spa_namespace_lock); 5409 } 5410 5411 /* 5412 * ========================================================================== 5413 * Miscellaneous routines 5414 * ========================================================================== 5415 */ 5416 5417 /* 5418 * Remove all pools in the system. 5419 */ 5420 void 5421 spa_evict_all(void) 5422 { 5423 spa_t *spa; 5424 5425 /* 5426 * Remove all cached state. All pools should be closed now, 5427 * so every spa in the AVL tree should be unreferenced. 5428 */ 5429 mutex_enter(&spa_namespace_lock); 5430 while ((spa = spa_next(NULL)) != NULL) { 5431 /* 5432 * Stop async tasks. The async thread may need to detach 5433 * a device that's been replaced, which requires grabbing 5434 * spa_namespace_lock, so we must drop it here. 5435 */ 5436 spa_open_ref(spa, FTAG); 5437 mutex_exit(&spa_namespace_lock); 5438 spa_async_suspend(spa); 5439 mutex_enter(&spa_namespace_lock); 5440 spa_close(spa, FTAG); 5441 5442 if (spa->spa_state != POOL_STATE_UNINITIALIZED) { 5443 spa_unload(spa); 5444 spa_deactivate(spa); 5445 } 5446 spa_remove(spa); 5447 } 5448 mutex_exit(&spa_namespace_lock); 5449 } 5450 5451 vdev_t * 5452 spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t aux) 5453 { 5454 vdev_t *vd; 5455 int i; 5456 5457 if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL) 5458 return (vd); 5459 5460 if (aux) { 5461 for (i = 0; i < spa->spa_l2cache.sav_count; i++) { 5462 vd = spa->spa_l2cache.sav_vdevs[i]; 5463 if (vd->vdev_guid == guid) 5464 return (vd); 5465 } 5466 5467 for (i = 0; i < spa->spa_spares.sav_count; i++) { 5468 vd = spa->spa_spares.sav_vdevs[i]; 5469 if (vd->vdev_guid == guid) 5470 return (vd); 5471 } 5472 } 5473 5474 return (NULL); 5475 } 5476 5477 void 5478 spa_upgrade(spa_t *spa, uint64_t version) 5479 { 5480 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 5481 5482 /* 5483 * This should only be called for a non-faulted pool, and since a 5484 * future version would result in an unopenable pool, this shouldn't be 5485 * possible. 5486 */ 5487 ASSERT(spa->spa_uberblock.ub_version <= SPA_VERSION); 5488 ASSERT(version >= spa->spa_uberblock.ub_version); 5489 5490 spa->spa_uberblock.ub_version = version; 5491 vdev_config_dirty(spa->spa_root_vdev); 5492 5493 spa_config_exit(spa, SCL_ALL, FTAG); 5494 5495 txg_wait_synced(spa_get_dsl(spa), 0); 5496 } 5497 5498 boolean_t 5499 spa_has_spare(spa_t *spa, uint64_t guid) 5500 { 5501 int i; 5502 uint64_t spareguid; 5503 spa_aux_vdev_t *sav = &spa->spa_spares; 5504 5505 for (i = 0; i < sav->sav_count; i++) 5506 if (sav->sav_vdevs[i]->vdev_guid == guid) 5507 return (B_TRUE); 5508 5509 for (i = 0; i < sav->sav_npending; i++) { 5510 if (nvlist_lookup_uint64(sav->sav_pending[i], ZPOOL_CONFIG_GUID, 5511 &spareguid) == 0 && spareguid == guid) 5512 return (B_TRUE); 5513 } 5514 5515 return (B_FALSE); 5516 } 5517 5518 /* 5519 * Check if a pool has an active shared spare device. 5520 * Note: reference count of an active spare is 2, as a spare and as a replace 5521 */ 5522 static boolean_t 5523 spa_has_active_shared_spare(spa_t *spa) 5524 { 5525 int i, refcnt; 5526 uint64_t pool; 5527 spa_aux_vdev_t *sav = &spa->spa_spares; 5528 5529 for (i = 0; i < sav->sav_count; i++) { 5530 if (spa_spare_exists(sav->sav_vdevs[i]->vdev_guid, &pool, 5531 &refcnt) && pool != 0ULL && pool == spa_guid(spa) && 5532 refcnt > 2) 5533 return (B_TRUE); 5534 } 5535 5536 return (B_FALSE); 5537 } 5538 5539 /* 5540 * Post a sysevent corresponding to the given event. The 'name' must be one of 5541 * the event definitions in sys/sysevent/eventdefs.h. The payload will be 5542 * filled in from the spa and (optionally) the vdev. This doesn't do anything 5543 * in the userland libzpool, as we don't want consumers to misinterpret ztest 5544 * or zdb as real changes. 5545 */ 5546 void 5547 spa_event_notify(spa_t *spa, vdev_t *vd, const char *name) 5548 { 5549 #ifdef _KERNEL 5550 sysevent_t *ev; 5551 sysevent_attr_list_t *attr = NULL; 5552 sysevent_value_t value; 5553 sysevent_id_t eid; 5554 5555 ev = sysevent_alloc(EC_ZFS, (char *)name, SUNW_KERN_PUB "zfs", 5556 SE_SLEEP); 5557 5558 value.value_type = SE_DATA_TYPE_STRING; 5559 value.value.sv_string = spa_name(spa); 5560 if (sysevent_add_attr(&attr, ZFS_EV_POOL_NAME, &value, SE_SLEEP) != 0) 5561 goto done; 5562 5563 value.value_type = SE_DATA_TYPE_UINT64; 5564 value.value.sv_uint64 = spa_guid(spa); 5565 if (sysevent_add_attr(&attr, ZFS_EV_POOL_GUID, &value, SE_SLEEP) != 0) 5566 goto done; 5567 5568 if (vd) { 5569 value.value_type = SE_DATA_TYPE_UINT64; 5570 value.value.sv_uint64 = vd->vdev_guid; 5571 if (sysevent_add_attr(&attr, ZFS_EV_VDEV_GUID, &value, 5572 SE_SLEEP) != 0) 5573 goto done; 5574 5575 if (vd->vdev_path) { 5576 value.value_type = SE_DATA_TYPE_STRING; 5577 value.value.sv_string = vd->vdev_path; 5578 if (sysevent_add_attr(&attr, ZFS_EV_VDEV_PATH, 5579 &value, SE_SLEEP) != 0) 5580 goto done; 5581 } 5582 } 5583 5584 if (sysevent_attach_attributes(ev, attr) != 0) 5585 goto done; 5586 attr = NULL; 5587 5588 (void) log_sysevent(ev, SE_SLEEP, &eid); 5589 5590 done: 5591 if (attr) 5592 sysevent_free_attr(attr); 5593 sysevent_free(ev); 5594 #endif 5595 } 5596