1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6ea8dc4b6Seschrock * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 21fa9e4066Sahrens /* 2239c23413Seschrock * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 27fa9e4066Sahrens 28fa9e4066Sahrens #include <sys/zfs_context.h> 29fa9e4066Sahrens #include <sys/spa_impl.h> 30fa9e4066Sahrens #include <sys/zio.h> 31fa9e4066Sahrens #include <sys/zio_checksum.h> 32fa9e4066Sahrens #include <sys/zio_compress.h> 33fa9e4066Sahrens #include <sys/dmu.h> 34fa9e4066Sahrens #include <sys/dmu_tx.h> 35fa9e4066Sahrens #include <sys/zap.h> 36fa9e4066Sahrens #include <sys/zil.h> 37fa9e4066Sahrens #include <sys/vdev_impl.h> 38fa9e4066Sahrens #include <sys/metaslab.h> 39fa9e4066Sahrens #include <sys/uberblock_impl.h> 40fa9e4066Sahrens #include <sys/txg.h> 41fa9e4066Sahrens #include <sys/avl.h> 42fa9e4066Sahrens #include <sys/unique.h> 43fa9e4066Sahrens #include <sys/dsl_pool.h> 44fa9e4066Sahrens #include <sys/dsl_dir.h> 45fa9e4066Sahrens #include <sys/dsl_prop.h> 46fa9e4066Sahrens #include <sys/fs/zfs.h> 47*6ce0521aSperrin #include <sys/metaslab_impl.h> 48fa9e4066Sahrens 49fa9e4066Sahrens /* 50fa9e4066Sahrens * SPA locking 51fa9e4066Sahrens * 52fa9e4066Sahrens * There are four basic locks for managing spa_t structures: 53fa9e4066Sahrens * 54fa9e4066Sahrens * spa_namespace_lock (global mutex) 55fa9e4066Sahrens * 5644cd46caSbillm * This lock must be acquired to do any of the following: 57fa9e4066Sahrens * 5844cd46caSbillm * - Lookup a spa_t by name 5944cd46caSbillm * - Add or remove a spa_t from the namespace 6044cd46caSbillm * - Increase spa_refcount from non-zero 6144cd46caSbillm * - Check if spa_refcount is zero 6244cd46caSbillm * - Rename a spa_t 63ea8dc4b6Seschrock * - add/remove/attach/detach devices 6444cd46caSbillm * - Held for the duration of create/destroy/import/export 65fa9e4066Sahrens * 6644cd46caSbillm * It does not need to handle recursion. A create or destroy may 6744cd46caSbillm * reference objects (files or zvols) in other pools, but by 6844cd46caSbillm * definition they must have an existing reference, and will never need 6944cd46caSbillm * to lookup a spa_t by name. 70fa9e4066Sahrens * 71fa9e4066Sahrens * spa_refcount (per-spa refcount_t protected by mutex) 72fa9e4066Sahrens * 7344cd46caSbillm * This reference count keep track of any active users of the spa_t. The 7444cd46caSbillm * spa_t cannot be destroyed or freed while this is non-zero. Internally, 7544cd46caSbillm * the refcount is never really 'zero' - opening a pool implicitly keeps 7644cd46caSbillm * some references in the DMU. Internally we check against SPA_MINREF, but 7744cd46caSbillm * present the image of a zero/non-zero value to consumers. 78fa9e4066Sahrens * 79fa9e4066Sahrens * spa_config_lock (per-spa crazy rwlock) 80fa9e4066Sahrens * 8144cd46caSbillm * This SPA special is a recursive rwlock, capable of being acquired from 8244cd46caSbillm * asynchronous threads. It has protects the spa_t from config changes, 8344cd46caSbillm * and must be held in the following circumstances: 84fa9e4066Sahrens * 8544cd46caSbillm * - RW_READER to perform I/O to the spa 8644cd46caSbillm * - RW_WRITER to change the vdev config 87fa9e4066Sahrens * 88fa9e4066Sahrens * spa_config_cache_lock (per-spa mutex) 89fa9e4066Sahrens * 9044cd46caSbillm * This mutex prevents the spa_config nvlist from being updated. No 91fa9e4066Sahrens * other locks are required to obtain this lock, although implicitly you 92fa9e4066Sahrens * must have the namespace lock or non-zero refcount to have any kind 93fa9e4066Sahrens * of spa_t pointer at all. 94fa9e4066Sahrens * 95fa9e4066Sahrens * The locking order is fairly straightforward: 96fa9e4066Sahrens * 9744cd46caSbillm * spa_namespace_lock -> spa_refcount 98fa9e4066Sahrens * 9944cd46caSbillm * The namespace lock must be acquired to increase the refcount from 0 10044cd46caSbillm * or to check if it is zero. 101fa9e4066Sahrens * 10244cd46caSbillm * spa_refcount -> spa_config_lock 103fa9e4066Sahrens * 10444cd46caSbillm * There must be at least one valid reference on the spa_t to acquire 10544cd46caSbillm * the config lock. 106fa9e4066Sahrens * 10744cd46caSbillm * spa_namespace_lock -> spa_config_lock 108fa9e4066Sahrens * 10944cd46caSbillm * The namespace lock must always be taken before the config lock. 110fa9e4066Sahrens * 111fa9e4066Sahrens * 112fa9e4066Sahrens * The spa_namespace_lock and spa_config_cache_lock can be acquired directly and 113fa9e4066Sahrens * are globally visible. 114fa9e4066Sahrens * 115fa9e4066Sahrens * The namespace is manipulated using the following functions, all which require 116fa9e4066Sahrens * the spa_namespace_lock to be held. 117fa9e4066Sahrens * 11844cd46caSbillm * spa_lookup() Lookup a spa_t by name. 119fa9e4066Sahrens * 12044cd46caSbillm * spa_add() Create a new spa_t in the namespace. 121fa9e4066Sahrens * 12244cd46caSbillm * spa_remove() Remove a spa_t from the namespace. This also 12344cd46caSbillm * frees up any memory associated with the spa_t. 124fa9e4066Sahrens * 12544cd46caSbillm * spa_next() Returns the next spa_t in the system, or the 12644cd46caSbillm * first if NULL is passed. 127fa9e4066Sahrens * 12844cd46caSbillm * spa_evict_all() Shutdown and remove all spa_t structures in 12944cd46caSbillm * the system. 130fa9e4066Sahrens * 131ea8dc4b6Seschrock * spa_guid_exists() Determine whether a pool/device guid exists. 132fa9e4066Sahrens * 133fa9e4066Sahrens * The spa_refcount is manipulated using the following functions: 134fa9e4066Sahrens * 13544cd46caSbillm * spa_open_ref() Adds a reference to the given spa_t. Must be 13644cd46caSbillm * called with spa_namespace_lock held if the 13744cd46caSbillm * refcount is currently zero. 138fa9e4066Sahrens * 13944cd46caSbillm * spa_close() Remove a reference from the spa_t. This will 14044cd46caSbillm * not free the spa_t or remove it from the 14144cd46caSbillm * namespace. No locking is required. 142fa9e4066Sahrens * 14344cd46caSbillm * spa_refcount_zero() Returns true if the refcount is currently 14444cd46caSbillm * zero. Must be called with spa_namespace_lock 14544cd46caSbillm * held. 146fa9e4066Sahrens * 147fa9e4066Sahrens * The spa_config_lock is manipulated using the following functions: 148fa9e4066Sahrens * 14944cd46caSbillm * spa_config_enter() Acquire the config lock as RW_READER or 15044cd46caSbillm * RW_WRITER. At least one reference on the spa_t 15144cd46caSbillm * must exist. 152fa9e4066Sahrens * 15344cd46caSbillm * spa_config_exit() Release the config lock. 154fa9e4066Sahrens * 15544cd46caSbillm * spa_config_held() Returns true if the config lock is currently 15644cd46caSbillm * held in the given state. 157fa9e4066Sahrens * 158ea8dc4b6Seschrock * The vdev configuration is protected by spa_vdev_enter() / spa_vdev_exit(). 159fa9e4066Sahrens * 16044cd46caSbillm * spa_vdev_enter() Acquire the namespace lock and the config lock 161ea8dc4b6Seschrock * for writing. 162fa9e4066Sahrens * 16344cd46caSbillm * spa_vdev_exit() Release the config lock, wait for all I/O 16444cd46caSbillm * to complete, sync the updated configs to the 165ea8dc4b6Seschrock * cache, and release the namespace lock. 166fa9e4066Sahrens * 167fa9e4066Sahrens * The spa_name() function also requires either the spa_namespace_lock 168fa9e4066Sahrens * or the spa_config_lock, as both are needed to do a rename. spa_rename() is 169fa9e4066Sahrens * also implemented within this file since is requires manipulation of the 170fa9e4066Sahrens * namespace. 171fa9e4066Sahrens */ 172fa9e4066Sahrens 173fa9e4066Sahrens static avl_tree_t spa_namespace_avl; 174fa9e4066Sahrens kmutex_t spa_namespace_lock; 175fa9e4066Sahrens static kcondvar_t spa_namespace_cv; 1760373e76bSbonwick static int spa_active_count; 177416e0cd8Sek int spa_max_replication_override = SPA_DVAS_PER_BP; 178fa9e4066Sahrens 17999653d4eSeschrock static kmutex_t spa_spare_lock; 18039c23413Seschrock static avl_tree_t spa_spare_avl; 18199653d4eSeschrock 182fa9e4066Sahrens kmem_cache_t *spa_buffer_pool; 183fa9e4066Sahrens int spa_mode; 184fa9e4066Sahrens 185fa9e4066Sahrens #ifdef ZFS_DEBUG 18640feaa91Sahrens /* Everything except dprintf is on by default in debug builds */ 18740feaa91Sahrens int zfs_flags = ~ZFS_DEBUG_DPRINTF; 188fa9e4066Sahrens #else 189fa9e4066Sahrens int zfs_flags = 0; 190fa9e4066Sahrens #endif 191fa9e4066Sahrens 1920125049cSahrens /* 1930125049cSahrens * zfs_recover can be set to nonzero to attempt to recover from 1940125049cSahrens * otherwise-fatal errors, typically caused by on-disk corruption. When 1950125049cSahrens * set, calls to zfs_panic_recover() will turn into warning messages. 1960125049cSahrens */ 1970125049cSahrens int zfs_recover = 0; 1980125049cSahrens 199fa9e4066Sahrens #define SPA_MINREF 5 /* spa_refcnt for an open-but-idle pool */ 200fa9e4066Sahrens 201fa9e4066Sahrens /* 202fa9e4066Sahrens * ========================================================================== 203fa9e4066Sahrens * SPA namespace functions 204fa9e4066Sahrens * ========================================================================== 205fa9e4066Sahrens */ 206fa9e4066Sahrens 207fa9e4066Sahrens /* 208fa9e4066Sahrens * Lookup the named spa_t in the AVL tree. The spa_namespace_lock must be held. 209fa9e4066Sahrens * Returns NULL if no matching spa_t is found. 210fa9e4066Sahrens */ 211fa9e4066Sahrens spa_t * 212fa9e4066Sahrens spa_lookup(const char *name) 213fa9e4066Sahrens { 214fa9e4066Sahrens spa_t search, *spa; 215fa9e4066Sahrens avl_index_t where; 21640feaa91Sahrens char c; 21740feaa91Sahrens char *cp; 218fa9e4066Sahrens 219fa9e4066Sahrens ASSERT(MUTEX_HELD(&spa_namespace_lock)); 220fa9e4066Sahrens 22140feaa91Sahrens /* 22240feaa91Sahrens * If it's a full dataset name, figure out the pool name and 22340feaa91Sahrens * just use that. 22440feaa91Sahrens */ 22540feaa91Sahrens cp = strpbrk(name, "/@"); 22640feaa91Sahrens if (cp) { 22740feaa91Sahrens c = *cp; 22840feaa91Sahrens *cp = '\0'; 22940feaa91Sahrens } 23040feaa91Sahrens 231fa9e4066Sahrens search.spa_name = (char *)name; 232fa9e4066Sahrens spa = avl_find(&spa_namespace_avl, &search, &where); 233fa9e4066Sahrens 23440feaa91Sahrens if (cp) 23540feaa91Sahrens *cp = c; 23640feaa91Sahrens 237fa9e4066Sahrens return (spa); 238fa9e4066Sahrens } 239fa9e4066Sahrens 240fa9e4066Sahrens /* 241fa9e4066Sahrens * Create an uninitialized spa_t with the given name. Requires 242fa9e4066Sahrens * spa_namespace_lock. The caller must ensure that the spa_t doesn't already 243fa9e4066Sahrens * exist by calling spa_lookup() first. 244fa9e4066Sahrens */ 245fa9e4066Sahrens spa_t * 2460373e76bSbonwick spa_add(const char *name, const char *altroot) 247fa9e4066Sahrens { 248fa9e4066Sahrens spa_t *spa; 249fa9e4066Sahrens 250fa9e4066Sahrens ASSERT(MUTEX_HELD(&spa_namespace_lock)); 251fa9e4066Sahrens 252fa9e4066Sahrens spa = kmem_zalloc(sizeof (spa_t), KM_SLEEP); 253fa9e4066Sahrens 254fa9e4066Sahrens spa->spa_name = spa_strdup(name); 255fa9e4066Sahrens spa->spa_state = POOL_STATE_UNINITIALIZED; 256fa9e4066Sahrens spa->spa_freeze_txg = UINT64_MAX; 2570373e76bSbonwick spa->spa_final_txg = UINT64_MAX; 258fa9e4066Sahrens 259fa9e4066Sahrens refcount_create(&spa->spa_refcount); 260ea8dc4b6Seschrock refcount_create(&spa->spa_config_lock.scl_count); 261fa9e4066Sahrens 262fa9e4066Sahrens avl_add(&spa_namespace_avl, spa); 263fa9e4066Sahrens 2640373e76bSbonwick /* 2650373e76bSbonwick * Set the alternate root, if there is one. 2660373e76bSbonwick */ 2670373e76bSbonwick if (altroot) { 2680373e76bSbonwick spa->spa_root = spa_strdup(altroot); 2690373e76bSbonwick spa_active_count++; 2700373e76bSbonwick } 2710373e76bSbonwick 272fa9e4066Sahrens return (spa); 273fa9e4066Sahrens } 274fa9e4066Sahrens 275fa9e4066Sahrens /* 276fa9e4066Sahrens * Removes a spa_t from the namespace, freeing up any memory used. Requires 277fa9e4066Sahrens * spa_namespace_lock. This is called only after the spa_t has been closed and 278fa9e4066Sahrens * deactivated. 279fa9e4066Sahrens */ 280fa9e4066Sahrens void 281fa9e4066Sahrens spa_remove(spa_t *spa) 282fa9e4066Sahrens { 283fa9e4066Sahrens ASSERT(MUTEX_HELD(&spa_namespace_lock)); 284fa9e4066Sahrens ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED); 285fa9e4066Sahrens ASSERT(spa->spa_scrub_thread == NULL); 286fa9e4066Sahrens 287fa9e4066Sahrens avl_remove(&spa_namespace_avl, spa); 288fa9e4066Sahrens cv_broadcast(&spa_namespace_cv); 289fa9e4066Sahrens 2900373e76bSbonwick if (spa->spa_root) { 291fa9e4066Sahrens spa_strfree(spa->spa_root); 2920373e76bSbonwick spa_active_count--; 2930373e76bSbonwick } 294fa9e4066Sahrens 295fa9e4066Sahrens if (spa->spa_name) 296fa9e4066Sahrens spa_strfree(spa->spa_name); 297fa9e4066Sahrens 298fa9e4066Sahrens spa_config_set(spa, NULL); 299fa9e4066Sahrens 300fa9e4066Sahrens refcount_destroy(&spa->spa_refcount); 301ea8dc4b6Seschrock refcount_destroy(&spa->spa_config_lock.scl_count); 302fa9e4066Sahrens 3035ad82045Snd mutex_destroy(&spa->spa_sync_bplist.bpl_lock); 3045ad82045Snd mutex_destroy(&spa->spa_config_lock.scl_lock); 3055ad82045Snd mutex_destroy(&spa->spa_errlist_lock); 3065ad82045Snd mutex_destroy(&spa->spa_errlog_lock); 3075ad82045Snd mutex_destroy(&spa->spa_scrub_lock); 3085ad82045Snd mutex_destroy(&spa->spa_config_cache_lock); 3095ad82045Snd mutex_destroy(&spa->spa_async_lock); 31006eeb2adSek mutex_destroy(&spa->spa_history_lock); 311b1b8ab34Slling mutex_destroy(&spa->spa_props_lock); 3125ad82045Snd 313fa9e4066Sahrens kmem_free(spa, sizeof (spa_t)); 314fa9e4066Sahrens } 315fa9e4066Sahrens 316fa9e4066Sahrens /* 317fa9e4066Sahrens * Given a pool, return the next pool in the namespace, or NULL if there is 318fa9e4066Sahrens * none. If 'prev' is NULL, return the first pool. 319fa9e4066Sahrens */ 320fa9e4066Sahrens spa_t * 321fa9e4066Sahrens spa_next(spa_t *prev) 322fa9e4066Sahrens { 323fa9e4066Sahrens ASSERT(MUTEX_HELD(&spa_namespace_lock)); 324fa9e4066Sahrens 325fa9e4066Sahrens if (prev) 326fa9e4066Sahrens return (AVL_NEXT(&spa_namespace_avl, prev)); 327fa9e4066Sahrens else 328fa9e4066Sahrens return (avl_first(&spa_namespace_avl)); 329fa9e4066Sahrens } 330fa9e4066Sahrens 331fa9e4066Sahrens /* 332fa9e4066Sahrens * ========================================================================== 333fa9e4066Sahrens * SPA refcount functions 334fa9e4066Sahrens * ========================================================================== 335fa9e4066Sahrens */ 336fa9e4066Sahrens 337fa9e4066Sahrens /* 338fa9e4066Sahrens * Add a reference to the given spa_t. Must have at least one reference, or 339fa9e4066Sahrens * have the namespace lock held. 340fa9e4066Sahrens */ 341fa9e4066Sahrens void 342fa9e4066Sahrens spa_open_ref(spa_t *spa, void *tag) 343fa9e4066Sahrens { 344fa9e4066Sahrens ASSERT(refcount_count(&spa->spa_refcount) > SPA_MINREF || 345fa9e4066Sahrens MUTEX_HELD(&spa_namespace_lock)); 346fa9e4066Sahrens 347fa9e4066Sahrens (void) refcount_add(&spa->spa_refcount, tag); 348fa9e4066Sahrens } 349fa9e4066Sahrens 350fa9e4066Sahrens /* 351fa9e4066Sahrens * Remove a reference to the given spa_t. Must have at least one reference, or 352fa9e4066Sahrens * have the namespace lock held. 353fa9e4066Sahrens */ 354fa9e4066Sahrens void 355fa9e4066Sahrens spa_close(spa_t *spa, void *tag) 356fa9e4066Sahrens { 357fa9e4066Sahrens ASSERT(refcount_count(&spa->spa_refcount) > SPA_MINREF || 358fa9e4066Sahrens MUTEX_HELD(&spa_namespace_lock)); 359fa9e4066Sahrens 360fa9e4066Sahrens (void) refcount_remove(&spa->spa_refcount, tag); 361fa9e4066Sahrens } 362fa9e4066Sahrens 363fa9e4066Sahrens /* 364fa9e4066Sahrens * Check to see if the spa refcount is zero. Must be called with 365fa9e4066Sahrens * spa_namespace_lock held. We really compare against SPA_MINREF, which is the 366fa9e4066Sahrens * number of references acquired when opening a pool 367fa9e4066Sahrens */ 368fa9e4066Sahrens boolean_t 369fa9e4066Sahrens spa_refcount_zero(spa_t *spa) 370fa9e4066Sahrens { 371fa9e4066Sahrens ASSERT(MUTEX_HELD(&spa_namespace_lock)); 372fa9e4066Sahrens 373fa9e4066Sahrens return (refcount_count(&spa->spa_refcount) == SPA_MINREF); 374fa9e4066Sahrens } 375fa9e4066Sahrens 37699653d4eSeschrock /* 37799653d4eSeschrock * ========================================================================== 37899653d4eSeschrock * SPA spare tracking 37999653d4eSeschrock * ========================================================================== 38099653d4eSeschrock */ 38199653d4eSeschrock 38299653d4eSeschrock /* 38339c23413Seschrock * Spares are tracked globally due to the following constraints: 38439c23413Seschrock * 38539c23413Seschrock * - A spare may be part of multiple pools. 38639c23413Seschrock * - A spare may be added to a pool even if it's actively in use within 38739c23413Seschrock * another pool. 38839c23413Seschrock * - A spare in use in any pool can only be the source of a replacement if 38939c23413Seschrock * the target is a spare in the same pool. 39039c23413Seschrock * 39139c23413Seschrock * We keep track of all spares on the system through the use of a reference 39239c23413Seschrock * counted AVL tree. When a vdev is added as a spare, or used as a replacement 39339c23413Seschrock * spare, then we bump the reference count in the AVL tree. In addition, we set 39439c23413Seschrock * the 'vdev_isspare' member to indicate that the device is a spare (active or 39539c23413Seschrock * inactive). When a spare is made active (used to replace a device in the 39639c23413Seschrock * pool), we also keep track of which pool its been made a part of. 39739c23413Seschrock * 39839c23413Seschrock * The 'spa_spare_lock' protects the AVL tree. These functions are normally 39939c23413Seschrock * called under the spa_namespace lock as part of vdev reconfiguration. The 40039c23413Seschrock * separate spare lock exists for the status query path, which does not need to 40139c23413Seschrock * be completely consistent with respect to other vdev configuration changes. 40299653d4eSeschrock */ 40339c23413Seschrock 40499653d4eSeschrock typedef struct spa_spare { 40599653d4eSeschrock uint64_t spare_guid; 40639c23413Seschrock uint64_t spare_pool; 40799653d4eSeschrock avl_node_t spare_avl; 40899653d4eSeschrock int spare_count; 40999653d4eSeschrock } spa_spare_t; 41099653d4eSeschrock 41199653d4eSeschrock static int 41299653d4eSeschrock spa_spare_compare(const void *a, const void *b) 41399653d4eSeschrock { 41499653d4eSeschrock const spa_spare_t *sa = a; 41599653d4eSeschrock const spa_spare_t *sb = b; 41699653d4eSeschrock 41799653d4eSeschrock if (sa->spare_guid < sb->spare_guid) 41899653d4eSeschrock return (-1); 41999653d4eSeschrock else if (sa->spare_guid > sb->spare_guid) 42099653d4eSeschrock return (1); 42199653d4eSeschrock else 42299653d4eSeschrock return (0); 42399653d4eSeschrock } 42499653d4eSeschrock 42599653d4eSeschrock void 42639c23413Seschrock spa_spare_add(vdev_t *vd) 42799653d4eSeschrock { 42899653d4eSeschrock avl_index_t where; 42999653d4eSeschrock spa_spare_t search; 43099653d4eSeschrock spa_spare_t *spare; 43199653d4eSeschrock 43299653d4eSeschrock mutex_enter(&spa_spare_lock); 43339c23413Seschrock ASSERT(!vd->vdev_isspare); 43499653d4eSeschrock 43539c23413Seschrock search.spare_guid = vd->vdev_guid; 43699653d4eSeschrock if ((spare = avl_find(&spa_spare_avl, &search, &where)) != NULL) { 43799653d4eSeschrock spare->spare_count++; 43899653d4eSeschrock } else { 43939c23413Seschrock spare = kmem_zalloc(sizeof (spa_spare_t), KM_SLEEP); 44039c23413Seschrock spare->spare_guid = vd->vdev_guid; 44199653d4eSeschrock spare->spare_count = 1; 44299653d4eSeschrock avl_insert(&spa_spare_avl, spare, where); 44399653d4eSeschrock } 44439c23413Seschrock vd->vdev_isspare = B_TRUE; 44599653d4eSeschrock 44699653d4eSeschrock mutex_exit(&spa_spare_lock); 44799653d4eSeschrock } 44899653d4eSeschrock 44999653d4eSeschrock void 45039c23413Seschrock spa_spare_remove(vdev_t *vd) 45199653d4eSeschrock { 45299653d4eSeschrock spa_spare_t search; 45399653d4eSeschrock spa_spare_t *spare; 45499653d4eSeschrock avl_index_t where; 45599653d4eSeschrock 45699653d4eSeschrock mutex_enter(&spa_spare_lock); 45799653d4eSeschrock 45839c23413Seschrock search.spare_guid = vd->vdev_guid; 45999653d4eSeschrock spare = avl_find(&spa_spare_avl, &search, &where); 46099653d4eSeschrock 46139c23413Seschrock ASSERT(vd->vdev_isspare); 46299653d4eSeschrock ASSERT(spare != NULL); 46399653d4eSeschrock 46499653d4eSeschrock if (--spare->spare_count == 0) { 46599653d4eSeschrock avl_remove(&spa_spare_avl, spare); 46699653d4eSeschrock kmem_free(spare, sizeof (spa_spare_t)); 46739c23413Seschrock } else if (spare->spare_pool == spa_guid(vd->vdev_spa)) { 46839c23413Seschrock spare->spare_pool = 0ULL; 46999653d4eSeschrock } 47099653d4eSeschrock 47139c23413Seschrock vd->vdev_isspare = B_FALSE; 47299653d4eSeschrock mutex_exit(&spa_spare_lock); 47399653d4eSeschrock } 47499653d4eSeschrock 47599653d4eSeschrock boolean_t 47639c23413Seschrock spa_spare_exists(uint64_t guid, uint64_t *pool) 47799653d4eSeschrock { 47839c23413Seschrock spa_spare_t search, *found; 47999653d4eSeschrock avl_index_t where; 48099653d4eSeschrock 48199653d4eSeschrock mutex_enter(&spa_spare_lock); 48299653d4eSeschrock 48399653d4eSeschrock search.spare_guid = guid; 48439c23413Seschrock found = avl_find(&spa_spare_avl, &search, &where); 48539c23413Seschrock 48639c23413Seschrock if (pool) { 48739c23413Seschrock if (found) 48839c23413Seschrock *pool = found->spare_pool; 48939c23413Seschrock else 49039c23413Seschrock *pool = 0ULL; 49139c23413Seschrock } 49299653d4eSeschrock 49399653d4eSeschrock mutex_exit(&spa_spare_lock); 49499653d4eSeschrock 49539c23413Seschrock return (found != NULL); 49639c23413Seschrock } 49739c23413Seschrock 49839c23413Seschrock void 49939c23413Seschrock spa_spare_activate(vdev_t *vd) 50039c23413Seschrock { 50139c23413Seschrock spa_spare_t search, *found; 50239c23413Seschrock avl_index_t where; 50339c23413Seschrock 50439c23413Seschrock mutex_enter(&spa_spare_lock); 50539c23413Seschrock ASSERT(vd->vdev_isspare); 50639c23413Seschrock 50739c23413Seschrock search.spare_guid = vd->vdev_guid; 50839c23413Seschrock found = avl_find(&spa_spare_avl, &search, &where); 50939c23413Seschrock ASSERT(found != NULL); 51039c23413Seschrock ASSERT(found->spare_pool == 0ULL); 51139c23413Seschrock 51239c23413Seschrock found->spare_pool = spa_guid(vd->vdev_spa); 51339c23413Seschrock mutex_exit(&spa_spare_lock); 51499653d4eSeschrock } 51599653d4eSeschrock 516fa9e4066Sahrens /* 517fa9e4066Sahrens * ========================================================================== 518fa9e4066Sahrens * SPA config locking 519fa9e4066Sahrens * ========================================================================== 520fa9e4066Sahrens */ 521fa9e4066Sahrens 522fa9e4066Sahrens /* 523fa9e4066Sahrens * Acquire the config lock. The config lock is a special rwlock that allows for 524fa9e4066Sahrens * recursive enters. Because these enters come from the same thread as well as 525fa9e4066Sahrens * asynchronous threads working on behalf of the owner, we must unilaterally 526fa9e4066Sahrens * allow all reads access as long at least one reader is held (even if a write 527fa9e4066Sahrens * is requested). This has the side effect of write starvation, but write locks 528fa9e4066Sahrens * are extremely rare, and a solution to this problem would be significantly 529fa9e4066Sahrens * more complex (if even possible). 530fa9e4066Sahrens * 531fa9e4066Sahrens * We would like to assert that the namespace lock isn't held, but this is a 532fa9e4066Sahrens * valid use during create. 533fa9e4066Sahrens */ 534fa9e4066Sahrens void 535ea8dc4b6Seschrock spa_config_enter(spa_t *spa, krw_t rw, void *tag) 536fa9e4066Sahrens { 537fa9e4066Sahrens spa_config_lock_t *scl = &spa->spa_config_lock; 538fa9e4066Sahrens 539fa9e4066Sahrens mutex_enter(&scl->scl_lock); 540fa9e4066Sahrens 541fa9e4066Sahrens if (scl->scl_writer != curthread) { 542fa9e4066Sahrens if (rw == RW_READER) { 543fa9e4066Sahrens while (scl->scl_writer != NULL) 544fa9e4066Sahrens cv_wait(&scl->scl_cv, &scl->scl_lock); 545fa9e4066Sahrens } else { 546ea8dc4b6Seschrock while (scl->scl_writer != NULL || 547ea8dc4b6Seschrock !refcount_is_zero(&scl->scl_count)) 548fa9e4066Sahrens cv_wait(&scl->scl_cv, &scl->scl_lock); 549fa9e4066Sahrens scl->scl_writer = curthread; 550fa9e4066Sahrens } 551fa9e4066Sahrens } 552fa9e4066Sahrens 553ea8dc4b6Seschrock (void) refcount_add(&scl->scl_count, tag); 554fa9e4066Sahrens 555fa9e4066Sahrens mutex_exit(&scl->scl_lock); 556fa9e4066Sahrens } 557fa9e4066Sahrens 558fa9e4066Sahrens /* 559fa9e4066Sahrens * Release the spa config lock, notifying any waiters in the process. 560fa9e4066Sahrens */ 561fa9e4066Sahrens void 562ea8dc4b6Seschrock spa_config_exit(spa_t *spa, void *tag) 563fa9e4066Sahrens { 564fa9e4066Sahrens spa_config_lock_t *scl = &spa->spa_config_lock; 565fa9e4066Sahrens 566fa9e4066Sahrens mutex_enter(&scl->scl_lock); 567fa9e4066Sahrens 568ea8dc4b6Seschrock ASSERT(!refcount_is_zero(&scl->scl_count)); 569ea8dc4b6Seschrock if (refcount_remove(&scl->scl_count, tag) == 0) { 570fa9e4066Sahrens cv_broadcast(&scl->scl_cv); 571fa9e4066Sahrens scl->scl_writer = NULL; /* OK in either case */ 572fa9e4066Sahrens } 573fa9e4066Sahrens 574fa9e4066Sahrens mutex_exit(&scl->scl_lock); 575fa9e4066Sahrens } 576fa9e4066Sahrens 577fa9e4066Sahrens /* 578fa9e4066Sahrens * Returns true if the config lock is held in the given manner. 579fa9e4066Sahrens */ 580fa9e4066Sahrens boolean_t 581fa9e4066Sahrens spa_config_held(spa_t *spa, krw_t rw) 582fa9e4066Sahrens { 583fa9e4066Sahrens spa_config_lock_t *scl = &spa->spa_config_lock; 584fa9e4066Sahrens boolean_t held; 585fa9e4066Sahrens 586fa9e4066Sahrens mutex_enter(&scl->scl_lock); 587fa9e4066Sahrens if (rw == RW_WRITER) 588fa9e4066Sahrens held = (scl->scl_writer == curthread); 589fa9e4066Sahrens else 590ea8dc4b6Seschrock held = !refcount_is_zero(&scl->scl_count); 591fa9e4066Sahrens mutex_exit(&scl->scl_lock); 592fa9e4066Sahrens 593fa9e4066Sahrens return (held); 594fa9e4066Sahrens } 595fa9e4066Sahrens 596fa9e4066Sahrens /* 597fa9e4066Sahrens * ========================================================================== 598fa9e4066Sahrens * SPA vdev locking 599fa9e4066Sahrens * ========================================================================== 600fa9e4066Sahrens */ 601fa9e4066Sahrens 602fa9e4066Sahrens /* 603ea8dc4b6Seschrock * Lock the given spa_t for the purpose of adding or removing a vdev. 604ea8dc4b6Seschrock * Grabs the global spa_namespace_lock plus the spa config lock for writing. 605fa9e4066Sahrens * It returns the next transaction group for the spa_t. 606fa9e4066Sahrens */ 607fa9e4066Sahrens uint64_t 608fa9e4066Sahrens spa_vdev_enter(spa_t *spa) 609fa9e4066Sahrens { 6103d7072f8Seschrock mutex_enter(&spa_namespace_lock); 6113d7072f8Seschrock 612ea8dc4b6Seschrock /* 6133d7072f8Seschrock * Suspend scrub activity while we mess with the config. We must do 6143d7072f8Seschrock * this after acquiring the namespace lock to avoid a 3-way deadlock 6153d7072f8Seschrock * with spa_scrub_stop() and the scrub thread. 616ea8dc4b6Seschrock */ 617ea8dc4b6Seschrock spa_scrub_suspend(spa); 618fa9e4066Sahrens 619ea8dc4b6Seschrock spa_config_enter(spa, RW_WRITER, spa); 620fa9e4066Sahrens 621fa9e4066Sahrens return (spa_last_synced_txg(spa) + 1); 622fa9e4066Sahrens } 623fa9e4066Sahrens 624fa9e4066Sahrens /* 625fa9e4066Sahrens * Unlock the spa_t after adding or removing a vdev. Besides undoing the 626fa9e4066Sahrens * locking of spa_vdev_enter(), we also want make sure the transactions have 627fa9e4066Sahrens * synced to disk, and then update the global configuration cache with the new 628fa9e4066Sahrens * information. 629fa9e4066Sahrens */ 630fa9e4066Sahrens int 631fa9e4066Sahrens spa_vdev_exit(spa_t *spa, vdev_t *vd, uint64_t txg, int error) 632fa9e4066Sahrens { 6330e34b6a7Sbonwick int config_changed = B_FALSE; 634ea8dc4b6Seschrock 6350373e76bSbonwick ASSERT(txg > spa_last_synced_txg(spa)); 6360e34b6a7Sbonwick 6370e34b6a7Sbonwick /* 6380e34b6a7Sbonwick * Reassess the DTLs. 6390e34b6a7Sbonwick */ 6400373e76bSbonwick vdev_dtl_reassess(spa->spa_root_vdev, 0, 0, B_FALSE); 6410e34b6a7Sbonwick 6420e34b6a7Sbonwick /* 6430373e76bSbonwick * If the config changed, notify the scrub thread that it must restart. 6440e34b6a7Sbonwick */ 6450e34b6a7Sbonwick if (error == 0 && !list_is_empty(&spa->spa_dirty_list)) { 6460e34b6a7Sbonwick config_changed = B_TRUE; 6470373e76bSbonwick spa_scrub_restart(spa, txg); 6480e34b6a7Sbonwick } 649ea8dc4b6Seschrock 650ea8dc4b6Seschrock spa_config_exit(spa, spa); 651fa9e4066Sahrens 652ea8dc4b6Seschrock /* 6535dabedeeSbonwick * Allow scrubbing to resume. 654ea8dc4b6Seschrock */ 655ea8dc4b6Seschrock spa_scrub_resume(spa); 656fa9e4066Sahrens 657fa9e4066Sahrens /* 658fa9e4066Sahrens * Note: this txg_wait_synced() is important because it ensures 659fa9e4066Sahrens * that there won't be more than one config change per txg. 660fa9e4066Sahrens * This allows us to use the txg as the generation number. 661fa9e4066Sahrens */ 662fa9e4066Sahrens if (error == 0) 663fa9e4066Sahrens txg_wait_synced(spa->spa_dsl_pool, txg); 664fa9e4066Sahrens 665fa9e4066Sahrens if (vd != NULL) { 666fa9e4066Sahrens ASSERT(!vd->vdev_detached || vd->vdev_dtl.smo_object == 0); 667fa9e4066Sahrens vdev_free(vd); 668fa9e4066Sahrens } 669fa9e4066Sahrens 670fa9e4066Sahrens /* 6710e34b6a7Sbonwick * If the config changed, update the config cache. 672fa9e4066Sahrens */ 6730e34b6a7Sbonwick if (config_changed) 674fa9e4066Sahrens spa_config_sync(); 675ea8dc4b6Seschrock 676ea8dc4b6Seschrock mutex_exit(&spa_namespace_lock); 677fa9e4066Sahrens 678fa9e4066Sahrens return (error); 679fa9e4066Sahrens } 680fa9e4066Sahrens 681fa9e4066Sahrens /* 682fa9e4066Sahrens * ========================================================================== 683fa9e4066Sahrens * Miscellaneous functions 684fa9e4066Sahrens * ========================================================================== 685fa9e4066Sahrens */ 686fa9e4066Sahrens 687fa9e4066Sahrens /* 688fa9e4066Sahrens * Rename a spa_t. 689fa9e4066Sahrens */ 690fa9e4066Sahrens int 691fa9e4066Sahrens spa_rename(const char *name, const char *newname) 692fa9e4066Sahrens { 693fa9e4066Sahrens spa_t *spa; 694fa9e4066Sahrens int err; 695fa9e4066Sahrens 696fa9e4066Sahrens /* 697fa9e4066Sahrens * Lookup the spa_t and grab the config lock for writing. We need to 698fa9e4066Sahrens * actually open the pool so that we can sync out the necessary labels. 699fa9e4066Sahrens * It's OK to call spa_open() with the namespace lock held because we 700ea8dc4b6Seschrock * allow recursive calls for other reasons. 701fa9e4066Sahrens */ 702fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 703fa9e4066Sahrens if ((err = spa_open(name, &spa, FTAG)) != 0) { 704fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 705fa9e4066Sahrens return (err); 706fa9e4066Sahrens } 707fa9e4066Sahrens 708ea8dc4b6Seschrock spa_config_enter(spa, RW_WRITER, FTAG); 709fa9e4066Sahrens 710fa9e4066Sahrens avl_remove(&spa_namespace_avl, spa); 711fa9e4066Sahrens spa_strfree(spa->spa_name); 712fa9e4066Sahrens spa->spa_name = spa_strdup(newname); 713fa9e4066Sahrens avl_add(&spa_namespace_avl, spa); 714fa9e4066Sahrens 715fa9e4066Sahrens /* 716fa9e4066Sahrens * Sync all labels to disk with the new names by marking the root vdev 717fa9e4066Sahrens * dirty and waiting for it to sync. It will pick up the new pool name 718fa9e4066Sahrens * during the sync. 719fa9e4066Sahrens */ 720fa9e4066Sahrens vdev_config_dirty(spa->spa_root_vdev); 721fa9e4066Sahrens 722ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 723fa9e4066Sahrens 7240373e76bSbonwick txg_wait_synced(spa->spa_dsl_pool, 0); 725fa9e4066Sahrens 726fa9e4066Sahrens /* 727fa9e4066Sahrens * Sync the updated config cache. 728fa9e4066Sahrens */ 729fa9e4066Sahrens spa_config_sync(); 730fa9e4066Sahrens 731fa9e4066Sahrens spa_close(spa, FTAG); 732fa9e4066Sahrens 733fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 734fa9e4066Sahrens 735fa9e4066Sahrens return (0); 736fa9e4066Sahrens } 737fa9e4066Sahrens 738fa9e4066Sahrens 739fa9e4066Sahrens /* 740fa9e4066Sahrens * Determine whether a pool with given pool_guid exists. If device_guid is 741fa9e4066Sahrens * non-zero, determine whether the pool exists *and* contains a device with the 742fa9e4066Sahrens * specified device_guid. 743fa9e4066Sahrens */ 744fa9e4066Sahrens boolean_t 745fa9e4066Sahrens spa_guid_exists(uint64_t pool_guid, uint64_t device_guid) 746fa9e4066Sahrens { 747fa9e4066Sahrens spa_t *spa; 748fa9e4066Sahrens avl_tree_t *t = &spa_namespace_avl; 749fa9e4066Sahrens 750ea8dc4b6Seschrock ASSERT(MUTEX_HELD(&spa_namespace_lock)); 751fa9e4066Sahrens 752fa9e4066Sahrens for (spa = avl_first(t); spa != NULL; spa = AVL_NEXT(t, spa)) { 753fa9e4066Sahrens if (spa->spa_state == POOL_STATE_UNINITIALIZED) 754fa9e4066Sahrens continue; 755fa9e4066Sahrens if (spa->spa_root_vdev == NULL) 756fa9e4066Sahrens continue; 75739c23413Seschrock if (spa_guid(spa) == pool_guid) { 75839c23413Seschrock if (device_guid == 0) 75939c23413Seschrock break; 76039c23413Seschrock 76139c23413Seschrock if (vdev_lookup_by_guid(spa->spa_root_vdev, 76239c23413Seschrock device_guid) != NULL) 76339c23413Seschrock break; 76439c23413Seschrock 76539c23413Seschrock /* 7668654d025Sperrin * Check any devices we may be in the process of adding. 76739c23413Seschrock */ 76839c23413Seschrock if (spa->spa_pending_vdev) { 76939c23413Seschrock if (vdev_lookup_by_guid(spa->spa_pending_vdev, 77039c23413Seschrock device_guid) != NULL) 77139c23413Seschrock break; 77239c23413Seschrock } 77339c23413Seschrock } 774fa9e4066Sahrens } 775fa9e4066Sahrens 776fa9e4066Sahrens return (spa != NULL); 777fa9e4066Sahrens } 778fa9e4066Sahrens 779fa9e4066Sahrens char * 780fa9e4066Sahrens spa_strdup(const char *s) 781fa9e4066Sahrens { 782fa9e4066Sahrens size_t len; 783fa9e4066Sahrens char *new; 784fa9e4066Sahrens 785fa9e4066Sahrens len = strlen(s); 786fa9e4066Sahrens new = kmem_alloc(len + 1, KM_SLEEP); 787fa9e4066Sahrens bcopy(s, new, len); 788fa9e4066Sahrens new[len] = '\0'; 789fa9e4066Sahrens 790fa9e4066Sahrens return (new); 791fa9e4066Sahrens } 792fa9e4066Sahrens 793fa9e4066Sahrens void 794fa9e4066Sahrens spa_strfree(char *s) 795fa9e4066Sahrens { 796fa9e4066Sahrens kmem_free(s, strlen(s) + 1); 797fa9e4066Sahrens } 798fa9e4066Sahrens 799fa9e4066Sahrens uint64_t 800fa9e4066Sahrens spa_get_random(uint64_t range) 801fa9e4066Sahrens { 802fa9e4066Sahrens uint64_t r; 803fa9e4066Sahrens 804fa9e4066Sahrens ASSERT(range != 0); 805fa9e4066Sahrens 806fa9e4066Sahrens (void) random_get_pseudo_bytes((void *)&r, sizeof (uint64_t)); 807fa9e4066Sahrens 808fa9e4066Sahrens return (r % range); 809fa9e4066Sahrens } 810fa9e4066Sahrens 811fa9e4066Sahrens void 812d80c45e0Sbonwick sprintf_blkptr(char *buf, int len, const blkptr_t *bp) 813fa9e4066Sahrens { 81444cd46caSbillm int d; 815fa9e4066Sahrens 816fa9e4066Sahrens if (bp == NULL) { 817fbabab8fSmaybee (void) snprintf(buf, len, "<NULL>"); 818fa9e4066Sahrens return; 819fa9e4066Sahrens } 820fa9e4066Sahrens 821fa9e4066Sahrens if (BP_IS_HOLE(bp)) { 822fbabab8fSmaybee (void) snprintf(buf, len, "<hole>"); 823fa9e4066Sahrens return; 824fa9e4066Sahrens } 825fa9e4066Sahrens 82644cd46caSbillm (void) snprintf(buf, len, "[L%llu %s] %llxL/%llxP ", 827fa9e4066Sahrens (u_longlong_t)BP_GET_LEVEL(bp), 828fa9e4066Sahrens dmu_ot[BP_GET_TYPE(bp)].ot_name, 829fa9e4066Sahrens (u_longlong_t)BP_GET_LSIZE(bp), 83044cd46caSbillm (u_longlong_t)BP_GET_PSIZE(bp)); 83144cd46caSbillm 83244cd46caSbillm for (d = 0; d < BP_GET_NDVAS(bp); d++) { 833d80c45e0Sbonwick const dva_t *dva = &bp->blk_dva[d]; 83444cd46caSbillm (void) snprintf(buf + strlen(buf), len - strlen(buf), 83544cd46caSbillm "DVA[%d]=<%llu:%llx:%llx> ", d, 83644cd46caSbillm (u_longlong_t)DVA_GET_VDEV(dva), 83744cd46caSbillm (u_longlong_t)DVA_GET_OFFSET(dva), 83844cd46caSbillm (u_longlong_t)DVA_GET_ASIZE(dva)); 83944cd46caSbillm } 84044cd46caSbillm 84144cd46caSbillm (void) snprintf(buf + strlen(buf), len - strlen(buf), 84244cd46caSbillm "%s %s %s %s birth=%llu fill=%llu cksum=%llx:%llx:%llx:%llx", 843fa9e4066Sahrens zio_checksum_table[BP_GET_CHECKSUM(bp)].ci_name, 844fa9e4066Sahrens zio_compress_table[BP_GET_COMPRESS(bp)].ci_name, 845fa9e4066Sahrens BP_GET_BYTEORDER(bp) == 0 ? "BE" : "LE", 84644cd46caSbillm BP_IS_GANG(bp) ? "gang" : "contiguous", 847fa9e4066Sahrens (u_longlong_t)bp->blk_birth, 848fa9e4066Sahrens (u_longlong_t)bp->blk_fill, 849fa9e4066Sahrens (u_longlong_t)bp->blk_cksum.zc_word[0], 850fa9e4066Sahrens (u_longlong_t)bp->blk_cksum.zc_word[1], 851fa9e4066Sahrens (u_longlong_t)bp->blk_cksum.zc_word[2], 852fa9e4066Sahrens (u_longlong_t)bp->blk_cksum.zc_word[3]); 853fa9e4066Sahrens } 854fa9e4066Sahrens 855fa9e4066Sahrens void 856fa9e4066Sahrens spa_freeze(spa_t *spa) 857fa9e4066Sahrens { 858fa9e4066Sahrens uint64_t freeze_txg = 0; 859fa9e4066Sahrens 860ea8dc4b6Seschrock spa_config_enter(spa, RW_WRITER, FTAG); 861fa9e4066Sahrens if (spa->spa_freeze_txg == UINT64_MAX) { 862fa9e4066Sahrens freeze_txg = spa_last_synced_txg(spa) + TXG_SIZE; 863fa9e4066Sahrens spa->spa_freeze_txg = freeze_txg; 864fa9e4066Sahrens } 865ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 866fa9e4066Sahrens if (freeze_txg != 0) 867fa9e4066Sahrens txg_wait_synced(spa_get_dsl(spa), freeze_txg); 868fa9e4066Sahrens } 869fa9e4066Sahrens 8700125049cSahrens void 8710125049cSahrens zfs_panic_recover(const char *fmt, ...) 8720125049cSahrens { 8730125049cSahrens va_list adx; 8740125049cSahrens 8750125049cSahrens va_start(adx, fmt); 8760125049cSahrens vcmn_err(zfs_recover ? CE_WARN : CE_PANIC, fmt, adx); 8770125049cSahrens va_end(adx); 8780125049cSahrens } 8790125049cSahrens 880fa9e4066Sahrens /* 881fa9e4066Sahrens * ========================================================================== 882fa9e4066Sahrens * Accessor functions 883fa9e4066Sahrens * ========================================================================== 884fa9e4066Sahrens */ 885fa9e4066Sahrens 886fa9e4066Sahrens krwlock_t * 887fa9e4066Sahrens spa_traverse_rwlock(spa_t *spa) 888fa9e4066Sahrens { 889fa9e4066Sahrens return (&spa->spa_traverse_lock); 890fa9e4066Sahrens } 891fa9e4066Sahrens 892fa9e4066Sahrens int 893fa9e4066Sahrens spa_traverse_wanted(spa_t *spa) 894fa9e4066Sahrens { 895fa9e4066Sahrens return (spa->spa_traverse_wanted); 896fa9e4066Sahrens } 897fa9e4066Sahrens 898fa9e4066Sahrens dsl_pool_t * 899fa9e4066Sahrens spa_get_dsl(spa_t *spa) 900fa9e4066Sahrens { 901fa9e4066Sahrens return (spa->spa_dsl_pool); 902fa9e4066Sahrens } 903fa9e4066Sahrens 904fa9e4066Sahrens blkptr_t * 905fa9e4066Sahrens spa_get_rootblkptr(spa_t *spa) 906fa9e4066Sahrens { 907fa9e4066Sahrens return (&spa->spa_ubsync.ub_rootbp); 908fa9e4066Sahrens } 909fa9e4066Sahrens 910fa9e4066Sahrens void 911fa9e4066Sahrens spa_set_rootblkptr(spa_t *spa, const blkptr_t *bp) 912fa9e4066Sahrens { 913fa9e4066Sahrens spa->spa_uberblock.ub_rootbp = *bp; 914fa9e4066Sahrens } 915fa9e4066Sahrens 916fa9e4066Sahrens void 917fa9e4066Sahrens spa_altroot(spa_t *spa, char *buf, size_t buflen) 918fa9e4066Sahrens { 919fa9e4066Sahrens if (spa->spa_root == NULL) 920fa9e4066Sahrens buf[0] = '\0'; 921fa9e4066Sahrens else 922fa9e4066Sahrens (void) strncpy(buf, spa->spa_root, buflen); 923fa9e4066Sahrens } 924fa9e4066Sahrens 925fa9e4066Sahrens int 926fa9e4066Sahrens spa_sync_pass(spa_t *spa) 927fa9e4066Sahrens { 928fa9e4066Sahrens return (spa->spa_sync_pass); 929fa9e4066Sahrens } 930fa9e4066Sahrens 931fa9e4066Sahrens char * 932fa9e4066Sahrens spa_name(spa_t *spa) 933fa9e4066Sahrens { 934fa9e4066Sahrens /* 935fa9e4066Sahrens * Accessing the name requires holding either the namespace lock or the 936fa9e4066Sahrens * config lock, both of which are required to do a rename. 937fa9e4066Sahrens */ 938fa9e4066Sahrens ASSERT(MUTEX_HELD(&spa_namespace_lock) || 939fa9e4066Sahrens spa_config_held(spa, RW_READER) || spa_config_held(spa, RW_WRITER)); 940fa9e4066Sahrens 941fa9e4066Sahrens return (spa->spa_name); 942fa9e4066Sahrens } 943fa9e4066Sahrens 944fa9e4066Sahrens uint64_t 945fa9e4066Sahrens spa_guid(spa_t *spa) 946fa9e4066Sahrens { 947b5989ec7Seschrock /* 948b5989ec7Seschrock * If we fail to parse the config during spa_load(), we can go through 949b5989ec7Seschrock * the error path (which posts an ereport) and end up here with no root 950b5989ec7Seschrock * vdev. We stash the original pool guid in 'spa_load_guid' to handle 951b5989ec7Seschrock * this case. 952b5989ec7Seschrock */ 953b5989ec7Seschrock if (spa->spa_root_vdev != NULL) 954b5989ec7Seschrock return (spa->spa_root_vdev->vdev_guid); 955b5989ec7Seschrock else 956b5989ec7Seschrock return (spa->spa_load_guid); 957fa9e4066Sahrens } 958fa9e4066Sahrens 959fa9e4066Sahrens uint64_t 960fa9e4066Sahrens spa_last_synced_txg(spa_t *spa) 961fa9e4066Sahrens { 962fa9e4066Sahrens return (spa->spa_ubsync.ub_txg); 963fa9e4066Sahrens } 964fa9e4066Sahrens 965fa9e4066Sahrens uint64_t 966fa9e4066Sahrens spa_first_txg(spa_t *spa) 967fa9e4066Sahrens { 968fa9e4066Sahrens return (spa->spa_first_txg); 969fa9e4066Sahrens } 970fa9e4066Sahrens 971fa9e4066Sahrens int 972fa9e4066Sahrens spa_state(spa_t *spa) 973fa9e4066Sahrens { 974fa9e4066Sahrens return (spa->spa_state); 975fa9e4066Sahrens } 976fa9e4066Sahrens 977fa9e4066Sahrens uint64_t 978fa9e4066Sahrens spa_freeze_txg(spa_t *spa) 979fa9e4066Sahrens { 980fa9e4066Sahrens return (spa->spa_freeze_txg); 981fa9e4066Sahrens } 982fa9e4066Sahrens 983fa9e4066Sahrens /* 98499653d4eSeschrock * Return how much space is allocated in the pool (ie. sum of all asize) 985fa9e4066Sahrens */ 986fa9e4066Sahrens uint64_t 987fa9e4066Sahrens spa_get_alloc(spa_t *spa) 988fa9e4066Sahrens { 989fa9e4066Sahrens return (spa->spa_root_vdev->vdev_stat.vs_alloc); 990fa9e4066Sahrens } 991fa9e4066Sahrens 992fa9e4066Sahrens /* 99399653d4eSeschrock * Return how much (raid-z inflated) space there is in the pool. 994fa9e4066Sahrens */ 995fa9e4066Sahrens uint64_t 996fa9e4066Sahrens spa_get_space(spa_t *spa) 997fa9e4066Sahrens { 998fa9e4066Sahrens return (spa->spa_root_vdev->vdev_stat.vs_space); 999fa9e4066Sahrens } 1000fa9e4066Sahrens 100199653d4eSeschrock /* 100299653d4eSeschrock * Return the amount of raid-z-deflated space in the pool. 100399653d4eSeschrock */ 100499653d4eSeschrock uint64_t 100599653d4eSeschrock spa_get_dspace(spa_t *spa) 100699653d4eSeschrock { 100799653d4eSeschrock if (spa->spa_deflate) 100899653d4eSeschrock return (spa->spa_root_vdev->vdev_stat.vs_dspace); 100999653d4eSeschrock else 101099653d4eSeschrock return (spa->spa_root_vdev->vdev_stat.vs_space); 101199653d4eSeschrock } 101299653d4eSeschrock 1013fa9e4066Sahrens /* ARGSUSED */ 1014fa9e4066Sahrens uint64_t 1015fa9e4066Sahrens spa_get_asize(spa_t *spa, uint64_t lsize) 1016fa9e4066Sahrens { 1017fa9e4066Sahrens /* 1018fa9e4066Sahrens * For now, the worst case is 512-byte RAID-Z blocks, in which 1019fa9e4066Sahrens * case the space requirement is exactly 2x; so just assume that. 102044cd46caSbillm * Add to this the fact that we can have up to 3 DVAs per bp, and 102144cd46caSbillm * we have to multiply by a total of 6x. 102244cd46caSbillm */ 102344cd46caSbillm return (lsize * 6); 102444cd46caSbillm } 102544cd46caSbillm 102644cd46caSbillm uint64_t 102744cd46caSbillm spa_version(spa_t *spa) 102844cd46caSbillm { 102944cd46caSbillm return (spa->spa_ubsync.ub_version); 103044cd46caSbillm } 103144cd46caSbillm 103244cd46caSbillm int 103344cd46caSbillm spa_max_replication(spa_t *spa) 103444cd46caSbillm { 103544cd46caSbillm /* 1036e7437265Sahrens * As of SPA_VERSION == SPA_VERSION_DITTO_BLOCKS, we are able to 103744cd46caSbillm * handle BPs with more than one DVA allocated. Set our max 103844cd46caSbillm * replication level accordingly. 1039fa9e4066Sahrens */ 1040e7437265Sahrens if (spa_version(spa) < SPA_VERSION_DITTO_BLOCKS) 104144cd46caSbillm return (1); 104244cd46caSbillm return (MIN(SPA_DVAS_PER_BP, spa_max_replication_override)); 1043fa9e4066Sahrens } 1044fa9e4066Sahrens 104599653d4eSeschrock uint64_t 104699653d4eSeschrock bp_get_dasize(spa_t *spa, const blkptr_t *bp) 104799653d4eSeschrock { 104899653d4eSeschrock int sz = 0, i; 104999653d4eSeschrock 105099653d4eSeschrock if (!spa->spa_deflate) 105199653d4eSeschrock return (BP_GET_ASIZE(bp)); 105299653d4eSeschrock 105399653d4eSeschrock for (i = 0; i < SPA_DVAS_PER_BP; i++) { 105499653d4eSeschrock vdev_t *vd = 105599653d4eSeschrock vdev_lookup_top(spa, DVA_GET_VDEV(&bp->blk_dva[i])); 105699653d4eSeschrock sz += (DVA_GET_ASIZE(&bp->blk_dva[i]) >> SPA_MINBLOCKSHIFT) * 105799653d4eSeschrock vd->vdev_deflate_ratio; 105899653d4eSeschrock } 105999653d4eSeschrock return (sz); 106099653d4eSeschrock } 106199653d4eSeschrock 1062fa9e4066Sahrens /* 1063fa9e4066Sahrens * ========================================================================== 1064fa9e4066Sahrens * Initialization and Termination 1065fa9e4066Sahrens * ========================================================================== 1066fa9e4066Sahrens */ 1067fa9e4066Sahrens 1068fa9e4066Sahrens static int 1069fa9e4066Sahrens spa_name_compare(const void *a1, const void *a2) 1070fa9e4066Sahrens { 1071fa9e4066Sahrens const spa_t *s1 = a1; 1072fa9e4066Sahrens const spa_t *s2 = a2; 1073fa9e4066Sahrens int s; 1074fa9e4066Sahrens 1075fa9e4066Sahrens s = strcmp(s1->spa_name, s2->spa_name); 1076fa9e4066Sahrens if (s > 0) 1077fa9e4066Sahrens return (1); 1078fa9e4066Sahrens if (s < 0) 1079fa9e4066Sahrens return (-1); 1080fa9e4066Sahrens return (0); 1081fa9e4066Sahrens } 1082fa9e4066Sahrens 10830373e76bSbonwick int 10840373e76bSbonwick spa_busy(void) 10850373e76bSbonwick { 10860373e76bSbonwick return (spa_active_count); 10870373e76bSbonwick } 10880373e76bSbonwick 1089fa9e4066Sahrens void 1090fa9e4066Sahrens spa_init(int mode) 1091fa9e4066Sahrens { 1092fa9e4066Sahrens mutex_init(&spa_namespace_lock, NULL, MUTEX_DEFAULT, NULL); 1093fa9e4066Sahrens cv_init(&spa_namespace_cv, NULL, CV_DEFAULT, NULL); 1094fa9e4066Sahrens 1095fa9e4066Sahrens avl_create(&spa_namespace_avl, spa_name_compare, sizeof (spa_t), 1096fa9e4066Sahrens offsetof(spa_t, spa_avl)); 1097fa9e4066Sahrens 109899653d4eSeschrock avl_create(&spa_spare_avl, spa_spare_compare, sizeof (spa_spare_t), 109999653d4eSeschrock offsetof(spa_spare_t, spare_avl)); 110099653d4eSeschrock 1101fa9e4066Sahrens spa_mode = mode; 1102fa9e4066Sahrens 1103fa9e4066Sahrens refcount_init(); 1104fa9e4066Sahrens unique_init(); 1105fa9e4066Sahrens zio_init(); 1106fa9e4066Sahrens dmu_init(); 1107fa9e4066Sahrens zil_init(); 1108fa9e4066Sahrens spa_config_load(); 1109fa9e4066Sahrens } 1110fa9e4066Sahrens 1111fa9e4066Sahrens void 1112fa9e4066Sahrens spa_fini(void) 1113fa9e4066Sahrens { 1114fa9e4066Sahrens spa_evict_all(); 1115fa9e4066Sahrens 1116fa9e4066Sahrens zil_fini(); 1117fa9e4066Sahrens dmu_fini(); 1118fa9e4066Sahrens zio_fini(); 1119fa9e4066Sahrens refcount_fini(); 1120fa9e4066Sahrens 1121fa9e4066Sahrens avl_destroy(&spa_namespace_avl); 112299653d4eSeschrock avl_destroy(&spa_spare_avl); 1123fa9e4066Sahrens 1124fa9e4066Sahrens cv_destroy(&spa_namespace_cv); 1125fa9e4066Sahrens mutex_destroy(&spa_namespace_lock); 1126fa9e4066Sahrens } 1127*6ce0521aSperrin 1128*6ce0521aSperrin /* 1129*6ce0521aSperrin * Return whether this pool has slogs. No locking needed. 1130*6ce0521aSperrin * It's not a problem if the wrong answer is returned as it's only for 1131*6ce0521aSperrin * performance and not correctness 1132*6ce0521aSperrin */ 1133*6ce0521aSperrin boolean_t 1134*6ce0521aSperrin spa_has_slogs(spa_t *spa) 1135*6ce0521aSperrin { 1136*6ce0521aSperrin return (spa->spa_log_class->mc_rotor != NULL); 1137*6ce0521aSperrin } 1138