1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #include <sys/zfs_context.h> 28 #include <sys/fm/fs/zfs.h> 29 #include <sys/spa.h> 30 #include <sys/spa_impl.h> 31 #include <sys/dmu.h> 32 #include <sys/dmu_tx.h> 33 #include <sys/vdev_impl.h> 34 #include <sys/uberblock_impl.h> 35 #include <sys/metaslab.h> 36 #include <sys/metaslab_impl.h> 37 #include <sys/space_map.h> 38 #include <sys/zio.h> 39 #include <sys/zap.h> 40 #include <sys/fs/zfs.h> 41 #include <sys/arc.h> 42 #include <sys/zil.h> 43 44 /* 45 * Virtual device management. 46 */ 47 48 static vdev_ops_t *vdev_ops_table[] = { 49 &vdev_root_ops, 50 &vdev_raidz_ops, 51 &vdev_mirror_ops, 52 &vdev_replacing_ops, 53 &vdev_spare_ops, 54 &vdev_disk_ops, 55 &vdev_file_ops, 56 &vdev_missing_ops, 57 &vdev_hole_ops, 58 NULL 59 }; 60 61 /* maximum scrub/resilver I/O queue per leaf vdev */ 62 int zfs_scrub_limit = 10; 63 64 /* 65 * Given a vdev type, return the appropriate ops vector. 66 */ 67 static vdev_ops_t * 68 vdev_getops(const char *type) 69 { 70 vdev_ops_t *ops, **opspp; 71 72 for (opspp = vdev_ops_table; (ops = *opspp) != NULL; opspp++) 73 if (strcmp(ops->vdev_op_type, type) == 0) 74 break; 75 76 return (ops); 77 } 78 79 /* 80 * Default asize function: return the MAX of psize with the asize of 81 * all children. This is what's used by anything other than RAID-Z. 82 */ 83 uint64_t 84 vdev_default_asize(vdev_t *vd, uint64_t psize) 85 { 86 uint64_t asize = P2ROUNDUP(psize, 1ULL << vd->vdev_top->vdev_ashift); 87 uint64_t csize; 88 89 for (int c = 0; c < vd->vdev_children; c++) { 90 csize = vdev_psize_to_asize(vd->vdev_child[c], psize); 91 asize = MAX(asize, csize); 92 } 93 94 return (asize); 95 } 96 97 /* 98 * Get the minimum allocatable size. We define the allocatable size as 99 * the vdev's asize rounded to the nearest metaslab. This allows us to 100 * replace or attach devices which don't have the same physical size but 101 * can still satisfy the same number of allocations. 102 */ 103 uint64_t 104 vdev_get_min_asize(vdev_t *vd) 105 { 106 vdev_t *pvd = vd->vdev_parent; 107 108 /* 109 * The our parent is NULL (inactive spare or cache) or is the root, 110 * just return our own asize. 111 */ 112 if (pvd == NULL) 113 return (vd->vdev_asize); 114 115 /* 116 * The top-level vdev just returns the allocatable size rounded 117 * to the nearest metaslab. 118 */ 119 if (vd == vd->vdev_top) 120 return (P2ALIGN(vd->vdev_asize, 1ULL << vd->vdev_ms_shift)); 121 122 /* 123 * The allocatable space for a raidz vdev is N * sizeof(smallest child), 124 * so each child must provide at least 1/Nth of its asize. 125 */ 126 if (pvd->vdev_ops == &vdev_raidz_ops) 127 return (pvd->vdev_min_asize / pvd->vdev_children); 128 129 return (pvd->vdev_min_asize); 130 } 131 132 void 133 vdev_set_min_asize(vdev_t *vd) 134 { 135 vd->vdev_min_asize = vdev_get_min_asize(vd); 136 137 for (int c = 0; c < vd->vdev_children; c++) 138 vdev_set_min_asize(vd->vdev_child[c]); 139 } 140 141 vdev_t * 142 vdev_lookup_top(spa_t *spa, uint64_t vdev) 143 { 144 vdev_t *rvd = spa->spa_root_vdev; 145 146 ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0); 147 148 if (vdev < rvd->vdev_children) { 149 ASSERT(rvd->vdev_child[vdev] != NULL); 150 return (rvd->vdev_child[vdev]); 151 } 152 153 return (NULL); 154 } 155 156 vdev_t * 157 vdev_lookup_by_guid(vdev_t *vd, uint64_t guid) 158 { 159 vdev_t *mvd; 160 161 if (vd->vdev_guid == guid) 162 return (vd); 163 164 for (int c = 0; c < vd->vdev_children; c++) 165 if ((mvd = vdev_lookup_by_guid(vd->vdev_child[c], guid)) != 166 NULL) 167 return (mvd); 168 169 return (NULL); 170 } 171 172 void 173 vdev_add_child(vdev_t *pvd, vdev_t *cvd) 174 { 175 size_t oldsize, newsize; 176 uint64_t id = cvd->vdev_id; 177 vdev_t **newchild; 178 179 ASSERT(spa_config_held(cvd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL); 180 ASSERT(cvd->vdev_parent == NULL); 181 182 cvd->vdev_parent = pvd; 183 184 if (pvd == NULL) 185 return; 186 187 ASSERT(id >= pvd->vdev_children || pvd->vdev_child[id] == NULL); 188 189 oldsize = pvd->vdev_children * sizeof (vdev_t *); 190 pvd->vdev_children = MAX(pvd->vdev_children, id + 1); 191 newsize = pvd->vdev_children * sizeof (vdev_t *); 192 193 newchild = kmem_zalloc(newsize, KM_SLEEP); 194 if (pvd->vdev_child != NULL) { 195 bcopy(pvd->vdev_child, newchild, oldsize); 196 kmem_free(pvd->vdev_child, oldsize); 197 } 198 199 pvd->vdev_child = newchild; 200 pvd->vdev_child[id] = cvd; 201 202 cvd->vdev_top = (pvd->vdev_top ? pvd->vdev_top: cvd); 203 ASSERT(cvd->vdev_top->vdev_parent->vdev_parent == NULL); 204 205 /* 206 * Walk up all ancestors to update guid sum. 207 */ 208 for (; pvd != NULL; pvd = pvd->vdev_parent) 209 pvd->vdev_guid_sum += cvd->vdev_guid_sum; 210 211 if (cvd->vdev_ops->vdev_op_leaf) 212 cvd->vdev_spa->spa_scrub_maxinflight += zfs_scrub_limit; 213 } 214 215 void 216 vdev_remove_child(vdev_t *pvd, vdev_t *cvd) 217 { 218 int c; 219 uint_t id = cvd->vdev_id; 220 221 ASSERT(cvd->vdev_parent == pvd); 222 223 if (pvd == NULL) 224 return; 225 226 ASSERT(id < pvd->vdev_children); 227 ASSERT(pvd->vdev_child[id] == cvd); 228 229 pvd->vdev_child[id] = NULL; 230 cvd->vdev_parent = NULL; 231 232 for (c = 0; c < pvd->vdev_children; c++) 233 if (pvd->vdev_child[c]) 234 break; 235 236 if (c == pvd->vdev_children) { 237 kmem_free(pvd->vdev_child, c * sizeof (vdev_t *)); 238 pvd->vdev_child = NULL; 239 pvd->vdev_children = 0; 240 } 241 242 /* 243 * Walk up all ancestors to update guid sum. 244 */ 245 for (; pvd != NULL; pvd = pvd->vdev_parent) 246 pvd->vdev_guid_sum -= cvd->vdev_guid_sum; 247 248 if (cvd->vdev_ops->vdev_op_leaf) 249 cvd->vdev_spa->spa_scrub_maxinflight -= zfs_scrub_limit; 250 } 251 252 /* 253 * Remove any holes in the child array. 254 */ 255 void 256 vdev_compact_children(vdev_t *pvd) 257 { 258 vdev_t **newchild, *cvd; 259 int oldc = pvd->vdev_children; 260 int newc; 261 262 ASSERT(spa_config_held(pvd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL); 263 264 for (int c = newc = 0; c < oldc; c++) 265 if (pvd->vdev_child[c]) 266 newc++; 267 268 newchild = kmem_alloc(newc * sizeof (vdev_t *), KM_SLEEP); 269 270 for (int c = newc = 0; c < oldc; c++) { 271 if ((cvd = pvd->vdev_child[c]) != NULL) { 272 newchild[newc] = cvd; 273 cvd->vdev_id = newc++; 274 } 275 } 276 277 kmem_free(pvd->vdev_child, oldc * sizeof (vdev_t *)); 278 pvd->vdev_child = newchild; 279 pvd->vdev_children = newc; 280 } 281 282 /* 283 * Allocate and minimally initialize a vdev_t. 284 */ 285 vdev_t * 286 vdev_alloc_common(spa_t *spa, uint_t id, uint64_t guid, vdev_ops_t *ops) 287 { 288 vdev_t *vd; 289 290 vd = kmem_zalloc(sizeof (vdev_t), KM_SLEEP); 291 292 if (spa->spa_root_vdev == NULL) { 293 ASSERT(ops == &vdev_root_ops); 294 spa->spa_root_vdev = vd; 295 } 296 297 if (guid == 0 && ops != &vdev_hole_ops) { 298 if (spa->spa_root_vdev == vd) { 299 /* 300 * The root vdev's guid will also be the pool guid, 301 * which must be unique among all pools. 302 */ 303 while (guid == 0 || spa_guid_exists(guid, 0)) 304 guid = spa_get_random(-1ULL); 305 } else { 306 /* 307 * Any other vdev's guid must be unique within the pool. 308 */ 309 while (guid == 0 || 310 spa_guid_exists(spa_guid(spa), guid)) 311 guid = spa_get_random(-1ULL); 312 } 313 ASSERT(!spa_guid_exists(spa_guid(spa), guid)); 314 } 315 316 vd->vdev_spa = spa; 317 vd->vdev_id = id; 318 vd->vdev_guid = guid; 319 vd->vdev_guid_sum = guid; 320 vd->vdev_ops = ops; 321 vd->vdev_state = VDEV_STATE_CLOSED; 322 vd->vdev_ishole = (ops == &vdev_hole_ops); 323 324 mutex_init(&vd->vdev_dtl_lock, NULL, MUTEX_DEFAULT, NULL); 325 mutex_init(&vd->vdev_stat_lock, NULL, MUTEX_DEFAULT, NULL); 326 mutex_init(&vd->vdev_probe_lock, NULL, MUTEX_DEFAULT, NULL); 327 for (int t = 0; t < DTL_TYPES; t++) { 328 space_map_create(&vd->vdev_dtl[t], 0, -1ULL, 0, 329 &vd->vdev_dtl_lock); 330 } 331 txg_list_create(&vd->vdev_ms_list, 332 offsetof(struct metaslab, ms_txg_node)); 333 txg_list_create(&vd->vdev_dtl_list, 334 offsetof(struct vdev, vdev_dtl_node)); 335 vd->vdev_stat.vs_timestamp = gethrtime(); 336 vdev_queue_init(vd); 337 vdev_cache_init(vd); 338 339 return (vd); 340 } 341 342 /* 343 * Allocate a new vdev. The 'alloctype' is used to control whether we are 344 * creating a new vdev or loading an existing one - the behavior is slightly 345 * different for each case. 346 */ 347 int 348 vdev_alloc(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent, uint_t id, 349 int alloctype) 350 { 351 vdev_ops_t *ops; 352 char *type; 353 uint64_t guid = 0, islog, nparity; 354 vdev_t *vd; 355 356 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 357 358 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) != 0) 359 return (EINVAL); 360 361 if ((ops = vdev_getops(type)) == NULL) 362 return (EINVAL); 363 364 /* 365 * If this is a load, get the vdev guid from the nvlist. 366 * Otherwise, vdev_alloc_common() will generate one for us. 367 */ 368 if (alloctype == VDEV_ALLOC_LOAD) { 369 uint64_t label_id; 370 371 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID, &label_id) || 372 label_id != id) 373 return (EINVAL); 374 375 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0) 376 return (EINVAL); 377 } else if (alloctype == VDEV_ALLOC_SPARE) { 378 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0) 379 return (EINVAL); 380 } else if (alloctype == VDEV_ALLOC_L2CACHE) { 381 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0) 382 return (EINVAL); 383 } else if (alloctype == VDEV_ALLOC_ROOTPOOL) { 384 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0) 385 return (EINVAL); 386 } 387 388 /* 389 * The first allocated vdev must be of type 'root'. 390 */ 391 if (ops != &vdev_root_ops && spa->spa_root_vdev == NULL) 392 return (EINVAL); 393 394 /* 395 * Determine whether we're a log vdev. 396 */ 397 islog = 0; 398 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG, &islog); 399 if (islog && spa_version(spa) < SPA_VERSION_SLOGS) 400 return (ENOTSUP); 401 402 if (ops == &vdev_hole_ops && spa_version(spa) < SPA_VERSION_HOLES) 403 return (ENOTSUP); 404 405 /* 406 * Set the nparity property for RAID-Z vdevs. 407 */ 408 nparity = -1ULL; 409 if (ops == &vdev_raidz_ops) { 410 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY, 411 &nparity) == 0) { 412 /* 413 * Currently, we can only support 3 parity devices. 414 */ 415 if (nparity == 0 || nparity > 3) 416 return (EINVAL); 417 /* 418 * Previous versions could only support 1 or 2 parity 419 * device. 420 */ 421 if (nparity > 1 && 422 spa_version(spa) < SPA_VERSION_RAIDZ2) 423 return (ENOTSUP); 424 if (nparity > 2 && 425 spa_version(spa) < SPA_VERSION_RAIDZ3) 426 return (ENOTSUP); 427 } else { 428 /* 429 * We require the parity to be specified for SPAs that 430 * support multiple parity levels. 431 */ 432 if (spa_version(spa) >= SPA_VERSION_RAIDZ2) 433 return (EINVAL); 434 /* 435 * Otherwise, we default to 1 parity device for RAID-Z. 436 */ 437 nparity = 1; 438 } 439 } else { 440 nparity = 0; 441 } 442 ASSERT(nparity != -1ULL); 443 444 vd = vdev_alloc_common(spa, id, guid, ops); 445 446 vd->vdev_islog = islog; 447 vd->vdev_nparity = nparity; 448 449 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &vd->vdev_path) == 0) 450 vd->vdev_path = spa_strdup(vd->vdev_path); 451 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_DEVID, &vd->vdev_devid) == 0) 452 vd->vdev_devid = spa_strdup(vd->vdev_devid); 453 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PHYS_PATH, 454 &vd->vdev_physpath) == 0) 455 vd->vdev_physpath = spa_strdup(vd->vdev_physpath); 456 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_FRU, &vd->vdev_fru) == 0) 457 vd->vdev_fru = spa_strdup(vd->vdev_fru); 458 459 /* 460 * Set the whole_disk property. If it's not specified, leave the value 461 * as -1. 462 */ 463 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK, 464 &vd->vdev_wholedisk) != 0) 465 vd->vdev_wholedisk = -1ULL; 466 467 /* 468 * Look for the 'not present' flag. This will only be set if the device 469 * was not present at the time of import. 470 */ 471 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 472 &vd->vdev_not_present); 473 474 /* 475 * Get the alignment requirement. 476 */ 477 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASHIFT, &vd->vdev_ashift); 478 479 /* 480 * Retrieve the vdev creation time. 481 */ 482 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_CREATE_TXG, 483 &vd->vdev_crtxg); 484 485 /* 486 * If we're a top-level vdev, try to load the allocation parameters. 487 */ 488 if (parent && !parent->vdev_parent && alloctype == VDEV_ALLOC_LOAD) { 489 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_METASLAB_ARRAY, 490 &vd->vdev_ms_array); 491 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_METASLAB_SHIFT, 492 &vd->vdev_ms_shift); 493 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASIZE, 494 &vd->vdev_asize); 495 } 496 497 /* 498 * If we're a leaf vdev, try to load the DTL object and other state. 499 */ 500 if (vd->vdev_ops->vdev_op_leaf && 501 (alloctype == VDEV_ALLOC_LOAD || alloctype == VDEV_ALLOC_L2CACHE || 502 alloctype == VDEV_ALLOC_ROOTPOOL)) { 503 if (alloctype == VDEV_ALLOC_LOAD) { 504 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DTL, 505 &vd->vdev_dtl_smo.smo_object); 506 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_UNSPARE, 507 &vd->vdev_unspare); 508 } 509 510 if (alloctype == VDEV_ALLOC_ROOTPOOL) { 511 uint64_t spare = 0; 512 513 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_SPARE, 514 &spare) == 0 && spare) 515 spa_spare_add(vd); 516 } 517 518 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE, 519 &vd->vdev_offline); 520 521 /* 522 * When importing a pool, we want to ignore the persistent fault 523 * state, as the diagnosis made on another system may not be 524 * valid in the current context. Local vdevs will 525 * remain in the faulted state. 526 */ 527 if (spa->spa_load_state == SPA_LOAD_OPEN) { 528 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_FAULTED, 529 &vd->vdev_faulted); 530 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DEGRADED, 531 &vd->vdev_degraded); 532 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVED, 533 &vd->vdev_removed); 534 535 if (vd->vdev_faulted || vd->vdev_degraded) { 536 char *aux; 537 538 vd->vdev_label_aux = 539 VDEV_AUX_ERR_EXCEEDED; 540 if (nvlist_lookup_string(nv, 541 ZPOOL_CONFIG_AUX_STATE, &aux) == 0 && 542 strcmp(aux, "external") == 0) 543 vd->vdev_label_aux = VDEV_AUX_EXTERNAL; 544 } 545 } 546 } 547 548 /* 549 * Add ourselves to the parent's list of children. 550 */ 551 vdev_add_child(parent, vd); 552 553 *vdp = vd; 554 555 return (0); 556 } 557 558 void 559 vdev_free(vdev_t *vd) 560 { 561 spa_t *spa = vd->vdev_spa; 562 563 /* 564 * vdev_free() implies closing the vdev first. This is simpler than 565 * trying to ensure complicated semantics for all callers. 566 */ 567 vdev_close(vd); 568 569 ASSERT(!list_link_active(&vd->vdev_config_dirty_node)); 570 571 /* 572 * Free all children. 573 */ 574 for (int c = 0; c < vd->vdev_children; c++) 575 vdev_free(vd->vdev_child[c]); 576 577 ASSERT(vd->vdev_child == NULL); 578 ASSERT(vd->vdev_guid_sum == vd->vdev_guid); 579 580 /* 581 * Discard allocation state. 582 */ 583 if (vd == vd->vdev_top) 584 vdev_metaslab_fini(vd); 585 586 ASSERT3U(vd->vdev_stat.vs_space, ==, 0); 587 ASSERT3U(vd->vdev_stat.vs_dspace, ==, 0); 588 ASSERT3U(vd->vdev_stat.vs_alloc, ==, 0); 589 590 /* 591 * Remove this vdev from its parent's child list. 592 */ 593 vdev_remove_child(vd->vdev_parent, vd); 594 595 ASSERT(vd->vdev_parent == NULL); 596 597 /* 598 * Clean up vdev structure. 599 */ 600 vdev_queue_fini(vd); 601 vdev_cache_fini(vd); 602 603 if (vd->vdev_path) 604 spa_strfree(vd->vdev_path); 605 if (vd->vdev_devid) 606 spa_strfree(vd->vdev_devid); 607 if (vd->vdev_physpath) 608 spa_strfree(vd->vdev_physpath); 609 if (vd->vdev_fru) 610 spa_strfree(vd->vdev_fru); 611 612 if (vd->vdev_isspare) 613 spa_spare_remove(vd); 614 if (vd->vdev_isl2cache) 615 spa_l2cache_remove(vd); 616 617 txg_list_destroy(&vd->vdev_ms_list); 618 txg_list_destroy(&vd->vdev_dtl_list); 619 620 mutex_enter(&vd->vdev_dtl_lock); 621 for (int t = 0; t < DTL_TYPES; t++) { 622 space_map_unload(&vd->vdev_dtl[t]); 623 space_map_destroy(&vd->vdev_dtl[t]); 624 } 625 mutex_exit(&vd->vdev_dtl_lock); 626 627 mutex_destroy(&vd->vdev_dtl_lock); 628 mutex_destroy(&vd->vdev_stat_lock); 629 mutex_destroy(&vd->vdev_probe_lock); 630 631 if (vd == spa->spa_root_vdev) 632 spa->spa_root_vdev = NULL; 633 634 kmem_free(vd, sizeof (vdev_t)); 635 } 636 637 /* 638 * Transfer top-level vdev state from svd to tvd. 639 */ 640 static void 641 vdev_top_transfer(vdev_t *svd, vdev_t *tvd) 642 { 643 spa_t *spa = svd->vdev_spa; 644 metaslab_t *msp; 645 vdev_t *vd; 646 int t; 647 648 ASSERT(tvd == tvd->vdev_top); 649 650 tvd->vdev_ms_array = svd->vdev_ms_array; 651 tvd->vdev_ms_shift = svd->vdev_ms_shift; 652 tvd->vdev_ms_count = svd->vdev_ms_count; 653 654 svd->vdev_ms_array = 0; 655 svd->vdev_ms_shift = 0; 656 svd->vdev_ms_count = 0; 657 658 tvd->vdev_mg = svd->vdev_mg; 659 tvd->vdev_ms = svd->vdev_ms; 660 661 svd->vdev_mg = NULL; 662 svd->vdev_ms = NULL; 663 664 if (tvd->vdev_mg != NULL) 665 tvd->vdev_mg->mg_vd = tvd; 666 667 tvd->vdev_stat.vs_alloc = svd->vdev_stat.vs_alloc; 668 tvd->vdev_stat.vs_space = svd->vdev_stat.vs_space; 669 tvd->vdev_stat.vs_dspace = svd->vdev_stat.vs_dspace; 670 671 svd->vdev_stat.vs_alloc = 0; 672 svd->vdev_stat.vs_space = 0; 673 svd->vdev_stat.vs_dspace = 0; 674 675 for (t = 0; t < TXG_SIZE; t++) { 676 while ((msp = txg_list_remove(&svd->vdev_ms_list, t)) != NULL) 677 (void) txg_list_add(&tvd->vdev_ms_list, msp, t); 678 while ((vd = txg_list_remove(&svd->vdev_dtl_list, t)) != NULL) 679 (void) txg_list_add(&tvd->vdev_dtl_list, vd, t); 680 if (txg_list_remove_this(&spa->spa_vdev_txg_list, svd, t)) 681 (void) txg_list_add(&spa->spa_vdev_txg_list, tvd, t); 682 } 683 684 if (list_link_active(&svd->vdev_config_dirty_node)) { 685 vdev_config_clean(svd); 686 vdev_config_dirty(tvd); 687 } 688 689 if (list_link_active(&svd->vdev_state_dirty_node)) { 690 vdev_state_clean(svd); 691 vdev_state_dirty(tvd); 692 } 693 694 tvd->vdev_deflate_ratio = svd->vdev_deflate_ratio; 695 svd->vdev_deflate_ratio = 0; 696 697 tvd->vdev_islog = svd->vdev_islog; 698 svd->vdev_islog = 0; 699 } 700 701 static void 702 vdev_top_update(vdev_t *tvd, vdev_t *vd) 703 { 704 if (vd == NULL) 705 return; 706 707 vd->vdev_top = tvd; 708 709 for (int c = 0; c < vd->vdev_children; c++) 710 vdev_top_update(tvd, vd->vdev_child[c]); 711 } 712 713 /* 714 * Add a mirror/replacing vdev above an existing vdev. 715 */ 716 vdev_t * 717 vdev_add_parent(vdev_t *cvd, vdev_ops_t *ops) 718 { 719 spa_t *spa = cvd->vdev_spa; 720 vdev_t *pvd = cvd->vdev_parent; 721 vdev_t *mvd; 722 723 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 724 725 mvd = vdev_alloc_common(spa, cvd->vdev_id, 0, ops); 726 727 mvd->vdev_asize = cvd->vdev_asize; 728 mvd->vdev_min_asize = cvd->vdev_min_asize; 729 mvd->vdev_ashift = cvd->vdev_ashift; 730 mvd->vdev_state = cvd->vdev_state; 731 mvd->vdev_crtxg = cvd->vdev_crtxg; 732 733 vdev_remove_child(pvd, cvd); 734 vdev_add_child(pvd, mvd); 735 cvd->vdev_id = mvd->vdev_children; 736 vdev_add_child(mvd, cvd); 737 vdev_top_update(cvd->vdev_top, cvd->vdev_top); 738 739 if (mvd == mvd->vdev_top) 740 vdev_top_transfer(cvd, mvd); 741 742 return (mvd); 743 } 744 745 /* 746 * Remove a 1-way mirror/replacing vdev from the tree. 747 */ 748 void 749 vdev_remove_parent(vdev_t *cvd) 750 { 751 vdev_t *mvd = cvd->vdev_parent; 752 vdev_t *pvd = mvd->vdev_parent; 753 754 ASSERT(spa_config_held(cvd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL); 755 756 ASSERT(mvd->vdev_children == 1); 757 ASSERT(mvd->vdev_ops == &vdev_mirror_ops || 758 mvd->vdev_ops == &vdev_replacing_ops || 759 mvd->vdev_ops == &vdev_spare_ops); 760 cvd->vdev_ashift = mvd->vdev_ashift; 761 762 vdev_remove_child(mvd, cvd); 763 vdev_remove_child(pvd, mvd); 764 765 /* 766 * If cvd will replace mvd as a top-level vdev, preserve mvd's guid. 767 * Otherwise, we could have detached an offline device, and when we 768 * go to import the pool we'll think we have two top-level vdevs, 769 * instead of a different version of the same top-level vdev. 770 */ 771 if (mvd->vdev_top == mvd) { 772 uint64_t guid_delta = mvd->vdev_guid - cvd->vdev_guid; 773 cvd->vdev_guid += guid_delta; 774 cvd->vdev_guid_sum += guid_delta; 775 } 776 cvd->vdev_id = mvd->vdev_id; 777 vdev_add_child(pvd, cvd); 778 vdev_top_update(cvd->vdev_top, cvd->vdev_top); 779 780 if (cvd == cvd->vdev_top) 781 vdev_top_transfer(mvd, cvd); 782 783 ASSERT(mvd->vdev_children == 0); 784 vdev_free(mvd); 785 } 786 787 int 788 vdev_metaslab_init(vdev_t *vd, uint64_t txg) 789 { 790 spa_t *spa = vd->vdev_spa; 791 objset_t *mos = spa->spa_meta_objset; 792 metaslab_class_t *mc; 793 uint64_t m; 794 uint64_t oldc = vd->vdev_ms_count; 795 uint64_t newc = vd->vdev_asize >> vd->vdev_ms_shift; 796 metaslab_t **mspp; 797 int error; 798 799 /* 800 * This vdev is not being allocated from yet or is a hole. 801 */ 802 if (vd->vdev_ms_shift == 0) 803 return (0); 804 805 ASSERT(!vd->vdev_ishole); 806 807 /* 808 * Compute the raidz-deflation ratio. Note, we hard-code 809 * in 128k (1 << 17) because it is the current "typical" blocksize. 810 * Even if SPA_MAXBLOCKSIZE changes, this algorithm must never change, 811 * or we will inconsistently account for existing bp's. 812 */ 813 vd->vdev_deflate_ratio = (1 << 17) / 814 (vdev_psize_to_asize(vd, 1 << 17) >> SPA_MINBLOCKSHIFT); 815 816 ASSERT(oldc <= newc); 817 818 if (vd->vdev_islog) 819 mc = spa->spa_log_class; 820 else 821 mc = spa->spa_normal_class; 822 823 if (vd->vdev_mg == NULL) 824 vd->vdev_mg = metaslab_group_create(mc, vd); 825 826 mspp = kmem_zalloc(newc * sizeof (*mspp), KM_SLEEP); 827 828 if (oldc != 0) { 829 bcopy(vd->vdev_ms, mspp, oldc * sizeof (*mspp)); 830 kmem_free(vd->vdev_ms, oldc * sizeof (*mspp)); 831 } 832 833 vd->vdev_ms = mspp; 834 vd->vdev_ms_count = newc; 835 836 for (m = oldc; m < newc; m++) { 837 space_map_obj_t smo = { 0, 0, 0 }; 838 if (txg == 0) { 839 uint64_t object = 0; 840 error = dmu_read(mos, vd->vdev_ms_array, 841 m * sizeof (uint64_t), sizeof (uint64_t), &object, 842 DMU_READ_PREFETCH); 843 if (error) 844 return (error); 845 if (object != 0) { 846 dmu_buf_t *db; 847 error = dmu_bonus_hold(mos, object, FTAG, &db); 848 if (error) 849 return (error); 850 ASSERT3U(db->db_size, >=, sizeof (smo)); 851 bcopy(db->db_data, &smo, sizeof (smo)); 852 ASSERT3U(smo.smo_object, ==, object); 853 dmu_buf_rele(db, FTAG); 854 } 855 } 856 vd->vdev_ms[m] = metaslab_init(vd->vdev_mg, &smo, 857 m << vd->vdev_ms_shift, 1ULL << vd->vdev_ms_shift, txg); 858 } 859 860 return (0); 861 } 862 863 void 864 vdev_metaslab_fini(vdev_t *vd) 865 { 866 uint64_t m; 867 uint64_t count = vd->vdev_ms_count; 868 869 if (vd->vdev_ms != NULL) { 870 for (m = 0; m < count; m++) 871 if (vd->vdev_ms[m] != NULL) 872 metaslab_fini(vd->vdev_ms[m]); 873 kmem_free(vd->vdev_ms, count * sizeof (metaslab_t *)); 874 vd->vdev_ms = NULL; 875 } 876 } 877 878 typedef struct vdev_probe_stats { 879 boolean_t vps_readable; 880 boolean_t vps_writeable; 881 int vps_flags; 882 } vdev_probe_stats_t; 883 884 static void 885 vdev_probe_done(zio_t *zio) 886 { 887 spa_t *spa = zio->io_spa; 888 vdev_t *vd = zio->io_vd; 889 vdev_probe_stats_t *vps = zio->io_private; 890 891 ASSERT(vd->vdev_probe_zio != NULL); 892 893 if (zio->io_type == ZIO_TYPE_READ) { 894 if (zio->io_error == 0) 895 vps->vps_readable = 1; 896 if (zio->io_error == 0 && spa_writeable(spa)) { 897 zio_nowait(zio_write_phys(vd->vdev_probe_zio, vd, 898 zio->io_offset, zio->io_size, zio->io_data, 899 ZIO_CHECKSUM_OFF, vdev_probe_done, vps, 900 ZIO_PRIORITY_SYNC_WRITE, vps->vps_flags, B_TRUE)); 901 } else { 902 zio_buf_free(zio->io_data, zio->io_size); 903 } 904 } else if (zio->io_type == ZIO_TYPE_WRITE) { 905 if (zio->io_error == 0) 906 vps->vps_writeable = 1; 907 zio_buf_free(zio->io_data, zio->io_size); 908 } else if (zio->io_type == ZIO_TYPE_NULL) { 909 zio_t *pio; 910 911 vd->vdev_cant_read |= !vps->vps_readable; 912 vd->vdev_cant_write |= !vps->vps_writeable; 913 914 if (vdev_readable(vd) && 915 (vdev_writeable(vd) || !spa_writeable(spa))) { 916 zio->io_error = 0; 917 } else { 918 ASSERT(zio->io_error != 0); 919 zfs_ereport_post(FM_EREPORT_ZFS_PROBE_FAILURE, 920 spa, vd, NULL, 0, 0); 921 zio->io_error = ENXIO; 922 } 923 924 mutex_enter(&vd->vdev_probe_lock); 925 ASSERT(vd->vdev_probe_zio == zio); 926 vd->vdev_probe_zio = NULL; 927 mutex_exit(&vd->vdev_probe_lock); 928 929 while ((pio = zio_walk_parents(zio)) != NULL) 930 if (!vdev_accessible(vd, pio)) 931 pio->io_error = ENXIO; 932 933 kmem_free(vps, sizeof (*vps)); 934 } 935 } 936 937 /* 938 * Determine whether this device is accessible by reading and writing 939 * to several known locations: the pad regions of each vdev label 940 * but the first (which we leave alone in case it contains a VTOC). 941 */ 942 zio_t * 943 vdev_probe(vdev_t *vd, zio_t *zio) 944 { 945 spa_t *spa = vd->vdev_spa; 946 vdev_probe_stats_t *vps = NULL; 947 zio_t *pio; 948 949 ASSERT(vd->vdev_ops->vdev_op_leaf); 950 951 /* 952 * Don't probe the probe. 953 */ 954 if (zio && (zio->io_flags & ZIO_FLAG_PROBE)) 955 return (NULL); 956 957 /* 958 * To prevent 'probe storms' when a device fails, we create 959 * just one probe i/o at a time. All zios that want to probe 960 * this vdev will become parents of the probe io. 961 */ 962 mutex_enter(&vd->vdev_probe_lock); 963 964 if ((pio = vd->vdev_probe_zio) == NULL) { 965 vps = kmem_zalloc(sizeof (*vps), KM_SLEEP); 966 967 vps->vps_flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_PROBE | 968 ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_AGGREGATE | 969 ZIO_FLAG_TRYHARD; 970 971 if (spa_config_held(spa, SCL_ZIO, RW_WRITER)) { 972 /* 973 * vdev_cant_read and vdev_cant_write can only 974 * transition from TRUE to FALSE when we have the 975 * SCL_ZIO lock as writer; otherwise they can only 976 * transition from FALSE to TRUE. This ensures that 977 * any zio looking at these values can assume that 978 * failures persist for the life of the I/O. That's 979 * important because when a device has intermittent 980 * connectivity problems, we want to ensure that 981 * they're ascribed to the device (ENXIO) and not 982 * the zio (EIO). 983 * 984 * Since we hold SCL_ZIO as writer here, clear both 985 * values so the probe can reevaluate from first 986 * principles. 987 */ 988 vps->vps_flags |= ZIO_FLAG_CONFIG_WRITER; 989 vd->vdev_cant_read = B_FALSE; 990 vd->vdev_cant_write = B_FALSE; 991 } 992 993 vd->vdev_probe_zio = pio = zio_null(NULL, spa, vd, 994 vdev_probe_done, vps, 995 vps->vps_flags | ZIO_FLAG_DONT_PROPAGATE); 996 997 if (zio != NULL) { 998 vd->vdev_probe_wanted = B_TRUE; 999 spa_async_request(spa, SPA_ASYNC_PROBE); 1000 } 1001 } 1002 1003 if (zio != NULL) 1004 zio_add_child(zio, pio); 1005 1006 mutex_exit(&vd->vdev_probe_lock); 1007 1008 if (vps == NULL) { 1009 ASSERT(zio != NULL); 1010 return (NULL); 1011 } 1012 1013 for (int l = 1; l < VDEV_LABELS; l++) { 1014 zio_nowait(zio_read_phys(pio, vd, 1015 vdev_label_offset(vd->vdev_psize, l, 1016 offsetof(vdev_label_t, vl_pad2)), 1017 VDEV_PAD_SIZE, zio_buf_alloc(VDEV_PAD_SIZE), 1018 ZIO_CHECKSUM_OFF, vdev_probe_done, vps, 1019 ZIO_PRIORITY_SYNC_READ, vps->vps_flags, B_TRUE)); 1020 } 1021 1022 if (zio == NULL) 1023 return (pio); 1024 1025 zio_nowait(pio); 1026 return (NULL); 1027 } 1028 1029 static void 1030 vdev_open_child(void *arg) 1031 { 1032 vdev_t *vd = arg; 1033 1034 vd->vdev_open_thread = curthread; 1035 vd->vdev_open_error = vdev_open(vd); 1036 vd->vdev_open_thread = NULL; 1037 } 1038 1039 boolean_t 1040 vdev_uses_zvols(vdev_t *vd) 1041 { 1042 if (vd->vdev_path && strncmp(vd->vdev_path, ZVOL_DIR, 1043 strlen(ZVOL_DIR)) == 0) 1044 return (B_TRUE); 1045 for (int c = 0; c < vd->vdev_children; c++) 1046 if (vdev_uses_zvols(vd->vdev_child[c])) 1047 return (B_TRUE); 1048 return (B_FALSE); 1049 } 1050 1051 void 1052 vdev_open_children(vdev_t *vd) 1053 { 1054 taskq_t *tq; 1055 int children = vd->vdev_children; 1056 1057 /* 1058 * in order to handle pools on top of zvols, do the opens 1059 * in a single thread so that the same thread holds the 1060 * spa_namespace_lock 1061 */ 1062 if (vdev_uses_zvols(vd)) { 1063 for (int c = 0; c < children; c++) 1064 vd->vdev_child[c]->vdev_open_error = 1065 vdev_open(vd->vdev_child[c]); 1066 return; 1067 } 1068 tq = taskq_create("vdev_open", children, minclsyspri, 1069 children, children, TASKQ_PREPOPULATE); 1070 1071 for (int c = 0; c < children; c++) 1072 VERIFY(taskq_dispatch(tq, vdev_open_child, vd->vdev_child[c], 1073 TQ_SLEEP) != NULL); 1074 1075 taskq_destroy(tq); 1076 } 1077 1078 /* 1079 * Prepare a virtual device for access. 1080 */ 1081 int 1082 vdev_open(vdev_t *vd) 1083 { 1084 spa_t *spa = vd->vdev_spa; 1085 int error; 1086 uint64_t osize = 0; 1087 uint64_t asize, psize; 1088 uint64_t ashift = 0; 1089 1090 ASSERT(vd->vdev_open_thread == curthread || 1091 spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL); 1092 ASSERT(vd->vdev_state == VDEV_STATE_CLOSED || 1093 vd->vdev_state == VDEV_STATE_CANT_OPEN || 1094 vd->vdev_state == VDEV_STATE_OFFLINE); 1095 1096 vd->vdev_stat.vs_aux = VDEV_AUX_NONE; 1097 vd->vdev_cant_read = B_FALSE; 1098 vd->vdev_cant_write = B_FALSE; 1099 vd->vdev_min_asize = vdev_get_min_asize(vd); 1100 1101 /* 1102 * If this vdev is not removed, check its fault status. If it's 1103 * faulted, bail out of the open. 1104 */ 1105 if (!vd->vdev_removed && vd->vdev_faulted) { 1106 ASSERT(vd->vdev_children == 0); 1107 ASSERT(vd->vdev_label_aux == VDEV_AUX_ERR_EXCEEDED || 1108 vd->vdev_label_aux == VDEV_AUX_EXTERNAL); 1109 vdev_set_state(vd, B_TRUE, VDEV_STATE_FAULTED, 1110 vd->vdev_label_aux); 1111 return (ENXIO); 1112 } else if (vd->vdev_offline) { 1113 ASSERT(vd->vdev_children == 0); 1114 vdev_set_state(vd, B_TRUE, VDEV_STATE_OFFLINE, VDEV_AUX_NONE); 1115 return (ENXIO); 1116 } 1117 1118 error = vd->vdev_ops->vdev_op_open(vd, &osize, &ashift); 1119 1120 /* 1121 * Reset the vdev_reopening flag so that we actually close 1122 * the vdev on error. 1123 */ 1124 vd->vdev_reopening = B_FALSE; 1125 if (zio_injection_enabled && error == 0) 1126 error = zio_handle_device_injection(vd, NULL, ENXIO); 1127 1128 if (error) { 1129 if (vd->vdev_removed && 1130 vd->vdev_stat.vs_aux != VDEV_AUX_OPEN_FAILED) 1131 vd->vdev_removed = B_FALSE; 1132 1133 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 1134 vd->vdev_stat.vs_aux); 1135 return (error); 1136 } 1137 1138 vd->vdev_removed = B_FALSE; 1139 1140 /* 1141 * Recheck the faulted flag now that we have confirmed that 1142 * the vdev is accessible. If we're faulted, bail. 1143 */ 1144 if (vd->vdev_faulted) { 1145 ASSERT(vd->vdev_children == 0); 1146 ASSERT(vd->vdev_label_aux == VDEV_AUX_ERR_EXCEEDED || 1147 vd->vdev_label_aux == VDEV_AUX_EXTERNAL); 1148 vdev_set_state(vd, B_TRUE, VDEV_STATE_FAULTED, 1149 vd->vdev_label_aux); 1150 return (ENXIO); 1151 } 1152 1153 if (vd->vdev_degraded) { 1154 ASSERT(vd->vdev_children == 0); 1155 vdev_set_state(vd, B_TRUE, VDEV_STATE_DEGRADED, 1156 VDEV_AUX_ERR_EXCEEDED); 1157 } else { 1158 vdev_set_state(vd, B_TRUE, VDEV_STATE_HEALTHY, 0); 1159 } 1160 1161 /* 1162 * For hole or missing vdevs we just return success. 1163 */ 1164 if (vd->vdev_ishole || vd->vdev_ops == &vdev_missing_ops) 1165 return (0); 1166 1167 for (int c = 0; c < vd->vdev_children; c++) { 1168 if (vd->vdev_child[c]->vdev_state != VDEV_STATE_HEALTHY) { 1169 vdev_set_state(vd, B_TRUE, VDEV_STATE_DEGRADED, 1170 VDEV_AUX_NONE); 1171 break; 1172 } 1173 } 1174 1175 osize = P2ALIGN(osize, (uint64_t)sizeof (vdev_label_t)); 1176 1177 if (vd->vdev_children == 0) { 1178 if (osize < SPA_MINDEVSIZE) { 1179 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 1180 VDEV_AUX_TOO_SMALL); 1181 return (EOVERFLOW); 1182 } 1183 psize = osize; 1184 asize = osize - (VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE); 1185 } else { 1186 if (vd->vdev_parent != NULL && osize < SPA_MINDEVSIZE - 1187 (VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE)) { 1188 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 1189 VDEV_AUX_TOO_SMALL); 1190 return (EOVERFLOW); 1191 } 1192 psize = 0; 1193 asize = osize; 1194 } 1195 1196 vd->vdev_psize = psize; 1197 1198 /* 1199 * Make sure the allocatable size hasn't shrunk. 1200 */ 1201 if (asize < vd->vdev_min_asize) { 1202 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 1203 VDEV_AUX_BAD_LABEL); 1204 return (EINVAL); 1205 } 1206 1207 if (vd->vdev_asize == 0) { 1208 /* 1209 * This is the first-ever open, so use the computed values. 1210 * For testing purposes, a higher ashift can be requested. 1211 */ 1212 vd->vdev_asize = asize; 1213 vd->vdev_ashift = MAX(ashift, vd->vdev_ashift); 1214 } else { 1215 /* 1216 * Make sure the alignment requirement hasn't increased. 1217 */ 1218 if (ashift > vd->vdev_top->vdev_ashift) { 1219 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 1220 VDEV_AUX_BAD_LABEL); 1221 return (EINVAL); 1222 } 1223 } 1224 1225 /* 1226 * If all children are healthy and the asize has increased, 1227 * then we've experienced dynamic LUN growth. If automatic 1228 * expansion is enabled then use the additional space. 1229 */ 1230 if (vd->vdev_state == VDEV_STATE_HEALTHY && asize > vd->vdev_asize && 1231 (vd->vdev_expanding || spa->spa_autoexpand)) 1232 vd->vdev_asize = asize; 1233 1234 vdev_set_min_asize(vd); 1235 1236 /* 1237 * Ensure we can issue some IO before declaring the 1238 * vdev open for business. 1239 */ 1240 if (vd->vdev_ops->vdev_op_leaf && 1241 (error = zio_wait(vdev_probe(vd, NULL))) != 0) { 1242 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 1243 VDEV_AUX_IO_FAILURE); 1244 return (error); 1245 } 1246 1247 /* 1248 * If a leaf vdev has a DTL, and seems healthy, then kick off a 1249 * resilver. But don't do this if we are doing a reopen for a scrub, 1250 * since this would just restart the scrub we are already doing. 1251 */ 1252 if (vd->vdev_ops->vdev_op_leaf && !spa->spa_scrub_reopen && 1253 vdev_resilver_needed(vd, NULL, NULL)) 1254 spa_async_request(spa, SPA_ASYNC_RESILVER); 1255 1256 return (0); 1257 } 1258 1259 /* 1260 * Called once the vdevs are all opened, this routine validates the label 1261 * contents. This needs to be done before vdev_load() so that we don't 1262 * inadvertently do repair I/Os to the wrong device. 1263 * 1264 * This function will only return failure if one of the vdevs indicates that it 1265 * has since been destroyed or exported. This is only possible if 1266 * /etc/zfs/zpool.cache was readonly at the time. Otherwise, the vdev state 1267 * will be updated but the function will return 0. 1268 */ 1269 int 1270 vdev_validate(vdev_t *vd) 1271 { 1272 spa_t *spa = vd->vdev_spa; 1273 nvlist_t *label; 1274 uint64_t guid, top_guid; 1275 uint64_t state; 1276 1277 for (int c = 0; c < vd->vdev_children; c++) 1278 if (vdev_validate(vd->vdev_child[c]) != 0) 1279 return (EBADF); 1280 1281 /* 1282 * If the device has already failed, or was marked offline, don't do 1283 * any further validation. Otherwise, label I/O will fail and we will 1284 * overwrite the previous state. 1285 */ 1286 if (vd->vdev_ops->vdev_op_leaf && vdev_readable(vd)) { 1287 1288 if ((label = vdev_label_read_config(vd)) == NULL) { 1289 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 1290 VDEV_AUX_BAD_LABEL); 1291 return (0); 1292 } 1293 1294 if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_GUID, 1295 &guid) != 0 || guid != spa_guid(spa)) { 1296 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN, 1297 VDEV_AUX_CORRUPT_DATA); 1298 nvlist_free(label); 1299 return (0); 1300 } 1301 1302 /* 1303 * If this vdev just became a top-level vdev because its 1304 * sibling was detached, it will have adopted the parent's 1305 * vdev guid -- but the label may or may not be on disk yet. 1306 * Fortunately, either version of the label will have the 1307 * same top guid, so if we're a top-level vdev, we can 1308 * safely compare to that instead. 1309 */ 1310 if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID, 1311 &guid) != 0 || 1312 nvlist_lookup_uint64(label, ZPOOL_CONFIG_TOP_GUID, 1313 &top_guid) != 0 || 1314 (vd->vdev_guid != guid && 1315 (vd->vdev_guid != top_guid || vd != vd->vdev_top))) { 1316 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN, 1317 VDEV_AUX_CORRUPT_DATA); 1318 nvlist_free(label); 1319 return (0); 1320 } 1321 1322 if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_STATE, 1323 &state) != 0) { 1324 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN, 1325 VDEV_AUX_CORRUPT_DATA); 1326 nvlist_free(label); 1327 return (0); 1328 } 1329 1330 nvlist_free(label); 1331 1332 /* 1333 * If spa->spa_load_verbatim is true, no need to check the 1334 * state of the pool. 1335 */ 1336 if (!spa->spa_load_verbatim && 1337 spa->spa_load_state == SPA_LOAD_OPEN && 1338 state != POOL_STATE_ACTIVE) 1339 return (EBADF); 1340 1341 /* 1342 * If we were able to open and validate a vdev that was 1343 * previously marked permanently unavailable, clear that state 1344 * now. 1345 */ 1346 if (vd->vdev_not_present) 1347 vd->vdev_not_present = 0; 1348 } 1349 1350 return (0); 1351 } 1352 1353 /* 1354 * Close a virtual device. 1355 */ 1356 void 1357 vdev_close(vdev_t *vd) 1358 { 1359 spa_t *spa = vd->vdev_spa; 1360 vdev_t *pvd = vd->vdev_parent; 1361 1362 ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL); 1363 1364 if (pvd != NULL && pvd->vdev_reopening) 1365 vd->vdev_reopening = pvd->vdev_reopening; 1366 1367 vd->vdev_ops->vdev_op_close(vd); 1368 1369 vdev_cache_purge(vd); 1370 1371 /* 1372 * We record the previous state before we close it, so that if we are 1373 * doing a reopen(), we don't generate FMA ereports if we notice that 1374 * it's still faulted. 1375 */ 1376 vd->vdev_prevstate = vd->vdev_state; 1377 1378 if (vd->vdev_offline) 1379 vd->vdev_state = VDEV_STATE_OFFLINE; 1380 else 1381 vd->vdev_state = VDEV_STATE_CLOSED; 1382 vd->vdev_stat.vs_aux = VDEV_AUX_NONE; 1383 } 1384 1385 /* 1386 * Reopen all interior vdevs and any unopened leaves. We don't actually 1387 * reopen leaf vdevs which had previously been opened as they might deadlock 1388 * on the spa_config_lock. Instead we only obtain the leaf's physical size. 1389 * If the leaf has never been opened then open it, as usual. 1390 */ 1391 void 1392 vdev_reopen(vdev_t *vd) 1393 { 1394 spa_t *spa = vd->vdev_spa; 1395 1396 ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL); 1397 1398 vd->vdev_reopening = B_TRUE; 1399 vdev_close(vd); 1400 (void) vdev_open(vd); 1401 1402 /* 1403 * Call vdev_validate() here to make sure we have the same device. 1404 * Otherwise, a device with an invalid label could be successfully 1405 * opened in response to vdev_reopen(). 1406 */ 1407 if (vd->vdev_aux) { 1408 (void) vdev_validate_aux(vd); 1409 if (vdev_readable(vd) && vdev_writeable(vd) && 1410 vd->vdev_aux == &spa->spa_l2cache && 1411 !l2arc_vdev_present(vd)) 1412 l2arc_add_vdev(spa, vd); 1413 } else { 1414 (void) vdev_validate(vd); 1415 } 1416 1417 /* 1418 * Reassess parent vdev's health. 1419 */ 1420 vdev_propagate_state(vd); 1421 } 1422 1423 int 1424 vdev_create(vdev_t *vd, uint64_t txg, boolean_t isreplacing) 1425 { 1426 int error; 1427 1428 /* 1429 * Normally, partial opens (e.g. of a mirror) are allowed. 1430 * For a create, however, we want to fail the request if 1431 * there are any components we can't open. 1432 */ 1433 error = vdev_open(vd); 1434 1435 if (error || vd->vdev_state != VDEV_STATE_HEALTHY) { 1436 vdev_close(vd); 1437 return (error ? error : ENXIO); 1438 } 1439 1440 /* 1441 * Recursively initialize all labels. 1442 */ 1443 if ((error = vdev_label_init(vd, txg, isreplacing ? 1444 VDEV_LABEL_REPLACE : VDEV_LABEL_CREATE)) != 0) { 1445 vdev_close(vd); 1446 return (error); 1447 } 1448 1449 return (0); 1450 } 1451 1452 void 1453 vdev_metaslab_set_size(vdev_t *vd) 1454 { 1455 /* 1456 * Aim for roughly 200 metaslabs per vdev. 1457 */ 1458 vd->vdev_ms_shift = highbit(vd->vdev_asize / 200); 1459 vd->vdev_ms_shift = MAX(vd->vdev_ms_shift, SPA_MAXBLOCKSHIFT); 1460 } 1461 1462 void 1463 vdev_dirty(vdev_t *vd, int flags, void *arg, uint64_t txg) 1464 { 1465 ASSERT(vd == vd->vdev_top); 1466 ASSERT(!vd->vdev_ishole); 1467 ASSERT(ISP2(flags)); 1468 1469 if (flags & VDD_METASLAB) 1470 (void) txg_list_add(&vd->vdev_ms_list, arg, txg); 1471 1472 if (flags & VDD_DTL) 1473 (void) txg_list_add(&vd->vdev_dtl_list, arg, txg); 1474 1475 (void) txg_list_add(&vd->vdev_spa->spa_vdev_txg_list, vd, txg); 1476 } 1477 1478 /* 1479 * DTLs. 1480 * 1481 * A vdev's DTL (dirty time log) is the set of transaction groups for which 1482 * the vdev has less than perfect replication. There are three kinds of DTL: 1483 * 1484 * DTL_MISSING: txgs for which the vdev has no valid copies of the data 1485 * 1486 * DTL_PARTIAL: txgs for which data is available, but not fully replicated 1487 * 1488 * DTL_SCRUB: the txgs that could not be repaired by the last scrub; upon 1489 * scrub completion, DTL_SCRUB replaces DTL_MISSING in the range of 1490 * txgs that was scrubbed. 1491 * 1492 * DTL_OUTAGE: txgs which cannot currently be read, whether due to 1493 * persistent errors or just some device being offline. 1494 * Unlike the other three, the DTL_OUTAGE map is not generally 1495 * maintained; it's only computed when needed, typically to 1496 * determine whether a device can be detached. 1497 * 1498 * For leaf vdevs, DTL_MISSING and DTL_PARTIAL are identical: the device 1499 * either has the data or it doesn't. 1500 * 1501 * For interior vdevs such as mirror and RAID-Z the picture is more complex. 1502 * A vdev's DTL_PARTIAL is the union of its children's DTL_PARTIALs, because 1503 * if any child is less than fully replicated, then so is its parent. 1504 * A vdev's DTL_MISSING is a modified union of its children's DTL_MISSINGs, 1505 * comprising only those txgs which appear in 'maxfaults' or more children; 1506 * those are the txgs we don't have enough replication to read. For example, 1507 * double-parity RAID-Z can tolerate up to two missing devices (maxfaults == 2); 1508 * thus, its DTL_MISSING consists of the set of txgs that appear in more than 1509 * two child DTL_MISSING maps. 1510 * 1511 * It should be clear from the above that to compute the DTLs and outage maps 1512 * for all vdevs, it suffices to know just the leaf vdevs' DTL_MISSING maps. 1513 * Therefore, that is all we keep on disk. When loading the pool, or after 1514 * a configuration change, we generate all other DTLs from first principles. 1515 */ 1516 void 1517 vdev_dtl_dirty(vdev_t *vd, vdev_dtl_type_t t, uint64_t txg, uint64_t size) 1518 { 1519 space_map_t *sm = &vd->vdev_dtl[t]; 1520 1521 ASSERT(t < DTL_TYPES); 1522 ASSERT(vd != vd->vdev_spa->spa_root_vdev); 1523 1524 mutex_enter(sm->sm_lock); 1525 if (!space_map_contains(sm, txg, size)) 1526 space_map_add(sm, txg, size); 1527 mutex_exit(sm->sm_lock); 1528 } 1529 1530 boolean_t 1531 vdev_dtl_contains(vdev_t *vd, vdev_dtl_type_t t, uint64_t txg, uint64_t size) 1532 { 1533 space_map_t *sm = &vd->vdev_dtl[t]; 1534 boolean_t dirty = B_FALSE; 1535 1536 ASSERT(t < DTL_TYPES); 1537 ASSERT(vd != vd->vdev_spa->spa_root_vdev); 1538 1539 mutex_enter(sm->sm_lock); 1540 if (sm->sm_space != 0) 1541 dirty = space_map_contains(sm, txg, size); 1542 mutex_exit(sm->sm_lock); 1543 1544 return (dirty); 1545 } 1546 1547 boolean_t 1548 vdev_dtl_empty(vdev_t *vd, vdev_dtl_type_t t) 1549 { 1550 space_map_t *sm = &vd->vdev_dtl[t]; 1551 boolean_t empty; 1552 1553 mutex_enter(sm->sm_lock); 1554 empty = (sm->sm_space == 0); 1555 mutex_exit(sm->sm_lock); 1556 1557 return (empty); 1558 } 1559 1560 /* 1561 * Reassess DTLs after a config change or scrub completion. 1562 */ 1563 void 1564 vdev_dtl_reassess(vdev_t *vd, uint64_t txg, uint64_t scrub_txg, int scrub_done) 1565 { 1566 spa_t *spa = vd->vdev_spa; 1567 avl_tree_t reftree; 1568 int minref; 1569 1570 ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0); 1571 1572 for (int c = 0; c < vd->vdev_children; c++) 1573 vdev_dtl_reassess(vd->vdev_child[c], txg, 1574 scrub_txg, scrub_done); 1575 1576 if (vd == spa->spa_root_vdev || vd->vdev_ishole) 1577 return; 1578 1579 if (vd->vdev_ops->vdev_op_leaf) { 1580 mutex_enter(&vd->vdev_dtl_lock); 1581 if (scrub_txg != 0 && 1582 (spa->spa_scrub_started || spa->spa_scrub_errors == 0)) { 1583 /* XXX should check scrub_done? */ 1584 /* 1585 * We completed a scrub up to scrub_txg. If we 1586 * did it without rebooting, then the scrub dtl 1587 * will be valid, so excise the old region and 1588 * fold in the scrub dtl. Otherwise, leave the 1589 * dtl as-is if there was an error. 1590 * 1591 * There's little trick here: to excise the beginning 1592 * of the DTL_MISSING map, we put it into a reference 1593 * tree and then add a segment with refcnt -1 that 1594 * covers the range [0, scrub_txg). This means 1595 * that each txg in that range has refcnt -1 or 0. 1596 * We then add DTL_SCRUB with a refcnt of 2, so that 1597 * entries in the range [0, scrub_txg) will have a 1598 * positive refcnt -- either 1 or 2. We then convert 1599 * the reference tree into the new DTL_MISSING map. 1600 */ 1601 space_map_ref_create(&reftree); 1602 space_map_ref_add_map(&reftree, 1603 &vd->vdev_dtl[DTL_MISSING], 1); 1604 space_map_ref_add_seg(&reftree, 0, scrub_txg, -1); 1605 space_map_ref_add_map(&reftree, 1606 &vd->vdev_dtl[DTL_SCRUB], 2); 1607 space_map_ref_generate_map(&reftree, 1608 &vd->vdev_dtl[DTL_MISSING], 1); 1609 space_map_ref_destroy(&reftree); 1610 } 1611 space_map_vacate(&vd->vdev_dtl[DTL_PARTIAL], NULL, NULL); 1612 space_map_walk(&vd->vdev_dtl[DTL_MISSING], 1613 space_map_add, &vd->vdev_dtl[DTL_PARTIAL]); 1614 if (scrub_done) 1615 space_map_vacate(&vd->vdev_dtl[DTL_SCRUB], NULL, NULL); 1616 space_map_vacate(&vd->vdev_dtl[DTL_OUTAGE], NULL, NULL); 1617 if (!vdev_readable(vd)) 1618 space_map_add(&vd->vdev_dtl[DTL_OUTAGE], 0, -1ULL); 1619 else 1620 space_map_walk(&vd->vdev_dtl[DTL_MISSING], 1621 space_map_add, &vd->vdev_dtl[DTL_OUTAGE]); 1622 mutex_exit(&vd->vdev_dtl_lock); 1623 1624 if (txg != 0) 1625 vdev_dirty(vd->vdev_top, VDD_DTL, vd, txg); 1626 return; 1627 } 1628 1629 mutex_enter(&vd->vdev_dtl_lock); 1630 for (int t = 0; t < DTL_TYPES; t++) { 1631 /* account for child's outage in parent's missing map */ 1632 int s = (t == DTL_MISSING) ? DTL_OUTAGE: t; 1633 if (t == DTL_SCRUB) 1634 continue; /* leaf vdevs only */ 1635 if (t == DTL_PARTIAL) 1636 minref = 1; /* i.e. non-zero */ 1637 else if (vd->vdev_nparity != 0) 1638 minref = vd->vdev_nparity + 1; /* RAID-Z */ 1639 else 1640 minref = vd->vdev_children; /* any kind of mirror */ 1641 space_map_ref_create(&reftree); 1642 for (int c = 0; c < vd->vdev_children; c++) { 1643 vdev_t *cvd = vd->vdev_child[c]; 1644 mutex_enter(&cvd->vdev_dtl_lock); 1645 space_map_ref_add_map(&reftree, &cvd->vdev_dtl[s], 1); 1646 mutex_exit(&cvd->vdev_dtl_lock); 1647 } 1648 space_map_ref_generate_map(&reftree, &vd->vdev_dtl[t], minref); 1649 space_map_ref_destroy(&reftree); 1650 } 1651 mutex_exit(&vd->vdev_dtl_lock); 1652 } 1653 1654 static int 1655 vdev_dtl_load(vdev_t *vd) 1656 { 1657 spa_t *spa = vd->vdev_spa; 1658 space_map_obj_t *smo = &vd->vdev_dtl_smo; 1659 objset_t *mos = spa->spa_meta_objset; 1660 dmu_buf_t *db; 1661 int error; 1662 1663 ASSERT(vd->vdev_children == 0); 1664 1665 if (smo->smo_object == 0) 1666 return (0); 1667 1668 ASSERT(!vd->vdev_ishole); 1669 1670 if ((error = dmu_bonus_hold(mos, smo->smo_object, FTAG, &db)) != 0) 1671 return (error); 1672 1673 ASSERT3U(db->db_size, >=, sizeof (*smo)); 1674 bcopy(db->db_data, smo, sizeof (*smo)); 1675 dmu_buf_rele(db, FTAG); 1676 1677 mutex_enter(&vd->vdev_dtl_lock); 1678 error = space_map_load(&vd->vdev_dtl[DTL_MISSING], 1679 NULL, SM_ALLOC, smo, mos); 1680 mutex_exit(&vd->vdev_dtl_lock); 1681 1682 return (error); 1683 } 1684 1685 void 1686 vdev_dtl_sync(vdev_t *vd, uint64_t txg) 1687 { 1688 spa_t *spa = vd->vdev_spa; 1689 space_map_obj_t *smo = &vd->vdev_dtl_smo; 1690 space_map_t *sm = &vd->vdev_dtl[DTL_MISSING]; 1691 objset_t *mos = spa->spa_meta_objset; 1692 space_map_t smsync; 1693 kmutex_t smlock; 1694 dmu_buf_t *db; 1695 dmu_tx_t *tx; 1696 1697 ASSERT(!vd->vdev_ishole); 1698 1699 tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg); 1700 1701 if (vd->vdev_detached) { 1702 if (smo->smo_object != 0) { 1703 int err = dmu_object_free(mos, smo->smo_object, tx); 1704 ASSERT3U(err, ==, 0); 1705 smo->smo_object = 0; 1706 } 1707 dmu_tx_commit(tx); 1708 return; 1709 } 1710 1711 if (smo->smo_object == 0) { 1712 ASSERT(smo->smo_objsize == 0); 1713 ASSERT(smo->smo_alloc == 0); 1714 smo->smo_object = dmu_object_alloc(mos, 1715 DMU_OT_SPACE_MAP, 1 << SPACE_MAP_BLOCKSHIFT, 1716 DMU_OT_SPACE_MAP_HEADER, sizeof (*smo), tx); 1717 ASSERT(smo->smo_object != 0); 1718 vdev_config_dirty(vd->vdev_top); 1719 } 1720 1721 mutex_init(&smlock, NULL, MUTEX_DEFAULT, NULL); 1722 1723 space_map_create(&smsync, sm->sm_start, sm->sm_size, sm->sm_shift, 1724 &smlock); 1725 1726 mutex_enter(&smlock); 1727 1728 mutex_enter(&vd->vdev_dtl_lock); 1729 space_map_walk(sm, space_map_add, &smsync); 1730 mutex_exit(&vd->vdev_dtl_lock); 1731 1732 space_map_truncate(smo, mos, tx); 1733 space_map_sync(&smsync, SM_ALLOC, smo, mos, tx); 1734 1735 space_map_destroy(&smsync); 1736 1737 mutex_exit(&smlock); 1738 mutex_destroy(&smlock); 1739 1740 VERIFY(0 == dmu_bonus_hold(mos, smo->smo_object, FTAG, &db)); 1741 dmu_buf_will_dirty(db, tx); 1742 ASSERT3U(db->db_size, >=, sizeof (*smo)); 1743 bcopy(smo, db->db_data, sizeof (*smo)); 1744 dmu_buf_rele(db, FTAG); 1745 1746 dmu_tx_commit(tx); 1747 } 1748 1749 /* 1750 * Determine whether the specified vdev can be offlined/detached/removed 1751 * without losing data. 1752 */ 1753 boolean_t 1754 vdev_dtl_required(vdev_t *vd) 1755 { 1756 spa_t *spa = vd->vdev_spa; 1757 vdev_t *tvd = vd->vdev_top; 1758 uint8_t cant_read = vd->vdev_cant_read; 1759 boolean_t required; 1760 1761 ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL); 1762 1763 if (vd == spa->spa_root_vdev || vd == tvd) 1764 return (B_TRUE); 1765 1766 /* 1767 * Temporarily mark the device as unreadable, and then determine 1768 * whether this results in any DTL outages in the top-level vdev. 1769 * If not, we can safely offline/detach/remove the device. 1770 */ 1771 vd->vdev_cant_read = B_TRUE; 1772 vdev_dtl_reassess(tvd, 0, 0, B_FALSE); 1773 required = !vdev_dtl_empty(tvd, DTL_OUTAGE); 1774 vd->vdev_cant_read = cant_read; 1775 vdev_dtl_reassess(tvd, 0, 0, B_FALSE); 1776 1777 return (required); 1778 } 1779 1780 /* 1781 * Determine if resilver is needed, and if so the txg range. 1782 */ 1783 boolean_t 1784 vdev_resilver_needed(vdev_t *vd, uint64_t *minp, uint64_t *maxp) 1785 { 1786 boolean_t needed = B_FALSE; 1787 uint64_t thismin = UINT64_MAX; 1788 uint64_t thismax = 0; 1789 1790 if (vd->vdev_children == 0) { 1791 mutex_enter(&vd->vdev_dtl_lock); 1792 if (vd->vdev_dtl[DTL_MISSING].sm_space != 0 && 1793 vdev_writeable(vd)) { 1794 space_seg_t *ss; 1795 1796 ss = avl_first(&vd->vdev_dtl[DTL_MISSING].sm_root); 1797 thismin = ss->ss_start - 1; 1798 ss = avl_last(&vd->vdev_dtl[DTL_MISSING].sm_root); 1799 thismax = ss->ss_end; 1800 needed = B_TRUE; 1801 } 1802 mutex_exit(&vd->vdev_dtl_lock); 1803 } else { 1804 for (int c = 0; c < vd->vdev_children; c++) { 1805 vdev_t *cvd = vd->vdev_child[c]; 1806 uint64_t cmin, cmax; 1807 1808 if (vdev_resilver_needed(cvd, &cmin, &cmax)) { 1809 thismin = MIN(thismin, cmin); 1810 thismax = MAX(thismax, cmax); 1811 needed = B_TRUE; 1812 } 1813 } 1814 } 1815 1816 if (needed && minp) { 1817 *minp = thismin; 1818 *maxp = thismax; 1819 } 1820 return (needed); 1821 } 1822 1823 void 1824 vdev_load(vdev_t *vd) 1825 { 1826 /* 1827 * Recursively load all children. 1828 */ 1829 for (int c = 0; c < vd->vdev_children; c++) 1830 vdev_load(vd->vdev_child[c]); 1831 1832 /* 1833 * If this is a top-level vdev, initialize its metaslabs. 1834 */ 1835 if (vd == vd->vdev_top && !vd->vdev_ishole && 1836 (vd->vdev_ashift == 0 || vd->vdev_asize == 0 || 1837 vdev_metaslab_init(vd, 0) != 0)) 1838 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN, 1839 VDEV_AUX_CORRUPT_DATA); 1840 1841 /* 1842 * If this is a leaf vdev, load its DTL. 1843 */ 1844 if (vd->vdev_ops->vdev_op_leaf && vdev_dtl_load(vd) != 0) 1845 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN, 1846 VDEV_AUX_CORRUPT_DATA); 1847 } 1848 1849 /* 1850 * The special vdev case is used for hot spares and l2cache devices. Its 1851 * sole purpose it to set the vdev state for the associated vdev. To do this, 1852 * we make sure that we can open the underlying device, then try to read the 1853 * label, and make sure that the label is sane and that it hasn't been 1854 * repurposed to another pool. 1855 */ 1856 int 1857 vdev_validate_aux(vdev_t *vd) 1858 { 1859 nvlist_t *label; 1860 uint64_t guid, version; 1861 uint64_t state; 1862 1863 if (!vdev_readable(vd)) 1864 return (0); 1865 1866 if ((label = vdev_label_read_config(vd)) == NULL) { 1867 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 1868 VDEV_AUX_CORRUPT_DATA); 1869 return (-1); 1870 } 1871 1872 if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_VERSION, &version) != 0 || 1873 version > SPA_VERSION || 1874 nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID, &guid) != 0 || 1875 guid != vd->vdev_guid || 1876 nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_STATE, &state) != 0) { 1877 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 1878 VDEV_AUX_CORRUPT_DATA); 1879 nvlist_free(label); 1880 return (-1); 1881 } 1882 1883 /* 1884 * We don't actually check the pool state here. If it's in fact in 1885 * use by another pool, we update this fact on the fly when requested. 1886 */ 1887 nvlist_free(label); 1888 return (0); 1889 } 1890 1891 void 1892 vdev_remove(vdev_t *vd, uint64_t txg) 1893 { 1894 spa_t *spa = vd->vdev_spa; 1895 objset_t *mos = spa->spa_meta_objset; 1896 dmu_tx_t *tx; 1897 1898 tx = dmu_tx_create_assigned(spa_get_dsl(spa), txg); 1899 1900 if (vd->vdev_dtl_smo.smo_object) { 1901 ASSERT3U(vd->vdev_dtl_smo.smo_alloc, ==, 0); 1902 (void) dmu_object_free(mos, vd->vdev_dtl_smo.smo_object, tx); 1903 vd->vdev_dtl_smo.smo_object = 0; 1904 } 1905 1906 if (vd->vdev_ms != NULL) { 1907 for (int m = 0; m < vd->vdev_ms_count; m++) { 1908 metaslab_t *msp = vd->vdev_ms[m]; 1909 1910 if (msp == NULL || msp->ms_smo.smo_object == 0) 1911 continue; 1912 1913 ASSERT3U(msp->ms_smo.smo_alloc, ==, 0); 1914 (void) dmu_object_free(mos, msp->ms_smo.smo_object, tx); 1915 msp->ms_smo.smo_object = 0; 1916 } 1917 } 1918 1919 if (vd->vdev_ms_array) { 1920 (void) dmu_object_free(mos, vd->vdev_ms_array, tx); 1921 vd->vdev_ms_array = 0; 1922 vd->vdev_ms_shift = 0; 1923 } 1924 dmu_tx_commit(tx); 1925 } 1926 1927 void 1928 vdev_sync_done(vdev_t *vd, uint64_t txg) 1929 { 1930 metaslab_t *msp; 1931 1932 ASSERT(!vd->vdev_ishole); 1933 1934 while (msp = txg_list_remove(&vd->vdev_ms_list, TXG_CLEAN(txg))) 1935 metaslab_sync_done(msp, txg); 1936 } 1937 1938 void 1939 vdev_sync(vdev_t *vd, uint64_t txg) 1940 { 1941 spa_t *spa = vd->vdev_spa; 1942 vdev_t *lvd; 1943 metaslab_t *msp; 1944 dmu_tx_t *tx; 1945 1946 ASSERT(!vd->vdev_ishole); 1947 1948 if (vd->vdev_ms_array == 0 && vd->vdev_ms_shift != 0) { 1949 ASSERT(vd == vd->vdev_top); 1950 tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg); 1951 vd->vdev_ms_array = dmu_object_alloc(spa->spa_meta_objset, 1952 DMU_OT_OBJECT_ARRAY, 0, DMU_OT_NONE, 0, tx); 1953 ASSERT(vd->vdev_ms_array != 0); 1954 vdev_config_dirty(vd); 1955 dmu_tx_commit(tx); 1956 } 1957 1958 if (vd->vdev_removing) 1959 vdev_remove(vd, txg); 1960 1961 while ((msp = txg_list_remove(&vd->vdev_ms_list, txg)) != NULL) { 1962 metaslab_sync(msp, txg); 1963 (void) txg_list_add(&vd->vdev_ms_list, msp, TXG_CLEAN(txg)); 1964 } 1965 1966 while ((lvd = txg_list_remove(&vd->vdev_dtl_list, txg)) != NULL) 1967 vdev_dtl_sync(lvd, txg); 1968 1969 (void) txg_list_add(&spa->spa_vdev_txg_list, vd, TXG_CLEAN(txg)); 1970 } 1971 1972 uint64_t 1973 vdev_psize_to_asize(vdev_t *vd, uint64_t psize) 1974 { 1975 return (vd->vdev_ops->vdev_op_asize(vd, psize)); 1976 } 1977 1978 /* 1979 * Mark the given vdev faulted. A faulted vdev behaves as if the device could 1980 * not be opened, and no I/O is attempted. 1981 */ 1982 int 1983 vdev_fault(spa_t *spa, uint64_t guid, vdev_aux_t aux) 1984 { 1985 vdev_t *vd; 1986 1987 spa_vdev_state_enter(spa, SCL_NONE); 1988 1989 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) 1990 return (spa_vdev_state_exit(spa, NULL, ENODEV)); 1991 1992 if (!vd->vdev_ops->vdev_op_leaf) 1993 return (spa_vdev_state_exit(spa, NULL, ENOTSUP)); 1994 1995 /* 1996 * We don't directly use the aux state here, but if we do a 1997 * vdev_reopen(), we need this value to be present to remember why we 1998 * were faulted. 1999 */ 2000 vd->vdev_label_aux = aux; 2001 2002 /* 2003 * Faulted state takes precedence over degraded. 2004 */ 2005 vd->vdev_faulted = 1ULL; 2006 vd->vdev_degraded = 0ULL; 2007 vdev_set_state(vd, B_FALSE, VDEV_STATE_FAULTED, aux); 2008 2009 /* 2010 * If marking the vdev as faulted cause the top-level vdev to become 2011 * unavailable, then back off and simply mark the vdev as degraded 2012 * instead. 2013 */ 2014 if (vdev_is_dead(vd->vdev_top) && !vd->vdev_islog && 2015 vd->vdev_aux == NULL) { 2016 vd->vdev_degraded = 1ULL; 2017 vd->vdev_faulted = 0ULL; 2018 2019 /* 2020 * If we reopen the device and it's not dead, only then do we 2021 * mark it degraded. 2022 */ 2023 vdev_reopen(vd); 2024 2025 if (vdev_readable(vd)) 2026 vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED, aux); 2027 } 2028 2029 return (spa_vdev_state_exit(spa, vd, 0)); 2030 } 2031 2032 /* 2033 * Mark the given vdev degraded. A degraded vdev is purely an indication to the 2034 * user that something is wrong. The vdev continues to operate as normal as far 2035 * as I/O is concerned. 2036 */ 2037 int 2038 vdev_degrade(spa_t *spa, uint64_t guid, vdev_aux_t aux) 2039 { 2040 vdev_t *vd; 2041 2042 spa_vdev_state_enter(spa, SCL_NONE); 2043 2044 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) 2045 return (spa_vdev_state_exit(spa, NULL, ENODEV)); 2046 2047 if (!vd->vdev_ops->vdev_op_leaf) 2048 return (spa_vdev_state_exit(spa, NULL, ENOTSUP)); 2049 2050 /* 2051 * If the vdev is already faulted, then don't do anything. 2052 */ 2053 if (vd->vdev_faulted || vd->vdev_degraded) 2054 return (spa_vdev_state_exit(spa, NULL, 0)); 2055 2056 vd->vdev_degraded = 1ULL; 2057 if (!vdev_is_dead(vd)) 2058 vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED, 2059 aux); 2060 2061 return (spa_vdev_state_exit(spa, vd, 0)); 2062 } 2063 2064 /* 2065 * Online the given vdev. If 'unspare' is set, it implies two things. First, 2066 * any attached spare device should be detached when the device finishes 2067 * resilvering. Second, the online should be treated like a 'test' online case, 2068 * so no FMA events are generated if the device fails to open. 2069 */ 2070 int 2071 vdev_online(spa_t *spa, uint64_t guid, uint64_t flags, vdev_state_t *newstate) 2072 { 2073 vdev_t *vd, *tvd, *pvd, *rvd = spa->spa_root_vdev; 2074 2075 spa_vdev_state_enter(spa, SCL_NONE); 2076 2077 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) 2078 return (spa_vdev_state_exit(spa, NULL, ENODEV)); 2079 2080 if (!vd->vdev_ops->vdev_op_leaf) 2081 return (spa_vdev_state_exit(spa, NULL, ENOTSUP)); 2082 2083 tvd = vd->vdev_top; 2084 vd->vdev_offline = B_FALSE; 2085 vd->vdev_tmpoffline = B_FALSE; 2086 vd->vdev_checkremove = !!(flags & ZFS_ONLINE_CHECKREMOVE); 2087 vd->vdev_forcefault = !!(flags & ZFS_ONLINE_FORCEFAULT); 2088 2089 /* XXX - L2ARC 1.0 does not support expansion */ 2090 if (!vd->vdev_aux) { 2091 for (pvd = vd; pvd != rvd; pvd = pvd->vdev_parent) 2092 pvd->vdev_expanding = !!(flags & ZFS_ONLINE_EXPAND); 2093 } 2094 2095 vdev_reopen(tvd); 2096 vd->vdev_checkremove = vd->vdev_forcefault = B_FALSE; 2097 2098 if (!vd->vdev_aux) { 2099 for (pvd = vd; pvd != rvd; pvd = pvd->vdev_parent) 2100 pvd->vdev_expanding = B_FALSE; 2101 } 2102 2103 if (newstate) 2104 *newstate = vd->vdev_state; 2105 if ((flags & ZFS_ONLINE_UNSPARE) && 2106 !vdev_is_dead(vd) && vd->vdev_parent && 2107 vd->vdev_parent->vdev_ops == &vdev_spare_ops && 2108 vd->vdev_parent->vdev_child[0] == vd) 2109 vd->vdev_unspare = B_TRUE; 2110 2111 if ((flags & ZFS_ONLINE_EXPAND) || spa->spa_autoexpand) { 2112 2113 /* XXX - L2ARC 1.0 does not support expansion */ 2114 if (vd->vdev_aux) 2115 return (spa_vdev_state_exit(spa, vd, ENOTSUP)); 2116 spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); 2117 } 2118 return (spa_vdev_state_exit(spa, vd, 0)); 2119 } 2120 2121 int 2122 vdev_offline_log(spa_t *spa) 2123 { 2124 int error = 0; 2125 2126 if ((error = dmu_objset_find(spa_name(spa), zil_vdev_offline, 2127 NULL, DS_FIND_CHILDREN)) == 0) { 2128 2129 /* 2130 * We successfully offlined the log device, sync out the 2131 * current txg so that the "stubby" block can be removed 2132 * by zil_sync(). 2133 */ 2134 txg_wait_synced(spa->spa_dsl_pool, 0); 2135 } 2136 return (error); 2137 } 2138 2139 int 2140 vdev_offline(spa_t *spa, uint64_t guid, uint64_t flags) 2141 { 2142 vdev_t *vd, *tvd; 2143 int error = 0; 2144 uint64_t generation; 2145 metaslab_group_t *mg; 2146 2147 top: 2148 spa_vdev_state_enter(spa, SCL_ALLOC); 2149 2150 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) 2151 return (spa_vdev_state_exit(spa, NULL, ENODEV)); 2152 2153 if (!vd->vdev_ops->vdev_op_leaf) 2154 return (spa_vdev_state_exit(spa, NULL, ENOTSUP)); 2155 2156 tvd = vd->vdev_top; 2157 mg = tvd->vdev_mg; 2158 generation = spa->spa_config_generation + 1; 2159 2160 /* 2161 * If the device isn't already offline, try to offline it. 2162 */ 2163 if (!vd->vdev_offline) { 2164 /* 2165 * If this device has the only valid copy of some data, 2166 * don't allow it to be offlined. Log devices are always 2167 * expendable. 2168 */ 2169 if (!tvd->vdev_islog && vd->vdev_aux == NULL && 2170 vdev_dtl_required(vd)) 2171 return (spa_vdev_state_exit(spa, NULL, EBUSY)); 2172 2173 /* 2174 * If the top-level is a slog and it's had allocations 2175 * then proceed. We check that the vdev's metaslab 2176 * grop is not NULL since it's possible that we may 2177 * have just added this vdev and have not yet initialized 2178 * it's metaslabs. 2179 */ 2180 if (tvd->vdev_islog && mg != NULL) { 2181 /* 2182 * Prevent any future allocations. 2183 */ 2184 metaslab_class_remove(spa->spa_log_class, mg); 2185 (void) spa_vdev_state_exit(spa, vd, 0); 2186 2187 error = vdev_offline_log(spa); 2188 2189 spa_vdev_state_enter(spa, SCL_ALLOC); 2190 2191 /* 2192 * Check to see if the config has changed. 2193 */ 2194 if (error || generation != spa->spa_config_generation) { 2195 metaslab_class_add(spa->spa_log_class, mg); 2196 if (error) 2197 return (spa_vdev_state_exit(spa, 2198 vd, error)); 2199 (void) spa_vdev_state_exit(spa, vd, 0); 2200 goto top; 2201 } 2202 ASSERT3U(tvd->vdev_stat.vs_alloc, ==, 0); 2203 } 2204 2205 /* 2206 * Offline this device and reopen its top-level vdev. 2207 * If the top-level vdev is a log device then just offline 2208 * it. Otherwise, if this action results in the top-level 2209 * vdev becoming unusable, undo it and fail the request. 2210 */ 2211 vd->vdev_offline = B_TRUE; 2212 vdev_reopen(tvd); 2213 2214 if (!tvd->vdev_islog && vd->vdev_aux == NULL && 2215 vdev_is_dead(tvd)) { 2216 vd->vdev_offline = B_FALSE; 2217 vdev_reopen(tvd); 2218 return (spa_vdev_state_exit(spa, NULL, EBUSY)); 2219 } 2220 2221 /* 2222 * Add the device back into the metaslab rotor so that 2223 * once we online the device it's open for business. 2224 */ 2225 if (tvd->vdev_islog && mg != NULL) 2226 metaslab_class_add(spa->spa_log_class, mg); 2227 } 2228 2229 vd->vdev_tmpoffline = !!(flags & ZFS_OFFLINE_TEMPORARY); 2230 2231 return (spa_vdev_state_exit(spa, vd, 0)); 2232 } 2233 2234 /* 2235 * Clear the error counts associated with this vdev. Unlike vdev_online() and 2236 * vdev_offline(), we assume the spa config is locked. We also clear all 2237 * children. If 'vd' is NULL, then the user wants to clear all vdevs. 2238 */ 2239 void 2240 vdev_clear(spa_t *spa, vdev_t *vd) 2241 { 2242 vdev_t *rvd = spa->spa_root_vdev; 2243 2244 ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL); 2245 2246 if (vd == NULL) 2247 vd = rvd; 2248 2249 vd->vdev_stat.vs_read_errors = 0; 2250 vd->vdev_stat.vs_write_errors = 0; 2251 vd->vdev_stat.vs_checksum_errors = 0; 2252 2253 for (int c = 0; c < vd->vdev_children; c++) 2254 vdev_clear(spa, vd->vdev_child[c]); 2255 2256 /* 2257 * If we're in the FAULTED state or have experienced failed I/O, then 2258 * clear the persistent state and attempt to reopen the device. We 2259 * also mark the vdev config dirty, so that the new faulted state is 2260 * written out to disk. 2261 */ 2262 if (vd->vdev_faulted || vd->vdev_degraded || 2263 !vdev_readable(vd) || !vdev_writeable(vd)) { 2264 2265 /* 2266 * When reopening in reponse to a clear event, it may be due to 2267 * a fmadm repair request. In this case, if the device is 2268 * still broken, we want to still post the ereport again. 2269 */ 2270 vd->vdev_forcefault = B_TRUE; 2271 2272 vd->vdev_faulted = vd->vdev_degraded = 0; 2273 vd->vdev_cant_read = B_FALSE; 2274 vd->vdev_cant_write = B_FALSE; 2275 2276 vdev_reopen(vd); 2277 2278 vd->vdev_forcefault = B_FALSE; 2279 2280 if (vd != rvd) 2281 vdev_state_dirty(vd->vdev_top); 2282 2283 if (vd->vdev_aux == NULL && !vdev_is_dead(vd)) 2284 spa_async_request(spa, SPA_ASYNC_RESILVER); 2285 2286 spa_event_notify(spa, vd, ESC_ZFS_VDEV_CLEAR); 2287 } 2288 2289 /* 2290 * When clearing a FMA-diagnosed fault, we always want to 2291 * unspare the device, as we assume that the original spare was 2292 * done in response to the FMA fault. 2293 */ 2294 if (!vdev_is_dead(vd) && vd->vdev_parent != NULL && 2295 vd->vdev_parent->vdev_ops == &vdev_spare_ops && 2296 vd->vdev_parent->vdev_child[0] == vd) 2297 vd->vdev_unspare = B_TRUE; 2298 } 2299 2300 boolean_t 2301 vdev_is_dead(vdev_t *vd) 2302 { 2303 /* 2304 * Holes and missing devices are always considered "dead". 2305 * This simplifies the code since we don't have to check for 2306 * these types of devices in the various code paths. 2307 * Instead we rely on the fact that we skip over dead devices 2308 * before issuing I/O to them. 2309 */ 2310 return (vd->vdev_state < VDEV_STATE_DEGRADED || vd->vdev_ishole || 2311 vd->vdev_ops == &vdev_missing_ops); 2312 } 2313 2314 boolean_t 2315 vdev_readable(vdev_t *vd) 2316 { 2317 return (!vdev_is_dead(vd) && !vd->vdev_cant_read); 2318 } 2319 2320 boolean_t 2321 vdev_writeable(vdev_t *vd) 2322 { 2323 return (!vdev_is_dead(vd) && !vd->vdev_cant_write); 2324 } 2325 2326 boolean_t 2327 vdev_allocatable(vdev_t *vd) 2328 { 2329 uint64_t state = vd->vdev_state; 2330 2331 /* 2332 * We currently allow allocations from vdevs which may be in the 2333 * process of reopening (i.e. VDEV_STATE_CLOSED). If the device 2334 * fails to reopen then we'll catch it later when we're holding 2335 * the proper locks. Note that we have to get the vdev state 2336 * in a local variable because although it changes atomically, 2337 * we're asking two separate questions about it. 2338 */ 2339 return (!(state < VDEV_STATE_DEGRADED && state != VDEV_STATE_CLOSED) && 2340 !vd->vdev_cant_write && !vd->vdev_ishole && !vd->vdev_removing); 2341 } 2342 2343 boolean_t 2344 vdev_accessible(vdev_t *vd, zio_t *zio) 2345 { 2346 ASSERT(zio->io_vd == vd); 2347 2348 if (vdev_is_dead(vd) || vd->vdev_remove_wanted) 2349 return (B_FALSE); 2350 2351 if (zio->io_type == ZIO_TYPE_READ) 2352 return (!vd->vdev_cant_read); 2353 2354 if (zio->io_type == ZIO_TYPE_WRITE) 2355 return (!vd->vdev_cant_write); 2356 2357 return (B_TRUE); 2358 } 2359 2360 /* 2361 * Get statistics for the given vdev. 2362 */ 2363 void 2364 vdev_get_stats(vdev_t *vd, vdev_stat_t *vs) 2365 { 2366 vdev_t *rvd = vd->vdev_spa->spa_root_vdev; 2367 2368 mutex_enter(&vd->vdev_stat_lock); 2369 bcopy(&vd->vdev_stat, vs, sizeof (*vs)); 2370 vs->vs_scrub_errors = vd->vdev_spa->spa_scrub_errors; 2371 vs->vs_timestamp = gethrtime() - vs->vs_timestamp; 2372 vs->vs_state = vd->vdev_state; 2373 vs->vs_rsize = vdev_get_min_asize(vd); 2374 if (vd->vdev_ops->vdev_op_leaf) 2375 vs->vs_rsize += VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE; 2376 mutex_exit(&vd->vdev_stat_lock); 2377 2378 /* 2379 * If we're getting stats on the root vdev, aggregate the I/O counts 2380 * over all top-level vdevs (i.e. the direct children of the root). 2381 */ 2382 if (vd == rvd) { 2383 for (int c = 0; c < rvd->vdev_children; c++) { 2384 vdev_t *cvd = rvd->vdev_child[c]; 2385 vdev_stat_t *cvs = &cvd->vdev_stat; 2386 2387 mutex_enter(&vd->vdev_stat_lock); 2388 for (int t = 0; t < ZIO_TYPES; t++) { 2389 vs->vs_ops[t] += cvs->vs_ops[t]; 2390 vs->vs_bytes[t] += cvs->vs_bytes[t]; 2391 } 2392 vs->vs_scrub_examined += cvs->vs_scrub_examined; 2393 mutex_exit(&vd->vdev_stat_lock); 2394 } 2395 } 2396 } 2397 2398 void 2399 vdev_clear_stats(vdev_t *vd) 2400 { 2401 mutex_enter(&vd->vdev_stat_lock); 2402 vd->vdev_stat.vs_space = 0; 2403 vd->vdev_stat.vs_dspace = 0; 2404 vd->vdev_stat.vs_alloc = 0; 2405 mutex_exit(&vd->vdev_stat_lock); 2406 } 2407 2408 void 2409 vdev_stat_update(zio_t *zio, uint64_t psize) 2410 { 2411 spa_t *spa = zio->io_spa; 2412 vdev_t *rvd = spa->spa_root_vdev; 2413 vdev_t *vd = zio->io_vd ? zio->io_vd : rvd; 2414 vdev_t *pvd; 2415 uint64_t txg = zio->io_txg; 2416 vdev_stat_t *vs = &vd->vdev_stat; 2417 zio_type_t type = zio->io_type; 2418 int flags = zio->io_flags; 2419 2420 /* 2421 * If this i/o is a gang leader, it didn't do any actual work. 2422 */ 2423 if (zio->io_gang_tree) 2424 return; 2425 2426 if (zio->io_error == 0) { 2427 /* 2428 * If this is a root i/o, don't count it -- we've already 2429 * counted the top-level vdevs, and vdev_get_stats() will 2430 * aggregate them when asked. This reduces contention on 2431 * the root vdev_stat_lock and implicitly handles blocks 2432 * that compress away to holes, for which there is no i/o. 2433 * (Holes never create vdev children, so all the counters 2434 * remain zero, which is what we want.) 2435 * 2436 * Note: this only applies to successful i/o (io_error == 0) 2437 * because unlike i/o counts, errors are not additive. 2438 * When reading a ditto block, for example, failure of 2439 * one top-level vdev does not imply a root-level error. 2440 */ 2441 if (vd == rvd) 2442 return; 2443 2444 ASSERT(vd == zio->io_vd); 2445 2446 if (flags & ZIO_FLAG_IO_BYPASS) 2447 return; 2448 2449 mutex_enter(&vd->vdev_stat_lock); 2450 2451 if (flags & ZIO_FLAG_IO_REPAIR) { 2452 if (flags & ZIO_FLAG_SCRUB_THREAD) 2453 vs->vs_scrub_repaired += psize; 2454 if (flags & ZIO_FLAG_SELF_HEAL) 2455 vs->vs_self_healed += psize; 2456 } 2457 2458 vs->vs_ops[type]++; 2459 vs->vs_bytes[type] += psize; 2460 2461 mutex_exit(&vd->vdev_stat_lock); 2462 return; 2463 } 2464 2465 if (flags & ZIO_FLAG_SPECULATIVE) 2466 return; 2467 2468 /* 2469 * If this is an I/O error that is going to be retried, then ignore the 2470 * error. Otherwise, the user may interpret B_FAILFAST I/O errors as 2471 * hard errors, when in reality they can happen for any number of 2472 * innocuous reasons (bus resets, MPxIO link failure, etc). 2473 */ 2474 if (zio->io_error == EIO && 2475 !(zio->io_flags & ZIO_FLAG_IO_RETRY)) 2476 return; 2477 2478 /* 2479 * Intent logs writes won't propagate their error to the root 2480 * I/O so don't mark these types of failures as pool-level 2481 * errors. 2482 */ 2483 if (zio->io_vd == NULL && (zio->io_flags & ZIO_FLAG_DONT_PROPAGATE)) 2484 return; 2485 2486 mutex_enter(&vd->vdev_stat_lock); 2487 if (type == ZIO_TYPE_READ && !vdev_is_dead(vd)) { 2488 if (zio->io_error == ECKSUM) 2489 vs->vs_checksum_errors++; 2490 else 2491 vs->vs_read_errors++; 2492 } 2493 if (type == ZIO_TYPE_WRITE && !vdev_is_dead(vd)) 2494 vs->vs_write_errors++; 2495 mutex_exit(&vd->vdev_stat_lock); 2496 2497 if (type == ZIO_TYPE_WRITE && txg != 0 && 2498 (!(flags & ZIO_FLAG_IO_REPAIR) || 2499 (flags & ZIO_FLAG_SCRUB_THREAD))) { 2500 /* 2501 * This is either a normal write (not a repair), or it's a 2502 * repair induced by the scrub thread. In the normal case, 2503 * we commit the DTL change in the same txg as the block 2504 * was born. In the scrub-induced repair case, we know that 2505 * scrubs run in first-pass syncing context, so we commit 2506 * the DTL change in spa->spa_syncing_txg. 2507 * 2508 * We currently do not make DTL entries for failed spontaneous 2509 * self-healing writes triggered by normal (non-scrubbing) 2510 * reads, because we have no transactional context in which to 2511 * do so -- and it's not clear that it'd be desirable anyway. 2512 */ 2513 if (vd->vdev_ops->vdev_op_leaf) { 2514 uint64_t commit_txg = txg; 2515 if (flags & ZIO_FLAG_SCRUB_THREAD) { 2516 ASSERT(flags & ZIO_FLAG_IO_REPAIR); 2517 ASSERT(spa_sync_pass(spa) == 1); 2518 vdev_dtl_dirty(vd, DTL_SCRUB, txg, 1); 2519 commit_txg = spa->spa_syncing_txg; 2520 } 2521 ASSERT(commit_txg >= spa->spa_syncing_txg); 2522 if (vdev_dtl_contains(vd, DTL_MISSING, txg, 1)) 2523 return; 2524 for (pvd = vd; pvd != rvd; pvd = pvd->vdev_parent) 2525 vdev_dtl_dirty(pvd, DTL_PARTIAL, txg, 1); 2526 vdev_dirty(vd->vdev_top, VDD_DTL, vd, commit_txg); 2527 } 2528 if (vd != rvd) 2529 vdev_dtl_dirty(vd, DTL_MISSING, txg, 1); 2530 } 2531 } 2532 2533 void 2534 vdev_scrub_stat_update(vdev_t *vd, pool_scrub_type_t type, boolean_t complete) 2535 { 2536 vdev_stat_t *vs = &vd->vdev_stat; 2537 2538 for (int c = 0; c < vd->vdev_children; c++) 2539 vdev_scrub_stat_update(vd->vdev_child[c], type, complete); 2540 2541 mutex_enter(&vd->vdev_stat_lock); 2542 2543 if (type == POOL_SCRUB_NONE) { 2544 /* 2545 * Update completion and end time. Leave everything else alone 2546 * so we can report what happened during the previous scrub. 2547 */ 2548 vs->vs_scrub_complete = complete; 2549 vs->vs_scrub_end = gethrestime_sec(); 2550 } else { 2551 vs->vs_scrub_type = type; 2552 vs->vs_scrub_complete = 0; 2553 vs->vs_scrub_examined = 0; 2554 vs->vs_scrub_repaired = 0; 2555 vs->vs_scrub_start = gethrestime_sec(); 2556 vs->vs_scrub_end = 0; 2557 } 2558 2559 mutex_exit(&vd->vdev_stat_lock); 2560 } 2561 2562 /* 2563 * Update the in-core space usage stats for this vdev and the root vdev. 2564 */ 2565 void 2566 vdev_space_update(vdev_t *vd, int64_t space_delta, int64_t alloc_delta, 2567 boolean_t update_root) 2568 { 2569 int64_t dspace_delta = space_delta; 2570 spa_t *spa = vd->vdev_spa; 2571 vdev_t *rvd = spa->spa_root_vdev; 2572 2573 ASSERT(vd == vd->vdev_top); 2574 2575 /* 2576 * Apply the inverse of the psize-to-asize (ie. RAID-Z) space-expansion 2577 * factor. We must calculate this here and not at the root vdev 2578 * because the root vdev's psize-to-asize is simply the max of its 2579 * childrens', thus not accurate enough for us. 2580 */ 2581 ASSERT((dspace_delta & (SPA_MINBLOCKSIZE-1)) == 0); 2582 ASSERT(vd->vdev_deflate_ratio != 0 || vd->vdev_isl2cache); 2583 dspace_delta = (dspace_delta >> SPA_MINBLOCKSHIFT) * 2584 vd->vdev_deflate_ratio; 2585 2586 mutex_enter(&vd->vdev_stat_lock); 2587 vd->vdev_stat.vs_space += space_delta; 2588 vd->vdev_stat.vs_alloc += alloc_delta; 2589 vd->vdev_stat.vs_dspace += dspace_delta; 2590 mutex_exit(&vd->vdev_stat_lock); 2591 2592 if (update_root) { 2593 ASSERT(rvd == vd->vdev_parent); 2594 ASSERT(vd->vdev_ms_count != 0); 2595 2596 /* 2597 * Don't count non-normal (e.g. intent log) space as part of 2598 * the pool's capacity. 2599 */ 2600 if (vd->vdev_islog) 2601 return; 2602 2603 mutex_enter(&rvd->vdev_stat_lock); 2604 rvd->vdev_stat.vs_space += space_delta; 2605 rvd->vdev_stat.vs_alloc += alloc_delta; 2606 rvd->vdev_stat.vs_dspace += dspace_delta; 2607 mutex_exit(&rvd->vdev_stat_lock); 2608 } 2609 } 2610 2611 /* 2612 * Mark a top-level vdev's config as dirty, placing it on the dirty list 2613 * so that it will be written out next time the vdev configuration is synced. 2614 * If the root vdev is specified (vdev_top == NULL), dirty all top-level vdevs. 2615 */ 2616 void 2617 vdev_config_dirty(vdev_t *vd) 2618 { 2619 spa_t *spa = vd->vdev_spa; 2620 vdev_t *rvd = spa->spa_root_vdev; 2621 int c; 2622 2623 /* 2624 * If this is an aux vdev (as with l2cache and spare devices), then we 2625 * update the vdev config manually and set the sync flag. 2626 */ 2627 if (vd->vdev_aux != NULL) { 2628 spa_aux_vdev_t *sav = vd->vdev_aux; 2629 nvlist_t **aux; 2630 uint_t naux; 2631 2632 for (c = 0; c < sav->sav_count; c++) { 2633 if (sav->sav_vdevs[c] == vd) 2634 break; 2635 } 2636 2637 if (c == sav->sav_count) { 2638 /* 2639 * We're being removed. There's nothing more to do. 2640 */ 2641 ASSERT(sav->sav_sync == B_TRUE); 2642 return; 2643 } 2644 2645 sav->sav_sync = B_TRUE; 2646 2647 if (nvlist_lookup_nvlist_array(sav->sav_config, 2648 ZPOOL_CONFIG_L2CACHE, &aux, &naux) != 0) { 2649 VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, 2650 ZPOOL_CONFIG_SPARES, &aux, &naux) == 0); 2651 } 2652 2653 ASSERT(c < naux); 2654 2655 /* 2656 * Setting the nvlist in the middle if the array is a little 2657 * sketchy, but it will work. 2658 */ 2659 nvlist_free(aux[c]); 2660 aux[c] = vdev_config_generate(spa, vd, B_TRUE, B_FALSE, B_TRUE); 2661 2662 return; 2663 } 2664 2665 /* 2666 * The dirty list is protected by the SCL_CONFIG lock. The caller 2667 * must either hold SCL_CONFIG as writer, or must be the sync thread 2668 * (which holds SCL_CONFIG as reader). There's only one sync thread, 2669 * so this is sufficient to ensure mutual exclusion. 2670 */ 2671 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_WRITER) || 2672 (dsl_pool_sync_context(spa_get_dsl(spa)) && 2673 spa_config_held(spa, SCL_CONFIG, RW_READER))); 2674 2675 if (vd == rvd) { 2676 for (c = 0; c < rvd->vdev_children; c++) 2677 vdev_config_dirty(rvd->vdev_child[c]); 2678 } else { 2679 ASSERT(vd == vd->vdev_top); 2680 2681 if (!list_link_active(&vd->vdev_config_dirty_node) && 2682 !vd->vdev_ishole) 2683 list_insert_head(&spa->spa_config_dirty_list, vd); 2684 } 2685 } 2686 2687 void 2688 vdev_config_clean(vdev_t *vd) 2689 { 2690 spa_t *spa = vd->vdev_spa; 2691 2692 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_WRITER) || 2693 (dsl_pool_sync_context(spa_get_dsl(spa)) && 2694 spa_config_held(spa, SCL_CONFIG, RW_READER))); 2695 2696 ASSERT(list_link_active(&vd->vdev_config_dirty_node)); 2697 list_remove(&spa->spa_config_dirty_list, vd); 2698 } 2699 2700 /* 2701 * Mark a top-level vdev's state as dirty, so that the next pass of 2702 * spa_sync() can convert this into vdev_config_dirty(). We distinguish 2703 * the state changes from larger config changes because they require 2704 * much less locking, and are often needed for administrative actions. 2705 */ 2706 void 2707 vdev_state_dirty(vdev_t *vd) 2708 { 2709 spa_t *spa = vd->vdev_spa; 2710 2711 ASSERT(vd == vd->vdev_top); 2712 2713 /* 2714 * The state list is protected by the SCL_STATE lock. The caller 2715 * must either hold SCL_STATE as writer, or must be the sync thread 2716 * (which holds SCL_STATE as reader). There's only one sync thread, 2717 * so this is sufficient to ensure mutual exclusion. 2718 */ 2719 ASSERT(spa_config_held(spa, SCL_STATE, RW_WRITER) || 2720 (dsl_pool_sync_context(spa_get_dsl(spa)) && 2721 spa_config_held(spa, SCL_STATE, RW_READER))); 2722 2723 if (!list_link_active(&vd->vdev_state_dirty_node)) 2724 list_insert_head(&spa->spa_state_dirty_list, vd); 2725 } 2726 2727 void 2728 vdev_state_clean(vdev_t *vd) 2729 { 2730 spa_t *spa = vd->vdev_spa; 2731 2732 ASSERT(spa_config_held(spa, SCL_STATE, RW_WRITER) || 2733 (dsl_pool_sync_context(spa_get_dsl(spa)) && 2734 spa_config_held(spa, SCL_STATE, RW_READER))); 2735 2736 ASSERT(list_link_active(&vd->vdev_state_dirty_node)); 2737 list_remove(&spa->spa_state_dirty_list, vd); 2738 } 2739 2740 /* 2741 * Propagate vdev state up from children to parent. 2742 */ 2743 void 2744 vdev_propagate_state(vdev_t *vd) 2745 { 2746 spa_t *spa = vd->vdev_spa; 2747 vdev_t *rvd = spa->spa_root_vdev; 2748 int degraded = 0, faulted = 0; 2749 int corrupted = 0; 2750 vdev_t *child; 2751 2752 if (vd->vdev_children > 0) { 2753 for (int c = 0; c < vd->vdev_children; c++) { 2754 child = vd->vdev_child[c]; 2755 2756 /* 2757 * Don't factor holes into the decision. 2758 */ 2759 if (child->vdev_ishole) 2760 continue; 2761 2762 if (!vdev_readable(child) || 2763 (!vdev_writeable(child) && spa_writeable(spa))) { 2764 /* 2765 * Root special: if there is a top-level log 2766 * device, treat the root vdev as if it were 2767 * degraded. 2768 */ 2769 if (child->vdev_islog && vd == rvd) 2770 degraded++; 2771 else 2772 faulted++; 2773 } else if (child->vdev_state <= VDEV_STATE_DEGRADED) { 2774 degraded++; 2775 } 2776 2777 if (child->vdev_stat.vs_aux == VDEV_AUX_CORRUPT_DATA) 2778 corrupted++; 2779 } 2780 2781 vd->vdev_ops->vdev_op_state_change(vd, faulted, degraded); 2782 2783 /* 2784 * Root special: if there is a top-level vdev that cannot be 2785 * opened due to corrupted metadata, then propagate the root 2786 * vdev's aux state as 'corrupt' rather than 'insufficient 2787 * replicas'. 2788 */ 2789 if (corrupted && vd == rvd && 2790 rvd->vdev_state == VDEV_STATE_CANT_OPEN) 2791 vdev_set_state(rvd, B_FALSE, VDEV_STATE_CANT_OPEN, 2792 VDEV_AUX_CORRUPT_DATA); 2793 } 2794 2795 if (vd->vdev_parent) 2796 vdev_propagate_state(vd->vdev_parent); 2797 } 2798 2799 /* 2800 * Set a vdev's state. If this is during an open, we don't update the parent 2801 * state, because we're in the process of opening children depth-first. 2802 * Otherwise, we propagate the change to the parent. 2803 * 2804 * If this routine places a device in a faulted state, an appropriate ereport is 2805 * generated. 2806 */ 2807 void 2808 vdev_set_state(vdev_t *vd, boolean_t isopen, vdev_state_t state, vdev_aux_t aux) 2809 { 2810 uint64_t save_state; 2811 spa_t *spa = vd->vdev_spa; 2812 2813 if (state == vd->vdev_state) { 2814 vd->vdev_stat.vs_aux = aux; 2815 return; 2816 } 2817 2818 save_state = vd->vdev_state; 2819 2820 vd->vdev_state = state; 2821 vd->vdev_stat.vs_aux = aux; 2822 2823 /* 2824 * If we are setting the vdev state to anything but an open state, then 2825 * always close the underlying device. Otherwise, we keep accessible 2826 * but invalid devices open forever. We don't call vdev_close() itself, 2827 * because that implies some extra checks (offline, etc) that we don't 2828 * want here. This is limited to leaf devices, because otherwise 2829 * closing the device will affect other children. 2830 */ 2831 if (vdev_is_dead(vd) && vd->vdev_ops->vdev_op_leaf) 2832 vd->vdev_ops->vdev_op_close(vd); 2833 2834 /* 2835 * If we have brought this vdev back into service, we need 2836 * to notify fmd so that it can gracefully repair any outstanding 2837 * cases due to a missing device. We do this in all cases, even those 2838 * that probably don't correlate to a repaired fault. This is sure to 2839 * catch all cases, and we let the zfs-retire agent sort it out. If 2840 * this is a transient state it's OK, as the retire agent will 2841 * double-check the state of the vdev before repairing it. 2842 */ 2843 if (state == VDEV_STATE_HEALTHY && vd->vdev_ops->vdev_op_leaf && 2844 vd->vdev_prevstate != state) 2845 zfs_post_state_change(spa, vd); 2846 2847 if (vd->vdev_removed && 2848 state == VDEV_STATE_CANT_OPEN && 2849 (aux == VDEV_AUX_OPEN_FAILED || vd->vdev_checkremove)) { 2850 /* 2851 * If the previous state is set to VDEV_STATE_REMOVED, then this 2852 * device was previously marked removed and someone attempted to 2853 * reopen it. If this failed due to a nonexistent device, then 2854 * keep the device in the REMOVED state. We also let this be if 2855 * it is one of our special test online cases, which is only 2856 * attempting to online the device and shouldn't generate an FMA 2857 * fault. 2858 */ 2859 vd->vdev_state = VDEV_STATE_REMOVED; 2860 vd->vdev_stat.vs_aux = VDEV_AUX_NONE; 2861 } else if (state == VDEV_STATE_REMOVED) { 2862 vd->vdev_removed = B_TRUE; 2863 } else if (state == VDEV_STATE_CANT_OPEN) { 2864 /* 2865 * If we fail to open a vdev during an import, we mark it as 2866 * "not available", which signifies that it was never there to 2867 * begin with. Failure to open such a device is not considered 2868 * an error. 2869 */ 2870 if (spa->spa_load_state == SPA_LOAD_IMPORT && 2871 vd->vdev_ops->vdev_op_leaf) 2872 vd->vdev_not_present = 1; 2873 2874 /* 2875 * Post the appropriate ereport. If the 'prevstate' field is 2876 * set to something other than VDEV_STATE_UNKNOWN, it indicates 2877 * that this is part of a vdev_reopen(). In this case, we don't 2878 * want to post the ereport if the device was already in the 2879 * CANT_OPEN state beforehand. 2880 * 2881 * If the 'checkremove' flag is set, then this is an attempt to 2882 * online the device in response to an insertion event. If we 2883 * hit this case, then we have detected an insertion event for a 2884 * faulted or offline device that wasn't in the removed state. 2885 * In this scenario, we don't post an ereport because we are 2886 * about to replace the device, or attempt an online with 2887 * vdev_forcefault, which will generate the fault for us. 2888 */ 2889 if ((vd->vdev_prevstate != state || vd->vdev_forcefault) && 2890 !vd->vdev_not_present && !vd->vdev_checkremove && 2891 vd != spa->spa_root_vdev) { 2892 const char *class; 2893 2894 switch (aux) { 2895 case VDEV_AUX_OPEN_FAILED: 2896 class = FM_EREPORT_ZFS_DEVICE_OPEN_FAILED; 2897 break; 2898 case VDEV_AUX_CORRUPT_DATA: 2899 class = FM_EREPORT_ZFS_DEVICE_CORRUPT_DATA; 2900 break; 2901 case VDEV_AUX_NO_REPLICAS: 2902 class = FM_EREPORT_ZFS_DEVICE_NO_REPLICAS; 2903 break; 2904 case VDEV_AUX_BAD_GUID_SUM: 2905 class = FM_EREPORT_ZFS_DEVICE_BAD_GUID_SUM; 2906 break; 2907 case VDEV_AUX_TOO_SMALL: 2908 class = FM_EREPORT_ZFS_DEVICE_TOO_SMALL; 2909 break; 2910 case VDEV_AUX_BAD_LABEL: 2911 class = FM_EREPORT_ZFS_DEVICE_BAD_LABEL; 2912 break; 2913 case VDEV_AUX_IO_FAILURE: 2914 class = FM_EREPORT_ZFS_IO_FAILURE; 2915 break; 2916 default: 2917 class = FM_EREPORT_ZFS_DEVICE_UNKNOWN; 2918 } 2919 2920 zfs_ereport_post(class, spa, vd, NULL, save_state, 0); 2921 } 2922 2923 /* Erase any notion of persistent removed state */ 2924 vd->vdev_removed = B_FALSE; 2925 } else { 2926 vd->vdev_removed = B_FALSE; 2927 } 2928 2929 if (!isopen && vd->vdev_parent) 2930 vdev_propagate_state(vd->vdev_parent); 2931 } 2932 2933 /* 2934 * Check the vdev configuration to ensure that it's capable of supporting 2935 * a root pool. Currently, we do not support RAID-Z or partial configuration. 2936 * In addition, only a single top-level vdev is allowed and none of the leaves 2937 * can be wholedisks. 2938 */ 2939 boolean_t 2940 vdev_is_bootable(vdev_t *vd) 2941 { 2942 if (!vd->vdev_ops->vdev_op_leaf) { 2943 char *vdev_type = vd->vdev_ops->vdev_op_type; 2944 2945 if (strcmp(vdev_type, VDEV_TYPE_ROOT) == 0 && 2946 vd->vdev_children > 1) { 2947 return (B_FALSE); 2948 } else if (strcmp(vdev_type, VDEV_TYPE_RAIDZ) == 0 || 2949 strcmp(vdev_type, VDEV_TYPE_MISSING) == 0) { 2950 return (B_FALSE); 2951 } 2952 } else if (vd->vdev_wholedisk == 1) { 2953 return (B_FALSE); 2954 } 2955 2956 for (int c = 0; c < vd->vdev_children; c++) { 2957 if (!vdev_is_bootable(vd->vdev_child[c])) 2958 return (B_FALSE); 2959 } 2960 return (B_TRUE); 2961 } 2962 2963 /* 2964 * Load the state from the original vdev tree (ovd) which 2965 * we've retrieved from the MOS config object. If the original 2966 * vdev was offline then we transfer that state to the device 2967 * in the current vdev tree (nvd). 2968 */ 2969 void 2970 vdev_load_log_state(vdev_t *nvd, vdev_t *ovd) 2971 { 2972 spa_t *spa = nvd->vdev_spa; 2973 2974 ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL); 2975 ASSERT3U(nvd->vdev_guid, ==, ovd->vdev_guid); 2976 2977 for (int c = 0; c < nvd->vdev_children; c++) 2978 vdev_load_log_state(nvd->vdev_child[c], ovd->vdev_child[c]); 2979 2980 if (nvd->vdev_ops->vdev_op_leaf && ovd->vdev_offline) { 2981 /* 2982 * It would be nice to call vdev_offline() 2983 * directly but the pool isn't fully loaded and 2984 * the txg threads have not been started yet. 2985 */ 2986 nvd->vdev_offline = ovd->vdev_offline; 2987 vdev_reopen(nvd->vdev_top); 2988 } 2989 } 2990 2991 /* 2992 * Expand a vdev if possible. 2993 */ 2994 void 2995 vdev_expand(vdev_t *vd, uint64_t txg) 2996 { 2997 ASSERT(vd->vdev_top == vd); 2998 ASSERT(spa_config_held(vd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL); 2999 3000 if ((vd->vdev_asize >> vd->vdev_ms_shift) > vd->vdev_ms_count) { 3001 VERIFY(vdev_metaslab_init(vd, txg) == 0); 3002 vdev_config_dirty(vd); 3003 } 3004 } 3005