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 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 #include <sys/zfs_context.h> 29 #include <sys/spa_impl.h> 30 #include <sys/zio.h> 31 #include <sys/zio_checksum.h> 32 #include <sys/zio_compress.h> 33 #include <sys/dmu.h> 34 #include <sys/dmu_tx.h> 35 #include <sys/zap.h> 36 #include <sys/zil.h> 37 #include <sys/vdev_impl.h> 38 #include <sys/metaslab.h> 39 #include <sys/uberblock_impl.h> 40 #include <sys/txg.h> 41 #include <sys/avl.h> 42 #include <sys/unique.h> 43 #include <sys/dsl_pool.h> 44 #include <sys/dsl_dir.h> 45 #include <sys/dsl_prop.h> 46 #include <sys/fs/zfs.h> 47 48 /* 49 * SPA locking 50 * 51 * There are four basic locks for managing spa_t structures: 52 * 53 * spa_namespace_lock (global mutex) 54 * 55 * This lock must be acquired to do any of the following: 56 * 57 * - Lookup a spa_t by name 58 * - Add or remove a spa_t from the namespace 59 * - Increase spa_refcount from non-zero 60 * - Check if spa_refcount is zero 61 * - Rename a spa_t 62 * - add/remove/attach/detach devices 63 * - Held for the duration of create/destroy/import/export 64 * 65 * It does not need to handle recursion. A create or destroy may 66 * reference objects (files or zvols) in other pools, but by 67 * definition they must have an existing reference, and will never need 68 * to lookup a spa_t by name. 69 * 70 * spa_refcount (per-spa refcount_t protected by mutex) 71 * 72 * This reference count keep track of any active users of the spa_t. The 73 * spa_t cannot be destroyed or freed while this is non-zero. Internally, 74 * the refcount is never really 'zero' - opening a pool implicitly keeps 75 * some references in the DMU. Internally we check against SPA_MINREF, but 76 * present the image of a zero/non-zero value to consumers. 77 * 78 * spa_config_lock (per-spa crazy rwlock) 79 * 80 * This SPA special is a recursive rwlock, capable of being acquired from 81 * asynchronous threads. It has protects the spa_t from config changes, 82 * and must be held in the following circumstances: 83 * 84 * - RW_READER to perform I/O to the spa 85 * - RW_WRITER to change the vdev config 86 * 87 * spa_config_cache_lock (per-spa mutex) 88 * 89 * This mutex prevents the spa_config nvlist from being updated. No 90 * other locks are required to obtain this lock, although implicitly you 91 * must have the namespace lock or non-zero refcount to have any kind 92 * of spa_t pointer at all. 93 * 94 * The locking order is fairly straightforward: 95 * 96 * spa_namespace_lock -> spa_refcount 97 * 98 * The namespace lock must be acquired to increase the refcount from 0 99 * or to check if it is zero. 100 * 101 * spa_refcount -> spa_config_lock 102 * 103 * There must be at least one valid reference on the spa_t to acquire 104 * the config lock. 105 * 106 * spa_namespace_lock -> spa_config_lock 107 * 108 * The namespace lock must always be taken before the config lock. 109 * 110 * 111 * The spa_namespace_lock and spa_config_cache_lock can be acquired directly and 112 * are globally visible. 113 * 114 * The namespace is manipulated using the following functions, all which require 115 * the spa_namespace_lock to be held. 116 * 117 * spa_lookup() Lookup a spa_t by name. 118 * 119 * spa_add() Create a new spa_t in the namespace. 120 * 121 * spa_remove() Remove a spa_t from the namespace. This also 122 * frees up any memory associated with the spa_t. 123 * 124 * spa_next() Returns the next spa_t in the system, or the 125 * first if NULL is passed. 126 * 127 * spa_evict_all() Shutdown and remove all spa_t structures in 128 * the system. 129 * 130 * spa_guid_exists() Determine whether a pool/device guid exists. 131 * 132 * The spa_refcount is manipulated using the following functions: 133 * 134 * spa_open_ref() Adds a reference to the given spa_t. Must be 135 * called with spa_namespace_lock held if the 136 * refcount is currently zero. 137 * 138 * spa_close() Remove a reference from the spa_t. This will 139 * not free the spa_t or remove it from the 140 * namespace. No locking is required. 141 * 142 * spa_refcount_zero() Returns true if the refcount is currently 143 * zero. Must be called with spa_namespace_lock 144 * held. 145 * 146 * The spa_config_lock is manipulated using the following functions: 147 * 148 * spa_config_enter() Acquire the config lock as RW_READER or 149 * RW_WRITER. At least one reference on the spa_t 150 * must exist. 151 * 152 * spa_config_exit() Release the config lock. 153 * 154 * spa_config_held() Returns true if the config lock is currently 155 * held in the given state. 156 * 157 * The vdev configuration is protected by spa_vdev_enter() / spa_vdev_exit(). 158 * 159 * spa_vdev_enter() Acquire the namespace lock and the config lock 160 * for writing. 161 * 162 * spa_vdev_exit() Release the config lock, wait for all I/O 163 * to complete, sync the updated configs to the 164 * cache, and release the namespace lock. 165 * 166 * The spa_name() function also requires either the spa_namespace_lock 167 * or the spa_config_lock, as both are needed to do a rename. spa_rename() is 168 * also implemented within this file since is requires manipulation of the 169 * namespace. 170 */ 171 172 static avl_tree_t spa_namespace_avl; 173 kmutex_t spa_namespace_lock; 174 static kcondvar_t spa_namespace_cv; 175 static int spa_active_count; 176 static int spa_max_replication_override = SPA_DVAS_PER_BP; 177 178 static avl_tree_t spa_spare_avl; 179 static kmutex_t spa_spare_lock; 180 181 kmem_cache_t *spa_buffer_pool; 182 int spa_mode; 183 184 #ifdef ZFS_DEBUG 185 int zfs_flags = ~0; 186 #else 187 int zfs_flags = 0; 188 #endif 189 190 #define SPA_MINREF 5 /* spa_refcnt for an open-but-idle pool */ 191 192 /* 193 * ========================================================================== 194 * SPA namespace functions 195 * ========================================================================== 196 */ 197 198 /* 199 * Lookup the named spa_t in the AVL tree. The spa_namespace_lock must be held. 200 * Returns NULL if no matching spa_t is found. 201 */ 202 spa_t * 203 spa_lookup(const char *name) 204 { 205 spa_t search, *spa; 206 avl_index_t where; 207 208 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 209 210 search.spa_name = (char *)name; 211 spa = avl_find(&spa_namespace_avl, &search, &where); 212 213 return (spa); 214 } 215 216 /* 217 * Create an uninitialized spa_t with the given name. Requires 218 * spa_namespace_lock. The caller must ensure that the spa_t doesn't already 219 * exist by calling spa_lookup() first. 220 */ 221 spa_t * 222 spa_add(const char *name, const char *altroot) 223 { 224 spa_t *spa; 225 226 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 227 228 spa = kmem_zalloc(sizeof (spa_t), KM_SLEEP); 229 230 spa->spa_name = spa_strdup(name); 231 spa->spa_state = POOL_STATE_UNINITIALIZED; 232 spa->spa_freeze_txg = UINT64_MAX; 233 spa->spa_final_txg = UINT64_MAX; 234 235 refcount_create(&spa->spa_refcount); 236 refcount_create(&spa->spa_config_lock.scl_count); 237 238 avl_add(&spa_namespace_avl, spa); 239 240 /* 241 * Set the alternate root, if there is one. 242 */ 243 if (altroot) { 244 spa->spa_root = spa_strdup(altroot); 245 spa_active_count++; 246 } 247 248 return (spa); 249 } 250 251 /* 252 * Removes a spa_t from the namespace, freeing up any memory used. Requires 253 * spa_namespace_lock. This is called only after the spa_t has been closed and 254 * deactivated. 255 */ 256 void 257 spa_remove(spa_t *spa) 258 { 259 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 260 ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED); 261 ASSERT(spa->spa_scrub_thread == NULL); 262 263 avl_remove(&spa_namespace_avl, spa); 264 cv_broadcast(&spa_namespace_cv); 265 266 if (spa->spa_root) { 267 spa_strfree(spa->spa_root); 268 spa_active_count--; 269 } 270 271 if (spa->spa_name) 272 spa_strfree(spa->spa_name); 273 274 spa_config_set(spa, NULL); 275 276 refcount_destroy(&spa->spa_refcount); 277 refcount_destroy(&spa->spa_config_lock.scl_count); 278 279 mutex_destroy(&spa->spa_sync_bplist.bpl_lock); 280 mutex_destroy(&spa->spa_config_lock.scl_lock); 281 mutex_destroy(&spa->spa_errlist_lock); 282 mutex_destroy(&spa->spa_errlog_lock); 283 mutex_destroy(&spa->spa_scrub_lock); 284 mutex_destroy(&spa->spa_config_cache_lock); 285 mutex_destroy(&spa->spa_async_lock); 286 287 kmem_free(spa, sizeof (spa_t)); 288 } 289 290 /* 291 * Given a pool, return the next pool in the namespace, or NULL if there is 292 * none. If 'prev' is NULL, return the first pool. 293 */ 294 spa_t * 295 spa_next(spa_t *prev) 296 { 297 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 298 299 if (prev) 300 return (AVL_NEXT(&spa_namespace_avl, prev)); 301 else 302 return (avl_first(&spa_namespace_avl)); 303 } 304 305 /* 306 * ========================================================================== 307 * SPA refcount functions 308 * ========================================================================== 309 */ 310 311 /* 312 * Add a reference to the given spa_t. Must have at least one reference, or 313 * have the namespace lock held. 314 */ 315 void 316 spa_open_ref(spa_t *spa, void *tag) 317 { 318 ASSERT(refcount_count(&spa->spa_refcount) > SPA_MINREF || 319 MUTEX_HELD(&spa_namespace_lock)); 320 321 (void) refcount_add(&spa->spa_refcount, tag); 322 } 323 324 /* 325 * Remove a reference to the given spa_t. Must have at least one reference, or 326 * have the namespace lock held. 327 */ 328 void 329 spa_close(spa_t *spa, void *tag) 330 { 331 ASSERT(refcount_count(&spa->spa_refcount) > SPA_MINREF || 332 MUTEX_HELD(&spa_namespace_lock)); 333 334 (void) refcount_remove(&spa->spa_refcount, tag); 335 } 336 337 /* 338 * Check to see if the spa refcount is zero. Must be called with 339 * spa_namespace_lock held. We really compare against SPA_MINREF, which is the 340 * number of references acquired when opening a pool 341 */ 342 boolean_t 343 spa_refcount_zero(spa_t *spa) 344 { 345 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 346 347 return (refcount_count(&spa->spa_refcount) == SPA_MINREF); 348 } 349 350 /* 351 * ========================================================================== 352 * SPA spare tracking 353 * ========================================================================== 354 */ 355 356 /* 357 * We track spare information on a global basis. This allows us to do two 358 * things: determine when a spare is no longer referenced by any active pool, 359 * and (quickly) determine if a spare is currently in use in another pool on the 360 * system. 361 */ 362 typedef struct spa_spare { 363 uint64_t spare_guid; 364 avl_node_t spare_avl; 365 int spare_count; 366 } spa_spare_t; 367 368 static int 369 spa_spare_compare(const void *a, const void *b) 370 { 371 const spa_spare_t *sa = a; 372 const spa_spare_t *sb = b; 373 374 if (sa->spare_guid < sb->spare_guid) 375 return (-1); 376 else if (sa->spare_guid > sb->spare_guid) 377 return (1); 378 else 379 return (0); 380 } 381 382 void 383 spa_spare_add(uint64_t guid) 384 { 385 avl_index_t where; 386 spa_spare_t search; 387 spa_spare_t *spare; 388 389 mutex_enter(&spa_spare_lock); 390 391 search.spare_guid = guid; 392 if ((spare = avl_find(&spa_spare_avl, &search, &where)) != NULL) { 393 spare->spare_count++; 394 } else { 395 spare = kmem_alloc(sizeof (spa_spare_t), KM_SLEEP); 396 spare->spare_guid = guid; 397 spare->spare_count = 1; 398 avl_insert(&spa_spare_avl, spare, where); 399 } 400 401 mutex_exit(&spa_spare_lock); 402 } 403 404 void 405 spa_spare_remove(uint64_t guid) 406 { 407 spa_spare_t search; 408 spa_spare_t *spare; 409 avl_index_t where; 410 411 mutex_enter(&spa_spare_lock); 412 413 search.spare_guid = guid; 414 spare = avl_find(&spa_spare_avl, &search, &where); 415 416 ASSERT(spare != NULL); 417 418 if (--spare->spare_count == 0) { 419 avl_remove(&spa_spare_avl, spare); 420 kmem_free(spare, sizeof (spa_spare_t)); 421 } 422 423 mutex_exit(&spa_spare_lock); 424 } 425 426 boolean_t 427 spa_spare_inuse(uint64_t guid) 428 { 429 spa_spare_t search; 430 avl_index_t where; 431 boolean_t ret; 432 433 mutex_enter(&spa_spare_lock); 434 435 search.spare_guid = guid; 436 ret = (avl_find(&spa_spare_avl, &search, &where) != NULL); 437 438 mutex_exit(&spa_spare_lock); 439 440 return (ret); 441 } 442 443 /* 444 * ========================================================================== 445 * SPA config locking 446 * ========================================================================== 447 */ 448 449 /* 450 * Acquire the config lock. The config lock is a special rwlock that allows for 451 * recursive enters. Because these enters come from the same thread as well as 452 * asynchronous threads working on behalf of the owner, we must unilaterally 453 * allow all reads access as long at least one reader is held (even if a write 454 * is requested). This has the side effect of write starvation, but write locks 455 * are extremely rare, and a solution to this problem would be significantly 456 * more complex (if even possible). 457 * 458 * We would like to assert that the namespace lock isn't held, but this is a 459 * valid use during create. 460 */ 461 void 462 spa_config_enter(spa_t *spa, krw_t rw, void *tag) 463 { 464 spa_config_lock_t *scl = &spa->spa_config_lock; 465 466 mutex_enter(&scl->scl_lock); 467 468 if (scl->scl_writer != curthread) { 469 if (rw == RW_READER) { 470 while (scl->scl_writer != NULL) 471 cv_wait(&scl->scl_cv, &scl->scl_lock); 472 } else { 473 while (scl->scl_writer != NULL || 474 !refcount_is_zero(&scl->scl_count)) 475 cv_wait(&scl->scl_cv, &scl->scl_lock); 476 scl->scl_writer = curthread; 477 } 478 } 479 480 (void) refcount_add(&scl->scl_count, tag); 481 482 mutex_exit(&scl->scl_lock); 483 } 484 485 /* 486 * Release the spa config lock, notifying any waiters in the process. 487 */ 488 void 489 spa_config_exit(spa_t *spa, void *tag) 490 { 491 spa_config_lock_t *scl = &spa->spa_config_lock; 492 493 mutex_enter(&scl->scl_lock); 494 495 ASSERT(!refcount_is_zero(&scl->scl_count)); 496 if (refcount_remove(&scl->scl_count, tag) == 0) { 497 cv_broadcast(&scl->scl_cv); 498 scl->scl_writer = NULL; /* OK in either case */ 499 } 500 501 mutex_exit(&scl->scl_lock); 502 } 503 504 /* 505 * Returns true if the config lock is held in the given manner. 506 */ 507 boolean_t 508 spa_config_held(spa_t *spa, krw_t rw) 509 { 510 spa_config_lock_t *scl = &spa->spa_config_lock; 511 boolean_t held; 512 513 mutex_enter(&scl->scl_lock); 514 if (rw == RW_WRITER) 515 held = (scl->scl_writer == curthread); 516 else 517 held = !refcount_is_zero(&scl->scl_count); 518 mutex_exit(&scl->scl_lock); 519 520 return (held); 521 } 522 523 /* 524 * ========================================================================== 525 * SPA vdev locking 526 * ========================================================================== 527 */ 528 529 /* 530 * Lock the given spa_t for the purpose of adding or removing a vdev. 531 * Grabs the global spa_namespace_lock plus the spa config lock for writing. 532 * It returns the next transaction group for the spa_t. 533 */ 534 uint64_t 535 spa_vdev_enter(spa_t *spa) 536 { 537 /* 538 * Suspend scrub activity while we mess with the config. 539 */ 540 spa_scrub_suspend(spa); 541 542 mutex_enter(&spa_namespace_lock); 543 544 spa_config_enter(spa, RW_WRITER, spa); 545 546 return (spa_last_synced_txg(spa) + 1); 547 } 548 549 /* 550 * Unlock the spa_t after adding or removing a vdev. Besides undoing the 551 * locking of spa_vdev_enter(), we also want make sure the transactions have 552 * synced to disk, and then update the global configuration cache with the new 553 * information. 554 */ 555 int 556 spa_vdev_exit(spa_t *spa, vdev_t *vd, uint64_t txg, int error) 557 { 558 int config_changed = B_FALSE; 559 560 ASSERT(txg > spa_last_synced_txg(spa)); 561 562 /* 563 * Reassess the DTLs. 564 */ 565 vdev_dtl_reassess(spa->spa_root_vdev, 0, 0, B_FALSE); 566 567 /* 568 * If the config changed, notify the scrub thread that it must restart. 569 */ 570 if (error == 0 && !list_is_empty(&spa->spa_dirty_list)) { 571 config_changed = B_TRUE; 572 spa_scrub_restart(spa, txg); 573 } 574 575 spa_config_exit(spa, spa); 576 577 /* 578 * Allow scrubbing to resume. 579 */ 580 spa_scrub_resume(spa); 581 582 /* 583 * Note: this txg_wait_synced() is important because it ensures 584 * that there won't be more than one config change per txg. 585 * This allows us to use the txg as the generation number. 586 */ 587 if (error == 0) 588 txg_wait_synced(spa->spa_dsl_pool, txg); 589 590 if (vd != NULL) { 591 ASSERT(!vd->vdev_detached || vd->vdev_dtl.smo_object == 0); 592 vdev_free(vd); 593 } 594 595 /* 596 * If the config changed, update the config cache. 597 */ 598 if (config_changed) 599 spa_config_sync(); 600 601 mutex_exit(&spa_namespace_lock); 602 603 return (error); 604 } 605 606 /* 607 * ========================================================================== 608 * Miscellaneous functions 609 * ========================================================================== 610 */ 611 612 /* 613 * Rename a spa_t. 614 */ 615 int 616 spa_rename(const char *name, const char *newname) 617 { 618 spa_t *spa; 619 int err; 620 621 /* 622 * Lookup the spa_t and grab the config lock for writing. We need to 623 * actually open the pool so that we can sync out the necessary labels. 624 * It's OK to call spa_open() with the namespace lock held because we 625 * allow recursive calls for other reasons. 626 */ 627 mutex_enter(&spa_namespace_lock); 628 if ((err = spa_open(name, &spa, FTAG)) != 0) { 629 mutex_exit(&spa_namespace_lock); 630 return (err); 631 } 632 633 spa_config_enter(spa, RW_WRITER, FTAG); 634 635 avl_remove(&spa_namespace_avl, spa); 636 spa_strfree(spa->spa_name); 637 spa->spa_name = spa_strdup(newname); 638 avl_add(&spa_namespace_avl, spa); 639 640 /* 641 * Sync all labels to disk with the new names by marking the root vdev 642 * dirty and waiting for it to sync. It will pick up the new pool name 643 * during the sync. 644 */ 645 vdev_config_dirty(spa->spa_root_vdev); 646 647 spa_config_exit(spa, FTAG); 648 649 txg_wait_synced(spa->spa_dsl_pool, 0); 650 651 /* 652 * Sync the updated config cache. 653 */ 654 spa_config_sync(); 655 656 spa_close(spa, FTAG); 657 658 mutex_exit(&spa_namespace_lock); 659 660 return (0); 661 } 662 663 664 /* 665 * Determine whether a pool with given pool_guid exists. If device_guid is 666 * non-zero, determine whether the pool exists *and* contains a device with the 667 * specified device_guid. 668 */ 669 boolean_t 670 spa_guid_exists(uint64_t pool_guid, uint64_t device_guid) 671 { 672 spa_t *spa; 673 avl_tree_t *t = &spa_namespace_avl; 674 675 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 676 677 for (spa = avl_first(t); spa != NULL; spa = AVL_NEXT(t, spa)) { 678 if (spa->spa_state == POOL_STATE_UNINITIALIZED) 679 continue; 680 if (spa->spa_root_vdev == NULL) 681 continue; 682 if (spa_guid(spa) == pool_guid && (device_guid == 0 || 683 vdev_lookup_by_guid(spa->spa_root_vdev, device_guid))) 684 break; 685 } 686 687 return (spa != NULL); 688 } 689 690 char * 691 spa_strdup(const char *s) 692 { 693 size_t len; 694 char *new; 695 696 len = strlen(s); 697 new = kmem_alloc(len + 1, KM_SLEEP); 698 bcopy(s, new, len); 699 new[len] = '\0'; 700 701 return (new); 702 } 703 704 void 705 spa_strfree(char *s) 706 { 707 kmem_free(s, strlen(s) + 1); 708 } 709 710 uint64_t 711 spa_get_random(uint64_t range) 712 { 713 uint64_t r; 714 715 ASSERT(range != 0); 716 717 (void) random_get_pseudo_bytes((void *)&r, sizeof (uint64_t)); 718 719 return (r % range); 720 } 721 722 void 723 sprintf_blkptr(char *buf, int len, const blkptr_t *bp) 724 { 725 int d; 726 727 if (bp == NULL) { 728 (void) snprintf(buf, len, "<NULL>"); 729 return; 730 } 731 732 if (BP_IS_HOLE(bp)) { 733 (void) snprintf(buf, len, "<hole>"); 734 return; 735 } 736 737 (void) snprintf(buf, len, "[L%llu %s] %llxL/%llxP ", 738 (u_longlong_t)BP_GET_LEVEL(bp), 739 dmu_ot[BP_GET_TYPE(bp)].ot_name, 740 (u_longlong_t)BP_GET_LSIZE(bp), 741 (u_longlong_t)BP_GET_PSIZE(bp)); 742 743 for (d = 0; d < BP_GET_NDVAS(bp); d++) { 744 const dva_t *dva = &bp->blk_dva[d]; 745 (void) snprintf(buf + strlen(buf), len - strlen(buf), 746 "DVA[%d]=<%llu:%llx:%llx> ", d, 747 (u_longlong_t)DVA_GET_VDEV(dva), 748 (u_longlong_t)DVA_GET_OFFSET(dva), 749 (u_longlong_t)DVA_GET_ASIZE(dva)); 750 } 751 752 (void) snprintf(buf + strlen(buf), len - strlen(buf), 753 "%s %s %s %s birth=%llu fill=%llu cksum=%llx:%llx:%llx:%llx", 754 zio_checksum_table[BP_GET_CHECKSUM(bp)].ci_name, 755 zio_compress_table[BP_GET_COMPRESS(bp)].ci_name, 756 BP_GET_BYTEORDER(bp) == 0 ? "BE" : "LE", 757 BP_IS_GANG(bp) ? "gang" : "contiguous", 758 (u_longlong_t)bp->blk_birth, 759 (u_longlong_t)bp->blk_fill, 760 (u_longlong_t)bp->blk_cksum.zc_word[0], 761 (u_longlong_t)bp->blk_cksum.zc_word[1], 762 (u_longlong_t)bp->blk_cksum.zc_word[2], 763 (u_longlong_t)bp->blk_cksum.zc_word[3]); 764 } 765 766 void 767 spa_freeze(spa_t *spa) 768 { 769 uint64_t freeze_txg = 0; 770 771 spa_config_enter(spa, RW_WRITER, FTAG); 772 if (spa->spa_freeze_txg == UINT64_MAX) { 773 freeze_txg = spa_last_synced_txg(spa) + TXG_SIZE; 774 spa->spa_freeze_txg = freeze_txg; 775 } 776 spa_config_exit(spa, FTAG); 777 if (freeze_txg != 0) 778 txg_wait_synced(spa_get_dsl(spa), freeze_txg); 779 } 780 781 /* 782 * ========================================================================== 783 * Accessor functions 784 * ========================================================================== 785 */ 786 787 krwlock_t * 788 spa_traverse_rwlock(spa_t *spa) 789 { 790 return (&spa->spa_traverse_lock); 791 } 792 793 int 794 spa_traverse_wanted(spa_t *spa) 795 { 796 return (spa->spa_traverse_wanted); 797 } 798 799 dsl_pool_t * 800 spa_get_dsl(spa_t *spa) 801 { 802 return (spa->spa_dsl_pool); 803 } 804 805 blkptr_t * 806 spa_get_rootblkptr(spa_t *spa) 807 { 808 return (&spa->spa_ubsync.ub_rootbp); 809 } 810 811 void 812 spa_set_rootblkptr(spa_t *spa, const blkptr_t *bp) 813 { 814 spa->spa_uberblock.ub_rootbp = *bp; 815 } 816 817 void 818 spa_altroot(spa_t *spa, char *buf, size_t buflen) 819 { 820 if (spa->spa_root == NULL) 821 buf[0] = '\0'; 822 else 823 (void) strncpy(buf, spa->spa_root, buflen); 824 } 825 826 int 827 spa_sync_pass(spa_t *spa) 828 { 829 return (spa->spa_sync_pass); 830 } 831 832 char * 833 spa_name(spa_t *spa) 834 { 835 /* 836 * Accessing the name requires holding either the namespace lock or the 837 * config lock, both of which are required to do a rename. 838 */ 839 ASSERT(MUTEX_HELD(&spa_namespace_lock) || 840 spa_config_held(spa, RW_READER) || spa_config_held(spa, RW_WRITER)); 841 842 return (spa->spa_name); 843 } 844 845 uint64_t 846 spa_guid(spa_t *spa) 847 { 848 /* 849 * If we fail to parse the config during spa_load(), we can go through 850 * the error path (which posts an ereport) and end up here with no root 851 * vdev. We stash the original pool guid in 'spa_load_guid' to handle 852 * this case. 853 */ 854 if (spa->spa_root_vdev != NULL) 855 return (spa->spa_root_vdev->vdev_guid); 856 else 857 return (spa->spa_load_guid); 858 } 859 860 uint64_t 861 spa_last_synced_txg(spa_t *spa) 862 { 863 return (spa->spa_ubsync.ub_txg); 864 } 865 866 uint64_t 867 spa_first_txg(spa_t *spa) 868 { 869 return (spa->spa_first_txg); 870 } 871 872 int 873 spa_state(spa_t *spa) 874 { 875 return (spa->spa_state); 876 } 877 878 uint64_t 879 spa_freeze_txg(spa_t *spa) 880 { 881 return (spa->spa_freeze_txg); 882 } 883 884 /* 885 * In the future, this may select among different metaslab classes 886 * depending on the zdp. For now, there's no such distinction. 887 */ 888 metaslab_class_t * 889 spa_metaslab_class_select(spa_t *spa) 890 { 891 return (spa->spa_normal_class); 892 } 893 894 /* 895 * Return how much space is allocated in the pool (ie. sum of all asize) 896 */ 897 uint64_t 898 spa_get_alloc(spa_t *spa) 899 { 900 return (spa->spa_root_vdev->vdev_stat.vs_alloc); 901 } 902 903 /* 904 * Return how much (raid-z inflated) space there is in the pool. 905 */ 906 uint64_t 907 spa_get_space(spa_t *spa) 908 { 909 return (spa->spa_root_vdev->vdev_stat.vs_space); 910 } 911 912 /* 913 * Return the amount of raid-z-deflated space in the pool. 914 */ 915 uint64_t 916 spa_get_dspace(spa_t *spa) 917 { 918 if (spa->spa_deflate) 919 return (spa->spa_root_vdev->vdev_stat.vs_dspace); 920 else 921 return (spa->spa_root_vdev->vdev_stat.vs_space); 922 } 923 924 /* ARGSUSED */ 925 uint64_t 926 spa_get_asize(spa_t *spa, uint64_t lsize) 927 { 928 /* 929 * For now, the worst case is 512-byte RAID-Z blocks, in which 930 * case the space requirement is exactly 2x; so just assume that. 931 * Add to this the fact that we can have up to 3 DVAs per bp, and 932 * we have to multiply by a total of 6x. 933 */ 934 return (lsize * 6); 935 } 936 937 uint64_t 938 spa_version(spa_t *spa) 939 { 940 return (spa->spa_ubsync.ub_version); 941 } 942 943 int 944 spa_max_replication(spa_t *spa) 945 { 946 /* 947 * As of ZFS_VERSION == ZFS_VERSION_DITTO_BLOCKS, we are able to 948 * handle BPs with more than one DVA allocated. Set our max 949 * replication level accordingly. 950 */ 951 if (spa_version(spa) < ZFS_VERSION_DITTO_BLOCKS) 952 return (1); 953 return (MIN(SPA_DVAS_PER_BP, spa_max_replication_override)); 954 } 955 956 uint64_t 957 bp_get_dasize(spa_t *spa, const blkptr_t *bp) 958 { 959 int sz = 0, i; 960 961 if (!spa->spa_deflate) 962 return (BP_GET_ASIZE(bp)); 963 964 for (i = 0; i < SPA_DVAS_PER_BP; i++) { 965 vdev_t *vd = 966 vdev_lookup_top(spa, DVA_GET_VDEV(&bp->blk_dva[i])); 967 sz += (DVA_GET_ASIZE(&bp->blk_dva[i]) >> SPA_MINBLOCKSHIFT) * 968 vd->vdev_deflate_ratio; 969 } 970 return (sz); 971 } 972 973 /* 974 * ========================================================================== 975 * Initialization and Termination 976 * ========================================================================== 977 */ 978 979 static int 980 spa_name_compare(const void *a1, const void *a2) 981 { 982 const spa_t *s1 = a1; 983 const spa_t *s2 = a2; 984 int s; 985 986 s = strcmp(s1->spa_name, s2->spa_name); 987 if (s > 0) 988 return (1); 989 if (s < 0) 990 return (-1); 991 return (0); 992 } 993 994 int 995 spa_busy(void) 996 { 997 return (spa_active_count); 998 } 999 1000 void 1001 spa_init(int mode) 1002 { 1003 mutex_init(&spa_namespace_lock, NULL, MUTEX_DEFAULT, NULL); 1004 cv_init(&spa_namespace_cv, NULL, CV_DEFAULT, NULL); 1005 1006 avl_create(&spa_namespace_avl, spa_name_compare, sizeof (spa_t), 1007 offsetof(spa_t, spa_avl)); 1008 1009 avl_create(&spa_spare_avl, spa_spare_compare, sizeof (spa_spare_t), 1010 offsetof(spa_spare_t, spare_avl)); 1011 1012 spa_mode = mode; 1013 1014 refcount_init(); 1015 unique_init(); 1016 zio_init(); 1017 dmu_init(); 1018 zil_init(); 1019 spa_config_load(); 1020 } 1021 1022 void 1023 spa_fini(void) 1024 { 1025 spa_evict_all(); 1026 1027 zil_fini(); 1028 dmu_fini(); 1029 zio_fini(); 1030 refcount_fini(); 1031 1032 avl_destroy(&spa_namespace_avl); 1033 avl_destroy(&spa_spare_avl); 1034 1035 cv_destroy(&spa_namespace_cv); 1036 mutex_destroy(&spa_namespace_lock); 1037 } 1038