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