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 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <sys/zfs_context.h> 30 #include <sys/fm/fs/zfs.h> 31 #include <sys/spa.h> 32 #include <sys/spa_impl.h> 33 #include <sys/dmu.h> 34 #include <sys/dmu_tx.h> 35 #include <sys/vdev_impl.h> 36 #include <sys/uberblock_impl.h> 37 #include <sys/metaslab.h> 38 #include <sys/metaslab_impl.h> 39 #include <sys/space_map.h> 40 #include <sys/zio.h> 41 #include <sys/zap.h> 42 #include <sys/fs/zfs.h> 43 #include <sys/arc.h> 44 45 /* 46 * Virtual device management. 47 */ 48 49 static vdev_ops_t *vdev_ops_table[] = { 50 &vdev_root_ops, 51 &vdev_raidz_ops, 52 &vdev_mirror_ops, 53 &vdev_replacing_ops, 54 &vdev_spare_ops, 55 &vdev_disk_ops, 56 &vdev_file_ops, 57 &vdev_missing_ops, 58 NULL 59 }; 60 61 /* maximum scrub/resilver I/O queue */ 62 int zfs_scrub_limit = 70; 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 uint64_t c; 89 90 for (c = 0; c < vd->vdev_children; c++) { 91 csize = vdev_psize_to_asize(vd->vdev_child[c], psize); 92 asize = MAX(asize, csize); 93 } 94 95 return (asize); 96 } 97 98 /* 99 * Get the replaceable or attachable device size. 100 * If the parent is a mirror or raidz, the replaceable size is the minimum 101 * psize of all its children. For the rest, just return our own psize. 102 * 103 * e.g. 104 * psize rsize 105 * root - - 106 * mirror/raidz - - 107 * disk1 20g 20g 108 * disk2 40g 20g 109 * disk3 80g 80g 110 */ 111 uint64_t 112 vdev_get_rsize(vdev_t *vd) 113 { 114 vdev_t *pvd, *cvd; 115 uint64_t c, rsize; 116 117 pvd = vd->vdev_parent; 118 119 /* 120 * If our parent is NULL or the root, just return our own psize. 121 */ 122 if (pvd == NULL || pvd->vdev_parent == NULL) 123 return (vd->vdev_psize); 124 125 rsize = 0; 126 127 for (c = 0; c < pvd->vdev_children; c++) { 128 cvd = pvd->vdev_child[c]; 129 rsize = MIN(rsize - 1, cvd->vdev_psize - 1) + 1; 130 } 131 132 return (rsize); 133 } 134 135 vdev_t * 136 vdev_lookup_top(spa_t *spa, uint64_t vdev) 137 { 138 vdev_t *rvd = spa->spa_root_vdev; 139 140 ASSERT(spa_config_held(spa, RW_READER) || 141 curthread == spa->spa_scrub_thread); 142 143 if (vdev < rvd->vdev_children) 144 return (rvd->vdev_child[vdev]); 145 146 return (NULL); 147 } 148 149 vdev_t * 150 vdev_lookup_by_guid(vdev_t *vd, uint64_t guid) 151 { 152 int c; 153 vdev_t *mvd; 154 155 if (vd->vdev_guid == guid) 156 return (vd); 157 158 for (c = 0; c < vd->vdev_children; c++) 159 if ((mvd = vdev_lookup_by_guid(vd->vdev_child[c], guid)) != 160 NULL) 161 return (mvd); 162 163 return (NULL); 164 } 165 166 void 167 vdev_add_child(vdev_t *pvd, vdev_t *cvd) 168 { 169 size_t oldsize, newsize; 170 uint64_t id = cvd->vdev_id; 171 vdev_t **newchild; 172 173 ASSERT(spa_config_held(cvd->vdev_spa, RW_WRITER)); 174 ASSERT(cvd->vdev_parent == NULL); 175 176 cvd->vdev_parent = pvd; 177 178 if (pvd == NULL) 179 return; 180 181 ASSERT(id >= pvd->vdev_children || pvd->vdev_child[id] == NULL); 182 183 oldsize = pvd->vdev_children * sizeof (vdev_t *); 184 pvd->vdev_children = MAX(pvd->vdev_children, id + 1); 185 newsize = pvd->vdev_children * sizeof (vdev_t *); 186 187 newchild = kmem_zalloc(newsize, KM_SLEEP); 188 if (pvd->vdev_child != NULL) { 189 bcopy(pvd->vdev_child, newchild, oldsize); 190 kmem_free(pvd->vdev_child, oldsize); 191 } 192 193 pvd->vdev_child = newchild; 194 pvd->vdev_child[id] = cvd; 195 196 cvd->vdev_top = (pvd->vdev_top ? pvd->vdev_top: cvd); 197 ASSERT(cvd->vdev_top->vdev_parent->vdev_parent == NULL); 198 199 /* 200 * Walk up all ancestors to update guid sum. 201 */ 202 for (; pvd != NULL; pvd = pvd->vdev_parent) 203 pvd->vdev_guid_sum += cvd->vdev_guid_sum; 204 205 if (cvd->vdev_ops->vdev_op_leaf) 206 cvd->vdev_spa->spa_scrub_maxinflight += zfs_scrub_limit; 207 } 208 209 void 210 vdev_remove_child(vdev_t *pvd, vdev_t *cvd) 211 { 212 int c; 213 uint_t id = cvd->vdev_id; 214 215 ASSERT(cvd->vdev_parent == pvd); 216 217 if (pvd == NULL) 218 return; 219 220 ASSERT(id < pvd->vdev_children); 221 ASSERT(pvd->vdev_child[id] == cvd); 222 223 pvd->vdev_child[id] = NULL; 224 cvd->vdev_parent = NULL; 225 226 for (c = 0; c < pvd->vdev_children; c++) 227 if (pvd->vdev_child[c]) 228 break; 229 230 if (c == pvd->vdev_children) { 231 kmem_free(pvd->vdev_child, c * sizeof (vdev_t *)); 232 pvd->vdev_child = NULL; 233 pvd->vdev_children = 0; 234 } 235 236 /* 237 * Walk up all ancestors to update guid sum. 238 */ 239 for (; pvd != NULL; pvd = pvd->vdev_parent) 240 pvd->vdev_guid_sum -= cvd->vdev_guid_sum; 241 242 if (cvd->vdev_ops->vdev_op_leaf) 243 cvd->vdev_spa->spa_scrub_maxinflight -= zfs_scrub_limit; 244 } 245 246 /* 247 * Remove any holes in the child array. 248 */ 249 void 250 vdev_compact_children(vdev_t *pvd) 251 { 252 vdev_t **newchild, *cvd; 253 int oldc = pvd->vdev_children; 254 int newc, c; 255 256 ASSERT(spa_config_held(pvd->vdev_spa, RW_WRITER)); 257 258 for (c = newc = 0; c < oldc; c++) 259 if (pvd->vdev_child[c]) 260 newc++; 261 262 newchild = kmem_alloc(newc * sizeof (vdev_t *), KM_SLEEP); 263 264 for (c = newc = 0; c < oldc; c++) { 265 if ((cvd = pvd->vdev_child[c]) != NULL) { 266 newchild[newc] = cvd; 267 cvd->vdev_id = newc++; 268 } 269 } 270 271 kmem_free(pvd->vdev_child, oldc * sizeof (vdev_t *)); 272 pvd->vdev_child = newchild; 273 pvd->vdev_children = newc; 274 } 275 276 /* 277 * Allocate and minimally initialize a vdev_t. 278 */ 279 static vdev_t * 280 vdev_alloc_common(spa_t *spa, uint_t id, uint64_t guid, vdev_ops_t *ops) 281 { 282 vdev_t *vd; 283 284 vd = kmem_zalloc(sizeof (vdev_t), KM_SLEEP); 285 286 if (spa->spa_root_vdev == NULL) { 287 ASSERT(ops == &vdev_root_ops); 288 spa->spa_root_vdev = vd; 289 } 290 291 if (guid == 0) { 292 if (spa->spa_root_vdev == vd) { 293 /* 294 * The root vdev's guid will also be the pool guid, 295 * which must be unique among all pools. 296 */ 297 while (guid == 0 || spa_guid_exists(guid, 0)) 298 guid = spa_get_random(-1ULL); 299 } else { 300 /* 301 * Any other vdev's guid must be unique within the pool. 302 */ 303 while (guid == 0 || 304 spa_guid_exists(spa_guid(spa), guid)) 305 guid = spa_get_random(-1ULL); 306 } 307 ASSERT(!spa_guid_exists(spa_guid(spa), guid)); 308 } 309 310 vd->vdev_spa = spa; 311 vd->vdev_id = id; 312 vd->vdev_guid = guid; 313 vd->vdev_guid_sum = guid; 314 vd->vdev_ops = ops; 315 vd->vdev_state = VDEV_STATE_CLOSED; 316 317 mutex_init(&vd->vdev_dtl_lock, NULL, MUTEX_DEFAULT, NULL); 318 mutex_init(&vd->vdev_stat_lock, NULL, MUTEX_DEFAULT, NULL); 319 space_map_create(&vd->vdev_dtl_map, 0, -1ULL, 0, &vd->vdev_dtl_lock); 320 space_map_create(&vd->vdev_dtl_scrub, 0, -1ULL, 0, &vd->vdev_dtl_lock); 321 txg_list_create(&vd->vdev_ms_list, 322 offsetof(struct metaslab, ms_txg_node)); 323 txg_list_create(&vd->vdev_dtl_list, 324 offsetof(struct vdev, vdev_dtl_node)); 325 vd->vdev_stat.vs_timestamp = gethrtime(); 326 vdev_queue_init(vd); 327 vdev_cache_init(vd); 328 329 return (vd); 330 } 331 332 /* 333 * Allocate a new vdev. The 'alloctype' is used to control whether we are 334 * creating a new vdev or loading an existing one - the behavior is slightly 335 * different for each case. 336 */ 337 int 338 vdev_alloc(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent, uint_t id, 339 int alloctype) 340 { 341 vdev_ops_t *ops; 342 char *type; 343 uint64_t guid = 0, islog, nparity; 344 vdev_t *vd; 345 346 ASSERT(spa_config_held(spa, RW_WRITER)); 347 348 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) != 0) 349 return (EINVAL); 350 351 if ((ops = vdev_getops(type)) == NULL) 352 return (EINVAL); 353 354 /* 355 * If this is a load, get the vdev guid from the nvlist. 356 * Otherwise, vdev_alloc_common() will generate one for us. 357 */ 358 if (alloctype == VDEV_ALLOC_LOAD) { 359 uint64_t label_id; 360 361 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID, &label_id) || 362 label_id != id) 363 return (EINVAL); 364 365 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0) 366 return (EINVAL); 367 } else if (alloctype == VDEV_ALLOC_SPARE) { 368 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0) 369 return (EINVAL); 370 } else if (alloctype == VDEV_ALLOC_L2CACHE) { 371 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0) 372 return (EINVAL); 373 } 374 375 /* 376 * The first allocated vdev must be of type 'root'. 377 */ 378 if (ops != &vdev_root_ops && spa->spa_root_vdev == NULL) 379 return (EINVAL); 380 381 /* 382 * Determine whether we're a log vdev. 383 */ 384 islog = 0; 385 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG, &islog); 386 if (islog && spa_version(spa) < SPA_VERSION_SLOGS) 387 return (ENOTSUP); 388 389 /* 390 * Set the nparity property for RAID-Z vdevs. 391 */ 392 nparity = -1ULL; 393 if (ops == &vdev_raidz_ops) { 394 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY, 395 &nparity) == 0) { 396 /* 397 * Currently, we can only support 2 parity devices. 398 */ 399 if (nparity == 0 || nparity > 2) 400 return (EINVAL); 401 /* 402 * Older versions can only support 1 parity device. 403 */ 404 if (nparity == 2 && 405 spa_version(spa) < SPA_VERSION_RAID6) 406 return (ENOTSUP); 407 } else { 408 /* 409 * We require the parity to be specified for SPAs that 410 * support multiple parity levels. 411 */ 412 if (spa_version(spa) >= SPA_VERSION_RAID6) 413 return (EINVAL); 414 /* 415 * Otherwise, we default to 1 parity device for RAID-Z. 416 */ 417 nparity = 1; 418 } 419 } else { 420 nparity = 0; 421 } 422 ASSERT(nparity != -1ULL); 423 424 vd = vdev_alloc_common(spa, id, guid, ops); 425 426 vd->vdev_islog = islog; 427 vd->vdev_nparity = nparity; 428 429 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &vd->vdev_path) == 0) 430 vd->vdev_path = spa_strdup(vd->vdev_path); 431 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_DEVID, &vd->vdev_devid) == 0) 432 vd->vdev_devid = spa_strdup(vd->vdev_devid); 433 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PHYS_PATH, 434 &vd->vdev_physpath) == 0) 435 vd->vdev_physpath = spa_strdup(vd->vdev_physpath); 436 437 /* 438 * Set the whole_disk property. If it's not specified, leave the value 439 * as -1. 440 */ 441 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK, 442 &vd->vdev_wholedisk) != 0) 443 vd->vdev_wholedisk = -1ULL; 444 445 /* 446 * Look for the 'not present' flag. This will only be set if the device 447 * was not present at the time of import. 448 */ 449 if (!spa->spa_import_faulted) 450 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 451 &vd->vdev_not_present); 452 453 /* 454 * Get the alignment requirement. 455 */ 456 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASHIFT, &vd->vdev_ashift); 457 458 /* 459 * If we're a top-level vdev, try to load the allocation parameters. 460 */ 461 if (parent && !parent->vdev_parent && alloctype == VDEV_ALLOC_LOAD) { 462 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_METASLAB_ARRAY, 463 &vd->vdev_ms_array); 464 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_METASLAB_SHIFT, 465 &vd->vdev_ms_shift); 466 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASIZE, 467 &vd->vdev_asize); 468 } 469 470 /* 471 * If we're a leaf vdev, try to load the DTL object and other state. 472 */ 473 if (vd->vdev_ops->vdev_op_leaf && 474 (alloctype == VDEV_ALLOC_LOAD || alloctype == VDEV_ALLOC_L2CACHE)) { 475 if (alloctype == VDEV_ALLOC_LOAD) { 476 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DTL, 477 &vd->vdev_dtl.smo_object); 478 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_UNSPARE, 479 &vd->vdev_unspare); 480 } 481 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE, 482 &vd->vdev_offline); 483 484 /* 485 * When importing a pool, we want to ignore the persistent fault 486 * state, as the diagnosis made on another system may not be 487 * valid in the current context. 488 */ 489 if (spa->spa_load_state == SPA_LOAD_OPEN) { 490 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_FAULTED, 491 &vd->vdev_faulted); 492 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DEGRADED, 493 &vd->vdev_degraded); 494 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVED, 495 &vd->vdev_removed); 496 } 497 } 498 499 /* 500 * Add ourselves to the parent's list of children. 501 */ 502 vdev_add_child(parent, vd); 503 504 *vdp = vd; 505 506 return (0); 507 } 508 509 void 510 vdev_free(vdev_t *vd) 511 { 512 int c; 513 spa_t *spa = vd->vdev_spa; 514 515 /* 516 * vdev_free() implies closing the vdev first. This is simpler than 517 * trying to ensure complicated semantics for all callers. 518 */ 519 vdev_close(vd); 520 521 522 ASSERT(!list_link_active(&vd->vdev_dirty_node)); 523 524 /* 525 * Free all children. 526 */ 527 for (c = 0; c < vd->vdev_children; c++) 528 vdev_free(vd->vdev_child[c]); 529 530 ASSERT(vd->vdev_child == NULL); 531 ASSERT(vd->vdev_guid_sum == vd->vdev_guid); 532 533 /* 534 * Discard allocation state. 535 */ 536 if (vd == vd->vdev_top) 537 vdev_metaslab_fini(vd); 538 539 ASSERT3U(vd->vdev_stat.vs_space, ==, 0); 540 ASSERT3U(vd->vdev_stat.vs_dspace, ==, 0); 541 ASSERT3U(vd->vdev_stat.vs_alloc, ==, 0); 542 543 /* 544 * Remove this vdev from its parent's child list. 545 */ 546 vdev_remove_child(vd->vdev_parent, vd); 547 548 ASSERT(vd->vdev_parent == NULL); 549 550 /* 551 * Clean up vdev structure. 552 */ 553 vdev_queue_fini(vd); 554 vdev_cache_fini(vd); 555 556 if (vd->vdev_path) 557 spa_strfree(vd->vdev_path); 558 if (vd->vdev_devid) 559 spa_strfree(vd->vdev_devid); 560 if (vd->vdev_physpath) 561 spa_strfree(vd->vdev_physpath); 562 563 if (vd->vdev_isspare) 564 spa_spare_remove(vd); 565 if (vd->vdev_isl2cache) 566 spa_l2cache_remove(vd); 567 568 txg_list_destroy(&vd->vdev_ms_list); 569 txg_list_destroy(&vd->vdev_dtl_list); 570 mutex_enter(&vd->vdev_dtl_lock); 571 space_map_unload(&vd->vdev_dtl_map); 572 space_map_destroy(&vd->vdev_dtl_map); 573 space_map_vacate(&vd->vdev_dtl_scrub, NULL, NULL); 574 space_map_destroy(&vd->vdev_dtl_scrub); 575 mutex_exit(&vd->vdev_dtl_lock); 576 mutex_destroy(&vd->vdev_dtl_lock); 577 mutex_destroy(&vd->vdev_stat_lock); 578 579 if (vd == spa->spa_root_vdev) 580 spa->spa_root_vdev = NULL; 581 582 kmem_free(vd, sizeof (vdev_t)); 583 } 584 585 /* 586 * Transfer top-level vdev state from svd to tvd. 587 */ 588 static void 589 vdev_top_transfer(vdev_t *svd, vdev_t *tvd) 590 { 591 spa_t *spa = svd->vdev_spa; 592 metaslab_t *msp; 593 vdev_t *vd; 594 int t; 595 596 ASSERT(tvd == tvd->vdev_top); 597 598 tvd->vdev_ms_array = svd->vdev_ms_array; 599 tvd->vdev_ms_shift = svd->vdev_ms_shift; 600 tvd->vdev_ms_count = svd->vdev_ms_count; 601 602 svd->vdev_ms_array = 0; 603 svd->vdev_ms_shift = 0; 604 svd->vdev_ms_count = 0; 605 606 tvd->vdev_mg = svd->vdev_mg; 607 tvd->vdev_ms = svd->vdev_ms; 608 609 svd->vdev_mg = NULL; 610 svd->vdev_ms = NULL; 611 612 if (tvd->vdev_mg != NULL) 613 tvd->vdev_mg->mg_vd = tvd; 614 615 tvd->vdev_stat.vs_alloc = svd->vdev_stat.vs_alloc; 616 tvd->vdev_stat.vs_space = svd->vdev_stat.vs_space; 617 tvd->vdev_stat.vs_dspace = svd->vdev_stat.vs_dspace; 618 619 svd->vdev_stat.vs_alloc = 0; 620 svd->vdev_stat.vs_space = 0; 621 svd->vdev_stat.vs_dspace = 0; 622 623 for (t = 0; t < TXG_SIZE; t++) { 624 while ((msp = txg_list_remove(&svd->vdev_ms_list, t)) != NULL) 625 (void) txg_list_add(&tvd->vdev_ms_list, msp, t); 626 while ((vd = txg_list_remove(&svd->vdev_dtl_list, t)) != NULL) 627 (void) txg_list_add(&tvd->vdev_dtl_list, vd, t); 628 if (txg_list_remove_this(&spa->spa_vdev_txg_list, svd, t)) 629 (void) txg_list_add(&spa->spa_vdev_txg_list, tvd, t); 630 } 631 632 if (list_link_active(&svd->vdev_dirty_node)) { 633 vdev_config_clean(svd); 634 vdev_config_dirty(tvd); 635 } 636 637 tvd->vdev_deflate_ratio = svd->vdev_deflate_ratio; 638 svd->vdev_deflate_ratio = 0; 639 640 tvd->vdev_islog = svd->vdev_islog; 641 svd->vdev_islog = 0; 642 } 643 644 static void 645 vdev_top_update(vdev_t *tvd, vdev_t *vd) 646 { 647 int c; 648 649 if (vd == NULL) 650 return; 651 652 vd->vdev_top = tvd; 653 654 for (c = 0; c < vd->vdev_children; c++) 655 vdev_top_update(tvd, vd->vdev_child[c]); 656 } 657 658 /* 659 * Add a mirror/replacing vdev above an existing vdev. 660 */ 661 vdev_t * 662 vdev_add_parent(vdev_t *cvd, vdev_ops_t *ops) 663 { 664 spa_t *spa = cvd->vdev_spa; 665 vdev_t *pvd = cvd->vdev_parent; 666 vdev_t *mvd; 667 668 ASSERT(spa_config_held(spa, RW_WRITER)); 669 670 mvd = vdev_alloc_common(spa, cvd->vdev_id, 0, ops); 671 672 mvd->vdev_asize = cvd->vdev_asize; 673 mvd->vdev_ashift = cvd->vdev_ashift; 674 mvd->vdev_state = cvd->vdev_state; 675 676 vdev_remove_child(pvd, cvd); 677 vdev_add_child(pvd, mvd); 678 cvd->vdev_id = mvd->vdev_children; 679 vdev_add_child(mvd, cvd); 680 vdev_top_update(cvd->vdev_top, cvd->vdev_top); 681 682 if (mvd == mvd->vdev_top) 683 vdev_top_transfer(cvd, mvd); 684 685 return (mvd); 686 } 687 688 /* 689 * Remove a 1-way mirror/replacing vdev from the tree. 690 */ 691 void 692 vdev_remove_parent(vdev_t *cvd) 693 { 694 vdev_t *mvd = cvd->vdev_parent; 695 vdev_t *pvd = mvd->vdev_parent; 696 697 ASSERT(spa_config_held(cvd->vdev_spa, RW_WRITER)); 698 699 ASSERT(mvd->vdev_children == 1); 700 ASSERT(mvd->vdev_ops == &vdev_mirror_ops || 701 mvd->vdev_ops == &vdev_replacing_ops || 702 mvd->vdev_ops == &vdev_spare_ops); 703 cvd->vdev_ashift = mvd->vdev_ashift; 704 705 vdev_remove_child(mvd, cvd); 706 vdev_remove_child(pvd, mvd); 707 cvd->vdev_id = mvd->vdev_id; 708 vdev_add_child(pvd, cvd); 709 /* 710 * If we created a new toplevel vdev, then we need to change the child's 711 * vdev GUID to match the old toplevel vdev. Otherwise, we could have 712 * detached an offline device, and when we go to import the pool we'll 713 * think we have two toplevel vdevs, instead of a different version of 714 * the same toplevel vdev. 715 */ 716 if (cvd->vdev_top == cvd) { 717 pvd->vdev_guid_sum -= cvd->vdev_guid; 718 cvd->vdev_guid_sum -= cvd->vdev_guid; 719 cvd->vdev_guid = mvd->vdev_guid; 720 cvd->vdev_guid_sum += mvd->vdev_guid; 721 pvd->vdev_guid_sum += cvd->vdev_guid; 722 } 723 vdev_top_update(cvd->vdev_top, cvd->vdev_top); 724 725 if (cvd == cvd->vdev_top) 726 vdev_top_transfer(mvd, cvd); 727 728 ASSERT(mvd->vdev_children == 0); 729 vdev_free(mvd); 730 } 731 732 int 733 vdev_metaslab_init(vdev_t *vd, uint64_t txg) 734 { 735 spa_t *spa = vd->vdev_spa; 736 objset_t *mos = spa->spa_meta_objset; 737 metaslab_class_t *mc; 738 uint64_t m; 739 uint64_t oldc = vd->vdev_ms_count; 740 uint64_t newc = vd->vdev_asize >> vd->vdev_ms_shift; 741 metaslab_t **mspp; 742 int error; 743 744 if (vd->vdev_ms_shift == 0) /* not being allocated from yet */ 745 return (0); 746 747 dprintf("%s oldc %llu newc %llu\n", vdev_description(vd), oldc, newc); 748 749 ASSERT(oldc <= newc); 750 751 if (vd->vdev_islog) 752 mc = spa->spa_log_class; 753 else 754 mc = spa->spa_normal_class; 755 756 if (vd->vdev_mg == NULL) 757 vd->vdev_mg = metaslab_group_create(mc, vd); 758 759 mspp = kmem_zalloc(newc * sizeof (*mspp), KM_SLEEP); 760 761 if (oldc != 0) { 762 bcopy(vd->vdev_ms, mspp, oldc * sizeof (*mspp)); 763 kmem_free(vd->vdev_ms, oldc * sizeof (*mspp)); 764 } 765 766 vd->vdev_ms = mspp; 767 vd->vdev_ms_count = newc; 768 769 for (m = oldc; m < newc; m++) { 770 space_map_obj_t smo = { 0, 0, 0 }; 771 if (txg == 0) { 772 uint64_t object = 0; 773 error = dmu_read(mos, vd->vdev_ms_array, 774 m * sizeof (uint64_t), sizeof (uint64_t), &object); 775 if (error) 776 return (error); 777 if (object != 0) { 778 dmu_buf_t *db; 779 error = dmu_bonus_hold(mos, object, FTAG, &db); 780 if (error) 781 return (error); 782 ASSERT3U(db->db_size, >=, sizeof (smo)); 783 bcopy(db->db_data, &smo, sizeof (smo)); 784 ASSERT3U(smo.smo_object, ==, object); 785 dmu_buf_rele(db, FTAG); 786 } 787 } 788 vd->vdev_ms[m] = metaslab_init(vd->vdev_mg, &smo, 789 m << vd->vdev_ms_shift, 1ULL << vd->vdev_ms_shift, txg); 790 } 791 792 return (0); 793 } 794 795 void 796 vdev_metaslab_fini(vdev_t *vd) 797 { 798 uint64_t m; 799 uint64_t count = vd->vdev_ms_count; 800 801 if (vd->vdev_ms != NULL) { 802 for (m = 0; m < count; m++) 803 if (vd->vdev_ms[m] != NULL) 804 metaslab_fini(vd->vdev_ms[m]); 805 kmem_free(vd->vdev_ms, count * sizeof (metaslab_t *)); 806 vd->vdev_ms = NULL; 807 } 808 } 809 810 int 811 vdev_probe(vdev_t *vd) 812 { 813 if (vd == NULL) 814 return (EINVAL); 815 816 /* 817 * Right now we only support status checks on the leaf vdevs. 818 */ 819 if (vd->vdev_ops->vdev_op_leaf) 820 return (vd->vdev_ops->vdev_op_probe(vd)); 821 822 return (0); 823 } 824 825 /* 826 * Prepare a virtual device for access. 827 */ 828 int 829 vdev_open(vdev_t *vd) 830 { 831 int error; 832 int c; 833 uint64_t osize = 0; 834 uint64_t asize, psize; 835 uint64_t ashift = 0; 836 837 ASSERT(vd->vdev_state == VDEV_STATE_CLOSED || 838 vd->vdev_state == VDEV_STATE_CANT_OPEN || 839 vd->vdev_state == VDEV_STATE_OFFLINE); 840 841 if (vd->vdev_fault_mode == VDEV_FAULT_COUNT) 842 vd->vdev_fault_arg >>= 1; 843 else 844 vd->vdev_fault_mode = VDEV_FAULT_NONE; 845 846 vd->vdev_stat.vs_aux = VDEV_AUX_NONE; 847 848 if (!vd->vdev_removed && vd->vdev_faulted) { 849 ASSERT(vd->vdev_children == 0); 850 vdev_set_state(vd, B_TRUE, VDEV_STATE_FAULTED, 851 VDEV_AUX_ERR_EXCEEDED); 852 return (ENXIO); 853 } else if (vd->vdev_offline) { 854 ASSERT(vd->vdev_children == 0); 855 vdev_set_state(vd, B_TRUE, VDEV_STATE_OFFLINE, VDEV_AUX_NONE); 856 return (ENXIO); 857 } 858 859 error = vd->vdev_ops->vdev_op_open(vd, &osize, &ashift); 860 861 if (zio_injection_enabled && error == 0) 862 error = zio_handle_device_injection(vd, ENXIO); 863 864 if (error) { 865 if (vd->vdev_removed && 866 vd->vdev_stat.vs_aux != VDEV_AUX_OPEN_FAILED) 867 vd->vdev_removed = B_FALSE; 868 869 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 870 vd->vdev_stat.vs_aux); 871 return (error); 872 } 873 874 vd->vdev_removed = B_FALSE; 875 876 if (vd->vdev_degraded) { 877 ASSERT(vd->vdev_children == 0); 878 vdev_set_state(vd, B_TRUE, VDEV_STATE_DEGRADED, 879 VDEV_AUX_ERR_EXCEEDED); 880 } else { 881 vd->vdev_state = VDEV_STATE_HEALTHY; 882 } 883 884 for (c = 0; c < vd->vdev_children; c++) 885 if (vd->vdev_child[c]->vdev_state != VDEV_STATE_HEALTHY) { 886 vdev_set_state(vd, B_TRUE, VDEV_STATE_DEGRADED, 887 VDEV_AUX_NONE); 888 break; 889 } 890 891 osize = P2ALIGN(osize, (uint64_t)sizeof (vdev_label_t)); 892 893 if (vd->vdev_children == 0) { 894 if (osize < SPA_MINDEVSIZE) { 895 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 896 VDEV_AUX_TOO_SMALL); 897 return (EOVERFLOW); 898 } 899 psize = osize; 900 asize = osize - (VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE); 901 } else { 902 if (vd->vdev_parent != NULL && osize < SPA_MINDEVSIZE - 903 (VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE)) { 904 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 905 VDEV_AUX_TOO_SMALL); 906 return (EOVERFLOW); 907 } 908 psize = 0; 909 asize = osize; 910 } 911 912 vd->vdev_psize = psize; 913 914 if (vd->vdev_asize == 0) { 915 /* 916 * This is the first-ever open, so use the computed values. 917 * For testing purposes, a higher ashift can be requested. 918 */ 919 vd->vdev_asize = asize; 920 vd->vdev_ashift = MAX(ashift, vd->vdev_ashift); 921 } else { 922 /* 923 * Make sure the alignment requirement hasn't increased. 924 */ 925 if (ashift > vd->vdev_top->vdev_ashift) { 926 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 927 VDEV_AUX_BAD_LABEL); 928 return (EINVAL); 929 } 930 931 /* 932 * Make sure the device hasn't shrunk. 933 */ 934 if (asize < vd->vdev_asize) { 935 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 936 VDEV_AUX_BAD_LABEL); 937 return (EINVAL); 938 } 939 940 /* 941 * If all children are healthy and the asize has increased, 942 * then we've experienced dynamic LUN growth. 943 */ 944 if (vd->vdev_state == VDEV_STATE_HEALTHY && 945 asize > vd->vdev_asize) { 946 vd->vdev_asize = asize; 947 } 948 } 949 950 /* 951 * Ensure we can issue some IO before declaring the 952 * vdev open for business. 953 */ 954 error = vdev_probe(vd); 955 if (error) { 956 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 957 VDEV_AUX_OPEN_FAILED); 958 return (error); 959 } 960 961 /* 962 * If this is a top-level vdev, compute the raidz-deflation 963 * ratio. Note, we hard-code in 128k (1<<17) because it is the 964 * current "typical" blocksize. Even if SPA_MAXBLOCKSIZE 965 * changes, this algorithm must never change, or we will 966 * inconsistently account for existing bp's. 967 */ 968 if (vd->vdev_top == vd) { 969 vd->vdev_deflate_ratio = (1<<17) / 970 (vdev_psize_to_asize(vd, 1<<17) >> SPA_MINBLOCKSHIFT); 971 } 972 973 return (0); 974 } 975 976 /* 977 * Called once the vdevs are all opened, this routine validates the label 978 * contents. This needs to be done before vdev_load() so that we don't 979 * inadvertently do repair I/Os to the wrong device. 980 * 981 * This function will only return failure if one of the vdevs indicates that it 982 * has since been destroyed or exported. This is only possible if 983 * /etc/zfs/zpool.cache was readonly at the time. Otherwise, the vdev state 984 * will be updated but the function will return 0. 985 */ 986 int 987 vdev_validate(vdev_t *vd) 988 { 989 spa_t *spa = vd->vdev_spa; 990 int c; 991 nvlist_t *label; 992 uint64_t guid; 993 uint64_t state; 994 995 for (c = 0; c < vd->vdev_children; c++) 996 if (vdev_validate(vd->vdev_child[c]) != 0) 997 return (EBADF); 998 999 /* 1000 * If the device has already failed, or was marked offline, don't do 1001 * any further validation. Otherwise, label I/O will fail and we will 1002 * overwrite the previous state. 1003 */ 1004 if (vd->vdev_ops->vdev_op_leaf && !vdev_is_dead(vd)) { 1005 1006 if ((label = vdev_label_read_config(vd)) == NULL) { 1007 vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN, 1008 VDEV_AUX_BAD_LABEL); 1009 return (0); 1010 } 1011 1012 if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_GUID, 1013 &guid) != 0 || guid != spa_guid(spa)) { 1014 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN, 1015 VDEV_AUX_CORRUPT_DATA); 1016 nvlist_free(label); 1017 return (0); 1018 } 1019 1020 if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID, 1021 &guid) != 0 || guid != vd->vdev_guid) { 1022 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN, 1023 VDEV_AUX_CORRUPT_DATA); 1024 nvlist_free(label); 1025 return (0); 1026 } 1027 1028 if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_STATE, 1029 &state) != 0) { 1030 vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN, 1031 VDEV_AUX_CORRUPT_DATA); 1032