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_meta_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_meta_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 zpool_get_rewind_policy(spa->spa_config, &policy); 1458 1459 if (policy.zrp_request & ZPOOL_NEVER_REWIND) 1460 return (0); 1461 1462 rio = zio_root(spa, NULL, &sle, 1463 ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE); 1464 1465 error = traverse_pool(spa, spa->spa_verify_min_txg, 1466 TRAVERSE_PRE | TRAVERSE_PREFETCH, spa_load_verify_cb, rio); 1467 1468 (void) zio_wait(rio); 1469 1470 spa->spa_load_meta_errors = sle.sle_meta_count; 1471 spa->spa_load_data_errors = sle.sle_data_count; 1472 1473 if (!error && sle.sle_meta_count <= policy.zrp_maxmeta && 1474 sle.sle_data_count <= policy.zrp_maxdata) { 1475 verify_ok = B_TRUE; 1476 spa->spa_load_txg = spa->spa_uberblock.ub_txg; 1477 spa->spa_load_txg_ts = spa->spa_uberblock.ub_timestamp; 1478 } else { 1479 spa->spa_load_max_txg = spa->spa_uberblock.ub_txg; 1480 } 1481 1482 if (error) { 1483 if (error != ENXIO && error != EIO) 1484 error = EIO; 1485 return (error); 1486 } 1487 1488 return (verify_ok ? 0 : EIO); 1489 } 1490 1491 /* 1492 * Find a value in the pool props object. 1493 */ 1494 static void 1495 spa_prop_find(spa_t *spa, zpool_prop_t prop, uint64_t *val) 1496 { 1497 (void) zap_lookup(spa->spa_meta_objset, spa->spa_pool_props_object, 1498 zpool_prop_to_name(prop), sizeof (uint64_t), 1, val); 1499 } 1500 1501 /* 1502 * Find a value in the pool directory object. 1503 */ 1504 static int 1505 spa_dir_prop(spa_t *spa, const char *name, uint64_t *val) 1506 { 1507 return (zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 1508 name, sizeof (uint64_t), 1, val)); 1509 } 1510 1511 static int 1512 spa_vdev_err(vdev_t *vdev, vdev_aux_t aux, int err) 1513 { 1514 vdev_set_state(vdev, B_TRUE, VDEV_STATE_CANT_OPEN, aux); 1515 return (err); 1516 } 1517 1518 /* 1519 * Fix up config after a partly-completed split. This is done with the 1520 * ZPOOL_CONFIG_SPLIT nvlist. Both the splitting pool and the split-off 1521 * pool have that entry in their config, but only the splitting one contains 1522 * a list of all the guids of the vdevs that are being split off. 1523 * 1524 * This function determines what to do with that list: either rejoin 1525 * all the disks to the pool, or complete the splitting process. To attempt 1526 * the rejoin, each disk that is offlined is marked online again, and 1527 * we do a reopen() call. If the vdev label for every disk that was 1528 * marked online indicates it was successfully split off (VDEV_AUX_SPLIT_POOL) 1529 * then we call vdev_split() on each disk, and complete the split. 1530 * 1531 * Otherwise we leave the config alone, with all the vdevs in place in 1532 * the original pool. 1533 */ 1534 static void 1535 spa_try_repair(spa_t *spa, nvlist_t *config) 1536 { 1537 uint_t extracted; 1538 uint64_t *glist; 1539 uint_t i, gcount; 1540 nvlist_t *nvl; 1541 vdev_t **vd; 1542 boolean_t attempt_reopen; 1543 1544 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT, &nvl) != 0) 1545 return; 1546 1547 /* check that the config is complete */ 1548 if (nvlist_lookup_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST, 1549 &glist, &gcount) != 0) 1550 return; 1551 1552 vd = kmem_zalloc(gcount * sizeof (vdev_t *), KM_SLEEP); 1553 1554 /* attempt to online all the vdevs & validate */ 1555 attempt_reopen = B_TRUE; 1556 for (i = 0; i < gcount; i++) { 1557 if (glist[i] == 0) /* vdev is hole */ 1558 continue; 1559 1560 vd[i] = spa_lookup_by_guid(spa, glist[i], B_FALSE); 1561 if (vd[i] == NULL) { 1562 /* 1563 * Don't bother attempting to reopen the disks; 1564 * just do the split. 1565 */ 1566 attempt_reopen = B_FALSE; 1567 } else { 1568 /* attempt to re-online it */ 1569 vd[i]->vdev_offline = B_FALSE; 1570 } 1571 } 1572 1573 if (attempt_reopen) { 1574 vdev_reopen(spa->spa_root_vdev); 1575 1576 /* check each device to see what state it's in */ 1577 for (extracted = 0, i = 0; i < gcount; i++) { 1578 if (vd[i] != NULL && 1579 vd[i]->vdev_stat.vs_aux != VDEV_AUX_SPLIT_POOL) 1580 break; 1581 ++extracted; 1582 } 1583 } 1584 1585 /* 1586 * If every disk has been moved to the new pool, or if we never 1587 * even attempted to look at them, then we split them off for 1588 * good. 1589 */ 1590 if (!attempt_reopen || gcount == extracted) { 1591 for (i = 0; i < gcount; i++) 1592 if (vd[i] != NULL) 1593 vdev_split(vd[i]); 1594 vdev_reopen(spa->spa_root_vdev); 1595 } 1596 1597 kmem_free(vd, gcount * sizeof (vdev_t *)); 1598 } 1599 1600 static int 1601 spa_load(spa_t *spa, spa_load_state_t state, spa_import_type_t type, 1602 boolean_t mosconfig) 1603 { 1604 nvlist_t *config = spa->spa_config; 1605 char *ereport = FM_EREPORT_ZFS_POOL; 1606 int error; 1607 uint64_t pool_guid; 1608 nvlist_t *nvl; 1609 1610 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid)) 1611 return (EINVAL); 1612 1613 /* 1614 * Versioning wasn't explicitly added to the label until later, so if 1615 * it's not present treat it as the initial version. 1616 */ 1617 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 1618 &spa->spa_ubsync.ub_version) != 0) 1619 spa->spa_ubsync.ub_version = SPA_VERSION_INITIAL; 1620 1621 (void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, 1622 &spa->spa_config_txg); 1623 1624 if ((state == SPA_LOAD_IMPORT || state == SPA_LOAD_TRYIMPORT) && 1625 spa_guid_exists(pool_guid, 0)) { 1626 error = EEXIST; 1627 } else { 1628 spa->spa_load_guid = pool_guid; 1629 1630 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT, 1631 &nvl) == 0) { 1632 VERIFY(nvlist_dup(nvl, &spa->spa_config_splitting, 1633 KM_SLEEP) == 0); 1634 } 1635 1636 error = spa_load_impl(spa, pool_guid, config, state, type, 1637 mosconfig, &ereport); 1638 } 1639 1640 spa->spa_minref = refcount_count(&spa->spa_refcount); 1641 if (error && error != EBADF) 1642 zfs_ereport_post(ereport, spa, NULL, NULL, 0, 0); 1643 spa->spa_load_state = error ? SPA_LOAD_ERROR : SPA_LOAD_NONE; 1644 spa->spa_ena = 0; 1645 1646 return (error); 1647 } 1648 1649 /* 1650 * Load an existing storage pool, using the pool's builtin spa_config as a 1651 * source of configuration information. 1652 */ 1653 static int 1654 spa_load_impl(spa_t *spa, uint64_t pool_guid, nvlist_t *config, 1655 spa_load_state_t state, spa_import_type_t type, boolean_t mosconfig, 1656 char **ereport) 1657 { 1658 int error = 0; 1659 nvlist_t *nvroot = NULL; 1660 vdev_t *rvd; 1661 uberblock_t *ub = &spa->spa_uberblock; 1662 uint64_t config_cache_txg = spa->spa_config_txg; 1663 int orig_mode = spa->spa_mode; 1664 int parse; 1665 1666 /* 1667 * If this is an untrusted config, access the pool in read-only mode. 1668 * This prevents things like resilvering recently removed devices. 1669 */ 1670 if (!mosconfig) 1671 spa->spa_mode = FREAD; 1672 1673 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 1674 1675 spa->spa_load_state = state; 1676 1677 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvroot)) 1678 return (EINVAL); 1679 1680 parse = (type == SPA_IMPORT_EXISTING ? 1681 VDEV_ALLOC_LOAD : VDEV_ALLOC_SPLIT); 1682 1683 /* 1684 * Create "The Godfather" zio to hold all async IOs 1685 */ 1686 spa->spa_async_zio_root = zio_root(spa, NULL, NULL, 1687 ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE | ZIO_FLAG_GODFATHER); 1688 1689 /* 1690 * Parse the configuration into a vdev tree. We explicitly set the 1691 * value that will be returned by spa_version() since parsing the 1692 * configuration requires knowing the version number. 1693 */ 1694 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1695 error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, parse); 1696 spa_config_exit(spa, SCL_ALL, FTAG); 1697 1698 if (error != 0) 1699 return (error); 1700 1701 ASSERT(spa->spa_root_vdev == rvd); 1702 1703 if (type != SPA_IMPORT_ASSEMBLE) { 1704 ASSERT(spa_guid(spa) == pool_guid); 1705 } 1706 1707 /* 1708 * Try to open all vdevs, loading each label in the process. 1709 */ 1710 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1711 error = vdev_open(rvd); 1712 spa_config_exit(spa, SCL_ALL, FTAG); 1713 if (error != 0) 1714 return (error); 1715 1716 /* 1717 * We need to validate the vdev labels against the configuration that 1718 * we have in hand, which is dependent on the setting of mosconfig. If 1719 * mosconfig is true then we're validating the vdev labels based on 1720 * that config. Otherwise, we're validating against the cached config 1721 * (zpool.cache) that was read when we loaded the zfs module, and then 1722 * later we will recursively call spa_load() and validate against 1723 * the vdev config. 1724 * 1725 * If we're assembling a new pool that's been split off from an 1726 * existing pool, the labels haven't yet been updated so we skip 1727 * validation for now. 1728 */ 1729 if (type != SPA_IMPORT_ASSEMBLE) { 1730 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1731 error = vdev_validate(rvd); 1732 spa_config_exit(spa, SCL_ALL, FTAG); 1733 1734 if (error != 0) 1735 return (error); 1736 1737 if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) 1738 return (ENXIO); 1739 } 1740 1741 /* 1742 * Find the best uberblock. 1743 */ 1744 vdev_uberblock_load(NULL, rvd, ub); 1745 1746 /* 1747 * If we weren't able to find a single valid uberblock, return failure. 1748 */ 1749 if (ub->ub_txg == 0) 1750 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, ENXIO)); 1751 1752 /* 1753 * If the pool is newer than the code, we can't open it. 1754 */ 1755 if (ub->ub_version > SPA_VERSION) 1756 return (spa_vdev_err(rvd, VDEV_AUX_VERSION_NEWER, ENOTSUP)); 1757 1758 /* 1759 * If the vdev guid sum doesn't match the uberblock, we have an 1760 * incomplete configuration. 1761 */ 1762 if (mosconfig && type != SPA_IMPORT_ASSEMBLE && 1763 rvd->vdev_guid_sum != ub->ub_guid_sum) 1764 return (spa_vdev_err(rvd, VDEV_AUX_BAD_GUID_SUM, ENXIO)); 1765 1766 if (type != SPA_IMPORT_ASSEMBLE && spa->spa_config_splitting) { 1767 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1768 spa_try_repair(spa, config); 1769 spa_config_exit(spa, SCL_ALL, FTAG); 1770 nvlist_free(spa->spa_config_splitting); 1771 spa->spa_config_splitting = NULL; 1772 } 1773 1774 /* 1775 * Initialize internal SPA structures. 1776 */ 1777 spa->spa_state = POOL_STATE_ACTIVE; 1778 spa->spa_ubsync = spa->spa_uberblock; 1779 spa->spa_verify_min_txg = spa->spa_extreme_rewind ? 1780 TXG_INITIAL - 1 : spa_last_synced_txg(spa) - TXG_DEFER_SIZE - 1; 1781 spa->spa_first_txg = spa->spa_last_ubsync_txg ? 1782 spa->spa_last_ubsync_txg : spa_last_synced_txg(spa) + 1; 1783 spa->spa_claim_max_txg = spa->spa_first_txg; 1784 1785 error = dsl_pool_open(spa, spa->spa_first_txg, &spa->spa_dsl_pool); 1786 if (error) 1787 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1788 spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset; 1789 1790 if (spa_dir_prop(spa, DMU_POOL_CONFIG, &spa->spa_config_object) != 0) 1791 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1792 1793 if (!mosconfig) { 1794 uint64_t hostid; 1795 nvlist_t *policy = NULL, *nvconfig; 1796 1797 if (load_nvlist(spa, spa->spa_config_object, &nvconfig) != 0) 1798 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1799 1800 if (!spa_is_root(spa) && nvlist_lookup_uint64(nvconfig, 1801 ZPOOL_CONFIG_HOSTID, &hostid) == 0) { 1802 char *hostname; 1803 unsigned long myhostid = 0; 1804 1805 VERIFY(nvlist_lookup_string(nvconfig, 1806 ZPOOL_CONFIG_HOSTNAME, &hostname) == 0); 1807 1808 #ifdef _KERNEL 1809 myhostid = zone_get_hostid(NULL); 1810 #else /* _KERNEL */ 1811 /* 1812 * We're emulating the system's hostid in userland, so 1813 * we can't use zone_get_hostid(). 1814 */ 1815 (void) ddi_strtoul(hw_serial, NULL, 10, &myhostid); 1816 #endif /* _KERNEL */ 1817 if (hostid != 0 && myhostid != 0 && 1818 hostid != myhostid) { 1819 nvlist_free(nvconfig); 1820 cmn_err(CE_WARN, "pool '%s' could not be " 1821 "loaded as it was last accessed by " 1822 "another system (host: %s hostid: 0x%lx). " 1823 "See: http://www.sun.com/msg/ZFS-8000-EY", 1824 spa_name(spa), hostname, 1825 (unsigned long)hostid); 1826 return (EBADF); 1827 } 1828 } 1829 if (nvlist_lookup_nvlist(spa->spa_config, 1830 ZPOOL_REWIND_POLICY, &policy) == 0) 1831 VERIFY(nvlist_add_nvlist(nvconfig, 1832 ZPOOL_REWIND_POLICY, policy) == 0); 1833 1834 spa_config_set(spa, nvconfig); 1835 spa_unload(spa); 1836 spa_deactivate(spa); 1837 spa_activate(spa, orig_mode); 1838 1839 return (spa_load(spa, state, SPA_IMPORT_EXISTING, B_TRUE)); 1840 } 1841 1842 if (spa_dir_prop(spa, DMU_POOL_SYNC_BPLIST, 1843 &spa->spa_deferred_bplist_obj) != 0) 1844 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1845 1846 /* 1847 * Load the bit that tells us to use the new accounting function 1848 * (raid-z deflation). If we have an older pool, this will not 1849 * be present. 1850 */ 1851 error = spa_dir_prop(spa, DMU_POOL_DEFLATE, &spa->spa_deflate); 1852 if (error != 0 && error != ENOENT) 1853 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1854 1855 /* 1856 * Load the persistent error log. If we have an older pool, this will 1857 * not be present. 1858 */ 1859 error = spa_dir_prop(spa, DMU_POOL_ERRLOG_LAST, &spa->spa_errlog_last); 1860 if (error != 0 && error != ENOENT) 1861 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1862 1863 error = spa_dir_prop(spa, DMU_POOL_ERRLOG_SCRUB, 1864 &spa->spa_errlog_scrub); 1865 if (error != 0 && error != ENOENT) 1866 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1867 1868 /* 1869 * Load the history object. If we have an older pool, this 1870 * will not be present. 1871 */ 1872 error = spa_dir_prop(spa, DMU_POOL_HISTORY, &spa->spa_history); 1873 if (error != 0 && error != ENOENT) 1874 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1875 1876 /* 1877 * If we're assembling the pool from the split-off vdevs of 1878 * an existing pool, we don't want to attach the spares & cache 1879 * devices. 1880 */ 1881 1882 /* 1883 * Load any hot spares for this pool. 1884 */ 1885 error = spa_dir_prop(spa, DMU_POOL_SPARES, &spa->spa_spares.sav_object); 1886 if (error != 0 && error != ENOENT) 1887 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1888 if (error == 0 && type != SPA_IMPORT_ASSEMBLE) { 1889 ASSERT(spa_version(spa) >= SPA_VERSION_SPARES); 1890 if (load_nvlist(spa, spa->spa_spares.sav_object, 1891 &spa->spa_spares.sav_config) != 0) 1892 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1893 1894 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1895 spa_load_spares(spa); 1896 spa_config_exit(spa, SCL_ALL, FTAG); 1897 } else if (error == 0) { 1898 spa->spa_spares.sav_sync = B_TRUE; 1899 } 1900 1901 /* 1902 * Load any level 2 ARC devices for this pool. 1903 */ 1904 error = spa_dir_prop(spa, DMU_POOL_L2CACHE, 1905 &spa->spa_l2cache.sav_object); 1906 if (error != 0 && error != ENOENT) 1907 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1908 if (error == 0 && type != SPA_IMPORT_ASSEMBLE) { 1909 ASSERT(spa_version(spa) >= SPA_VERSION_L2CACHE); 1910 if (load_nvlist(spa, spa->spa_l2cache.sav_object, 1911 &spa->spa_l2cache.sav_config) != 0) 1912 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1913 1914 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1915 spa_load_l2cache(spa); 1916 spa_config_exit(spa, SCL_ALL, FTAG); 1917 } else if (error == 0) { 1918 spa->spa_l2cache.sav_sync = B_TRUE; 1919 } 1920 1921 spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION); 1922 1923 error = spa_dir_prop(spa, DMU_POOL_PROPS, &spa->spa_pool_props_object); 1924 if (error && error != ENOENT) 1925 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1926 1927 if (error == 0) { 1928 uint64_t autoreplace; 1929 1930 spa_prop_find(spa, ZPOOL_PROP_BOOTFS, &spa->spa_bootfs); 1931 spa_prop_find(spa, ZPOOL_PROP_AUTOREPLACE, &autoreplace); 1932 spa_prop_find(spa, ZPOOL_PROP_DELEGATION, &spa->spa_delegation); 1933 spa_prop_find(spa, ZPOOL_PROP_FAILUREMODE, &spa->spa_failmode); 1934 spa_prop_find(spa, ZPOOL_PROP_AUTOEXPAND, &spa->spa_autoexpand); 1935 spa_prop_find(spa, ZPOOL_PROP_DEDUPDITTO, 1936 &spa->spa_dedup_ditto); 1937 1938 spa->spa_autoreplace = (autoreplace != 0); 1939 } 1940 1941 /* 1942 * If the 'autoreplace' property is set, then post a resource notifying 1943 * the ZFS DE that it should not issue any faults for unopenable 1944 * devices. We also iterate over the vdevs, and post a sysevent for any 1945 * unopenable vdevs so that the normal autoreplace handler can take 1946 * over. 1947 */ 1948 if (spa->spa_autoreplace && state != SPA_LOAD_TRYIMPORT) { 1949 spa_check_removed(spa->spa_root_vdev); 1950 /* 1951 * For the import case, this is done in spa_import(), because 1952 * at this point we're using the spare definitions from 1953 * the MOS config, not necessarily from the userland config. 1954 */ 1955 if (state != SPA_LOAD_IMPORT) { 1956 spa_aux_check_removed(&spa->spa_spares); 1957 spa_aux_check_removed(&spa->spa_l2cache); 1958 } 1959 } 1960 1961 /* 1962 * Load the vdev state for all toplevel vdevs. 1963 */ 1964 vdev_load(rvd); 1965 1966 /* 1967 * Propagate the leaf DTLs we just loaded all the way up the tree. 1968 */ 1969 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 1970 vdev_dtl_reassess(rvd, 0, 0, B_FALSE); 1971 spa_config_exit(spa, SCL_ALL, FTAG); 1972 1973 /* 1974 * Check the state of the root vdev. If it can't be opened, it 1975 * indicates one or more toplevel vdevs are faulted. 1976 */ 1977 if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) 1978 return (ENXIO); 1979 1980 /* 1981 * Load the DDTs (dedup tables). 1982 */ 1983 error = ddt_load(spa); 1984 if (error != 0) 1985 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 1986 1987 spa_update_dspace(spa); 1988 1989 if (state != SPA_LOAD_TRYIMPORT) { 1990 error = spa_load_verify(spa); 1991 if (error) 1992 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, 1993 error)); 1994 } 1995 1996 /* 1997 * Load the intent log state and check log integrity. If we're 1998 * assembling a pool from a split, the log is not transferred over. 1999 */ 2000 if (type != SPA_IMPORT_ASSEMBLE) { 2001 nvlist_t *nvconfig; 2002 2003 if (load_nvlist(spa, spa->spa_config_object, &nvconfig) != 0) 2004 return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2005 2006 VERIFY(nvlist_lookup_nvlist(nvconfig, ZPOOL_CONFIG_VDEV_TREE, 2007 &nvroot) == 0); 2008 spa_load_log_state(spa, nvroot); 2009 nvlist_free(nvconfig); 2010 2011 if (spa_check_logs(spa)) { 2012 *ereport = FM_EREPORT_ZFS_LOG_REPLAY; 2013 return (spa_vdev_err(rvd, VDEV_AUX_BAD_LOG, ENXIO)); 2014 } 2015 } 2016 2017 if (spa_writeable(spa) && (state == SPA_LOAD_RECOVER || 2018 spa->spa_load_max_txg == UINT64_MAX)) { 2019 dmu_tx_t *tx; 2020 int need_update = B_FALSE; 2021 2022 ASSERT(state != SPA_LOAD_TRYIMPORT); 2023 2024 /* 2025 * Claim log blocks that haven't been committed yet. 2026 * This must all happen in a single txg. 2027 * Note: spa_claim_max_txg is updated by spa_claim_notify(), 2028 * invoked from zil_claim_log_block()'s i/o done callback. 2029 * Price of rollback is that we abandon the log. 2030 */ 2031 spa->spa_claiming = B_TRUE; 2032 2033 tx = dmu_tx_create_assigned(spa_get_dsl(spa), 2034 spa_first_txg(spa)); 2035 (void) dmu_objset_find(spa_name(spa), 2036 zil_claim, tx, DS_FIND_CHILDREN); 2037 dmu_tx_commit(tx); 2038 2039 spa->spa_claiming = B_FALSE; 2040 2041 spa_set_log_state(spa, SPA_LOG_GOOD); 2042 spa->spa_sync_on = B_TRUE; 2043 txg_sync_start(spa->spa_dsl_pool); 2044 2045 /* 2046 * Wait for all claims to sync. We sync up to the highest 2047 * claimed log block birth time so that claimed log blocks 2048 * don't appear to be from the future. spa_claim_max_txg 2049 * will have been set for us by either zil_check_log_chain() 2050 * (invoked from spa_check_logs()) or zil_claim() above. 2051 */ 2052 txg_wait_synced(spa->spa_dsl_pool, spa->spa_claim_max_txg); 2053 2054 /* 2055 * If the config cache is stale, or we have uninitialized 2056 * metaslabs (see spa_vdev_add()), then update the config. 2057 * 2058 * If spa_load_verbatim is true, trust the current 2059 * in-core spa_config and update the disk labels. 2060 */ 2061 if (config_cache_txg != spa->spa_config_txg || 2062 state == SPA_LOAD_IMPORT || spa->spa_load_verbatim || 2063 state == SPA_LOAD_RECOVER) 2064 need_update = B_TRUE; 2065 2066 for (int c = 0; c < rvd->vdev_children; c++) 2067 if (rvd->vdev_child[c]->vdev_ms_array == 0) 2068 need_update = B_TRUE; 2069 2070 /* 2071 * Update the config cache asychronously in case we're the 2072 * root pool, in which case the config cache isn't writable yet. 2073 */ 2074 if (need_update) 2075 spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); 2076 2077 /* 2078 * Check all DTLs to see if anything needs resilvering. 2079 */ 2080 if (vdev_resilver_needed(rvd, NULL, NULL)) 2081 spa_async_request(spa, SPA_ASYNC_RESILVER); 2082 2083 /* 2084 * Delete any inconsistent datasets. 2085 */ 2086 (void) dmu_objset_find(spa_name(spa), 2087 dsl_destroy_inconsistent, NULL, DS_FIND_CHILDREN); 2088 2089 /* 2090 * Clean up any stale temporary dataset userrefs. 2091 */ 2092 dsl_pool_clean_tmp_userrefs(spa->spa_dsl_pool); 2093 } 2094 2095 return (0); 2096 } 2097 2098 static int 2099 spa_load_retry(spa_t *spa, spa_load_state_t state, int mosconfig) 2100 { 2101 spa_unload(spa); 2102 spa_deactivate(spa); 2103 2104 spa->spa_load_max_txg--; 2105 2106 spa_activate(spa, spa_mode_global); 2107 spa_async_suspend(spa); 2108 2109 return (spa_load(spa, state, SPA_IMPORT_EXISTING, mosconfig)); 2110 } 2111 2112 static int 2113 spa_load_best(spa_t *spa, spa_load_state_t state, int mosconfig, 2114 uint64_t max_request, int rewind_flags) 2115 { 2116 nvlist_t *config = NULL; 2117 int load_error, rewind_error; 2118 uint64_t safe_rewind_txg; 2119 uint64_t min_txg; 2120 2121 if (spa->spa_load_txg && state == SPA_LOAD_RECOVER) { 2122 spa->spa_load_max_txg = spa->spa_load_txg; 2123 spa_set_log_state(spa, SPA_LOG_CLEAR); 2124 } else { 2125 spa->spa_load_max_txg = max_request; 2126 } 2127 2128 load_error = rewind_error = spa_load(spa, state, SPA_IMPORT_EXISTING, 2129 mosconfig); 2130 if (load_error == 0) 2131 return (0); 2132 2133 if (spa->spa_root_vdev != NULL) 2134 config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 2135 2136 spa->spa_last_ubsync_txg = spa->spa_uberblock.ub_txg; 2137 spa->spa_last_ubsync_txg_ts = spa->spa_uberblock.ub_timestamp; 2138 2139 if (rewind_flags & ZPOOL_NEVER_REWIND) { 2140 nvlist_free(config); 2141 return (load_error); 2142 } 2143 2144 /* Price of rolling back is discarding txgs, including log */ 2145 if (state == SPA_LOAD_RECOVER) 2146 spa_set_log_state(spa, SPA_LOG_CLEAR); 2147 2148 spa->spa_load_max_txg = spa->spa_last_ubsync_txg; 2149 safe_rewind_txg = spa->spa_last_ubsync_txg - TXG_DEFER_SIZE; 2150 min_txg = (rewind_flags & ZPOOL_EXTREME_REWIND) ? 2151 TXG_INITIAL : safe_rewind_txg; 2152 2153 /* 2154 * Continue as long as we're finding errors, we're still within 2155 * the acceptable rewind range, and we're still finding uberblocks 2156 */ 2157 while (rewind_error && spa->spa_uberblock.ub_txg >= min_txg && 2158 spa->spa_uberblock.ub_txg <= spa->spa_load_max_txg) { 2159 if (spa->spa_load_max_txg < safe_rewind_txg) 2160 spa->spa_extreme_rewind = B_TRUE; 2161 rewind_error = spa_load_retry(spa, state, mosconfig); 2162 } 2163 2164 if (config) 2165 spa_rewind_data_to_nvlist(spa, config); 2166 2167 spa->spa_extreme_rewind = B_FALSE; 2168 spa->spa_load_max_txg = UINT64_MAX; 2169 2170 if (config && (rewind_error || state != SPA_LOAD_RECOVER)) 2171 spa_config_set(spa, config); 2172 2173 return (state == SPA_LOAD_RECOVER ? rewind_error : load_error); 2174 } 2175 2176 /* 2177 * Pool Open/Import 2178 * 2179 * The import case is identical to an open except that the configuration is sent 2180 * down from userland, instead of grabbed from the configuration cache. For the 2181 * case of an open, the pool configuration will exist in the 2182 * POOL_STATE_UNINITIALIZED state. 2183 * 2184 * The stats information (gen/count/ustats) is used to gather vdev statistics at 2185 * the same time open the pool, without having to keep around the spa_t in some 2186 * ambiguous state. 2187 */ 2188 static int 2189 spa_open_common(const char *pool, spa_t **spapp, void *tag, nvlist_t *nvpolicy, 2190 nvlist_t **config) 2191 { 2192 spa_t *spa; 2193 zpool_rewind_policy_t policy; 2194 spa_load_state_t state = SPA_LOAD_OPEN; 2195 int error; 2196 int locked = B_FALSE; 2197 2198 *spapp = NULL; 2199 2200 /* 2201 * As disgusting as this is, we need to support recursive calls to this 2202 * function because dsl_dir_open() is called during spa_load(), and ends 2203 * up calling spa_open() again. The real fix is to figure out how to 2204 * avoid dsl_dir_open() calling this in the first place. 2205 */ 2206 if (mutex_owner(&spa_namespace_lock) != curthread) { 2207 mutex_enter(&spa_namespace_lock); 2208 locked = B_TRUE; 2209 } 2210 2211 if ((spa = spa_lookup(pool)) == NULL) { 2212 if (locked) 2213 mutex_exit(&spa_namespace_lock); 2214 return (ENOENT); 2215 } 2216 2217 zpool_get_rewind_policy(nvpolicy ? nvpolicy : spa->spa_config, &policy); 2218 if (policy.zrp_request & ZPOOL_DO_REWIND) 2219 state = SPA_LOAD_RECOVER; 2220 2221 if (spa->spa_state == POOL_STATE_UNINITIALIZED) { 2222 2223 spa_activate(spa, spa_mode_global); 2224 2225 if (spa->spa_last_open_failed && (policy.zrp_request & 2226 (ZPOOL_NO_REWIND | ZPOOL_NEVER_REWIND))) { 2227 if (config != NULL && spa->spa_config) 2228 VERIFY(nvlist_dup(spa->spa_config, 2229 config, KM_SLEEP) == 0); 2230 spa_deactivate(spa); 2231 if (locked) 2232 mutex_exit(&spa_namespace_lock); 2233 return (spa->spa_last_open_failed); 2234 } 2235 2236 if (state != SPA_LOAD_RECOVER) 2237 spa->spa_last_ubsync_txg = spa->spa_load_txg = 0; 2238 2239 error = spa_load_best(spa, state, B_FALSE, policy.zrp_txg, 2240 policy.zrp_request); 2241 2242 if (error == EBADF) { 2243 /* 2244 * If vdev_validate() returns failure (indicated by 2245 * EBADF), it indicates that one of the vdevs indicates 2246 * that the pool has been exported or destroyed. If 2247 * this is the case, the config cache is out of sync and 2248 * we should remove the pool from the namespace. 2249 */ 2250 spa_unload(spa); 2251 spa_deactivate(spa); 2252 spa_config_sync(spa, B_TRUE, B_TRUE); 2253 spa_remove(spa); 2254 if (locked) 2255 mutex_exit(&spa_namespace_lock); 2256 return (ENOENT); 2257 } 2258 2259 if (error) { 2260 /* 2261 * We can't open the pool, but we still have useful 2262 * information: the state of each vdev after the 2263 * attempted vdev_open(). Return this to the user. 2264 */ 2265 if (config != NULL && spa->spa_config) 2266 VERIFY(nvlist_dup(spa->spa_config, config, 2267 KM_SLEEP) == 0); 2268 spa_unload(spa); 2269 spa_deactivate(spa); 2270 spa->spa_last_open_failed = error; 2271 if (locked) 2272 mutex_exit(&spa_namespace_lock); 2273 *spapp = NULL; 2274 return (error); 2275 } 2276 2277 } 2278 2279 spa_open_ref(spa, tag); 2280 2281 2282 if (config != NULL) 2283 *config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 2284 2285 if (locked) { 2286 spa->spa_last_open_failed = 0; 2287 spa->spa_last_ubsync_txg = 0; 2288 spa->spa_load_txg = 0; 2289 mutex_exit(&spa_namespace_lock); 2290 } 2291 2292 *spapp = spa; 2293 2294 return (0); 2295 } 2296 2297 int 2298 spa_open_rewind(const char *name, spa_t **spapp, void *tag, nvlist_t *policy, 2299 nvlist_t **config) 2300 { 2301 return (spa_open_common(name, spapp, tag, policy, config)); 2302 } 2303 2304 int 2305 spa_open(const char *name, spa_t **spapp, void *tag) 2306 { 2307 return (spa_open_common(name, spapp, tag, NULL, NULL)); 2308 } 2309 2310 /* 2311 * Lookup the given spa_t, incrementing the inject count in the process, 2312 * preventing it from being exported or destroyed. 2313 */ 2314 spa_t * 2315 spa_inject_addref(char *name) 2316 { 2317 spa_t *spa; 2318 2319 mutex_enter(&spa_namespace_lock); 2320 if ((spa = spa_lookup(name)) == NULL) { 2321 mutex_exit(&spa_namespace_lock); 2322 return (NULL); 2323 } 2324 spa->spa_inject_ref++; 2325 mutex_exit(&spa_namespace_lock); 2326 2327 return (spa); 2328 } 2329 2330 void 2331 spa_inject_delref(spa_t *spa) 2332 { 2333 mutex_enter(&spa_namespace_lock); 2334 spa->spa_inject_ref--; 2335 mutex_exit(&spa_namespace_lock); 2336 } 2337 2338 /* 2339 * Add spares device information to the nvlist. 2340 */ 2341 static void 2342 spa_add_spares(spa_t *spa, nvlist_t *config) 2343 { 2344 nvlist_t **spares; 2345 uint_t i, nspares; 2346 nvlist_t *nvroot; 2347 uint64_t guid; 2348 vdev_stat_t *vs; 2349 uint_t vsc; 2350 uint64_t pool; 2351 2352 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); 2353 2354 if (spa->spa_spares.sav_count == 0) 2355 return; 2356 2357 VERIFY(nvlist_lookup_nvlist(config, 2358 ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); 2359 VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, 2360 ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0); 2361 if (nspares != 0) { 2362 VERIFY(nvlist_add_nvlist_array(nvroot, 2363 ZPOOL_CONFIG_SPARES, spares, nspares) == 0); 2364 VERIFY(nvlist_lookup_nvlist_array(nvroot, 2365 ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0); 2366 2367 /* 2368 * Go through and find any spares which have since been 2369 * repurposed as an active spare. If this is the case, update 2370 * their status appropriately. 2371 */ 2372 for (i = 0; i < nspares; i++) { 2373 VERIFY(nvlist_lookup_uint64(spares[i], 2374 ZPOOL_CONFIG_GUID, &guid) == 0); 2375 if (spa_spare_exists(guid, &pool, NULL) && 2376 pool != 0ULL) { 2377 VERIFY(nvlist_lookup_uint64_array( 2378 spares[i], ZPOOL_CONFIG_STATS, 2379 (uint64_t **)&vs, &vsc) == 0); 2380 vs->vs_state = VDEV_STATE_CANT_OPEN; 2381 vs->vs_aux = VDEV_AUX_SPARED; 2382 } 2383 } 2384 } 2385 } 2386 2387 /* 2388 * Add l2cache device information to the nvlist, including vdev stats. 2389 */ 2390 static void 2391 spa_add_l2cache(spa_t *spa, nvlist_t *config) 2392 { 2393 nvlist_t **l2cache; 2394 uint_t i, j, nl2cache; 2395 nvlist_t *nvroot; 2396 uint64_t guid; 2397 vdev_t *vd; 2398 vdev_stat_t *vs; 2399 uint_t vsc; 2400 2401 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); 2402 2403 if (spa->spa_l2cache.sav_count == 0) 2404 return; 2405 2406 VERIFY(nvlist_lookup_nvlist(config, 2407 ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); 2408 VERIFY(nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config, 2409 ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0); 2410 if (nl2cache != 0) { 2411 VERIFY(nvlist_add_nvlist_array(nvroot, 2412 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); 2413 VERIFY(nvlist_lookup_nvlist_array(nvroot, 2414 ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0); 2415 2416 /* 2417 * Update level 2 cache device stats. 2418 */ 2419 2420 for (i = 0; i < nl2cache; i++) { 2421 VERIFY(nvlist_lookup_uint64(l2cache[i], 2422 ZPOOL_CONFIG_GUID, &guid) == 0); 2423 2424 vd = NULL; 2425 for (j = 0; j < spa->spa_l2cache.sav_count; j++) { 2426 if (guid == 2427 spa->spa_l2cache.sav_vdevs[j]->vdev_guid) { 2428 vd = spa->spa_l2cache.sav_vdevs[j]; 2429 break; 2430 } 2431 } 2432 ASSERT(vd != NULL); 2433 2434 VERIFY(nvlist_lookup_uint64_array(l2cache[i], 2435 ZPOOL_CONFIG_STATS, (uint64_t **)&vs, &vsc) == 0); 2436 vdev_get_stats(vd, vs); 2437 } 2438 } 2439 } 2440 2441 int 2442 spa_get_stats(const char *name, nvlist_t **config, char *altroot, size_t buflen) 2443 { 2444 int error; 2445 spa_t *spa; 2446 2447 *config = NULL; 2448 error = spa_open_common(name, &spa, FTAG, NULL, config); 2449 2450 if (spa != NULL) { 2451 /* 2452 * This still leaves a window of inconsistency where the spares 2453 * or l2cache devices could change and the config would be 2454 * self-inconsistent. 2455 */ 2456 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 2457 2458 if (*config != NULL) { 2459 VERIFY(nvlist_add_uint64(*config, 2460 ZPOOL_CONFIG_ERRCOUNT, 2461 spa_get_errlog_size(spa)) == 0); 2462 2463 if (spa_suspended(spa)) 2464 VERIFY(nvlist_add_uint64(*config, 2465 ZPOOL_CONFIG_SUSPENDED, 2466 spa->spa_failmode) == 0); 2467 2468 spa_add_spares(spa, *config); 2469 spa_add_l2cache(spa, *config); 2470 } 2471 } 2472 2473 /* 2474 * We want to get the alternate root even for faulted pools, so we cheat 2475 * and call spa_lookup() directly. 2476 */ 2477 if (altroot) { 2478 if (spa == NULL) { 2479 mutex_enter(&spa_namespace_lock); 2480 spa = spa_lookup(name); 2481 if (spa) 2482 spa_altroot(spa, altroot, buflen); 2483 else 2484 altroot[0] = '\0'; 2485 spa = NULL; 2486 mutex_exit(&spa_namespace_lock); 2487 } else { 2488 spa_altroot(spa, altroot, buflen); 2489 } 2490 } 2491 2492 if (spa != NULL) { 2493 spa_config_exit(spa, SCL_CONFIG, FTAG); 2494 spa_close(spa, FTAG); 2495 } 2496 2497 return (error); 2498 } 2499 2500 /* 2501 * Validate that the auxiliary device array is well formed. We must have an 2502 * array of nvlists, each which describes a valid leaf vdev. If this is an 2503 * import (mode is VDEV_ALLOC_SPARE), then we allow corrupted spares to be 2504 * specified, as long as they are well-formed. 2505 */ 2506 static int 2507 spa_validate_aux_devs(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode, 2508 spa_aux_vdev_t *sav, const char *config, uint64_t version, 2509 vdev_labeltype_t label) 2510 { 2511 nvlist_t **dev; 2512 uint_t i, ndev; 2513 vdev_t *vd; 2514 int error; 2515 2516 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 2517 2518 /* 2519 * It's acceptable to have no devs specified. 2520 */ 2521 if (nvlist_lookup_nvlist_array(nvroot, config, &dev, &ndev) != 0) 2522 return (0); 2523 2524 if (ndev == 0) 2525 return (EINVAL); 2526 2527 /* 2528 * Make sure the pool is formatted with a version that supports this 2529 * device type. 2530 */ 2531 if (spa_version(spa) < version) 2532 return (ENOTSUP); 2533 2534 /* 2535 * Set the pending device list so we correctly handle device in-use 2536 * checking. 2537 */ 2538 sav->sav_pending = dev; 2539 sav->sav_npending = ndev; 2540 2541 for (i = 0; i < ndev; i++) { 2542 if ((error = spa_config_parse(spa, &vd, dev[i], NULL, 0, 2543 mode)) != 0) 2544 goto out; 2545 2546 if (!vd->vdev_ops->vdev_op_leaf) { 2547 vdev_free(vd); 2548 error = EINVAL; 2549 goto out; 2550 } 2551 2552 /* 2553 * The L2ARC currently only supports disk devices in 2554 * kernel context. For user-level testing, we allow it. 2555 */ 2556 #ifdef _KERNEL 2557 if ((strcmp(config, ZPOOL_CONFIG_L2CACHE) == 0) && 2558 strcmp(vd->vdev_ops->vdev_op_type, VDEV_TYPE_DISK) != 0) { 2559 error = ENOTBLK; 2560 goto out; 2561 } 2562 #endif 2563 vd->vdev_top = vd; 2564 2565 if ((error = vdev_open(vd)) == 0 && 2566 (error = vdev_label_init(vd, crtxg, label)) == 0) { 2567 VERIFY(nvlist_add_uint64(dev[i], ZPOOL_CONFIG_GUID, 2568 vd->vdev_guid) == 0); 2569 } 2570 2571 vdev_free(vd); 2572 2573 if (error && 2574 (mode != VDEV_ALLOC_SPARE && mode != VDEV_ALLOC_L2CACHE)) 2575 goto out; 2576 else 2577 error = 0; 2578 } 2579 2580 out: 2581 sav->sav_pending = NULL; 2582 sav->sav_npending = 0; 2583 return (error); 2584 } 2585 2586 static int 2587 spa_validate_aux(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode) 2588 { 2589 int error; 2590 2591 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 2592 2593 if ((error = spa_validate_aux_devs(spa, nvroot, crtxg, mode, 2594 &spa->spa_spares, ZPOOL_CONFIG_SPARES, SPA_VERSION_SPARES, 2595 VDEV_LABEL_SPARE)) != 0) { 2596 return (error); 2597 } 2598 2599 return (spa_validate_aux_devs(spa, nvroot, crtxg, mode, 2600 &spa->spa_l2cache, ZPOOL_CONFIG_L2CACHE, SPA_VERSION_L2CACHE, 2601 VDEV_LABEL_L2CACHE)); 2602 } 2603 2604 static void 2605 spa_set_aux_vdevs(spa_aux_vdev_t *sav, nvlist_t **devs, int ndevs, 2606 const char *config) 2607 { 2608 int i; 2609 2610 if (sav->sav_config != NULL) { 2611 nvlist_t **olddevs; 2612 uint_t oldndevs; 2613 nvlist_t **newdevs; 2614 2615 /* 2616 * Generate new dev list by concatentating with the 2617 * current dev list. 2618 */ 2619 VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, config, 2620 &olddevs, &oldndevs) == 0); 2621 2622 newdevs = kmem_alloc(sizeof (void *) * 2623 (ndevs + oldndevs), KM_SLEEP); 2624 for (i = 0; i < oldndevs; i++) 2625 VERIFY(nvlist_dup(olddevs[i], &newdevs[i], 2626 KM_SLEEP) == 0); 2627 for (i = 0; i < ndevs; i++) 2628 VERIFY(nvlist_dup(devs[i], &newdevs[i + oldndevs], 2629 KM_SLEEP) == 0); 2630 2631 VERIFY(nvlist_remove(sav->sav_config, config, 2632 DATA_TYPE_NVLIST_ARRAY) == 0); 2633 2634 VERIFY(nvlist_add_nvlist_array(sav->sav_config, 2635 config, newdevs, ndevs + oldndevs) == 0); 2636 for (i = 0; i < oldndevs + ndevs; i++) 2637 nvlist_free(newdevs[i]); 2638 kmem_free(newdevs, (oldndevs + ndevs) * sizeof (void *)); 2639 } else { 2640 /* 2641 * Generate a new dev list. 2642 */ 2643 VERIFY(nvlist_alloc(&sav->sav_config, NV_UNIQUE_NAME, 2644 KM_SLEEP) == 0); 2645 VERIFY(nvlist_add_nvlist_array(sav->sav_config, config, 2646 devs, ndevs) == 0); 2647 } 2648 } 2649 2650 /* 2651 * Stop and drop level 2 ARC devices 2652 */ 2653 void 2654 spa_l2cache_drop(spa_t *spa) 2655 { 2656 vdev_t *vd; 2657 int i; 2658 spa_aux_vdev_t *sav = &spa->spa_l2cache; 2659 2660 for (i = 0; i < sav->sav_count; i++) { 2661 uint64_t pool; 2662 2663 vd = sav->sav_vdevs[i]; 2664 ASSERT(vd != NULL); 2665 2666 if (spa_l2cache_exists(vd->vdev_guid, &pool) && 2667 pool != 0ULL && l2arc_vdev_present(vd)) 2668 l2arc_remove_vdev(vd); 2669 if (vd->vdev_isl2cache) 2670 spa_l2cache_remove(vd); 2671 vdev_clear_stats(vd); 2672 (void) vdev_close(vd); 2673 } 2674 } 2675 2676 /* 2677 * Pool Creation 2678 */ 2679 int 2680 spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props, 2681 const char *history_str, nvlist_t *zplprops) 2682 { 2683 spa_t *spa; 2684 char *altroot = NULL; 2685 vdev_t *rvd; 2686 dsl_pool_t *dp; 2687 dmu_tx_t *tx; 2688 int error = 0; 2689 uint64_t txg = TXG_INITIAL; 2690 nvlist_t **spares, **l2cache; 2691 uint_t nspares, nl2cache; 2692 uint64_t version; 2693 2694 /* 2695 * If this pool already exists, return failure. 2696 */ 2697 mutex_enter(&spa_namespace_lock); 2698 if (spa_lookup(pool) != NULL) { 2699 mutex_exit(&spa_namespace_lock); 2700 return (EEXIST); 2701 } 2702 2703 /* 2704 * Allocate a new spa_t structure. 2705 */ 2706 (void) nvlist_lookup_string(props, 2707 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 2708 spa = spa_add(pool, NULL, altroot); 2709 spa_activate(spa, spa_mode_global); 2710 2711 if (props && (error = spa_prop_validate(spa, props))) { 2712 spa_deactivate(spa); 2713 spa_remove(spa); 2714 mutex_exit(&spa_namespace_lock); 2715 return (error); 2716 } 2717 2718 if (nvlist_lookup_uint64(props, zpool_prop_to_name(ZPOOL_PROP_VERSION), 2719 &version) != 0) 2720 version = SPA_VERSION; 2721 ASSERT(version <= SPA_VERSION); 2722 2723 spa->spa_first_txg = txg; 2724 spa->spa_uberblock.ub_txg = txg - 1; 2725 spa->spa_uberblock.ub_version = version; 2726 spa->spa_ubsync = spa->spa_uberblock; 2727 2728 /* 2729 * Create "The Godfather" zio to hold all async IOs 2730 */ 2731 spa->spa_async_zio_root = zio_root(spa, NULL, NULL, 2732 ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE | ZIO_FLAG_GODFATHER); 2733 2734 /* 2735 * Create the root vdev. 2736 */ 2737 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 2738 2739 error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_ADD); 2740 2741 ASSERT(error != 0 || rvd != NULL); 2742 ASSERT(error != 0 || spa->spa_root_vdev == rvd); 2743 2744 if (error == 0 && !zfs_allocatable_devs(nvroot)) 2745 error = EINVAL; 2746 2747 if (error == 0 && 2748 (error = vdev_create(rvd, txg, B_FALSE)) == 0 && 2749 (error = spa_validate_aux(spa, nvroot, txg, 2750 VDEV_ALLOC_ADD)) == 0) { 2751 for (int c = 0; c < rvd->vdev_children; c++) { 2752 vdev_metaslab_set_size(rvd->vdev_child[c]); 2753 vdev_expand(rvd->vdev_child[c], txg); 2754 } 2755 } 2756 2757 spa_config_exit(spa, SCL_ALL, FTAG); 2758 2759 if (error != 0) { 2760 spa_unload(spa); 2761 spa_deactivate(spa); 2762 spa_remove(spa); 2763 mutex_exit(&spa_namespace_lock); 2764 return (error); 2765 } 2766 2767 /* 2768 * Get the list of spares, if specified. 2769 */ 2770 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 2771 &spares, &nspares) == 0) { 2772 VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, NV_UNIQUE_NAME, 2773 KM_SLEEP) == 0); 2774 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config, 2775 ZPOOL_CONFIG_SPARES, spares, nspares) == 0); 2776 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 2777 spa_load_spares(spa); 2778 spa_config_exit(spa, SCL_ALL, FTAG); 2779 spa->spa_spares.sav_sync = B_TRUE; 2780 } 2781 2782 /* 2783 * Get the list of level 2 cache devices, if specified. 2784 */ 2785 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 2786 &l2cache, &nl2cache) == 0) { 2787 VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config, 2788 NV_UNIQUE_NAME, KM_SLEEP) == 0); 2789 VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config, 2790 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); 2791 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 2792 spa_load_l2cache(spa); 2793 spa_config_exit(spa, SCL_ALL, FTAG); 2794 spa->spa_l2cache.sav_sync = B_TRUE; 2795 } 2796 2797 spa->spa_dsl_pool = dp = dsl_pool_create(spa, zplprops, txg); 2798 spa->spa_meta_objset = dp->dp_meta_objset; 2799 2800 /* 2801 * Create DDTs (dedup tables). 2802 */ 2803 ddt_create(spa); 2804 2805 spa_update_dspace(spa); 2806 2807 tx = dmu_tx_create_assigned(dp, txg); 2808 2809 /* 2810 * Create the pool config object. 2811 */ 2812 spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset, 2813 DMU_OT_PACKED_NVLIST, SPA_CONFIG_BLOCKSIZE, 2814 DMU_OT_PACKED_NVLIST_SIZE, sizeof (uint64_t), tx); 2815 2816 if (zap_add(spa->spa_meta_objset, 2817 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG, 2818 sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) { 2819 cmn_err(CE_PANIC, "failed to add pool config"); 2820 } 2821 2822 /* Newly created pools with the right version are always deflated. */ 2823 if (version >= SPA_VERSION_RAIDZ_DEFLATE) { 2824 spa->spa_deflate = TRUE; 2825 if (zap_add(spa->spa_meta_objset, 2826 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE, 2827 sizeof (uint64_t), 1, &spa->spa_deflate, tx) != 0) { 2828 cmn_err(CE_PANIC, "failed to add deflate"); 2829 } 2830 } 2831 2832 /* 2833 * Create the deferred-free bplist object. Turn off compression 2834 * because sync-to-convergence takes longer if the blocksize 2835 * keeps changing. 2836 */ 2837 spa->spa_deferred_bplist_obj = bplist_create(spa->spa_meta_objset, 2838 1 << 14, tx); 2839 dmu_object_set_compress(spa->spa_meta_objset, 2840 spa->spa_deferred_bplist_obj, ZIO_COMPRESS_OFF, tx); 2841 2842 if (zap_add(spa->spa_meta_objset, 2843 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST, 2844 sizeof (uint64_t), 1, &spa->spa_deferred_bplist_obj, tx) != 0) { 2845 cmn_err(CE_PANIC, "failed to add bplist"); 2846 } 2847 2848 /* 2849 * Create the pool's history object. 2850 */ 2851 if (version >= SPA_VERSION_ZPOOL_HISTORY) 2852 spa_history_create_obj(spa, tx); 2853 2854 /* 2855 * Set pool properties. 2856 */ 2857 spa->spa_bootfs = zpool_prop_default_numeric(ZPOOL_PROP_BOOTFS); 2858 spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION); 2859 spa->spa_failmode = zpool_prop_default_numeric(ZPOOL_PROP_FAILUREMODE); 2860 spa->spa_autoexpand = zpool_prop_default_numeric(ZPOOL_PROP_AUTOEXPAND); 2861 2862 if (props != NULL) { 2863 spa_configfile_set(spa, props, B_FALSE); 2864 spa_sync_props(spa, props, CRED(), tx); 2865 } 2866 2867 dmu_tx_commit(tx); 2868 2869 spa->spa_sync_on = B_TRUE; 2870 txg_sync_start(spa->spa_dsl_pool); 2871 2872 /* 2873 * We explicitly wait for the first transaction to complete so that our 2874 * bean counters are appropriately updated. 2875 */ 2876 txg_wait_synced(spa->spa_dsl_pool, txg); 2877 2878 spa_config_sync(spa, B_FALSE, B_TRUE); 2879 2880 if (version >= SPA_VERSION_ZPOOL_HISTORY && history_str != NULL) 2881 (void) spa_history_log(spa, history_str, LOG_CMD_POOL_CREATE); 2882 spa_history_log_version(spa, LOG_POOL_CREATE); 2883 2884 spa->spa_minref = refcount_count(&spa->spa_refcount); 2885 2886 mutex_exit(&spa_namespace_lock); 2887 2888 return (0); 2889 } 2890 2891 #ifdef _KERNEL 2892 /* 2893 * Get the root pool information from the root disk, then import the root pool 2894 * during the system boot up time. 2895 */ 2896 extern int vdev_disk_read_rootlabel(char *, char *, nvlist_t **); 2897 2898 static nvlist_t * 2899 spa_generate_rootconf(char *devpath, char *devid, uint64_t *guid) 2900 { 2901 nvlist_t *config; 2902 nvlist_t *nvtop, *nvroot; 2903 uint64_t pgid; 2904 2905 if (vdev_disk_read_rootlabel(devpath, devid, &config) != 0) 2906 return (NULL); 2907 2908 /* 2909 * Add this top-level vdev to the child array. 2910 */ 2911 VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 2912 &nvtop) == 0); 2913 VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 2914 &pgid) == 0); 2915 VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, guid) == 0); 2916 2917 /* 2918 * Put this pool's top-level vdevs into a root vdev. 2919 */ 2920 VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0); 2921 VERIFY(nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE, 2922 VDEV_TYPE_ROOT) == 0); 2923 VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_ID, 0ULL) == 0); 2924 VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_GUID, pgid) == 0); 2925 VERIFY(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 2926 &nvtop, 1) == 0); 2927 2928 /* 2929 * Replace the existing vdev_tree with the new root vdev in 2930 * this pool's configuration (remove the old, add the new). 2931 */ 2932 VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, nvroot) == 0); 2933 nvlist_free(nvroot); 2934 return (config); 2935 } 2936 2937 /* 2938 * Walk the vdev tree and see if we can find a device with "better" 2939 * configuration. A configuration is "better" if the label on that 2940 * device has a more recent txg. 2941 */ 2942 static void 2943 spa_alt_rootvdev(vdev_t *vd, vdev_t **avd, uint64_t *txg) 2944 { 2945 for (int c = 0; c < vd->vdev_children; c++) 2946 spa_alt_rootvdev(vd->vdev_child[c], avd, txg); 2947 2948 if (vd->vdev_ops->vdev_op_leaf) { 2949 nvlist_t *label; 2950 uint64_t label_txg; 2951 2952 if (vdev_disk_read_rootlabel(vd->vdev_physpath, vd->vdev_devid, 2953 &label) != 0) 2954 return; 2955 2956 VERIFY(nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_TXG, 2957 &label_txg) == 0); 2958 2959 /* 2960 * Do we have a better boot device? 2961 */ 2962 if (label_txg > *txg) { 2963 *txg = label_txg; 2964 *avd = vd; 2965 } 2966 nvlist_free(label); 2967 } 2968 } 2969 2970 /* 2971 * Import a root pool. 2972 * 2973 * For x86. devpath_list will consist of devid and/or physpath name of 2974 * the vdev (e.g. "id1,sd@SSEAGATE..." or "/pci@1f,0/ide@d/disk@0,0:a"). 2975 * The GRUB "findroot" command will return the vdev we should boot. 2976 * 2977 * For Sparc, devpath_list consists the physpath name of the booting device 2978 * no matter the rootpool is a single device pool or a mirrored pool. 2979 * e.g. 2980 * "/pci@1f,0/ide@d/disk@0,0:a" 2981 */ 2982 int 2983 spa_import_rootpool(char *devpath, char *devid) 2984 { 2985 spa_t *spa; 2986 vdev_t *rvd, *bvd, *avd = NULL; 2987 nvlist_t *config, *nvtop; 2988 uint64_t guid, txg; 2989 char *pname; 2990 int error; 2991 2992 /* 2993 * Read the label from the boot device and generate a configuration. 2994 */ 2995 config = spa_generate_rootconf(devpath, devid, &guid); 2996 #if defined(_OBP) && defined(_KERNEL) 2997 if (config == NULL) { 2998 if (strstr(devpath, "/iscsi/ssd") != NULL) { 2999 /* iscsi boot */ 3000 get_iscsi_bootpath_phy(devpath); 3001 config = spa_generate_rootconf(devpath, devid, &guid); 3002 } 3003 } 3004 #endif 3005 if (config == NULL) { 3006 cmn_err(CE_NOTE, "Can not read the pool label from '%s'", 3007 devpath); 3008 return (EIO); 3009 } 3010 3011 VERIFY(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 3012 &pname) == 0); 3013 VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, &txg) == 0); 3014 3015 mutex_enter(&spa_namespace_lock); 3016 if ((spa = spa_lookup(pname)) != NULL) { 3017 /* 3018 * Remove the existing root pool from the namespace so that we 3019 * can replace it with the correct config we just read in. 3020 */ 3021 spa_remove(spa); 3022 } 3023 3024 spa = spa_add(pname, config, NULL); 3025 spa->spa_is_root = B_TRUE; 3026 spa->spa_load_verbatim = B_TRUE; 3027 3028 /* 3029 * Build up a vdev tree based on the boot device's label config. 3030 */ 3031 VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 3032 &nvtop) == 0); 3033 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3034 error = spa_config_parse(spa, &rvd, nvtop, NULL, 0, 3035 VDEV_ALLOC_ROOTPOOL); 3036 spa_config_exit(spa, SCL_ALL, FTAG); 3037 if (error) { 3038 mutex_exit(&spa_namespace_lock); 3039 nvlist_free(config); 3040 cmn_err(CE_NOTE, "Can not parse the config for pool '%s'", 3041 pname); 3042 return (error); 3043 } 3044 3045 /* 3046 * Get the boot vdev. 3047 */ 3048 if ((bvd = vdev_lookup_by_guid(rvd, guid)) == NULL) { 3049 cmn_err(CE_NOTE, "Can not find the boot vdev for guid %llu", 3050 (u_longlong_t)guid); 3051 error = ENOENT; 3052 goto out; 3053 } 3054 3055 /* 3056 * Determine if there is a better boot device. 3057 */ 3058 avd = bvd; 3059 spa_alt_rootvdev(rvd, &avd, &txg); 3060 if (avd != bvd) { 3061 cmn_err(CE_NOTE, "The boot device is 'degraded'. Please " 3062 "try booting from '%s'", avd->vdev_path); 3063 error = EINVAL; 3064 goto out; 3065 } 3066 3067 /* 3068 * If the boot device is part of a spare vdev then ensure that 3069 * we're booting off the active spare. 3070 */ 3071 if (bvd->vdev_parent->vdev_ops == &vdev_spare_ops && 3072 !bvd->vdev_isspare) { 3073 cmn_err(CE_NOTE, "The boot device is currently spared. Please " 3074 "try booting from '%s'", 3075 bvd->vdev_parent->vdev_child[1]->vdev_path); 3076 error = EINVAL; 3077 goto out; 3078 } 3079 3080 error = 0; 3081 spa_history_log_version(spa, LOG_POOL_IMPORT); 3082 out: 3083 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3084 vdev_free(rvd); 3085 spa_config_exit(spa, SCL_ALL, FTAG); 3086 mutex_exit(&spa_namespace_lock); 3087 3088 nvlist_free(config); 3089 return (error); 3090 } 3091 3092 #endif 3093 3094 /* 3095 * Take a pool and insert it into the namespace as if it had been loaded at 3096 * boot. 3097 */ 3098 int 3099 spa_import_verbatim(const char *pool, nvlist_t *config, nvlist_t *props) 3100 { 3101 spa_t *spa; 3102 char *altroot = NULL; 3103 3104 mutex_enter(&spa_namespace_lock); 3105 if (spa_lookup(pool) != NULL) { 3106 mutex_exit(&spa_namespace_lock); 3107 return (EEXIST); 3108 } 3109 3110 (void) nvlist_lookup_string(props, 3111 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 3112 spa = spa_add(pool, config, altroot); 3113 3114 spa->spa_load_verbatim = B_TRUE; 3115 3116 if (props != NULL) 3117 spa_configfile_set(spa, props, B_FALSE); 3118 3119 spa_config_sync(spa, B_FALSE, B_TRUE); 3120 3121 mutex_exit(&spa_namespace_lock); 3122 spa_history_log_version(spa, LOG_POOL_IMPORT); 3123 3124 return (0); 3125 } 3126 3127 /* 3128 * Import a non-root pool into the system. 3129 */ 3130 int 3131 spa_import(const char *pool, nvlist_t *config, nvlist_t *props) 3132 { 3133 spa_t *spa; 3134 char *altroot = NULL; 3135 spa_load_state_t state = SPA_LOAD_IMPORT; 3136 zpool_rewind_policy_t policy; 3137 int error; 3138 nvlist_t *nvroot; 3139 nvlist_t **spares, **l2cache; 3140 uint_t nspares, nl2cache; 3141 3142 /* 3143 * If a pool with this name exists, return failure. 3144 */ 3145 mutex_enter(&spa_namespace_lock); 3146 if (spa_lookup(pool) != NULL) { 3147 mutex_exit(&spa_namespace_lock); 3148 return (EEXIST); 3149 } 3150 3151 zpool_get_rewind_policy(config, &policy); 3152 if (policy.zrp_request & ZPOOL_DO_REWIND) 3153 state = SPA_LOAD_RECOVER; 3154 3155 /* 3156 * Create and initialize the spa structure. 3157 */ 3158 (void) nvlist_lookup_string(props, 3159 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 3160 spa = spa_add(pool, config, altroot); 3161 spa_activate(spa, spa_mode_global); 3162 3163 /* 3164 * Don't start async tasks until we know everything is healthy. 3165 */ 3166 spa_async_suspend(spa); 3167 3168 /* 3169 * Pass off the heavy lifting to spa_load(). Pass TRUE for mosconfig 3170 * because the user-supplied config is actually the one to trust when 3171 * doing an import. 3172 */ 3173 if (state != SPA_LOAD_RECOVER) 3174 spa->spa_last_ubsync_txg = spa->spa_load_txg = 0; 3175 error = spa_load_best(spa, state, B_TRUE, policy.zrp_txg, 3176 policy.zrp_request); 3177 3178 /* 3179 * Propagate anything learned about failing or best txgs 3180 * back to caller 3181 */ 3182 spa_rewind_data_to_nvlist(spa, config); 3183 3184 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3185 /* 3186 * Toss any existing sparelist, as it doesn't have any validity 3187 * anymore, and conflicts with spa_has_spare(). 3188 */ 3189 if (spa->spa_spares.sav_config) { 3190 nvlist_free(spa->spa_spares.sav_config); 3191 spa->spa_spares.sav_config = NULL; 3192 spa_load_spares(spa); 3193 } 3194 if (spa->spa_l2cache.sav_config) { 3195 nvlist_free(spa->spa_l2cache.sav_config); 3196 spa->spa_l2cache.sav_config = NULL; 3197 spa_load_l2cache(spa); 3198 } 3199 3200 VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 3201 &nvroot) == 0); 3202 if (error == 0) 3203 error = spa_validate_aux(spa, nvroot, -1ULL, 3204 VDEV_ALLOC_SPARE); 3205 if (error == 0) 3206 error = spa_validate_aux(spa, nvroot, -1ULL, 3207 VDEV_ALLOC_L2CACHE); 3208 spa_config_exit(spa, SCL_ALL, FTAG); 3209 3210 if (props != NULL) 3211 spa_configfile_set(spa, props, B_FALSE); 3212 3213 if (error != 0 || (props && spa_writeable(spa) && 3214 (error = spa_prop_set(spa, props)))) { 3215 spa_unload(spa); 3216 spa_deactivate(spa); 3217 spa_remove(spa); 3218 mutex_exit(&spa_namespace_lock); 3219 return (error); 3220 } 3221 3222 spa_async_resume(spa); 3223 3224 /* 3225 * Override any spares and level 2 cache devices as specified by 3226 * the user, as these may have correct device names/devids, etc. 3227 */ 3228 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 3229 &spares, &nspares) == 0) { 3230 if (spa->spa_spares.sav_config) 3231 VERIFY(nvlist_remove(spa->spa_spares.sav_config, 3232 ZPOOL_CONFIG_SPARES, DATA_TYPE_NVLIST_ARRAY) == 0); 3233 else 3234 VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, 3235 NV_UNIQUE_NAME, KM_SLEEP) == 0); 3236 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config, 3237 ZPOOL_CONFIG_SPARES, spares, nspares) == 0); 3238 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3239 spa_load_spares(spa); 3240 spa_config_exit(spa, SCL_ALL, FTAG); 3241 spa->spa_spares.sav_sync = B_TRUE; 3242 } 3243 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 3244 &l2cache, &nl2cache) == 0) { 3245 if (spa->spa_l2cache.sav_config) 3246 VERIFY(nvlist_remove(spa->spa_l2cache.sav_config, 3247 ZPOOL_CONFIG_L2CACHE, DATA_TYPE_NVLIST_ARRAY) == 0); 3248 else 3249 VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config, 3250 NV_UNIQUE_NAME, KM_SLEEP) == 0); 3251 VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config, 3252 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); 3253 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3254 spa_load_l2cache(spa); 3255 spa_config_exit(spa, SCL_ALL, FTAG); 3256 spa->spa_l2cache.sav_sync = B_TRUE; 3257 } 3258 3259 /* 3260 * Check for any removed devices. 3261 */ 3262 if (spa->spa_autoreplace) { 3263 spa_aux_check_removed(&spa->spa_spares); 3264 spa_aux_check_removed(&spa->spa_l2cache); 3265 } 3266 3267 if (spa_writeable(spa)) { 3268 /* 3269 * Update the config cache to include the newly-imported pool. 3270 */ 3271 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 3272 } 3273 3274 /* 3275 * It's possible that the pool was expanded while it was exported. 3276 * We kick off an async task to handle this for us. 3277 */ 3278 spa_async_request(spa, SPA_ASYNC_AUTOEXPAND); 3279 3280 mutex_exit(&spa_namespace_lock); 3281 spa_history_log_version(spa, LOG_POOL_IMPORT); 3282 3283 return (0); 3284 } 3285 3286 nvlist_t * 3287 spa_tryimport(nvlist_t *tryconfig) 3288 { 3289 nvlist_t *config = NULL; 3290 char *poolname; 3291 spa_t *spa; 3292 uint64_t state; 3293 int error; 3294 3295 if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname)) 3296 return (NULL); 3297 3298 if (nvlist_lookup_uint64(tryconfig, ZPOOL_CONFIG_POOL_STATE, &state)) 3299 return (NULL); 3300 3301 /* 3302 * Create and initialize the spa structure. 3303 */ 3304 mutex_enter(&spa_namespace_lock); 3305 spa = spa_add(TRYIMPORT_NAME, tryconfig, NULL); 3306 spa_activate(spa, FREAD); 3307 3308 /* 3309 * Pass off the heavy lifting to spa_load(). 3310 * Pass TRUE for mosconfig because the user-supplied config 3311 * is actually the one to trust when doing an import. 3312 */ 3313 error = spa_load(spa, SPA_LOAD_TRYIMPORT, SPA_IMPORT_EXISTING, B_TRUE); 3314 3315 /* 3316 * If 'tryconfig' was at least parsable, return the current config. 3317 */ 3318 if (spa->spa_root_vdev != NULL) { 3319 config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 3320 VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, 3321 poolname) == 0); 3322 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE, 3323 state) == 0); 3324 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_TIMESTAMP, 3325 spa->spa_uberblock.ub_timestamp) == 0); 3326 3327 /* 3328 * If the bootfs property exists on this pool then we 3329 * copy it out so that external consumers can tell which 3330 * pools are bootable. 3331 */ 3332 if ((!error || error == EEXIST) && spa->spa_bootfs) { 3333 char *tmpname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 3334 3335 /* 3336 * We have to play games with the name since the 3337 * pool was opened as TRYIMPORT_NAME. 3338 */ 3339 if (dsl_dsobj_to_dsname(spa_name(spa), 3340 spa->spa_bootfs, tmpname) == 0) { 3341 char *cp; 3342 char *dsname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 3343 3344 cp = strchr(tmpname, '/'); 3345 if (cp == NULL) { 3346 (void) strlcpy(dsname, tmpname, 3347 MAXPATHLEN); 3348 } else { 3349 (void) snprintf(dsname, MAXPATHLEN, 3350 "%s/%s", poolname, ++cp); 3351 } 3352 VERIFY(nvlist_add_string(config, 3353 ZPOOL_CONFIG_BOOTFS, dsname) == 0); 3354 kmem_free(dsname, MAXPATHLEN); 3355 } 3356 kmem_free(tmpname, MAXPATHLEN); 3357 } 3358 3359 /* 3360 * Add the list of hot spares and level 2 cache devices. 3361 */ 3362 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 3363 spa_add_spares(spa, config); 3364 spa_add_l2cache(spa, config); 3365 spa_config_exit(spa, SCL_CONFIG, FTAG); 3366 } 3367 3368 spa_unload(spa); 3369 spa_deactivate(spa); 3370 spa_remove(spa); 3371 mutex_exit(&spa_namespace_lock); 3372 3373 return (config); 3374 } 3375 3376 /* 3377 * Pool export/destroy 3378 * 3379 * The act of destroying or exporting a pool is very simple. We make sure there 3380 * is no more pending I/O and any references to the pool are gone. Then, we 3381 * update the pool state and sync all the labels to disk, removing the 3382 * configuration from the cache afterwards. If the 'hardforce' flag is set, then 3383 * we don't sync the labels or remove the configuration cache. 3384 */ 3385 static int 3386 spa_export_common(char *pool, int new_state, nvlist_t **oldconfig, 3387 boolean_t force, boolean_t hardforce) 3388 { 3389 spa_t *spa; 3390 3391 if (oldconfig) 3392 *oldconfig = NULL; 3393 3394 if (!(spa_mode_global & FWRITE)) 3395 return (EROFS); 3396 3397 mutex_enter(&spa_namespace_lock); 3398 if ((spa = spa_lookup(pool)) == NULL) { 3399 mutex_exit(&spa_namespace_lock); 3400 return (ENOENT); 3401 } 3402 3403 /* 3404 * Put a hold on the pool, drop the namespace lock, stop async tasks, 3405 * reacquire the namespace lock, and see if we can export. 3406 */ 3407 spa_open_ref(spa, FTAG); 3408 mutex_exit(&spa_namespace_lock); 3409 spa_async_suspend(spa); 3410 mutex_enter(&spa_namespace_lock); 3411 spa_close(spa, FTAG); 3412 3413 /* 3414 * The pool will be in core if it's openable, 3415 * in which case we can modify its state. 3416 */ 3417 if (spa->spa_state != POOL_STATE_UNINITIALIZED && spa->spa_sync_on) { 3418 /* 3419 * Objsets may be open only because they're dirty, so we 3420 * have to force it to sync before checking spa_refcnt. 3421 */ 3422 txg_wait_synced(spa->spa_dsl_pool, 0); 3423 3424 /* 3425 * A pool cannot be exported or destroyed if there are active 3426 * references. If we are resetting a pool, allow references by 3427 * fault injection handlers. 3428 */ 3429 if (!spa_refcount_zero(spa) || 3430 (spa->spa_inject_ref != 0 && 3431 new_state != POOL_STATE_UNINITIALIZED)) { 3432 spa_async_resume(spa); 3433 mutex_exit(&spa_namespace_lock); 3434 return (EBUSY); 3435 } 3436 3437 /* 3438 * A pool cannot be exported if it has an active shared spare. 3439 * This is to prevent other pools stealing the active spare 3440 * from an exported pool. At user's own will, such pool can 3441 * be forcedly exported. 3442 */ 3443 if (!force && new_state == POOL_STATE_EXPORTED && 3444 spa_has_active_shared_spare(spa)) { 3445 spa_async_resume(spa); 3446 mutex_exit(&spa_namespace_lock); 3447 return (EXDEV); 3448 } 3449 3450 /* 3451 * We want this to be reflected on every label, 3452 * so mark them all dirty. spa_unload() will do the 3453 * final sync that pushes these changes out. 3454 */ 3455 if (new_state != POOL_STATE_UNINITIALIZED && !hardforce) { 3456 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3457 spa->spa_state = new_state; 3458 spa->spa_final_txg = spa_last_synced_txg(spa) + 1; 3459 vdev_config_dirty(spa->spa_root_vdev); 3460 spa_config_exit(spa, SCL_ALL, FTAG); 3461 } 3462 } 3463 3464 spa_event_notify(spa, NULL, ESC_ZFS_POOL_DESTROY); 3465 3466 if (spa->spa_state != POOL_STATE_UNINITIALIZED) { 3467 spa_unload(spa); 3468 spa_deactivate(spa); 3469 } 3470 3471 if (oldconfig && spa->spa_config) 3472 VERIFY(nvlist_dup(spa->spa_config, oldconfig, 0) == 0); 3473 3474 if (new_state != POOL_STATE_UNINITIALIZED) { 3475 if (!hardforce) 3476 spa_config_sync(spa, B_TRUE, B_TRUE); 3477 spa_remove(spa); 3478 } 3479 mutex_exit(&spa_namespace_lock); 3480 3481 return (0); 3482 } 3483 3484 /* 3485 * Destroy a storage pool. 3486 */ 3487 int 3488 spa_destroy(char *pool) 3489 { 3490 return (spa_export_common(pool, POOL_STATE_DESTROYED, NULL, 3491 B_FALSE, B_FALSE)); 3492 } 3493 3494 /* 3495 * Export a storage pool. 3496 */ 3497 int 3498 spa_export(char *pool, nvlist_t **oldconfig, boolean_t force, 3499 boolean_t hardforce) 3500 { 3501 return (spa_export_common(pool, POOL_STATE_EXPORTED, oldconfig, 3502 force, hardforce)); 3503 } 3504 3505 /* 3506 * Similar to spa_export(), this unloads the spa_t without actually removing it 3507 * from the namespace in any way. 3508 */ 3509 int 3510 spa_reset(char *pool) 3511 { 3512 return (spa_export_common(pool, POOL_STATE_UNINITIALIZED, NULL, 3513 B_FALSE, B_FALSE)); 3514 } 3515 3516 /* 3517 * ========================================================================== 3518 * Device manipulation 3519 * ========================================================================== 3520 */ 3521 3522 /* 3523 * Add a device to a storage pool. 3524 */ 3525 int 3526 spa_vdev_add(spa_t *spa, nvlist_t *nvroot) 3527 { 3528 uint64_t txg, id; 3529 int error; 3530 vdev_t *rvd = spa->spa_root_vdev; 3531 vdev_t *vd, *tvd; 3532 nvlist_t **spares, **l2cache; 3533 uint_t nspares, nl2cache; 3534 3535 txg = spa_vdev_enter(spa); 3536 3537 if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0, 3538 VDEV_ALLOC_ADD)) != 0) 3539 return (spa_vdev_exit(spa, NULL, txg, error)); 3540 3541 spa->spa_pending_vdev = vd; /* spa_vdev_exit() will clear this */ 3542 3543 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, &spares, 3544 &nspares) != 0) 3545 nspares = 0; 3546 3547 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, &l2cache, 3548 &nl2cache) != 0) 3549 nl2cache = 0; 3550 3551 if (vd->vdev_children == 0 && nspares == 0 && nl2cache == 0) 3552 return (spa_vdev_exit(spa, vd, txg, EINVAL)); 3553 3554 if (vd->vdev_children != 0 && 3555 (error = vdev_create(vd, txg, B_FALSE)) != 0) 3556 return (spa_vdev_exit(spa, vd, txg, error)); 3557 3558 /* 3559 * We must validate the spares and l2cache devices after checking the 3560 * children. Otherwise, vdev_inuse() will blindly overwrite the spare. 3561 */ 3562 if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0) 3563 return (spa_vdev_exit(spa, vd, txg, error)); 3564 3565 /* 3566 * Transfer each new top-level vdev from vd to rvd. 3567 */ 3568 for (int c = 0; c < vd->vdev_children; c++) { 3569 3570 /* 3571 * Set the vdev id to the first hole, if one exists. 3572 */ 3573 for (id = 0; id < rvd->vdev_children; id++) { 3574 if (rvd->vdev_child[id]->vdev_ishole) { 3575 vdev_free(rvd->vdev_child[id]); 3576 break; 3577 } 3578 } 3579 tvd = vd->vdev_child[c]; 3580 vdev_remove_child(vd, tvd); 3581 tvd->vdev_id = id; 3582 vdev_add_child(rvd, tvd); 3583 vdev_config_dirty(tvd); 3584 } 3585 3586 if (nspares != 0) { 3587 spa_set_aux_vdevs(&spa->spa_spares, spares, nspares, 3588 ZPOOL_CONFIG_SPARES); 3589 spa_load_spares(spa); 3590 spa->spa_spares.sav_sync = B_TRUE; 3591 } 3592 3593 if (nl2cache != 0) { 3594 spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache, 3595 ZPOOL_CONFIG_L2CACHE); 3596 spa_load_l2cache(spa); 3597 spa->spa_l2cache.sav_sync = B_TRUE; 3598 } 3599 3600 /* 3601 * We have to be careful when adding new vdevs to an existing pool. 3602 * If other threads start allocating from these vdevs before we 3603 * sync the config cache, and we lose power, then upon reboot we may 3604 * fail to open the pool because there are DVAs that the config cache 3605 * can't translate. Therefore, we first add the vdevs without 3606 * initializing metaslabs; sync the config cache (via spa_vdev_exit()); 3607 * and then let spa_config_update() initialize the new metaslabs. 3608 * 3609 * spa_load() checks for added-but-not-initialized vdevs, so that 3610 * if we lose power at any point in this sequence, the remaining 3611 * steps will be completed the next time we load the pool. 3612 */ 3613 (void) spa_vdev_exit(spa, vd, txg, 0); 3614 3615 mutex_enter(&spa_namespace_lock); 3616 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 3617 mutex_exit(&spa_namespace_lock); 3618 3619 return (0); 3620 } 3621 3622 /* 3623 * Attach a device to a mirror. The arguments are the path to any device 3624 * in the mirror, and the nvroot for the new device. If the path specifies 3625 * a device that is not mirrored, we automatically insert the mirror vdev. 3626 * 3627 * If 'replacing' is specified, the new device is intended to replace the 3628 * existing device; in this case the two devices are made into their own 3629 * mirror using the 'replacing' vdev, which is functionally identical to 3630 * the mirror vdev (it actually reuses all the same ops) but has a few 3631 * extra rules: you can't attach to it after it's been created, and upon 3632 * completion of resilvering, the first disk (the one being replaced) 3633 * is automatically detached. 3634 */ 3635 int 3636 spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing) 3637 { 3638 uint64_t txg, open_txg; 3639 vdev_t *rvd = spa->spa_root_vdev; 3640 vdev_t *oldvd, *newvd, *newrootvd, *pvd, *tvd; 3641 vdev_ops_t *pvops; 3642 char *oldvdpath, *newvdpath; 3643 int newvd_isspare; 3644 int error; 3645 3646 txg = spa_vdev_enter(spa); 3647 3648 oldvd = spa_lookup_by_guid(spa, guid, B_FALSE); 3649 3650 if (oldvd == NULL) 3651 return (spa_vdev_exit(spa, NULL, txg, ENODEV)); 3652 3653 if (!oldvd->vdev_ops->vdev_op_leaf) 3654 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 3655 3656 pvd = oldvd->vdev_parent; 3657 3658 if ((error = spa_config_parse(spa, &newrootvd, nvroot, NULL, 0, 3659 VDEV_ALLOC_ADD)) != 0) 3660 return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 3661 3662 if (newrootvd->vdev_children != 1) 3663 return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); 3664 3665 newvd = newrootvd->vdev_child[0]; 3666 3667 if (!newvd->vdev_ops->vdev_op_leaf) 3668 return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); 3669 3670 if ((error = vdev_create(newrootvd, txg, replacing)) != 0) 3671 return (spa_vdev_exit(spa, newrootvd, txg, error)); 3672 3673 /* 3674 * Spares can't replace logs 3675 */ 3676 if (oldvd->vdev_top->vdev_islog && newvd->vdev_isspare) 3677 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 3678 3679 if (!replacing) { 3680 /* 3681 * For attach, the only allowable parent is a mirror or the root 3682 * vdev. 3683 */ 3684 if (pvd->vdev_ops != &vdev_mirror_ops && 3685 pvd->vdev_ops != &vdev_root_ops) 3686 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 3687 3688 pvops = &vdev_mirror_ops; 3689 } else { 3690 /* 3691 * Active hot spares can only be replaced by inactive hot 3692 * spares. 3693 */ 3694 if (pvd->vdev_ops == &vdev_spare_ops && 3695 pvd->vdev_child[1] == oldvd && 3696 !spa_has_spare(spa, newvd->vdev_guid)) 3697 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 3698 3699 /* 3700 * If the source is a hot spare, and the parent isn't already a 3701 * spare, then we want to create a new hot spare. Otherwise, we 3702 * want to create a replacing vdev. The user is not allowed to 3703 * attach to a spared vdev child unless the 'isspare' state is 3704 * the same (spare replaces spare, non-spare replaces 3705 * non-spare). 3706 */ 3707 if (pvd->vdev_ops == &vdev_replacing_ops) 3708 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 3709 else if (pvd->vdev_ops == &vdev_spare_ops && 3710 newvd->vdev_isspare != oldvd->vdev_isspare) 3711 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 3712 else if (pvd->vdev_ops != &vdev_spare_ops && 3713 newvd->vdev_isspare) 3714 pvops = &vdev_spare_ops; 3715 else 3716 pvops = &vdev_replacing_ops; 3717 } 3718 3719 /* 3720 * Make sure the new device is big enough. 3721 */ 3722 if (newvd->vdev_asize < vdev_get_min_asize(oldvd)) 3723 return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW)); 3724 3725 /* 3726 * The new device cannot have a higher alignment requirement 3727 * than the top-level vdev. 3728 */ 3729 if (newvd->vdev_ashift > oldvd->vdev_top->vdev_ashift) 3730 return (spa_vdev_exit(spa, newrootvd, txg, EDOM)); 3731 3732 /* 3733 * If this is an in-place replacement, update oldvd's path and devid 3734 * to make it distinguishable from newvd, and unopenable from now on. 3735 */ 3736 if (strcmp(oldvd->vdev_path, newvd->vdev_path) == 0) { 3737 spa_strfree(oldvd->vdev_path); 3738 oldvd->vdev_path = kmem_alloc(strlen(newvd->vdev_path) + 5, 3739 KM_SLEEP); 3740 (void) sprintf(oldvd->vdev_path, "%s/%s", 3741 newvd->vdev_path, "old"); 3742 if (oldvd->vdev_devid != NULL) { 3743 spa_strfree(oldvd->vdev_devid); 3744 oldvd->vdev_devid = NULL; 3745 } 3746 } 3747 3748 /* 3749 * If the parent is not a mirror, or if we're replacing, insert the new 3750 * mirror/replacing/spare vdev above oldvd. 3751 */ 3752 if (pvd->vdev_ops != pvops) 3753 pvd = vdev_add_parent(oldvd, pvops); 3754 3755 ASSERT(pvd->vdev_top->vdev_parent == rvd); 3756 ASSERT(pvd->vdev_ops == pvops); 3757 ASSERT(oldvd->vdev_parent == pvd); 3758 3759 /* 3760 * Extract the new device from its root and add it to pvd. 3761 */ 3762 vdev_remove_child(newrootvd, newvd); 3763 newvd->vdev_id = pvd->vdev_children; 3764 newvd->vdev_crtxg = oldvd->vdev_crtxg; 3765 vdev_add_child(pvd, newvd); 3766 3767 tvd = newvd->vdev_top; 3768 ASSERT(pvd->vdev_top == tvd); 3769 ASSERT(tvd->vdev_parent == rvd); 3770 3771 vdev_config_dirty(tvd); 3772 3773 /* 3774 * Set newvd's DTL to [TXG_INITIAL, open_txg]. It will propagate 3775 * upward when spa_vdev_exit() calls vdev_dtl_reassess(). 3776 */ 3777 open_txg = txg + TXG_CONCURRENT_STATES - 1; 3778 3779 vdev_dtl_dirty(newvd, DTL_MISSING, 3780 TXG_INITIAL, open_txg - TXG_INITIAL + 1); 3781 3782 if (newvd->vdev_isspare) { 3783 spa_spare_activate(newvd); 3784 spa_event_notify(spa, newvd, ESC_ZFS_VDEV_SPARE); 3785 } 3786 3787 oldvdpath = spa_strdup(oldvd->vdev_path); 3788 newvdpath = spa_strdup(newvd->vdev_path); 3789 newvd_isspare = newvd->vdev_isspare; 3790 3791 /* 3792 * Mark newvd's DTL dirty in this txg. 3793 */ 3794 vdev_dirty(tvd, VDD_DTL, newvd, txg); 3795 3796 (void) spa_vdev_exit(spa, newrootvd, open_txg, 0); 3797 3798 spa_history_internal_log(LOG_POOL_VDEV_ATTACH, spa, NULL, 3799 CRED(), "%s vdev=%s %s vdev=%s", 3800 replacing && newvd_isspare ? "spare in" : 3801 replacing ? "replace" : "attach", newvdpath, 3802 replacing ? "for" : "to", oldvdpath); 3803 3804 spa_strfree(oldvdpath); 3805 spa_strfree(newvdpath); 3806 3807 /* 3808 * Kick off a resilver to update newvd. 3809 */ 3810 VERIFY3U(spa_scrub(spa, POOL_SCRUB_RESILVER), ==, 0); 3811 3812 return (0); 3813 } 3814 3815 /* 3816 * Detach a device from a mirror or replacing vdev. 3817 * If 'replace_done' is specified, only detach if the parent 3818 * is a replacing vdev. 3819 */ 3820 int 3821 spa_vdev_detach(spa_t *spa, uint64_t guid, uint64_t pguid, int replace_done) 3822 { 3823 uint64_t txg; 3824 int error; 3825 vdev_t *rvd = spa->spa_root_vdev; 3826 vdev_t *vd, *pvd, *cvd, *tvd; 3827 boolean_t unspare = B_FALSE; 3828 uint64_t unspare_guid; 3829 size_t len; 3830 char *vdpath; 3831 3832 txg = spa_vdev_enter(spa); 3833 3834 vd = spa_lookup_by_guid(spa, guid, B_FALSE); 3835 3836 if (vd == NULL) 3837 return (spa_vdev_exit(spa, NULL, txg, ENODEV)); 3838 3839 if (!vd->vdev_ops->vdev_op_leaf) 3840 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 3841 3842 pvd = vd->vdev_parent; 3843 3844 /* 3845 * If the parent/child relationship is not as expected, don't do it. 3846 * Consider M(A,R(B,C)) -- that is, a mirror of A with a replacing 3847 * vdev that's replacing B with C. The user's intent in replacing 3848 * is to go from M(A,B) to M(A,C). If the user decides to cancel 3849 * the replace by detaching C, the expected behavior is to end up 3850 * M(A,B). But suppose that right after deciding to detach C, 3851 * the replacement of B completes. We would have M(A,C), and then 3852 * ask to detach C, which would leave us with just A -- not what 3853 * the user wanted. To prevent this, we make sure that the 3854 * parent/child relationship hasn't changed -- in this example, 3855 * that C's parent is still the replacing vdev R. 3856 */ 3857 if (pvd->vdev_guid != pguid && pguid != 0) 3858 return (spa_vdev_exit(spa, NULL, txg, EBUSY)); 3859 3860 /* 3861 * If replace_done is specified, only remove this device if it's 3862 * the first child of a replacing vdev. For the 'spare' vdev, either 3863 * disk can be removed. 3864 */ 3865 if (replace_done) { 3866 if (pvd->vdev_ops == &vdev_replacing_ops) { 3867 if (vd->vdev_id != 0) 3868 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 3869 } else if (pvd->vdev_ops != &vdev_spare_ops) { 3870 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 3871 } 3872 } 3873 3874 ASSERT(pvd->vdev_ops != &vdev_spare_ops || 3875 spa_version(spa) >= SPA_VERSION_SPARES); 3876 3877 /* 3878 * Only mirror, replacing, and spare vdevs support detach. 3879 */ 3880 if (pvd->vdev_ops != &vdev_replacing_ops && 3881 pvd->vdev_ops != &vdev_mirror_ops && 3882 pvd->vdev_ops != &vdev_spare_ops) 3883 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 3884 3885 /* 3886 * If this device has the only valid copy of some data, 3887 * we cannot safely detach it. 3888 */ 3889 if (vdev_dtl_required(vd)) 3890 return (spa_vdev_exit(spa, NULL, txg, EBUSY)); 3891 3892 ASSERT(pvd->vdev_children >= 2); 3893 3894 /* 3895 * If we are detaching the second disk from a replacing vdev, then 3896 * check to see if we changed the original vdev's path to have "/old" 3897 * at the end in spa_vdev_attach(). If so, undo that change now. 3898 */ 3899 if (pvd->vdev_ops == &vdev_replacing_ops && vd->vdev_id == 1 && 3900 pvd->vdev_child[0]->vdev_path != NULL && 3901 pvd->vdev_child[1]->vdev_path != NULL) { 3902 ASSERT(pvd->vdev_child[1] == vd); 3903 cvd = pvd->vdev_child[0]; 3904 len = strlen(vd->vdev_path); 3905 if (strncmp(cvd->vdev_path, vd->vdev_path, len) == 0 && 3906 strcmp(cvd->vdev_path + len, "/old") == 0) { 3907 spa_strfree(cvd->vdev_path); 3908 cvd->vdev_path = spa_strdup(vd->vdev_path); 3909 } 3910 } 3911 3912 /* 3913 * If we are detaching the original disk from a spare, then it implies 3914 * that the spare should become a real disk, and be removed from the 3915 * active spare list for the pool. 3916 */ 3917 if (pvd->vdev_ops == &vdev_spare_ops && 3918 vd->vdev_id == 0 && pvd->vdev_child[1]->vdev_isspare) 3919 unspare = B_TRUE; 3920 3921 /* 3922 * Erase the disk labels so the disk can be used for other things. 3923 * This must be done after all other error cases are handled, 3924 * but before we disembowel vd (so we can still do I/O to it). 3925 * But if we can't do it, don't treat the error as fatal -- 3926 * it may be that the unwritability of the disk is the reason 3927 * it's being detached! 3928 */ 3929 error = vdev_label_init(vd, 0, VDEV_LABEL_REMOVE); 3930 3931 /* 3932 * Remove vd from its parent and compact the parent's children. 3933 */ 3934 vdev_remove_child(pvd, vd); 3935 vdev_compact_children(pvd); 3936 3937 /* 3938 * Remember one of the remaining children so we can get tvd below. 3939 */ 3940 cvd = pvd->vdev_child[0]; 3941 3942 /* 3943 * If we need to remove the remaining child from the list of hot spares, 3944 * do it now, marking the vdev as no longer a spare in the process. 3945 * We must do this before vdev_remove_parent(), because that can 3946 * change the GUID if it creates a new toplevel GUID. For a similar 3947 * reason, we must remove the spare now, in the same txg as the detach; 3948 * otherwise someone could attach a new sibling, change the GUID, and 3949 * the subsequent attempt to spa_vdev_remove(unspare_guid) would fail. 3950 */ 3951 if (unspare) { 3952 ASSERT(cvd->vdev_isspare); 3953 spa_spare_remove(cvd); 3954 unspare_guid = cvd->vdev_guid; 3955 (void) spa_vdev_remove(spa, unspare_guid, B_TRUE); 3956 } 3957 3958 /* 3959 * If the parent mirror/replacing vdev only has one child, 3960 * the parent is no longer needed. Remove it from the tree. 3961 */ 3962 if (pvd->vdev_children == 1) 3963 vdev_remove_parent(cvd); 3964 3965 /* 3966 * We don't set tvd until now because the parent we just removed 3967 * may have been the previous top-level vdev. 3968 */ 3969 tvd = cvd->vdev_top; 3970 ASSERT(tvd->vdev_parent == rvd); 3971 3972 /* 3973 * Reevaluate the parent vdev state. 3974 */ 3975 vdev_propagate_state(cvd); 3976 3977 /* 3978 * If the 'autoexpand' property is set on the pool then automatically 3979 * try to expand the size of the pool. For example if the device we 3980 * just detached was smaller than the others, it may be possible to 3981 * add metaslabs (i.e. grow the pool). We need to reopen the vdev 3982 * first so that we can obtain the updated sizes of the leaf vdevs. 3983 */ 3984 if (spa->spa_autoexpand) { 3985 vdev_reopen(tvd); 3986 vdev_expand(tvd, txg); 3987 } 3988 3989 vdev_config_dirty(tvd); 3990 3991 /* 3992 * Mark vd's DTL as dirty in this txg. vdev_dtl_sync() will see that 3993 * vd->vdev_detached is set and free vd's DTL object in syncing context. 3994 * But first make sure we're not on any *other* txg's DTL list, to 3995 * prevent vd from being accessed after it's freed. 3996 */ 3997 vdpath = spa_strdup(vd->vdev_path); 3998 for (int t = 0; t < TXG_SIZE; t++) 3999 (void) txg_list_remove_this(&tvd->vdev_dtl_list, vd, t); 4000 vd->vdev_detached = B_TRUE; 4001 vdev_dirty(tvd, VDD_DTL, vd, txg); 4002 4003 spa_event_notify(spa, vd, ESC_ZFS_VDEV_REMOVE); 4004 4005 error = spa_vdev_exit(spa, vd, txg, 0); 4006 4007 spa_history_internal_log(LOG_POOL_VDEV_DETACH, spa, NULL, CRED(), 4008 "vdev=%s", vdpath); 4009 spa_strfree(vdpath); 4010 4011 /* 4012 * If this was the removal of the original device in a hot spare vdev, 4013 * then we want to go through and remove the device from the hot spare 4014 * list of every other pool. 4015 */ 4016 if (unspare) { 4017 spa_t *myspa = spa; 4018 spa = NULL; 4019 mutex_enter(&spa_namespace_lock); 4020 while ((spa = spa_next(spa)) != NULL) { 4021 if (spa->spa_state != POOL_STATE_ACTIVE) 4022 continue; 4023 if (spa == myspa) 4024 continue; 4025 spa_open_ref(spa, FTAG); 4026 mutex_exit(&spa_namespace_lock); 4027 (void) spa_vdev_remove(spa, unspare_guid, B_TRUE); 4028 mutex_enter(&spa_namespace_lock); 4029 spa_close(spa, FTAG); 4030 } 4031 mutex_exit(&spa_namespace_lock); 4032 } 4033 4034 return (error); 4035 } 4036 4037 /* 4038 * Split a set of devices from their mirrors, and create a new pool from them. 4039 */ 4040 int 4041 spa_vdev_split_mirror(spa_t *spa, char *newname, nvlist_t *config, 4042 nvlist_t *props, boolean_t exp) 4043 { 4044 int error = 0; 4045 uint64_t txg, *glist; 4046 spa_t *newspa; 4047 uint_t c, children, lastlog; 4048 nvlist_t **child, *nvl, *tmp; 4049 dmu_tx_t *tx; 4050 char *altroot = NULL; 4051 vdev_t *rvd, **vml = NULL; /* vdev modify list */ 4052 boolean_t activate_slog; 4053 4054 if (!spa_writeable(spa)) 4055 return (EROFS); 4056 4057 txg = spa_vdev_enter(spa); 4058 4059 /* clear the log and flush everything up to now */ 4060 activate_slog = spa_passivate_log(spa); 4061 (void) spa_vdev_config_exit(spa, NULL, txg, 0, FTAG); 4062 error = spa_offline_log(spa); 4063 txg = spa_vdev_config_enter(spa); 4064 4065 if (activate_slog) 4066 spa_activate_log(spa); 4067 4068 if (error != 0) 4069 return (spa_vdev_exit(spa, NULL, txg, error)); 4070 4071 /* check new spa name before going any further */ 4072 if (spa_lookup(newname) != NULL) 4073 return (spa_vdev_exit(spa, NULL, txg, EEXIST)); 4074 4075 /* 4076 * scan through all the children to ensure they're all mirrors 4077 */ 4078 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvl) != 0 || 4079 nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_CHILDREN, &child, 4080 &children) != 0) 4081 return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 4082 4083 /* first, check to ensure we've got the right child count */ 4084 rvd = spa->spa_root_vdev; 4085 lastlog = 0; 4086 for (c = 0; c < rvd->vdev_children; c++) { 4087 vdev_t *vd = rvd->vdev_child[c]; 4088 4089 /* don't count the holes & logs as children */ 4090 if (vd->vdev_islog || vd->vdev_ishole) { 4091 if (lastlog == 0) 4092 lastlog = c; 4093 continue; 4094 } 4095 4096 lastlog = 0; 4097 } 4098 if (children != (lastlog != 0 ? lastlog : rvd->vdev_children)) 4099 return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 4100 4101 /* next, ensure no spare or cache devices are part of the split */ 4102 if (nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_SPARES, &tmp) == 0 || 4103 nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_L2CACHE, &tmp) == 0) 4104 return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 4105 4106 vml = kmem_zalloc(children * sizeof (vdev_t *), KM_SLEEP); 4107 glist = kmem_zalloc(children * sizeof (uint64_t), KM_SLEEP); 4108 4109 /* then, loop over each vdev and validate it */ 4110 for (c = 0; c < children; c++) { 4111 uint64_t is_hole = 0; 4112 4113 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE, 4114 &is_hole); 4115 4116 if (is_hole != 0) { 4117 if (spa->spa_root_vdev->vdev_child[c]->vdev_ishole || 4118 spa->spa_root_vdev->vdev_child[c]->vdev_islog) { 4119 continue; 4120 } else { 4121 error = EINVAL; 4122 break; 4123 } 4124 } 4125 4126 /* which disk is going to be split? */ 4127 if (nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_GUID, 4128 &glist[c]) != 0) { 4129 error = EINVAL; 4130 break; 4131 } 4132 4133 /* look it up in the spa */ 4134 vml[c] = spa_lookup_by_guid(spa, glist[c], B_FALSE); 4135 if (vml[c] == NULL) { 4136 error = ENODEV; 4137 break; 4138 } 4139 4140 /* make sure there's nothing stopping the split */ 4141 if (vml[c]->vdev_parent->vdev_ops != &vdev_mirror_ops || 4142 vml[c]->vdev_islog || 4143 vml[c]->vdev_ishole || 4144 vml[c]->vdev_isspare || 4145 vml[c]->vdev_isl2cache || 4146 !vdev_writeable(vml[c]) || 4147 vml[c]->vdev_children != 0 || 4148 vml[c]->vdev_state != VDEV_STATE_HEALTHY || 4149 c != spa->spa_root_vdev->vdev_child[c]->vdev_id) { 4150 error = EINVAL; 4151 break; 4152 } 4153 4154 if (vdev_dtl_required(vml[c])) { 4155 error = EBUSY; 4156 break; 4157 } 4158 4159 /* we need certain info from the top level */ 4160 VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_ARRAY, 4161 vml[c]->vdev_top->vdev_ms_array) == 0); 4162 VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_SHIFT, 4163 vml[c]->vdev_top->vdev_ms_shift) == 0); 4164 VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASIZE, 4165 vml[c]->vdev_top->vdev_asize) == 0); 4166 VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASHIFT, 4167 vml[c]->vdev_top->vdev_ashift) == 0); 4168 } 4169 4170 if (error != 0) { 4171 kmem_free(vml, children * sizeof (vdev_t *)); 4172 kmem_free(glist, children * sizeof (uint64_t)); 4173 return (spa_vdev_exit(spa, NULL, txg, error)); 4174 } 4175 4176 /* stop writers from using the disks */ 4177 for (c = 0; c < children; c++) { 4178 if (vml[c] != NULL) 4179 vml[c]->vdev_offline = B_TRUE; 4180 } 4181 vdev_reopen(spa->spa_root_vdev); 4182 4183 /* 4184 * Temporarily record the splitting vdevs in the spa config. This 4185 * will disappear once the config is regenerated. 4186 */ 4187 VERIFY(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP) == 0); 4188 VERIFY(nvlist_add_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST, 4189 glist, children) == 0); 4190 kmem_free(glist, children * sizeof (uint64_t)); 4191 4192 VERIFY(nvlist_add_nvlist(spa->spa_config, ZPOOL_CONFIG_SPLIT, 4193 nvl) == 0); 4194 spa->spa_config_splitting = nvl; 4195 vdev_config_dirty(spa->spa_root_vdev); 4196 4197 /* configure and create the new pool */ 4198 VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, newname) == 0); 4199 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE, 4200 exp ? POOL_STATE_EXPORTED : POOL_STATE_ACTIVE) == 0); 4201 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VERSION, 4202 spa_version(spa)) == 0); 4203 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_TXG, 4204 spa->spa_config_txg) == 0); 4205 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_GUID, 4206 spa_generate_guid(NULL)) == 0); 4207 (void) nvlist_lookup_string(props, 4208 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 4209 4210 /* add the new pool to the namespace */ 4211 newspa = spa_add(newname, config, altroot); 4212 newspa->spa_config_txg = spa->spa_config_txg; 4213 spa_set_log_state(newspa, SPA_LOG_CLEAR); 4214 4215 /* release the spa config lock, retaining the namespace lock */ 4216 spa_vdev_config_exit(spa, NULL, txg, 0, FTAG); 4217 4218 if (zio_injection_enabled) 4219 zio_handle_panic_injection(spa, FTAG, 1); 4220 4221 spa_activate(newspa, spa_mode_global); 4222 spa_async_suspend(newspa); 4223 4224 /* create the new pool from the disks of the original pool */ 4225 error = spa_load(newspa, SPA_LOAD_IMPORT, SPA_IMPORT_ASSEMBLE, B_TRUE); 4226 if (error) 4227 goto out; 4228 4229 /* if that worked, generate a real config for the new pool */ 4230 if (newspa->spa_root_vdev != NULL) { 4231 VERIFY(nvlist_alloc(&newspa->spa_config_splitting, 4232 NV_UNIQUE_NAME, KM_SLEEP) == 0); 4233 VERIFY(nvlist_add_uint64(newspa->spa_config_splitting, 4234 ZPOOL_CONFIG_SPLIT_GUID, spa_guid(spa)) == 0); 4235 spa_config_set(newspa, spa_config_generate(newspa, NULL, -1ULL, 4236 B_TRUE)); 4237 } 4238 4239 /* set the props */ 4240 if (props != NULL) { 4241 spa_configfile_set(newspa, props, B_FALSE); 4242 error = spa_prop_set(newspa, props); 4243 if (error) 4244 goto out; 4245 } 4246 4247 /* flush everything */ 4248 txg = spa_vdev_config_enter(newspa); 4249 vdev_config_dirty(newspa->spa_root_vdev); 4250 (void) spa_vdev_config_exit(newspa, NULL, txg, 0, FTAG); 4251 4252 if (zio_injection_enabled) 4253 zio_handle_panic_injection(spa, FTAG, 2); 4254 4255 spa_async_resume(newspa); 4256 4257 /* finally, update the original pool's config */ 4258 txg = spa_vdev_config_enter(spa); 4259 tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir); 4260 error = dmu_tx_assign(tx, TXG_WAIT); 4261 if (error != 0) 4262 dmu_tx_abort(tx); 4263 for (c = 0; c < children; c++) { 4264 if (vml[c] != NULL) { 4265 vdev_split(vml[c]); 4266 if (error == 0) 4267 spa_history_internal_log(LOG_POOL_VDEV_DETACH, 4268 spa, tx, CRED(), "vdev=%s", 4269 vml[c]->vdev_path); 4270 vdev_free(vml[c]); 4271 } 4272 } 4273 vdev_config_dirty(spa->spa_root_vdev); 4274 spa->spa_config_splitting = NULL; 4275 nvlist_free(nvl); 4276 if (error == 0) 4277 dmu_tx_commit(tx); 4278 (void) spa_vdev_exit(spa, NULL, txg, 0); 4279 4280 if (zio_injection_enabled) 4281 zio_handle_panic_injection(spa, FTAG, 3); 4282 4283 /* split is complete; log a history record */ 4284 spa_history_internal_log(LOG_POOL_SPLIT, newspa, NULL, CRED(), 4285 "split new pool %s from pool %s", newname, spa_name(spa)); 4286 4287 kmem_free(vml, children * sizeof (vdev_t *)); 4288 4289 /* if we're not going to mount the filesystems in userland, export */ 4290 if (exp) 4291 error = spa_export_common(newname, POOL_STATE_EXPORTED, NULL, 4292 B_FALSE, B_FALSE); 4293 4294 return (error); 4295 4296 out: 4297 spa_unload(newspa); 4298 spa_deactivate(newspa); 4299 spa_remove(newspa); 4300 4301 txg = spa_vdev_config_enter(spa); 4302 nvlist_free(spa->spa_config_splitting); 4303 spa->spa_config_splitting = NULL; 4304 (void) spa_vdev_exit(spa, NULL, txg, error); 4305 4306 kmem_free(vml, children * sizeof (vdev_t *)); 4307 return (error); 4308 } 4309 4310 static nvlist_t * 4311 spa_nvlist_lookup_by_guid(nvlist_t **nvpp, int count, uint64_t target_guid) 4312 { 4313 for (int i = 0; i < count; i++) { 4314 uint64_t guid; 4315 4316 VERIFY(nvlist_lookup_uint64(nvpp[i], ZPOOL_CONFIG_GUID, 4317 &guid) == 0); 4318 4319 if (guid == target_guid) 4320 return (nvpp[i]); 4321 } 4322 4323 return (NULL); 4324 } 4325 4326 static void 4327 spa_vdev_remove_aux(nvlist_t *config, char *name, nvlist_t **dev, int count, 4328 nvlist_t *dev_to_remove) 4329 { 4330 nvlist_t **newdev = NULL; 4331 4332 if (count > 1) 4333 newdev = kmem_alloc((count - 1) * sizeof (void *), KM_SLEEP); 4334 4335 for (int i = 0, j = 0; i < count; i++) { 4336 if (dev[i] == dev_to_remove) 4337 continue; 4338 VERIFY(nvlist_dup(dev[i], &newdev[j++], KM_SLEEP) == 0); 4339 } 4340 4341 VERIFY(nvlist_remove(config, name, DATA_TYPE_NVLIST_ARRAY) == 0); 4342 VERIFY(nvlist_add_nvlist_array(config, name, newdev, count - 1) == 0); 4343 4344 for (int i = 0; i < count - 1; i++) 4345 nvlist_free(newdev[i]); 4346 4347 if (count > 1) 4348 kmem_free(newdev, (count - 1) * sizeof (void *)); 4349 } 4350 4351 /* 4352 * Removing a device from the vdev namespace requires several steps 4353 * and can take a significant amount of time. As a result we use 4354 * the spa_vdev_config_[enter/exit] functions which allow us to 4355 * grab and release the spa_config_lock while still holding the namespace 4356 * lock. During each step the configuration is synced out. 4357 */ 4358 4359 /* 4360 * Evacuate the device. 4361 */ 4362 int 4363 spa_vdev_remove_evacuate(spa_t *spa, vdev_t *vd) 4364 { 4365 int error = 0; 4366 uint64_t txg; 4367 4368 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 4369 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0); 4370 ASSERT(vd == vd->vdev_top); 4371 4372 /* 4373 * Evacuate the device. We don't hold the config lock as writer 4374 * since we need to do I/O but we do keep the 4375 * spa_namespace_lock held. Once this completes the device 4376 * should no longer have any blocks allocated on it. 4377 */ 4378 if (vd->vdev_islog) { 4379 error = dmu_objset_find(spa_name(spa), zil_vdev_offline, 4380 NULL, DS_FIND_CHILDREN); 4381 } else { 4382 error = ENOTSUP; /* until we have bp rewrite */ 4383 } 4384 4385 txg_wait_synced(spa_get_dsl(spa), 0); 4386 4387 if (error) 4388 return (error); 4389 4390 /* 4391 * The evacuation succeeded. Remove any remaining MOS metadata 4392 * associated with this vdev, and wait for these changes to sync. 4393 */ 4394 txg = spa_vdev_config_enter(spa); 4395 vd->vdev_removing = B_TRUE; 4396 vdev_dirty(vd, 0, NULL, txg); 4397 vdev_config_dirty(vd); 4398 spa_vdev_config_exit(spa, NULL, txg, 0, FTAG); 4399 4400 return (0); 4401 } 4402 4403 /* 4404 * Complete the removal by cleaning up the namespace. 4405 */ 4406 void 4407 spa_vdev_remove_from_namespace(spa_t *spa, vdev_t *vd) 4408 { 4409 vdev_t *rvd = spa->spa_root_vdev; 4410 uint64_t id = vd->vdev_id; 4411 boolean_t last_vdev = (id == (rvd->vdev_children - 1)); 4412 4413 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 4414 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 4415 ASSERT(vd == vd->vdev_top); 4416 4417 (void) vdev_label_init(vd, 0, VDEV_LABEL_REMOVE); 4418 4419 if (list_link_active(&vd->vdev_state_dirty_node)) 4420 vdev_state_clean(vd); 4421 if (list_link_active(&vd->vdev_config_dirty_node)) 4422 vdev_config_clean(vd); 4423 4424 vdev_free(vd); 4425 4426 if (last_vdev) { 4427 vdev_compact_children(rvd); 4428 } else { 4429 vd = vdev_alloc_common(spa, id, 0, &vdev_hole_ops); 4430 vdev_add_child(rvd, vd); 4431 } 4432 vdev_config_dirty(rvd); 4433 4434 /* 4435 * Reassess the health of our root vdev. 4436 */ 4437 vdev_reopen(rvd); 4438 } 4439 4440 /* 4441 * Remove a device from the pool. Currently, this supports removing only hot 4442 * spares, slogs, and level 2 ARC devices. 4443 */ 4444 int 4445 spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare) 4446 { 4447 vdev_t *vd; 4448 metaslab_group_t *mg; 4449 nvlist_t **spares, **l2cache, *nv; 4450 uint64_t txg = 0; 4451 uint_t nspares, nl2cache; 4452 int error = 0; 4453 boolean_t locked = MUTEX_HELD(&spa_namespace_lock); 4454 4455 if (!locked) 4456 txg = spa_vdev_enter(spa); 4457 4458 vd = spa_lookup_by_guid(spa, guid, B_FALSE); 4459 4460 if (spa->spa_spares.sav_vdevs != NULL && 4461 nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, 4462 ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0 && 4463 (nv = spa_nvlist_lookup_by_guid(spares, nspares, guid)) != NULL) { 4464 /* 4465 * Only remove the hot spare if it's not currently in use 4466 * in this pool. 4467 */ 4468 if (vd == NULL || unspare) { 4469 spa_vdev_remove_aux(spa->spa_spares.sav_config, 4470 ZPOOL_CONFIG_SPARES, spares, nspares, nv); 4471 spa_load_spares(spa); 4472 spa->spa_spares.sav_sync = B_TRUE; 4473 } else { 4474 error = EBUSY; 4475 } 4476 } else if (spa->spa_l2cache.sav_vdevs != NULL && 4477 nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config, 4478 ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0 && 4479 (nv = spa_nvlist_lookup_by_guid(l2cache, nl2cache, guid)) != NULL) { 4480 /* 4481 * Cache devices can always be removed. 4482 */ 4483 spa_vdev_remove_aux(spa->spa_l2cache.sav_config, 4484 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache, nv); 4485 spa_load_l2cache(spa); 4486 spa->spa_l2cache.sav_sync = B_TRUE; 4487 } else if (vd != NULL && vd->vdev_islog) { 4488 ASSERT(!locked); 4489 ASSERT(vd == vd->vdev_top); 4490 4491 /* 4492 * XXX - Once we have bp-rewrite this should 4493 * become the common case. 4494 */ 4495 4496 mg = vd->vdev_mg; 4497 4498 /* 4499 * Stop allocating from this vdev. 4500 */ 4501 metaslab_group_passivate(mg); 4502 4503 /* 4504 * Wait for the youngest allocations and frees to sync, 4505 * and then wait for the deferral of those frees to finish. 4506 */ 4507 spa_vdev_config_exit(spa, NULL, 4508 txg + TXG_CONCURRENT_STATES + TXG_DEFER_SIZE, 0, FTAG); 4509 4510 /* 4511 * Attempt to evacuate the vdev. 4512 */ 4513 error = spa_vdev_remove_evacuate(spa, vd); 4514 4515 txg = spa_vdev_config_enter(spa); 4516 4517 /* 4518 * If we couldn't evacuate the vdev, unwind. 4519 */ 4520 if (error) { 4521 metaslab_group_activate(mg); 4522 return (spa_vdev_exit(spa, NULL, txg, error)); 4523 } 4524 4525 /* 4526 * Clean up the vdev namespace. 4527 */ 4528 spa_vdev_remove_from_namespace(spa, vd); 4529 4530 } else if (vd != NULL) { 4531 /* 4532 * Normal vdevs cannot be removed (yet). 4533 */ 4534 error = ENOTSUP; 4535 } else { 4536 /* 4537 * There is no vdev of any kind with the specified guid. 4538 */ 4539 error = ENOENT; 4540 } 4541 4542 if (!locked) 4543 return (spa_vdev_exit(spa, NULL, txg, error)); 4544 4545 return (error); 4546 } 4547 4548 /* 4549 * Find any device that's done replacing, or a vdev marked 'unspare' that's 4550 * current spared, so we can detach it. 4551 */ 4552 static vdev_t * 4553 spa_vdev_resilver_done_hunt(vdev_t *vd) 4554 { 4555 vdev_t *newvd, *oldvd; 4556 4557 for (int c = 0; c < vd->vdev_children; c++) { 4558 oldvd = spa_vdev_resilver_done_hunt(vd->vdev_child[c]); 4559 if (oldvd != NULL) 4560 return (oldvd); 4561 } 4562 4563 /* 4564 * Check for a completed replacement. 4565 */ 4566 if (vd->vdev_ops == &vdev_replacing_ops && vd->vdev_children == 2) { 4567 oldvd = vd->vdev_child[0]; 4568 newvd = vd->vdev_child[1]; 4569 4570 if (vdev_dtl_empty(newvd, DTL_MISSING) && 4571 !vdev_dtl_required(oldvd)) 4572 return (oldvd); 4573 } 4574 4575 /* 4576 * Check for a completed resilver with the 'unspare' flag set. 4577 */ 4578 if (vd->vdev_ops == &vdev_spare_ops && vd->vdev_children == 2) { 4579 newvd = vd->vdev_child[0]; 4580 oldvd = vd->vdev_child[1]; 4581 4582 if (newvd->vdev_unspare && 4583 vdev_dtl_empty(newvd, DTL_MISSING) && 4584 !vdev_dtl_required(oldvd)) { 4585 newvd->vdev_unspare = 0; 4586 return (oldvd); 4587 } 4588 } 4589 4590 return (NULL); 4591 } 4592 4593 static void 4594 spa_vdev_resilver_done(spa_t *spa) 4595 { 4596 vdev_t *vd, *pvd, *ppvd; 4597 uint64_t guid, sguid, pguid, ppguid; 4598 4599 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 4600 4601 while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) { 4602 pvd = vd->vdev_parent; 4603 ppvd = pvd->vdev_parent; 4604 guid = vd->vdev_guid; 4605 pguid = pvd->vdev_guid; 4606 ppguid = ppvd->vdev_guid; 4607 sguid = 0; 4608 /* 4609 * If we have just finished replacing a hot spared device, then 4610 * we need to detach the parent's first child (the original hot 4611 * spare) as well. 4612 */ 4613 if (ppvd->vdev_ops == &vdev_spare_ops && pvd->vdev_id == 0) { 4614 ASSERT(pvd->vdev_ops == &vdev_replacing_ops); 4615 ASSERT(ppvd->vdev_children == 2); 4616 sguid = ppvd->vdev_child[1]->vdev_guid; 4617 } 4618 spa_config_exit(spa, SCL_ALL, FTAG); 4619 if (spa_vdev_detach(spa, guid, pguid, B_TRUE) != 0) 4620 return; 4621 if (sguid && spa_vdev_detach(spa, sguid, ppguid, B_TRUE) != 0) 4622 return; 4623 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 4624 } 4625 4626 spa_config_exit(spa, SCL_ALL, FTAG); 4627 } 4628 4629 /* 4630 * Update the stored path or FRU for this vdev. 4631 */ 4632 int 4633 spa_vdev_set_common(spa_t *spa, uint64_t guid, const char *value, 4634 boolean_t ispath) 4635 { 4636 vdev_t *vd; 4637 boolean_t sync = B_FALSE; 4638 4639 spa_vdev_state_enter(spa, SCL_ALL); 4640 4641 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) 4642 return (spa_vdev_state_exit(spa, NULL, ENOENT)); 4643 4644 if (!vd->vdev_ops->vdev_op_leaf) 4645 return (spa_vdev_state_exit(spa, NULL, ENOTSUP)); 4646 4647 if (ispath) { 4648 if (strcmp(value, vd->vdev_path) != 0) { 4649 spa_strfree(vd->vdev_path); 4650 vd->vdev_path = spa_strdup(value); 4651 sync = B_TRUE; 4652 } 4653 } else { 4654 if (vd->vdev_fru == NULL) { 4655 vd->vdev_fru = spa_strdup(value); 4656 sync = B_TRUE; 4657 } else if (strcmp(value, vd->vdev_fru) != 0) { 4658 spa_strfree(vd->vdev_fru); 4659 vd->vdev_fru = spa_strdup(value); 4660 sync = B_TRUE; 4661 } 4662 } 4663 4664 return (spa_vdev_state_exit(spa, sync ? vd : NULL, 0)); 4665 } 4666 4667 int 4668 spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath) 4669 { 4670 return (spa_vdev_set_common(spa, guid, newpath, B_TRUE)); 4671 } 4672 4673 int 4674 spa_vdev_setfru(spa_t *spa, uint64_t guid, const char *newfru) 4675 { 4676 return (spa_vdev_set_common(spa, guid, newfru, B_FALSE)); 4677 } 4678 4679 /* 4680 * ========================================================================== 4681 * SPA Scrubbing 4682 * ========================================================================== 4683 */ 4684 4685 int 4686 spa_scrub(spa_t *spa, pool_scrub_type_t type) 4687 { 4688 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0); 4689 4690 if ((uint_t)type >= POOL_SCRUB_TYPES) 4691 return (ENOTSUP); 4692 4693 /* 4694 * If a resilver was requested, but there is no DTL on a 4695 * writeable leaf device, we have nothing to do. 4696 */ 4697 if (type == POOL_SCRUB_RESILVER && 4698 !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) { 4699 spa_async_request(spa, SPA_ASYNC_RESILVER_DONE); 4700 return (0); 4701 } 4702 4703 if (type == POOL_SCRUB_EVERYTHING && 4704 spa->spa_dsl_pool->dp_scrub_func != SCRUB_FUNC_NONE && 4705 spa->spa_dsl_pool->dp_scrub_isresilver) 4706 return (EBUSY); 4707 4708 if (type == POOL_SCRUB_EVERYTHING || type == POOL_SCRUB_RESILVER) { 4709 return (dsl_pool_scrub_clean(spa->spa_dsl_pool)); 4710 } else if (type == POOL_SCRUB_NONE) { 4711 return (dsl_pool_scrub_cancel(spa->spa_dsl_pool)); 4712 } else { 4713 return (EINVAL); 4714 } 4715 } 4716 4717 /* 4718 * ========================================================================== 4719 * SPA async task processing 4720 * ========================================================================== 4721 */ 4722 4723 static void 4724 spa_async_remove(spa_t *spa, vdev_t *vd) 4725 { 4726 if (vd->vdev_remove_wanted) { 4727 vd->vdev_remove_wanted = 0; 4728 vdev_set_state(vd, B_FALSE, VDEV_STATE_REMOVED, VDEV_AUX_NONE); 4729 4730 /* 4731 * We want to clear the stats, but we don't want to do a full 4732 * vdev_clear() as that will cause us to throw away 4733 * degraded/faulted state as well as attempt to reopen the 4734 * device, all of which is a waste. 4735 */ 4736 vd->vdev_stat.vs_read_errors = 0; 4737 vd->vdev_stat.vs_write_errors = 0; 4738 vd->vdev_stat.vs_checksum_errors = 0; 4739 4740 vdev_state_dirty(vd->vdev_top); 4741 } 4742 4743 for (int c = 0; c < vd->vdev_children; c++) 4744 spa_async_remove(spa, vd->vdev_child[c]); 4745 } 4746 4747 static void 4748 spa_async_probe(spa_t *spa, vdev_t *vd) 4749 { 4750 if (vd->vdev_probe_wanted) { 4751 vd->vdev_probe_wanted = 0; 4752 vdev_reopen(vd); /* vdev_open() does the actual probe */ 4753 } 4754 4755 for (int c = 0; c < vd->vdev_children; c++) 4756 spa_async_probe(spa, vd->vdev_child[c]); 4757 } 4758 4759 static void 4760 spa_async_autoexpand(spa_t *spa, vdev_t *vd) 4761 { 4762 sysevent_id_t eid; 4763 nvlist_t *attr; 4764 char *physpath; 4765 4766 if (!spa->spa_autoexpand) 4767 return; 4768 4769 for (int c = 0; c < vd->vdev_children; c++) { 4770 vdev_t *cvd = vd->vdev_child[c]; 4771 spa_async_autoexpand(spa, cvd); 4772 } 4773 4774 if (!vd->vdev_ops->vdev_op_leaf || vd->vdev_physpath == NULL) 4775 return; 4776 4777 physpath = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 4778 (void) snprintf(physpath, MAXPATHLEN, "/devices%s", vd->vdev_physpath); 4779 4780 VERIFY(nvlist_alloc(&attr, NV_UNIQUE_NAME, KM_SLEEP) == 0); 4781 VERIFY(nvlist_add_string(attr, DEV_PHYS_PATH, physpath) == 0); 4782 4783 (void) ddi_log_sysevent(zfs_dip, SUNW_VENDOR, EC_DEV_STATUS, 4784 ESC_DEV_DLE, attr, &eid, DDI_SLEEP); 4785 4786 nvlist_free(attr); 4787 kmem_free(physpath, MAXPATHLEN); 4788 } 4789 4790 static void 4791 spa_async_thread(spa_t *spa) 4792 { 4793 int tasks; 4794 4795 ASSERT(spa->spa_sync_on); 4796 4797 mutex_enter(&spa->spa_async_lock); 4798 tasks = spa->spa_async_tasks; 4799 spa->spa_async_tasks = 0; 4800 mutex_exit(&spa->spa_async_lock); 4801 4802 /* 4803 * See if the config needs to be updated. 4804 */ 4805 if (tasks & SPA_ASYNC_CONFIG_UPDATE) { 4806 uint64_t old_space, new_space; 4807 4808 mutex_enter(&spa_namespace_lock); 4809 old_space = metaslab_class_get_space(spa_normal_class(spa)); 4810 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 4811 new_space = metaslab_class_get_space(spa_normal_class(spa)); 4812 mutex_exit(&spa_namespace_lock); 4813 4814 /* 4815 * If the pool grew as a result of the config update, 4816 * then log an internal history event. 4817 */ 4818 if (new_space != old_space) { 4819 spa_history_internal_log(LOG_POOL_VDEV_ONLINE, 4820 spa, NULL, CRED(), 4821 "pool '%s' size: %llu(+%llu)", 4822 spa_name(spa), new_space, new_space - old_space); 4823 } 4824 } 4825 4826 /* 4827 * See if any devices need to be marked REMOVED. 4828 */ 4829 if (tasks & SPA_ASYNC_REMOVE) { 4830 spa_vdev_state_enter(spa, SCL_NONE); 4831 spa_async_remove(spa, spa->spa_root_vdev); 4832 for (int i = 0; i < spa->spa_l2cache.sav_count; i++) 4833 spa_async_remove(spa, spa->spa_l2cache.sav_vdevs[i]); 4834 for (int i = 0; i < spa->spa_spares.sav_count; i++) 4835 spa_async_remove(spa, spa->spa_spares.sav_vdevs[i]); 4836 (void) spa_vdev_state_exit(spa, NULL, 0); 4837 } 4838 4839 if ((tasks & SPA_ASYNC_AUTOEXPAND) && !spa_suspended(spa)) { 4840 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 4841 spa_async_autoexpand(spa, spa->spa_root_vdev); 4842 spa_config_exit(spa, SCL_CONFIG, FTAG); 4843 } 4844 4845 /* 4846 * See if any devices need to be probed. 4847 */ 4848 if (tasks & SPA_ASYNC_PROBE) { 4849 spa_vdev_state_enter(spa, SCL_NONE); 4850 spa_async_probe(spa, spa->spa_root_vdev); 4851 (void) spa_vdev_state_exit(spa, NULL, 0); 4852 } 4853 4854 /* 4855 * If any devices are done replacing, detach them. 4856 */ 4857 if (tasks & SPA_ASYNC_RESILVER_DONE) 4858 spa_vdev_resilver_done(spa); 4859 4860 /* 4861 * Kick off a resilver. 4862 */ 4863 if (tasks & SPA_ASYNC_RESILVER) 4864 VERIFY(spa_scrub(spa, POOL_SCRUB_RESILVER) == 0); 4865 4866 /* 4867 * Let the world know that we're done. 4868 */ 4869 mutex_enter(&spa->spa_async_lock); 4870 spa->spa_async_thread = NULL; 4871 cv_broadcast(&spa->spa_async_cv); 4872 mutex_exit(&spa->spa_async_lock); 4873 thread_exit(); 4874 } 4875 4876 void 4877 spa_async_suspend(spa_t *spa) 4878 { 4879 mutex_enter(&spa->spa_async_lock); 4880 spa->spa_async_suspended++; 4881 while (spa->spa_async_thread != NULL) 4882 cv_wait(&spa->spa_async_cv, &spa->spa_async_lock); 4883 mutex_exit(&spa->spa_async_lock); 4884 } 4885 4886 void 4887 spa_async_resume(spa_t *spa) 4888 { 4889 mutex_enter(&spa->spa_async_lock); 4890 ASSERT(spa->spa_async_suspended != 0); 4891 spa->spa_async_suspended--; 4892 mutex_exit(&spa->spa_async_lock); 4893 } 4894 4895 static void 4896 spa_async_dispatch(spa_t *spa) 4897 { 4898 mutex_enter(&spa->spa_async_lock); 4899 if (spa->spa_async_tasks && !spa->spa_async_suspended && 4900 spa->spa_async_thread == NULL && 4901 rootdir != NULL && !vn_is_readonly(rootdir)) 4902 spa->spa_async_thread = thread_create(NULL, 0, 4903 spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri); 4904 mutex_exit(&spa->spa_async_lock); 4905 } 4906 4907 void 4908 spa_async_request(spa_t *spa, int task) 4909 { 4910 mutex_enter(&spa->spa_async_lock); 4911 spa->spa_async_tasks |= task; 4912 mutex_exit(&spa->spa_async_lock); 4913 } 4914 4915 /* 4916 * ========================================================================== 4917 * SPA syncing routines 4918 * ========================================================================== 4919 */ 4920 static void 4921 spa_sync_deferred_bplist(spa_t *spa, bplist_t *bpl, dmu_tx_t *tx, uint64_t txg) 4922 { 4923 blkptr_t blk; 4924 uint64_t itor = 0; 4925 uint8_t c = 1; 4926 4927 while (bplist_iterate(bpl, &itor, &blk) == 0) { 4928 ASSERT(blk.blk_birth < txg); 4929 zio_free(spa, txg, &blk); 4930 } 4931 4932 bplist_vacate(bpl, tx); 4933 4934 /* 4935 * Pre-dirty the first block so we sync to convergence faster. 4936 * (Usually only the first block is needed.) 4937 */ 4938 dmu_write(bpl->bpl_mos, spa->spa_deferred_bplist_obj, 0, 1, &c, tx); 4939 } 4940 4941 static void 4942 spa_sync_free(void *arg, const blkptr_t *bp, dmu_tx_t *tx) 4943 { 4944 zio_t *zio = arg; 4945 4946 zio_nowait(zio_free_sync(zio, zio->io_spa, dmu_tx_get_txg(tx), bp, 4947 zio->io_flags)); 4948 } 4949 4950 static void 4951 spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx) 4952 { 4953 char *packed = NULL; 4954 size_t bufsize; 4955 size_t nvsize = 0; 4956 dmu_buf_t *db; 4957 4958 VERIFY(nvlist_size(nv, &nvsize, NV_ENCODE_XDR) == 0); 4959 4960 /* 4961 * Write full (SPA_CONFIG_BLOCKSIZE) blocks of configuration 4962 * information. This avoids the dbuf_will_dirty() path and 4963 * saves us a pre-read to get data we don't actually care about. 4964 */ 4965 bufsize = P2ROUNDUP(nvsize, SPA_CONFIG_BLOCKSIZE); 4966 packed = kmem_alloc(bufsize, KM_SLEEP); 4967 4968 VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR, 4969 KM_SLEEP) == 0); 4970 bzero(packed + nvsize, bufsize - nvsize); 4971 4972 dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx); 4973 4974 kmem_free(packed, bufsize); 4975 4976 VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db)); 4977 dmu_buf_will_dirty(db, tx); 4978 *(uint64_t *)db->db_data = nvsize; 4979 dmu_buf_rele(db, FTAG); 4980 } 4981 4982 static void 4983 spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx, 4984 const char *config, const char *entry) 4985 { 4986 nvlist_t *nvroot; 4987 nvlist_t **list; 4988 int i; 4989 4990 if (!sav->sav_sync) 4991 return; 4992 4993 /* 4994 * Update the MOS nvlist describing the list of available devices. 4995 * spa_validate_aux() will have already made sure this nvlist is 4996 * valid and the vdevs are labeled appropriately. 4997 */ 4998 if (sav->sav_object == 0) { 4999 sav->sav_object = dmu_object_alloc(spa->spa_meta_objset, 5000 DMU_OT_PACKED_NVLIST, 1 << 14, DMU_OT_PACKED_NVLIST_SIZE, 5001 sizeof (uint64_t), tx); 5002 VERIFY(zap_update(spa->spa_meta_objset, 5003 DMU_POOL_DIRECTORY_OBJECT, entry, sizeof (uint64_t), 1, 5004 &sav->sav_object, tx) == 0); 5005 } 5006 5007 VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0); 5008 if (sav->sav_count == 0) { 5009 VERIFY(nvlist_add_nvlist_array(nvroot, config, NULL, 0) == 0); 5010 } else { 5011 list = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP); 5012 for (i = 0; i < sav->sav_count; i++) 5013 list[i] = vdev_config_generate(spa, sav->sav_vdevs[i], 5014 B_FALSE, B_FALSE, B_TRUE); 5015 VERIFY(nvlist_add_nvlist_array(nvroot, config, list, 5016 sav->sav_count) == 0); 5017 for (i = 0; i < sav->sav_count; i++) 5018 nvlist_free(list[i]); 5019 kmem_free(list, sav->sav_count * sizeof (void *)); 5020 } 5021 5022 spa_sync_nvlist(spa, sav->sav_object, nvroot, tx); 5023 nvlist_free(nvroot); 5024 5025 sav->sav_sync = B_FALSE; 5026 } 5027 5028 static void 5029 spa_sync_config_object(spa_t *spa, dmu_tx_t *tx) 5030 { 5031 nvlist_t *config; 5032 5033 if (list_is_empty(&spa->spa_config_dirty_list)) 5034 return; 5035 5036 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 5037 5038 config = spa_config_generate(spa, spa->spa_root_vdev, 5039 dmu_tx_get_txg(tx), B_FALSE); 5040 5041 spa_config_exit(spa, SCL_STATE, FTAG); 5042 5043 if (spa->spa_config_syncing) 5044 nvlist_free(spa->spa_config_syncing); 5045 spa->spa_config_syncing = config; 5046 5047 spa_sync_nvlist(spa, spa->spa_config_object, config, tx); 5048 } 5049 5050 /* 5051 * Set zpool properties. 5052 */ 5053 static void 5054 spa_sync_props(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) 5055 { 5056 spa_t *spa = arg1; 5057 objset_t *mos = spa->spa_meta_objset; 5058 nvlist_t *nvp = arg2; 5059 nvpair_t *elem; 5060 uint64_t intval; 5061 char *strval; 5062 zpool_prop_t prop; 5063 const char *propname; 5064 zprop_type_t proptype; 5065 5066 mutex_enter(&spa->spa_props_lock); 5067 5068 elem = NULL; 5069 while ((elem = nvlist_next_nvpair(nvp, elem))) { 5070 switch (prop = zpool_name_to_prop(nvpair_name(elem))) { 5071 case ZPOOL_PROP_VERSION: 5072 /* 5073 * Only set version for non-zpool-creation cases 5074 * (set/import). spa_create() needs special care 5075 * for version setting. 5076 */ 5077 if (tx->tx_txg != TXG_INITIAL) { 5078 VERIFY(nvpair_value_uint64(elem, 5079 &intval) == 0); 5080 ASSERT(intval <= SPA_VERSION); 5081 ASSERT(intval >= spa_version(spa)); 5082 spa->spa_uberblock.ub_version = intval; 5083 vdev_config_dirty(spa->spa_root_vdev); 5084 } 5085 break; 5086 5087 case ZPOOL_PROP_ALTROOT: 5088 /* 5089 * 'altroot' is a non-persistent property. It should 5090 * have been set temporarily at creation or import time. 5091 */ 5092 ASSERT(spa->spa_root != NULL); 5093 break; 5094 5095 case ZPOOL_PROP_CACHEFILE: 5096 /* 5097 * 'cachefile' is also a non-persisitent property. 5098 */ 5099 break; 5100 default: 5101 /* 5102 * Set pool property values in the poolprops mos object. 5103 */ 5104 if (spa->spa_pool_props_object == 0) { 5105 VERIFY((spa->spa_pool_props_object = 5106 zap_create(mos, DMU_OT_POOL_PROPS, 5107 DMU_OT_NONE, 0, tx)) > 0); 5108 5109 VERIFY(zap_update(mos, 5110 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_PROPS, 5111 8, 1, &spa->spa_pool_props_object, tx) 5112 == 0); 5113 } 5114 5115 /* normalize the property name */ 5116 propname = zpool_prop_to_name(prop); 5117 proptype = zpool_prop_get_type(prop); 5118 5119 if (nvpair_type(elem) == DATA_TYPE_STRING) { 5120 ASSERT(proptype == PROP_TYPE_STRING); 5121 VERIFY(nvpair_value_string(elem, &strval) == 0); 5122 VERIFY(zap_update(mos, 5123 spa->spa_pool_props_object, propname, 5124 1, strlen(strval) + 1, strval, tx) == 0); 5125 5126 } else if (nvpair_type(elem) == DATA_TYPE_UINT64) { 5127 VERIFY(nvpair_value_uint64(elem, &intval) == 0); 5128 5129 if (proptype == PROP_TYPE_INDEX) { 5130 const char *unused; 5131 VERIFY(zpool_prop_index_to_string( 5132 prop, intval, &unused) == 0); 5133 } 5134 VERIFY(zap_update(mos, 5135 spa->spa_pool_props_object, propname, 5136 8, 1, &intval, tx) == 0); 5137 } else { 5138 ASSERT(0); /* not allowed */ 5139 } 5140 5141 switch (prop) { 5142 case ZPOOL_PROP_DELEGATION: 5143 spa->spa_delegation = intval; 5144 break; 5145 case ZPOOL_PROP_BOOTFS: 5146 spa->spa_bootfs = intval; 5147 break; 5148 case ZPOOL_PROP_FAILUREMODE: 5149 spa->spa_failmode = intval; 5150 break; 5151 case ZPOOL_PROP_AUTOEXPAND: 5152 spa->spa_autoexpand = intval; 5153 spa_async_request(spa, SPA_ASYNC_AUTOEXPAND); 5154 break; 5155 case ZPOOL_PROP_DEDUPDITTO: 5156 spa->spa_dedup_ditto = intval; 5157 break; 5158 default: 5159 break; 5160 } 5161 } 5162 5163 /* log internal history if this is not a zpool create */ 5164 if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY && 5165 tx->tx_txg != TXG_INITIAL) { 5166 spa_history_internal_log(LOG_POOL_PROPSET, 5167 spa, tx, cr, "%s %lld %s", 5168 nvpair_name(elem), intval, spa_name(spa)); 5169 } 5170 } 5171 5172 mutex_exit(&spa->spa_props_lock); 5173 } 5174 5175 /* 5176 * Sync the specified transaction group. New blocks may be dirtied as 5177 * part of the process, so we iterate until it converges. 5178 */ 5179 void 5180 spa_sync(spa_t *spa, uint64_t txg) 5181 { 5182 dsl_pool_t *dp = spa->spa_dsl_pool; 5183 objset_t *mos = spa->spa_meta_objset; 5184 bplist_t *defer_bpl = &spa->spa_deferred_bplist; 5185 bplist_t *free_bpl = &spa->spa_free_bplist[txg & TXG_MASK]; 5186 vdev_t *rvd = spa->spa_root_vdev; 5187 vdev_t *vd; 5188 dmu_tx_t *tx; 5189 int error; 5190 5191 /* 5192 * Lock out configuration changes. 5193 */ 5194 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 5195 5196 spa->spa_syncing_txg = txg; 5197 spa->spa_sync_pass = 0; 5198 5199 /* 5200 * If there are any pending vdev state changes, convert them 5201 * into config changes that go out with this transaction group. 5202 */ 5203 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 5204 while (list_head(&spa->spa_state_dirty_list) != NULL) { 5205 /* 5206 * We need the write lock here because, for aux vdevs, 5207 * calling vdev_config_dirty() modifies sav_config. 5208 * This is ugly and will become unnecessary when we 5209 * eliminate the aux vdev wart by integrating all vdevs 5210 * into the root vdev tree. 5211 */ 5212 spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 5213 spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_WRITER); 5214 while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) { 5215 vdev_state_clean(vd); 5216 vdev_config_dirty(vd); 5217 } 5218 spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 5219 spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER); 5220 } 5221 spa_config_exit(spa, SCL_STATE, FTAG); 5222 5223 VERIFY(0 == bplist_open(defer_bpl, mos, spa->spa_deferred_bplist_obj)); 5224 5225 tx = dmu_tx_create_assigned(dp, txg); 5226 5227 /* 5228 * If we are upgrading to SPA_VERSION_RAIDZ_DEFLATE this txg, 5229 * set spa_deflate if we have no raid-z vdevs. 5230 */ 5231 if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE && 5232 spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) { 5233 int i; 5234 5235 for (i = 0; i < rvd->vdev_children; i++) { 5236 vd = rvd->vdev_child[i]; 5237 if (vd->vdev_deflate_ratio != SPA_MINBLOCKSIZE) 5238 break; 5239 } 5240 if (i == rvd->vdev_children) { 5241 spa->spa_deflate = TRUE; 5242 VERIFY(0 == zap_add(spa->spa_meta_objset, 5243 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE, 5244 sizeof (uint64_t), 1, &spa->spa_deflate, tx)); 5245 } 5246 } 5247 5248 if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN && 5249 spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) { 5250 dsl_pool_create_origin(dp, tx); 5251 5252 /* Keeping the origin open increases spa_minref */ 5253 spa->spa_minref += 3; 5254 } 5255 5256 if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES && 5257 spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) { 5258 dsl_pool_upgrade_clones(dp, tx); 5259 } 5260 5261 /* 5262 * If anything has changed in this txg, push the deferred frees 5263 * from the previous txg. If not, leave them alone so that we 5264 * don't generate work on an otherwise idle system. 5265 */ 5266 if (!txg_list_empty(&dp->dp_dirty_datasets, txg) || 5267 !txg_list_empty(&dp->dp_dirty_dirs, txg) || 5268 !txg_list_empty(&dp->dp_sync_tasks, txg)) 5269 spa_sync_deferred_bplist(spa, defer_bpl, tx, txg); 5270 5271 /* 5272 * Iterate to convergence. 5273 */ 5274 do { 5275 int pass = ++spa->spa_sync_pass; 5276 5277 spa_sync_config_object(spa, tx); 5278 spa_sync_aux_dev(spa, &spa->spa_spares, tx, 5279 ZPOOL_CONFIG_SPARES, DMU_POOL_SPARES); 5280 spa_sync_aux_dev(spa, &spa->spa_l2cache, tx, 5281 ZPOOL_CONFIG_L2CACHE, DMU_POOL_L2CACHE); 5282 spa_errlog_sync(spa, txg); 5283 dsl_pool_sync(dp, txg); 5284 5285 if (pass <= SYNC_PASS_DEFERRED_FREE) { 5286 zio_t *zio = zio_root(spa, NULL, NULL, 0); 5287 bplist_sync(free_bpl, spa_sync_free, zio, tx); 5288 VERIFY(zio_wait(zio) == 0); 5289 } else { 5290 bplist_sync(free_bpl, bplist_enqueue_cb, defer_bpl, tx); 5291 } 5292 5293 ddt_sync(spa, txg); 5294 5295 mutex_enter(&spa->spa_scrub_lock); 5296 while (spa->spa_scrub_inflight > 0) 5297 cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock); 5298 mutex_exit(&spa->spa_scrub_lock); 5299 5300 while (vd = txg_list_remove(&spa->spa_vdev_txg_list, txg)) 5301 vdev_sync(vd, txg); 5302 5303 } while (dmu_objset_is_dirty(mos, txg)); 5304 5305 ASSERT(free_bpl->bpl_queue == NULL); 5306 5307 bplist_close(defer_bpl); 5308 5309 /* 5310 * Rewrite the vdev configuration (which includes the uberblock) 5311 * to commit the transaction group. 5312 * 5313 * If there are no dirty vdevs, we sync the uberblock to a few 5314 * random top-level vdevs that are known to be visible in the 5315 * config cache (see spa_vdev_add() for a complete description). 5316 * If there *are* dirty vdevs, sync the uberblock to all vdevs. 5317 */ 5318 for (;;) { 5319 /* 5320 * We hold SCL_STATE to prevent vdev open/close/etc. 5321 * while we're attempting to write the vdev labels. 5322 */ 5323 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 5324 5325 if (list_is_empty(&spa->spa_config_dirty_list)) { 5326 vdev_t *svd[SPA_DVAS_PER_BP]; 5327 int svdcount = 0; 5328 int children = rvd->vdev_children; 5329 int c0 = spa_get_random(children); 5330 5331 for (int c = 0; c < children; c++) { 5332 vd = rvd->vdev_child[(c0 + c) % children]; 5333 if (vd->vdev_ms_array == 0 || vd->vdev_islog) 5334 continue; 5335 svd[svdcount++] = vd; 5336 if (svdcount == SPA_DVAS_PER_BP) 5337 break; 5338 } 5339 error = vdev_config_sync(svd, svdcount, txg, B_FALSE); 5340 if (error != 0) 5341 error = vdev_config_sync(svd, svdcount, txg, 5342 B_TRUE); 5343 } else { 5344 error = vdev_config_sync(rvd->vdev_child, 5345 rvd->vdev_children, txg, B_FALSE); 5346 if (error != 0) 5347 error = vdev_config_sync(rvd->vdev_child, 5348 rvd->vdev_children, txg, B_TRUE); 5349 } 5350 5351 spa_config_exit(spa, SCL_STATE, FTAG); 5352 5353 if (error == 0) 5354 break; 5355 zio_suspend(spa, NULL); 5356 zio_resume_wait(spa); 5357 } 5358 dmu_tx_commit(tx); 5359 5360 /* 5361 * Clear the dirty config list. 5362 */ 5363 while ((vd = list_head(&spa->spa_config_dirty_list)) != NULL) 5364 vdev_config_clean(vd); 5365 5366 /* 5367 * Now that the new config has synced transactionally, 5368 * let it become visible to the config cache. 5369 */ 5370 if (spa->spa_config_syncing != NULL) { 5371 spa_config_set(spa, spa->spa_config_syncing); 5372 spa->spa_config_txg = txg; 5373 spa->spa_config_syncing = NULL; 5374 } 5375 5376 spa->spa_ubsync = spa->spa_uberblock; 5377 5378 dsl_pool_sync_done(dp, txg); 5379 5380 /* 5381 * Update usable space statistics. 5382 */ 5383 while (vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg))) 5384 vdev_sync_done(vd, txg); 5385 5386 spa_update_dspace(spa); 5387 5388 /* 5389 * It had better be the case that we didn't dirty anything 5390 * since vdev_config_sync(). 5391 */ 5392 ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg)); 5393 ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg)); 5394 ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg)); 5395 ASSERT(defer_bpl->bpl_queue == NULL); 5396 ASSERT(free_bpl->bpl_queue == NULL); 5397 5398 spa->spa_sync_pass = 0; 5399 5400 spa_config_exit(spa, SCL_CONFIG, FTAG); 5401 5402 spa_handle_ignored_writes(spa); 5403 5404 /* 5405 * If any async tasks have been requested, kick them off. 5406 */ 5407 spa_async_dispatch(spa); 5408 } 5409 5410 /* 5411 * Sync all pools. We don't want to hold the namespace lock across these 5412 * operations, so we take a reference on the spa_t and drop the lock during the 5413 * sync. 5414 */ 5415 void 5416 spa_sync_allpools(void) 5417 { 5418 spa_t *spa = NULL; 5419 mutex_enter(&spa_namespace_lock); 5420 while ((spa = spa_next(spa)) != NULL) { 5421 if (spa_state(spa) != POOL_STATE_ACTIVE || spa_suspended(spa)) 5422 continue; 5423 spa_open_ref(spa, FTAG); 5424 mutex_exit(&spa_namespace_lock); 5425 txg_wait_synced(spa_get_dsl(spa), 0); 5426 mutex_enter(&spa_namespace_lock); 5427 spa_close(spa, FTAG); 5428 } 5429 mutex_exit(&spa_namespace_lock); 5430 } 5431 5432 /* 5433 * ========================================================================== 5434 * Miscellaneous routines 5435 * ========================================================================== 5436 */ 5437 5438 /* 5439 * Remove all pools in the system. 5440 */ 5441 void 5442 spa_evict_all(void) 5443 { 5444 spa_t *spa; 5445 5446 /* 5447 * Remove all cached state. All pools should be closed now, 5448 * so every spa in the AVL tree should be unreferenced. 5449 */ 5450 mutex_enter(&spa_namespace_lock); 5451 while ((spa = spa_next(NULL)) != NULL) { 5452 /* 5453 * Stop async tasks. The async thread may need to detach 5454 * a device that's been replaced, which requires grabbing 5455 * spa_namespace_lock, so we must drop it here. 5456 */ 5457 spa_open_ref(spa, FTAG); 5458 mutex_exit(&spa_namespace_lock); 5459 spa_async_suspend(spa); 5460 mutex_enter(&spa_namespace_lock); 5461 spa_close(spa, FTAG); 5462 5463 if (spa->spa_state != POOL_STATE_UNINITIALIZED) { 5464 spa_unload(spa); 5465 spa_deactivate(spa); 5466 } 5467 spa_remove(spa); 5468 } 5469 mutex_exit(&spa_namespace_lock); 5470 } 5471 5472 vdev_t * 5473 spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t aux) 5474 { 5475 vdev_t *vd; 5476 int i; 5477 5478 if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL) 5479 return (vd); 5480 5481 if (aux) { 5482 for (i = 0; i < spa->spa_l2cache.sav_count; i++) { 5483 vd = spa->spa_l2cache.sav_vdevs[i]; 5484 if (vd->vdev_guid == guid) 5485 return (vd); 5486 } 5487 5488 for (i = 0; i < spa->spa_spares.sav_count; i++) { 5489 vd = spa->spa_spares.sav_vdevs[i]; 5490 if (vd->vdev_guid == guid) 5491 return (vd); 5492 } 5493 } 5494 5495 return (NULL); 5496 } 5497 5498 void 5499 spa_upgrade(spa_t *spa, uint64_t version) 5500 { 5501 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 5502 5503 /* 5504 * This should only be called for a non-faulted pool, and since a 5505 * future version would result in an unopenable pool, this shouldn't be 5506 * possible. 5507 */ 5508 ASSERT(spa->spa_uberblock.ub_version <= SPA_VERSION); 5509 ASSERT(version >= spa->spa_uberblock.ub_version); 5510 5511 spa->spa_uberblock.ub_version = version; 5512 vdev_config_dirty(spa->spa_root_vdev); 5513 5514 spa_config_exit(spa, SCL_ALL, FTAG); 5515 5516 txg_wait_synced(spa_get_dsl(spa), 0); 5517 } 5518 5519 boolean_t 5520 spa_has_spare(spa_t *spa, uint64_t guid) 5521 { 5522 int i; 5523 uint64_t spareguid; 5524 spa_aux_vdev_t *sav = &spa->spa_spares; 5525 5526 for (i = 0; i < sav->sav_count; i++) 5527 if (sav->sav_vdevs[i]->vdev_guid == guid) 5528 return (B_TRUE); 5529 5530 for (i = 0; i < sav->sav_npending; i++) { 5531 if (nvlist_lookup_uint64(sav->sav_pending[i], ZPOOL_CONFIG_GUID, 5532 &spareguid) == 0 && spareguid == guid) 5533 return (B_TRUE); 5534 } 5535 5536 return (B_FALSE); 5537 } 5538 5539 /* 5540 * Check if a pool has an active shared spare device. 5541 * Note: reference count of an active spare is 2, as a spare and as a replace 5542 */ 5543 static boolean_t 5544 spa_has_active_shared_spare(spa_t *spa) 5545 { 5546 int i, refcnt; 5547 uint64_t pool; 5548 spa_aux_vdev_t *sav = &spa->spa_spares; 5549 5550 for (i = 0; i < sav->sav_count; i++) { 5551 if (spa_spare_exists(sav->sav_vdevs[i]->vdev_guid, &pool, 5552 &refcnt) && pool != 0ULL && pool == spa_guid(spa) && 5553 refcnt > 2) 5554 return (B_TRUE); 5555 } 5556 5557 return (B_FALSE); 5558 } 5559 5560 /* 5561 * Post a sysevent corresponding to the given event. The 'name' must be one of 5562 * the event definitions in sys/sysevent/eventdefs.h. The payload will be 5563 * filled in from the spa and (optionally) the vdev. This doesn't do anything 5564 * in the userland libzpool, as we don't want consumers to misinterpret ztest 5565 * or zdb as real changes. 5566 */ 5567 void 5568 spa_event_notify(spa_t *spa, vdev_t *vd, const char *name) 5569 { 5570 #ifdef _KERNEL 5571 sysevent_t *ev; 5572 sysevent_attr_list_t *attr = NULL; 5573 sysevent_value_t value; 5574 sysevent_id_t eid; 5575 5576 ev = sysevent_alloc(EC_ZFS, (char *)name, SUNW_KERN_PUB "zfs", 5577 SE_SLEEP); 5578 5579 value.value_type = SE_DATA_TYPE_STRING; 5580 value.value.sv_string = spa_name(spa); 5581 if (sysevent_add_attr(&attr, ZFS_EV_POOL_NAME, &value, SE_SLEEP) != 0) 5582 goto done; 5583 5584 value.value_type = SE_DATA_TYPE_UINT64; 5585 value.value.sv_uint64 = spa_guid(spa); 5586 if (sysevent_add_attr(&attr, ZFS_EV_POOL_GUID, &value, SE_SLEEP) != 0) 5587 goto done; 5588 5589 if (vd) { 5590 value.value_type = SE_DATA_TYPE_UINT64; 5591 value.value.sv_uint64 = vd->vdev_guid; 5592 if (sysevent_add_attr(&attr, ZFS_EV_VDEV_GUID, &value, 5593 SE_SLEEP) != 0) 5594 goto done; 5595 5596 if (vd->vdev_path) { 5597 value.value_type = SE_DATA_TYPE_STRING; 5598 value.value.sv_string = vd->vdev_path; 5599 if (sysevent_add_attr(&attr, ZFS_EV_VDEV_PATH, 5600 &value, SE_SLEEP) != 0) 5601 goto done; 5602 } 5603 } 5604 5605 if (sysevent_attach_attributes(ev, attr) != 0) 5606 goto done; 5607 attr = NULL; 5608 5609 (void) log_sysevent(ev, SE_SLEEP, &eid); 5610 5611 done: 5612 if (attr) 5613 sysevent_free_attr(attr); 5614 sysevent_free(ev); 5615 #endif 5616 } 5617