1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5*ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6*ea8dc4b6Seschrock * 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 /* 22c67d9675Seschrock * Copyright 2006 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 /* 29fa9e4066Sahrens * This file contains all the routines used when modifying on-disk SPA state. 30fa9e4066Sahrens * This includes opening, importing, destroying, exporting a pool, and syncing a 31fa9e4066Sahrens * pool. 32fa9e4066Sahrens */ 33fa9e4066Sahrens 34fa9e4066Sahrens #include <sys/zfs_context.h> 35*ea8dc4b6Seschrock #include <sys/fm/fs/zfs.h> 36fa9e4066Sahrens #include <sys/spa_impl.h> 37fa9e4066Sahrens #include <sys/zio.h> 38fa9e4066Sahrens #include <sys/zio_checksum.h> 39fa9e4066Sahrens #include <sys/zio_compress.h> 40fa9e4066Sahrens #include <sys/dmu.h> 41fa9e4066Sahrens #include <sys/dmu_tx.h> 42fa9e4066Sahrens #include <sys/zap.h> 43fa9e4066Sahrens #include <sys/zil.h> 44fa9e4066Sahrens #include <sys/vdev_impl.h> 45fa9e4066Sahrens #include <sys/metaslab.h> 46fa9e4066Sahrens #include <sys/uberblock_impl.h> 47fa9e4066Sahrens #include <sys/txg.h> 48fa9e4066Sahrens #include <sys/avl.h> 49fa9e4066Sahrens #include <sys/dmu_traverse.h> 50fa9e4066Sahrens #include <sys/unique.h> 51fa9e4066Sahrens #include <sys/dsl_pool.h> 52fa9e4066Sahrens #include <sys/dsl_dir.h> 53fa9e4066Sahrens #include <sys/dsl_prop.h> 54fa9e4066Sahrens #include <sys/fs/zfs.h> 55fa9e4066Sahrens #include <sys/callb.h> 56fa9e4066Sahrens 57fa9e4066Sahrens static uint32_t spa_active_count; 58fa9e4066Sahrens 59fa9e4066Sahrens /* 60fa9e4066Sahrens * ========================================================================== 61fa9e4066Sahrens * SPA state manipulation (open/create/destroy/import/export) 62fa9e4066Sahrens * ========================================================================== 63fa9e4066Sahrens */ 64fa9e4066Sahrens 65*ea8dc4b6Seschrock static int 66*ea8dc4b6Seschrock spa_error_entry_compare(const void *a, const void *b) 67*ea8dc4b6Seschrock { 68*ea8dc4b6Seschrock spa_error_entry_t *sa = (spa_error_entry_t *)a; 69*ea8dc4b6Seschrock spa_error_entry_t *sb = (spa_error_entry_t *)b; 70*ea8dc4b6Seschrock int ret; 71*ea8dc4b6Seschrock 72*ea8dc4b6Seschrock ret = bcmp(&sa->se_bookmark, &sb->se_bookmark, 73*ea8dc4b6Seschrock sizeof (zbookmark_t)); 74*ea8dc4b6Seschrock 75*ea8dc4b6Seschrock if (ret < 0) 76*ea8dc4b6Seschrock return (-1); 77*ea8dc4b6Seschrock else if (ret > 0) 78*ea8dc4b6Seschrock return (1); 79*ea8dc4b6Seschrock else 80*ea8dc4b6Seschrock return (0); 81*ea8dc4b6Seschrock } 82*ea8dc4b6Seschrock 83*ea8dc4b6Seschrock /* 84*ea8dc4b6Seschrock * Utility function which retrieves copies of the current logs and 85*ea8dc4b6Seschrock * re-initializes them in the process. 86*ea8dc4b6Seschrock */ 87*ea8dc4b6Seschrock void 88*ea8dc4b6Seschrock spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub) 89*ea8dc4b6Seschrock { 90*ea8dc4b6Seschrock ASSERT(MUTEX_HELD(&spa->spa_errlist_lock)); 91*ea8dc4b6Seschrock 92*ea8dc4b6Seschrock bcopy(&spa->spa_errlist_last, last, sizeof (avl_tree_t)); 93*ea8dc4b6Seschrock bcopy(&spa->spa_errlist_scrub, scrub, sizeof (avl_tree_t)); 94*ea8dc4b6Seschrock 95*ea8dc4b6Seschrock avl_create(&spa->spa_errlist_scrub, 96*ea8dc4b6Seschrock spa_error_entry_compare, sizeof (spa_error_entry_t), 97*ea8dc4b6Seschrock offsetof(spa_error_entry_t, se_avl)); 98*ea8dc4b6Seschrock avl_create(&spa->spa_errlist_last, 99*ea8dc4b6Seschrock spa_error_entry_compare, sizeof (spa_error_entry_t), 100*ea8dc4b6Seschrock offsetof(spa_error_entry_t, se_avl)); 101*ea8dc4b6Seschrock } 102*ea8dc4b6Seschrock 103fa9e4066Sahrens /* 104fa9e4066Sahrens * Activate an uninitialized pool. 105fa9e4066Sahrens */ 106fa9e4066Sahrens static void 107fa9e4066Sahrens spa_activate(spa_t *spa) 108fa9e4066Sahrens { 109fa9e4066Sahrens int t; 110fa9e4066Sahrens 111fa9e4066Sahrens ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED); 112fa9e4066Sahrens 113fa9e4066Sahrens spa->spa_state = POOL_STATE_ACTIVE; 114fa9e4066Sahrens 115fa9e4066Sahrens spa->spa_normal_class = metaslab_class_create(); 116fa9e4066Sahrens 117fa9e4066Sahrens for (t = 0; t < ZIO_TYPES; t++) { 118fa9e4066Sahrens spa->spa_zio_issue_taskq[t] = taskq_create("spa_zio_issue", 119fa9e4066Sahrens 8, maxclsyspri, 50, INT_MAX, 120fa9e4066Sahrens TASKQ_PREPOPULATE); 121fa9e4066Sahrens spa->spa_zio_intr_taskq[t] = taskq_create("spa_zio_intr", 122fa9e4066Sahrens 8, maxclsyspri, 50, INT_MAX, 123fa9e4066Sahrens TASKQ_PREPOPULATE); 124fa9e4066Sahrens } 125fa9e4066Sahrens 126fa9e4066Sahrens rw_init(&spa->spa_traverse_lock, NULL, RW_DEFAULT, NULL); 127fa9e4066Sahrens 128fa9e4066Sahrens list_create(&spa->spa_dirty_list, sizeof (vdev_t), 129fa9e4066Sahrens offsetof(vdev_t, vdev_dirty_node)); 130fa9e4066Sahrens 131fa9e4066Sahrens txg_list_create(&spa->spa_vdev_txg_list, 132fa9e4066Sahrens offsetof(struct vdev, vdev_txg_node)); 133*ea8dc4b6Seschrock 134*ea8dc4b6Seschrock avl_create(&spa->spa_errlist_scrub, 135*ea8dc4b6Seschrock spa_error_entry_compare, sizeof (spa_error_entry_t), 136*ea8dc4b6Seschrock offsetof(spa_error_entry_t, se_avl)); 137*ea8dc4b6Seschrock avl_create(&spa->spa_errlist_last, 138*ea8dc4b6Seschrock spa_error_entry_compare, sizeof (spa_error_entry_t), 139*ea8dc4b6Seschrock offsetof(spa_error_entry_t, se_avl)); 140fa9e4066Sahrens } 141fa9e4066Sahrens 142fa9e4066Sahrens /* 143fa9e4066Sahrens * Opposite of spa_activate(). 144fa9e4066Sahrens */ 145fa9e4066Sahrens static void 146fa9e4066Sahrens spa_deactivate(spa_t *spa) 147fa9e4066Sahrens { 148fa9e4066Sahrens int t; 149fa9e4066Sahrens 150fa9e4066Sahrens ASSERT(spa->spa_sync_on == B_FALSE); 151fa9e4066Sahrens ASSERT(spa->spa_dsl_pool == NULL); 152fa9e4066Sahrens ASSERT(spa->spa_root_vdev == NULL); 153fa9e4066Sahrens 154fa9e4066Sahrens ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED); 155fa9e4066Sahrens 156fa9e4066Sahrens txg_list_destroy(&spa->spa_vdev_txg_list); 157fa9e4066Sahrens 158fa9e4066Sahrens list_destroy(&spa->spa_dirty_list); 159fa9e4066Sahrens 160fa9e4066Sahrens rw_destroy(&spa->spa_traverse_lock); 161fa9e4066Sahrens 162fa9e4066Sahrens for (t = 0; t < ZIO_TYPES; t++) { 163fa9e4066Sahrens taskq_destroy(spa->spa_zio_issue_taskq[t]); 164fa9e4066Sahrens taskq_destroy(spa->spa_zio_intr_taskq[t]); 165fa9e4066Sahrens spa->spa_zio_issue_taskq[t] = NULL; 166fa9e4066Sahrens spa->spa_zio_intr_taskq[t] = NULL; 167fa9e4066Sahrens } 168fa9e4066Sahrens 169fa9e4066Sahrens metaslab_class_destroy(spa->spa_normal_class); 170fa9e4066Sahrens spa->spa_normal_class = NULL; 171fa9e4066Sahrens 172*ea8dc4b6Seschrock /* 173*ea8dc4b6Seschrock * If this was part of an import or the open otherwise failed, we may 174*ea8dc4b6Seschrock * still have errors left in the queues. Empty them just in case. 175*ea8dc4b6Seschrock */ 176*ea8dc4b6Seschrock spa_errlog_drain(spa); 177*ea8dc4b6Seschrock 178*ea8dc4b6Seschrock avl_destroy(&spa->spa_errlist_scrub); 179*ea8dc4b6Seschrock avl_destroy(&spa->spa_errlist_last); 180*ea8dc4b6Seschrock 181fa9e4066Sahrens spa->spa_state = POOL_STATE_UNINITIALIZED; 182fa9e4066Sahrens } 183fa9e4066Sahrens 184fa9e4066Sahrens /* 185fa9e4066Sahrens * Verify a pool configuration, and construct the vdev tree appropriately. This 186fa9e4066Sahrens * will create all the necessary vdevs in the appropriate layout, with each vdev 187fa9e4066Sahrens * in the CLOSED state. This will prep the pool before open/creation/import. 188fa9e4066Sahrens * All vdev validation is done by the vdev_alloc() routine. 189fa9e4066Sahrens */ 190fa9e4066Sahrens static vdev_t * 191fa9e4066Sahrens spa_config_parse(spa_t *spa, nvlist_t *nv, vdev_t *parent, uint_t id, int atype) 192fa9e4066Sahrens { 193fa9e4066Sahrens nvlist_t **child; 194fa9e4066Sahrens uint_t c, children; 195fa9e4066Sahrens vdev_t *vd; 196fa9e4066Sahrens 197fa9e4066Sahrens if ((vd = vdev_alloc(spa, nv, parent, id, atype)) == NULL) 198fa9e4066Sahrens return (NULL); 199fa9e4066Sahrens 200fa9e4066Sahrens if (vd->vdev_ops->vdev_op_leaf) 201fa9e4066Sahrens return (vd); 202fa9e4066Sahrens 203fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 204fa9e4066Sahrens &child, &children) != 0) { 205fa9e4066Sahrens vdev_free(vd); 206fa9e4066Sahrens return (NULL); 207fa9e4066Sahrens } 208fa9e4066Sahrens 209fa9e4066Sahrens for (c = 0; c < children; c++) { 210fa9e4066Sahrens if (spa_config_parse(spa, child[c], vd, c, atype) == NULL) { 211fa9e4066Sahrens vdev_free(vd); 212fa9e4066Sahrens return (NULL); 213fa9e4066Sahrens } 214fa9e4066Sahrens } 215fa9e4066Sahrens 216fa9e4066Sahrens return (vd); 217fa9e4066Sahrens } 218fa9e4066Sahrens 219fa9e4066Sahrens /* 220fa9e4066Sahrens * Opposite of spa_load(). 221fa9e4066Sahrens */ 222fa9e4066Sahrens static void 223fa9e4066Sahrens spa_unload(spa_t *spa) 224fa9e4066Sahrens { 225*ea8dc4b6Seschrock /* 226*ea8dc4b6Seschrock * Stop async tasks. 227*ea8dc4b6Seschrock */ 228*ea8dc4b6Seschrock spa_async_suspend(spa); 229*ea8dc4b6Seschrock 230fa9e4066Sahrens /* 231fa9e4066Sahrens * Stop syncing. 232fa9e4066Sahrens */ 233fa9e4066Sahrens if (spa->spa_sync_on) { 234fa9e4066Sahrens txg_sync_stop(spa->spa_dsl_pool); 235fa9e4066Sahrens spa->spa_sync_on = B_FALSE; 236fa9e4066Sahrens } 237fa9e4066Sahrens 238fa9e4066Sahrens /* 239fa9e4066Sahrens * Wait for any outstanding prefetch I/O to complete. 240fa9e4066Sahrens */ 241*ea8dc4b6Seschrock spa_config_enter(spa, RW_WRITER, FTAG); 242*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 243fa9e4066Sahrens 244fa9e4066Sahrens /* 245fa9e4066Sahrens * Close the dsl pool. 246fa9e4066Sahrens */ 247fa9e4066Sahrens if (spa->spa_dsl_pool) { 248fa9e4066Sahrens dsl_pool_close(spa->spa_dsl_pool); 249fa9e4066Sahrens spa->spa_dsl_pool = NULL; 250fa9e4066Sahrens } 251fa9e4066Sahrens 252fa9e4066Sahrens /* 253fa9e4066Sahrens * Close all vdevs. 254fa9e4066Sahrens */ 255fa9e4066Sahrens if (spa->spa_root_vdev) { 256fa9e4066Sahrens vdev_free(spa->spa_root_vdev); 257fa9e4066Sahrens spa->spa_root_vdev = NULL; 258fa9e4066Sahrens } 259*ea8dc4b6Seschrock 260*ea8dc4b6Seschrock spa->spa_async_suspended = 0; 261fa9e4066Sahrens } 262fa9e4066Sahrens 263fa9e4066Sahrens /* 264fa9e4066Sahrens * Load an existing storage pool, using the pool's builtin spa_config as a 265*ea8dc4b6Seschrock * source of configuration information. 266fa9e4066Sahrens */ 267fa9e4066Sahrens static int 268*ea8dc4b6Seschrock spa_load(spa_t *spa, nvlist_t *config, spa_load_state_t state, int mosconfig) 269fa9e4066Sahrens { 270fa9e4066Sahrens int error = 0; 271fa9e4066Sahrens nvlist_t *nvroot = NULL; 272fa9e4066Sahrens vdev_t *rvd; 273fa9e4066Sahrens uberblock_t *ub = &spa->spa_uberblock; 274fa9e4066Sahrens uint64_t pool_guid; 275fa9e4066Sahrens zio_t *zio; 276fa9e4066Sahrens 277*ea8dc4b6Seschrock spa->spa_load_state = state; 278fa9e4066Sahrens if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvroot) || 279*ea8dc4b6Seschrock nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid)) { 280*ea8dc4b6Seschrock error = EINVAL; 281*ea8dc4b6Seschrock goto out; 282*ea8dc4b6Seschrock } 283fa9e4066Sahrens 284fa9e4066Sahrens (void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, 285fa9e4066Sahrens &spa->spa_config_txg); 286fa9e4066Sahrens 287*ea8dc4b6Seschrock if ((spa->spa_load_state == SPA_LOAD_IMPORT || 288*ea8dc4b6Seschrock spa->spa_load_state == SPA_LOAD_TRYIMPORT) && 289*ea8dc4b6Seschrock spa_guid_exists(pool_guid, 0)) { 290*ea8dc4b6Seschrock error = EEXIST; 291*ea8dc4b6Seschrock goto out; 292*ea8dc4b6Seschrock } 293fa9e4066Sahrens 294fa9e4066Sahrens /* 295fa9e4066Sahrens * Parse the configuration into a vdev tree. 296fa9e4066Sahrens */ 297*ea8dc4b6Seschrock spa_config_enter(spa, RW_WRITER, FTAG); 298fa9e4066Sahrens rvd = spa_config_parse(spa, nvroot, NULL, 0, VDEV_ALLOC_LOAD); 299*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 300fa9e4066Sahrens 301*ea8dc4b6Seschrock if (rvd == NULL) { 302*ea8dc4b6Seschrock error = EINVAL; 303*ea8dc4b6Seschrock goto out; 304*ea8dc4b6Seschrock } 305fa9e4066Sahrens 306fa9e4066Sahrens spa->spa_root_vdev = rvd; 307fa9e4066Sahrens ASSERT(spa_guid(spa) == pool_guid); 308fa9e4066Sahrens 309fa9e4066Sahrens /* 310fa9e4066Sahrens * Try to open all vdevs, loading each label in the process. 311fa9e4066Sahrens */ 312*ea8dc4b6Seschrock if (vdev_open(rvd) != 0) { 313*ea8dc4b6Seschrock error = ENXIO; 314*ea8dc4b6Seschrock goto out; 315*ea8dc4b6Seschrock } 316fa9e4066Sahrens 317fa9e4066Sahrens /* 318fa9e4066Sahrens * Find the best uberblock. 319fa9e4066Sahrens */ 320fa9e4066Sahrens bzero(ub, sizeof (uberblock_t)); 321fa9e4066Sahrens 322fa9e4066Sahrens zio = zio_root(spa, NULL, NULL, 323fa9e4066Sahrens ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE); 324fa9e4066Sahrens vdev_uberblock_load(zio, rvd, ub); 325fa9e4066Sahrens error = zio_wait(zio); 326fa9e4066Sahrens 327fa9e4066Sahrens /* 328fa9e4066Sahrens * If we weren't able to find a single valid uberblock, return failure. 329fa9e4066Sahrens */ 330fa9e4066Sahrens if (ub->ub_txg == 0) { 331*ea8dc4b6Seschrock error = ENXIO; 332*ea8dc4b6Seschrock goto out; 333*ea8dc4b6Seschrock } 334*ea8dc4b6Seschrock 335*ea8dc4b6Seschrock /* 336*ea8dc4b6Seschrock * If the pool is newer than the code, we can't open it. 337*ea8dc4b6Seschrock */ 338*ea8dc4b6Seschrock if (ub->ub_version > UBERBLOCK_VERSION) { 339*ea8dc4b6Seschrock error = ENOTSUP; 340*ea8dc4b6Seschrock goto out; 341fa9e4066Sahrens } 342fa9e4066Sahrens 343fa9e4066Sahrens /* 344fa9e4066Sahrens * If the vdev guid sum doesn't match the uberblock, we have an 345fa9e4066Sahrens * incomplete configuration. 346fa9e4066Sahrens */ 347fa9e4066Sahrens if (rvd->vdev_guid_sum != ub->ub_guid_sum && mosconfig) { 348*ea8dc4b6Seschrock vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, 349*ea8dc4b6Seschrock VDEV_AUX_BAD_GUID_SUM); 350*ea8dc4b6Seschrock error = ENXIO; 351*ea8dc4b6Seschrock goto out; 352fa9e4066Sahrens } 353fa9e4066Sahrens 354fa9e4066Sahrens /* 355fa9e4066Sahrens * Initialize internal SPA structures. 356fa9e4066Sahrens */ 357fa9e4066Sahrens spa->spa_state = POOL_STATE_ACTIVE; 358fa9e4066Sahrens spa->spa_ubsync = spa->spa_uberblock; 359fa9e4066Sahrens spa->spa_first_txg = spa_last_synced_txg(spa) + 1; 360*ea8dc4b6Seschrock error = dsl_pool_open(spa, spa->spa_first_txg, &spa->spa_dsl_pool); 361*ea8dc4b6Seschrock if (error) { 362*ea8dc4b6Seschrock vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, 363*ea8dc4b6Seschrock VDEV_AUX_CORRUPT_DATA); 364*ea8dc4b6Seschrock goto out; 365*ea8dc4b6Seschrock } 366fa9e4066Sahrens spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset; 367fa9e4066Sahrens 368*ea8dc4b6Seschrock if (zap_lookup(spa->spa_meta_objset, 369fa9e4066Sahrens DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG, 370*ea8dc4b6Seschrock sizeof (uint64_t), 1, &spa->spa_config_object) != 0) { 371*ea8dc4b6Seschrock vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, 372*ea8dc4b6Seschrock VDEV_AUX_CORRUPT_DATA); 373*ea8dc4b6Seschrock error = EIO; 374*ea8dc4b6Seschrock goto out; 375*ea8dc4b6Seschrock } 376fa9e4066Sahrens 377fa9e4066Sahrens if (!mosconfig) { 378fa9e4066Sahrens dmu_buf_t *db; 379fa9e4066Sahrens char *packed = NULL; 380fa9e4066Sahrens size_t nvsize = 0; 381fa9e4066Sahrens nvlist_t *newconfig = NULL; 382fa9e4066Sahrens 383*ea8dc4b6Seschrock VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, 384*ea8dc4b6Seschrock spa->spa_config_object, FTAG, &db)); 385fa9e4066Sahrens nvsize = *(uint64_t *)db->db_data; 386*ea8dc4b6Seschrock dmu_buf_rele(db, FTAG); 387fa9e4066Sahrens 388fa9e4066Sahrens packed = kmem_alloc(nvsize, KM_SLEEP); 389*ea8dc4b6Seschrock error = dmu_read(spa->spa_meta_objset, 390fa9e4066Sahrens spa->spa_config_object, 0, nvsize, packed); 391fa9e4066Sahrens if (error == 0) 392fa9e4066Sahrens error = nvlist_unpack(packed, nvsize, &newconfig, 0); 393fa9e4066Sahrens kmem_free(packed, nvsize); 394fa9e4066Sahrens 395*ea8dc4b6Seschrock if (error) { 396*ea8dc4b6Seschrock vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, 397*ea8dc4b6Seschrock VDEV_AUX_CORRUPT_DATA); 398*ea8dc4b6Seschrock error = EIO; 399*ea8dc4b6Seschrock goto out; 400*ea8dc4b6Seschrock } 401fa9e4066Sahrens 402fa9e4066Sahrens spa_config_set(spa, newconfig); 403fa9e4066Sahrens 404fa9e4066Sahrens spa_unload(spa); 405fa9e4066Sahrens spa_deactivate(spa); 406fa9e4066Sahrens spa_activate(spa); 407fa9e4066Sahrens 408*ea8dc4b6Seschrock return (spa_load(spa, newconfig, state, B_TRUE)); 409fa9e4066Sahrens } 410fa9e4066Sahrens 411*ea8dc4b6Seschrock if (zap_lookup(spa->spa_meta_objset, 412fa9e4066Sahrens DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST, 413*ea8dc4b6Seschrock sizeof (uint64_t), 1, &spa->spa_sync_bplist_obj) != 0) { 414*ea8dc4b6Seschrock vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, 415*ea8dc4b6Seschrock VDEV_AUX_CORRUPT_DATA); 416*ea8dc4b6Seschrock error = EIO; 417*ea8dc4b6Seschrock goto out; 418*ea8dc4b6Seschrock } 419fa9e4066Sahrens 420fa9e4066Sahrens /* 421*ea8dc4b6Seschrock * Load the persistent error log. If we have an older pool, this will 422*ea8dc4b6Seschrock * not be present. 423fa9e4066Sahrens */ 424*ea8dc4b6Seschrock error = zap_lookup(spa->spa_meta_objset, 425*ea8dc4b6Seschrock DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ERRLOG_LAST, 426*ea8dc4b6Seschrock sizeof (uint64_t), 1, &spa->spa_errlog_last); 427*ea8dc4b6Seschrock if (error != 0 &&error != ENOENT) { 428*ea8dc4b6Seschrock vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, 429*ea8dc4b6Seschrock VDEV_AUX_CORRUPT_DATA); 430*ea8dc4b6Seschrock error = EIO; 431*ea8dc4b6Seschrock goto out; 432*ea8dc4b6Seschrock } 433*ea8dc4b6Seschrock 434*ea8dc4b6Seschrock error = zap_lookup(spa->spa_meta_objset, 435*ea8dc4b6Seschrock DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ERRLOG_SCRUB, 436*ea8dc4b6Seschrock sizeof (uint64_t), 1, &spa->spa_errlog_scrub); 437*ea8dc4b6Seschrock if (error != 0 && error != ENOENT) { 438*ea8dc4b6Seschrock vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, 439*ea8dc4b6Seschrock VDEV_AUX_CORRUPT_DATA); 440*ea8dc4b6Seschrock error = EIO; 441*ea8dc4b6Seschrock goto out; 442*ea8dc4b6Seschrock } 443*ea8dc4b6Seschrock 444*ea8dc4b6Seschrock /* 445*ea8dc4b6Seschrock * Load the vdev state for all top level vdevs. We need to grab the 446*ea8dc4b6Seschrock * config lock because all label I/O is done with the 447*ea8dc4b6Seschrock * ZIO_FLAG_CONFIG_HELD flag. 448*ea8dc4b6Seschrock */ 449*ea8dc4b6Seschrock spa_config_enter(spa, RW_READER, FTAG); 450*ea8dc4b6Seschrock if ((error = vdev_load(rvd)) != 0) { 451*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 452*ea8dc4b6Seschrock goto out; 453*ea8dc4b6Seschrock } 454*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 455fa9e4066Sahrens 456fa9e4066Sahrens /* 457fa9e4066Sahrens * Propagate the leaf DTLs we just loaded all the way up the tree. 458fa9e4066Sahrens */ 459*ea8dc4b6Seschrock spa_config_enter(spa, RW_WRITER, FTAG); 460fa9e4066Sahrens vdev_dtl_reassess(rvd, 0, 0, B_FALSE); 461*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 462fa9e4066Sahrens 463fa9e4066Sahrens /* 464fa9e4066Sahrens * Check the state of the root vdev. If it can't be opened, it 465fa9e4066Sahrens * indicates one or more toplevel vdevs are faulted. 466fa9e4066Sahrens */ 467*ea8dc4b6Seschrock if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) { 468*ea8dc4b6Seschrock error = ENXIO; 469*ea8dc4b6Seschrock goto out; 470*ea8dc4b6Seschrock } 471fa9e4066Sahrens 472fa9e4066Sahrens /* 473fa9e4066Sahrens * Claim log blocks that haven't been committed yet, and update all 474fa9e4066Sahrens * top-level vdevs to sync any config changes found in vdev_load(). 475fa9e4066Sahrens * This must all happen in a single txg. 476fa9e4066Sahrens */ 477*ea8dc4b6Seschrock if ((spa_mode & FWRITE) && state != SPA_LOAD_TRYIMPORT) { 478fa9e4066Sahrens dmu_tx_t *tx = dmu_tx_create_assigned(spa_get_dsl(spa), 479fa9e4066Sahrens spa_first_txg(spa)); 480fa9e4066Sahrens dmu_objset_find(spa->spa_name, zil_claim, tx, 0); 481fa9e4066Sahrens vdev_config_dirty(rvd); 482fa9e4066Sahrens dmu_tx_commit(tx); 483fa9e4066Sahrens 484fa9e4066Sahrens spa->spa_sync_on = B_TRUE; 485fa9e4066Sahrens txg_sync_start(spa->spa_dsl_pool); 486fa9e4066Sahrens 487fa9e4066Sahrens /* 488fa9e4066Sahrens * Wait for all claims to sync. 489fa9e4066Sahrens */ 490fa9e4066Sahrens txg_wait_synced(spa->spa_dsl_pool, 0); 491fa9e4066Sahrens } 492fa9e4066Sahrens 493*ea8dc4b6Seschrock error = 0; 494*ea8dc4b6Seschrock out: 495*ea8dc4b6Seschrock if (error) 496*ea8dc4b6Seschrock zfs_ereport_post(FM_EREPORT_ZFS_POOL, spa, NULL, NULL, 0, 0); 497*ea8dc4b6Seschrock spa->spa_load_state = SPA_LOAD_NONE; 498*ea8dc4b6Seschrock spa->spa_ena = 0; 499*ea8dc4b6Seschrock 500*ea8dc4b6Seschrock return (error); 501fa9e4066Sahrens } 502fa9e4066Sahrens 503fa9e4066Sahrens /* 504fa9e4066Sahrens * Pool Open/Import 505fa9e4066Sahrens * 506fa9e4066Sahrens * The import case is identical to an open except that the configuration is sent 507fa9e4066Sahrens * down from userland, instead of grabbed from the configuration cache. For the 508fa9e4066Sahrens * case of an open, the pool configuration will exist in the 509fa9e4066Sahrens * POOL_STATE_UNITIALIZED state. 510fa9e4066Sahrens * 511fa9e4066Sahrens * The stats information (gen/count/ustats) is used to gather vdev statistics at 512fa9e4066Sahrens * the same time open the pool, without having to keep around the spa_t in some 513fa9e4066Sahrens * ambiguous state. 514fa9e4066Sahrens */ 515fa9e4066Sahrens static int 516fa9e4066Sahrens spa_open_common(const char *pool, spa_t **spapp, void *tag, nvlist_t **config) 517fa9e4066Sahrens { 518fa9e4066Sahrens spa_t *spa; 519fa9e4066Sahrens int error; 520fa9e4066Sahrens int loaded = B_FALSE; 521fa9e4066Sahrens int locked = B_FALSE; 522fa9e4066Sahrens 523fa9e4066Sahrens *spapp = NULL; 524fa9e4066Sahrens 525fa9e4066Sahrens /* 526fa9e4066Sahrens * As disgusting as this is, we need to support recursive calls to this 527fa9e4066Sahrens * function because dsl_dir_open() is called during spa_load(), and ends 528fa9e4066Sahrens * up calling spa_open() again. The real fix is to figure out how to 529fa9e4066Sahrens * avoid dsl_dir_open() calling this in the first place. 530fa9e4066Sahrens */ 531fa9e4066Sahrens if (mutex_owner(&spa_namespace_lock) != curthread) { 532fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 533fa9e4066Sahrens locked = B_TRUE; 534fa9e4066Sahrens } 535fa9e4066Sahrens 536fa9e4066Sahrens if ((spa = spa_lookup(pool)) == NULL) { 537fa9e4066Sahrens if (locked) 538fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 539fa9e4066Sahrens return (ENOENT); 540fa9e4066Sahrens } 541fa9e4066Sahrens if (spa->spa_state == POOL_STATE_UNINITIALIZED) { 542fa9e4066Sahrens 543fa9e4066Sahrens spa_activate(spa); 544fa9e4066Sahrens 545fa9e4066Sahrens error = spa_load(spa, spa->spa_config, 546*ea8dc4b6Seschrock SPA_LOAD_OPEN, B_FALSE); 547fa9e4066Sahrens 548fa9e4066Sahrens if (error == EBADF) { 549fa9e4066Sahrens /* 550fa9e4066Sahrens * If vdev_load() returns EBADF, it indicates that one 551fa9e4066Sahrens * of the vdevs indicates that the pool has been 552fa9e4066Sahrens * exported or destroyed. If this is the case, the 553fa9e4066Sahrens * config cache is out of sync and we should remove the 554fa9e4066Sahrens * pool from the namespace. 555fa9e4066Sahrens */ 556fa9e4066Sahrens spa_unload(spa); 557fa9e4066Sahrens spa_deactivate(spa); 558fa9e4066Sahrens spa_remove(spa); 559fa9e4066Sahrens spa_config_sync(); 560fa9e4066Sahrens if (locked) 561fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 562fa9e4066Sahrens return (ENOENT); 563*ea8dc4b6Seschrock } 564*ea8dc4b6Seschrock 565*ea8dc4b6Seschrock if (error) { 566fa9e4066Sahrens /* 567fa9e4066Sahrens * We can't open the pool, but we still have useful 568fa9e4066Sahrens * information: the state of each vdev after the 569fa9e4066Sahrens * attempted vdev_open(). Return this to the user. 570fa9e4066Sahrens */ 571fa9e4066Sahrens if (config != NULL && spa->spa_root_vdev != NULL) 572fa9e4066Sahrens *config = spa_config_generate(spa, NULL, -1ULL, 573fa9e4066Sahrens B_TRUE); 574fa9e4066Sahrens spa_unload(spa); 575fa9e4066Sahrens spa_deactivate(spa); 576*ea8dc4b6Seschrock spa->spa_last_open_failed = B_TRUE; 577fa9e4066Sahrens if (locked) 578fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 579fa9e4066Sahrens *spapp = NULL; 580fa9e4066Sahrens return (error); 581*ea8dc4b6Seschrock } else { 582*ea8dc4b6Seschrock zfs_post_ok(spa, NULL); 583*ea8dc4b6Seschrock spa->spa_last_open_failed = B_FALSE; 584fa9e4066Sahrens } 585fa9e4066Sahrens 586fa9e4066Sahrens loaded = B_TRUE; 587fa9e4066Sahrens } 588fa9e4066Sahrens 589fa9e4066Sahrens spa_open_ref(spa, tag); 590fa9e4066Sahrens if (locked) 591fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 592fa9e4066Sahrens 593fa9e4066Sahrens *spapp = spa; 594fa9e4066Sahrens 595fa9e4066Sahrens if (config != NULL) { 596*ea8dc4b6Seschrock spa_config_enter(spa, RW_READER, FTAG); 597fa9e4066Sahrens *config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 598*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 599fa9e4066Sahrens } 600fa9e4066Sahrens 601fa9e4066Sahrens /* 602fa9e4066Sahrens * If we just loaded the pool, resilver anything that's out of date. 603fa9e4066Sahrens */ 604fa9e4066Sahrens if (loaded && (spa_mode & FWRITE)) 605fa9e4066Sahrens VERIFY(spa_scrub(spa, POOL_SCRUB_RESILVER, B_TRUE) == 0); 606fa9e4066Sahrens 607fa9e4066Sahrens return (0); 608fa9e4066Sahrens } 609fa9e4066Sahrens 610fa9e4066Sahrens int 611fa9e4066Sahrens spa_open(const char *name, spa_t **spapp, void *tag) 612fa9e4066Sahrens { 613fa9e4066Sahrens return (spa_open_common(name, spapp, tag, NULL)); 614fa9e4066Sahrens } 615fa9e4066Sahrens 616*ea8dc4b6Seschrock /* 617*ea8dc4b6Seschrock * Lookup the given spa_t, incrementing the inject count in the process, 618*ea8dc4b6Seschrock * preventing it from being exported or destroyed. 619*ea8dc4b6Seschrock */ 620*ea8dc4b6Seschrock spa_t * 621*ea8dc4b6Seschrock spa_inject_addref(char *name) 622*ea8dc4b6Seschrock { 623*ea8dc4b6Seschrock spa_t *spa; 624*ea8dc4b6Seschrock 625*ea8dc4b6Seschrock mutex_enter(&spa_namespace_lock); 626*ea8dc4b6Seschrock if ((spa = spa_lookup(name)) == NULL) { 627*ea8dc4b6Seschrock mutex_exit(&spa_namespace_lock); 628*ea8dc4b6Seschrock return (NULL); 629*ea8dc4b6Seschrock } 630*ea8dc4b6Seschrock spa->spa_inject_ref++; 631*ea8dc4b6Seschrock mutex_exit(&spa_namespace_lock); 632*ea8dc4b6Seschrock 633*ea8dc4b6Seschrock return (spa); 634*ea8dc4b6Seschrock } 635*ea8dc4b6Seschrock 636*ea8dc4b6Seschrock void 637*ea8dc4b6Seschrock spa_inject_delref(spa_t *spa) 638*ea8dc4b6Seschrock { 639*ea8dc4b6Seschrock mutex_enter(&spa_namespace_lock); 640*ea8dc4b6Seschrock spa->spa_inject_ref--; 641*ea8dc4b6Seschrock mutex_exit(&spa_namespace_lock); 642*ea8dc4b6Seschrock } 643*ea8dc4b6Seschrock 644fa9e4066Sahrens int 645*ea8dc4b6Seschrock spa_get_stats(const char *name, nvlist_t **config, char *altroot, size_t buflen) 646fa9e4066Sahrens { 647fa9e4066Sahrens int error; 648fa9e4066Sahrens spa_t *spa; 649fa9e4066Sahrens 650fa9e4066Sahrens *config = NULL; 651fa9e4066Sahrens error = spa_open_common(name, &spa, FTAG, config); 652fa9e4066Sahrens 653*ea8dc4b6Seschrock if (spa && *config != NULL) 654*ea8dc4b6Seschrock VERIFY(nvlist_add_uint64(*config, ZPOOL_CONFIG_ERRCOUNT, 655*ea8dc4b6Seschrock spa_get_errlog_size(spa)) == 0); 656*ea8dc4b6Seschrock 657*ea8dc4b6Seschrock /* 658*ea8dc4b6Seschrock * We want to get the alternate root even for faulted pools, so we cheat 659*ea8dc4b6Seschrock * and call spa_lookup() directly. 660*ea8dc4b6Seschrock */ 661*ea8dc4b6Seschrock if (altroot) { 662*ea8dc4b6Seschrock if (spa == NULL) { 663*ea8dc4b6Seschrock mutex_enter(&spa_namespace_lock); 664*ea8dc4b6Seschrock spa = spa_lookup(name); 665*ea8dc4b6Seschrock if (spa) 666*ea8dc4b6Seschrock spa_altroot(spa, altroot, buflen); 667*ea8dc4b6Seschrock else 668*ea8dc4b6Seschrock altroot[0] = '\0'; 669*ea8dc4b6Seschrock spa = NULL; 670*ea8dc4b6Seschrock mutex_exit(&spa_namespace_lock); 671*ea8dc4b6Seschrock } else { 672*ea8dc4b6Seschrock spa_altroot(spa, altroot, buflen); 673*ea8dc4b6Seschrock } 674*ea8dc4b6Seschrock } 675*ea8dc4b6Seschrock 676fa9e4066Sahrens if (spa != NULL) 677fa9e4066Sahrens spa_close(spa, FTAG); 678fa9e4066Sahrens 679fa9e4066Sahrens return (error); 680fa9e4066Sahrens } 681fa9e4066Sahrens 682fa9e4066Sahrens /* 683fa9e4066Sahrens * Pool Creation 684fa9e4066Sahrens */ 685fa9e4066Sahrens int 686fa9e4066Sahrens spa_create(const char *pool, nvlist_t *nvroot, char *altroot) 687fa9e4066Sahrens { 688fa9e4066Sahrens spa_t *spa; 689fa9e4066Sahrens dsl_pool_t *dp; 690fa9e4066Sahrens dmu_tx_t *tx; 691fa9e4066Sahrens int error; 692fa9e4066Sahrens uint64_t txg = TXG_INITIAL; 693fa9e4066Sahrens 694fa9e4066Sahrens /* 695fa9e4066Sahrens * If this pool already exists, return failure. 696fa9e4066Sahrens */ 697fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 698fa9e4066Sahrens if (spa_lookup(pool) != NULL) { 699fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 700fa9e4066Sahrens return (EEXIST); 701fa9e4066Sahrens } 702fa9e4066Sahrens spa = spa_add(pool); 703fa9e4066Sahrens 704fa9e4066Sahrens /* 705fa9e4066Sahrens * Allocate a new spa_t structure. 706fa9e4066Sahrens */ 707fa9e4066Sahrens spa_activate(spa); 708fa9e4066Sahrens 709fa9e4066Sahrens spa->spa_uberblock.ub_txg = txg - 1; 710fa9e4066Sahrens spa->spa_ubsync = spa->spa_uberblock; 711fa9e4066Sahrens 712fa9e4066Sahrens error = spa_vdev_add(spa, nvroot); 713fa9e4066Sahrens 714fa9e4066Sahrens if (error) { 715fa9e4066Sahrens spa_unload(spa); 716fa9e4066Sahrens spa_deactivate(spa); 717fa9e4066Sahrens spa_remove(spa); 718fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 719fa9e4066Sahrens return (error); 720fa9e4066Sahrens } 721fa9e4066Sahrens 722fa9e4066Sahrens if (altroot != NULL) { 723fa9e4066Sahrens spa->spa_root = spa_strdup(altroot); 724fa9e4066Sahrens atomic_add_32(&spa_active_count, 1); 725fa9e4066Sahrens } 726fa9e4066Sahrens 727fa9e4066Sahrens spa->spa_dsl_pool = dp = dsl_pool_create(spa, txg); 728fa9e4066Sahrens spa->spa_meta_objset = dp->dp_meta_objset; 729fa9e4066Sahrens 730fa9e4066Sahrens tx = dmu_tx_create_assigned(dp, txg); 731fa9e4066Sahrens 732fa9e4066Sahrens /* 733fa9e4066Sahrens * Create the pool config object. 734fa9e4066Sahrens */ 735fa9e4066Sahrens spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset, 736fa9e4066Sahrens DMU_OT_PACKED_NVLIST, 1 << 14, 737fa9e4066Sahrens DMU_OT_PACKED_NVLIST_SIZE, sizeof (uint64_t), tx); 738fa9e4066Sahrens 739*ea8dc4b6Seschrock if (zap_add(spa->spa_meta_objset, 740fa9e4066Sahrens DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG, 741*ea8dc4b6Seschrock sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) { 742*ea8dc4b6Seschrock cmn_err(CE_PANIC, "failed to add pool config"); 743*ea8dc4b6Seschrock } 744fa9e4066Sahrens 745fa9e4066Sahrens /* 746fa9e4066Sahrens * Create the deferred-free bplist object. Turn off compression 747fa9e4066Sahrens * because sync-to-convergence takes longer if the blocksize 748fa9e4066Sahrens * keeps changing. 749fa9e4066Sahrens */ 750fa9e4066Sahrens spa->spa_sync_bplist_obj = bplist_create(spa->spa_meta_objset, 751fa9e4066Sahrens 1 << 14, tx); 752fa9e4066Sahrens dmu_object_set_compress(spa->spa_meta_objset, spa->spa_sync_bplist_obj, 753fa9e4066Sahrens ZIO_COMPRESS_OFF, tx); 754fa9e4066Sahrens 755*ea8dc4b6Seschrock if (zap_add(spa->spa_meta_objset, 756fa9e4066Sahrens DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST, 757*ea8dc4b6Seschrock sizeof (uint64_t), 1, &spa->spa_sync_bplist_obj, tx) != 0) { 758*ea8dc4b6Seschrock cmn_err(CE_PANIC, "failed to add bplist"); 759*ea8dc4b6Seschrock } 760fa9e4066Sahrens 761fa9e4066Sahrens dmu_tx_commit(tx); 762fa9e4066Sahrens 763fa9e4066Sahrens spa->spa_sync_on = B_TRUE; 764fa9e4066Sahrens txg_sync_start(spa->spa_dsl_pool); 765fa9e4066Sahrens 766fa9e4066Sahrens /* 767fa9e4066Sahrens * We explicitly wait for the first transaction to complete so that our 768fa9e4066Sahrens * bean counters are appropriately updated. 769fa9e4066Sahrens */ 770fa9e4066Sahrens txg_wait_synced(spa->spa_dsl_pool, txg); 771fa9e4066Sahrens 772fa9e4066Sahrens spa_config_sync(); 773fa9e4066Sahrens 774fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 775fa9e4066Sahrens 776fa9e4066Sahrens return (0); 777fa9e4066Sahrens } 778fa9e4066Sahrens 779fa9e4066Sahrens /* 780fa9e4066Sahrens * Import the given pool into the system. We set up the necessary spa_t and 781fa9e4066Sahrens * then call spa_load() to do the dirty work. 782fa9e4066Sahrens */ 783fa9e4066Sahrens int 784fa9e4066Sahrens spa_import(const char *pool, nvlist_t *config, char *altroot) 785fa9e4066Sahrens { 786fa9e4066Sahrens spa_t *spa; 787fa9e4066Sahrens int error; 788fa9e4066Sahrens 789fa9e4066Sahrens if (!(spa_mode & FWRITE)) 790fa9e4066Sahrens return (EROFS); 791fa9e4066Sahrens 792fa9e4066Sahrens /* 793fa9e4066Sahrens * If a pool with this name exists, return failure. 794fa9e4066Sahrens */ 795fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 796fa9e4066Sahrens if (spa_lookup(pool) != NULL) { 797fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 798fa9e4066Sahrens return (EEXIST); 799fa9e4066Sahrens } 800fa9e4066Sahrens 801fa9e4066Sahrens /* 802fa9e4066Sahrens * Create an initialize the spa structure 803fa9e4066Sahrens */ 804fa9e4066Sahrens spa = spa_add(pool); 805fa9e4066Sahrens spa_activate(spa); 806fa9e4066Sahrens 807fa9e4066Sahrens /* 808fa9e4066Sahrens * Pass off the heavy lifting to spa_load(). We pass TRUE for mosconfig 809fa9e4066Sahrens * so that we don't try to open the pool if the config is damaged. 810fa9e4066Sahrens */ 811*ea8dc4b6Seschrock error = spa_load(spa, config, SPA_LOAD_IMPORT, B_TRUE); 812fa9e4066Sahrens 813fa9e4066Sahrens if (error) { 814fa9e4066Sahrens spa_unload(spa); 815fa9e4066Sahrens spa_deactivate(spa); 816fa9e4066Sahrens spa_remove(spa); 817fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 818fa9e4066Sahrens return (error); 819fa9e4066Sahrens } 820fa9e4066Sahrens 821fa9e4066Sahrens /* 822fa9e4066Sahrens * Set the alternate root, if there is one. 823fa9e4066Sahrens */ 824fa9e4066Sahrens if (altroot != NULL) { 825fa9e4066Sahrens atomic_add_32(&spa_active_count, 1); 826fa9e4066Sahrens spa->spa_root = spa_strdup(altroot); 827fa9e4066Sahrens } 828fa9e4066Sahrens 829fa9e4066Sahrens /* 830fa9e4066Sahrens * Initialize the config based on the in-core state. 831fa9e4066Sahrens */ 832fa9e4066Sahrens config = spa_config_generate(spa, NULL, spa_last_synced_txg(spa), 0); 833fa9e4066Sahrens 834fa9e4066Sahrens spa_config_set(spa, config); 835fa9e4066Sahrens 836fa9e4066Sahrens /* 837fa9e4066Sahrens * Sync the configuration cache. 838fa9e4066Sahrens */ 839fa9e4066Sahrens spa_config_sync(); 840fa9e4066Sahrens 841fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 842fa9e4066Sahrens 843fa9e4066Sahrens /* 844fa9e4066Sahrens * Resilver anything that's out of date. 845fa9e4066Sahrens */ 846fa9e4066Sahrens if (spa_mode & FWRITE) 847fa9e4066Sahrens VERIFY(spa_scrub(spa, POOL_SCRUB_RESILVER, B_TRUE) == 0); 848fa9e4066Sahrens 849fa9e4066Sahrens return (0); 850fa9e4066Sahrens } 851fa9e4066Sahrens 852fa9e4066Sahrens /* 853fa9e4066Sahrens * This (illegal) pool name is used when temporarily importing a spa_t in order 854fa9e4066Sahrens * to get the vdev stats associated with the imported devices. 855fa9e4066Sahrens */ 856fa9e4066Sahrens #define TRYIMPORT_NAME "$import" 857fa9e4066Sahrens 858fa9e4066Sahrens nvlist_t * 859fa9e4066Sahrens spa_tryimport(nvlist_t *tryconfig) 860fa9e4066Sahrens { 861fa9e4066Sahrens nvlist_t *config = NULL; 862fa9e4066Sahrens char *poolname; 863fa9e4066Sahrens spa_t *spa; 864fa9e4066Sahrens uint64_t state; 865fa9e4066Sahrens 866fa9e4066Sahrens if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname)) 867fa9e4066Sahrens return (NULL); 868fa9e4066Sahrens 869fa9e4066Sahrens if (nvlist_lookup_uint64(tryconfig, ZPOOL_CONFIG_POOL_STATE, &state)) 870fa9e4066Sahrens return (NULL); 871fa9e4066Sahrens 872fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 873fa9e4066Sahrens spa = spa_add(TRYIMPORT_NAME); 874fa9e4066Sahrens 875fa9e4066Sahrens ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED); 876fa9e4066Sahrens 877fa9e4066Sahrens /* 878fa9e4066Sahrens * Initialize the spa_t structure. 879fa9e4066Sahrens */ 880fa9e4066Sahrens spa_activate(spa); 881fa9e4066Sahrens 882fa9e4066Sahrens /* 883fa9e4066Sahrens * Pass off the heavy lifting to spa_load(). We pass TRUE for mosconfig 884fa9e4066Sahrens * so we don't try to open the pool if the config is damaged. 885fa9e4066Sahrens */ 886*ea8dc4b6Seschrock (void) spa_load(spa, tryconfig, SPA_LOAD_TRYIMPORT, B_TRUE); 887fa9e4066Sahrens 888fa9e4066Sahrens /* 889fa9e4066Sahrens * If 'tryconfig' was at least parsable, return the current config. 890fa9e4066Sahrens */ 891fa9e4066Sahrens if (spa->spa_root_vdev != NULL) { 892fa9e4066Sahrens config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 893fa9e4066Sahrens VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, 894fa9e4066Sahrens poolname) == 0); 895fa9e4066Sahrens VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE, 896fa9e4066Sahrens state) == 0); 897fa9e4066Sahrens } 898fa9e4066Sahrens 899fa9e4066Sahrens spa_unload(spa); 900fa9e4066Sahrens spa_deactivate(spa); 901fa9e4066Sahrens spa_remove(spa); 902fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 903fa9e4066Sahrens 904fa9e4066Sahrens return (config); 905fa9e4066Sahrens } 906fa9e4066Sahrens 907fa9e4066Sahrens /* 908fa9e4066Sahrens * Pool export/destroy 909fa9e4066Sahrens * 910fa9e4066Sahrens * The act of destroying or exporting a pool is very simple. We make sure there 911fa9e4066Sahrens * is no more pending I/O and any references to the pool are gone. Then, we 912fa9e4066Sahrens * update the pool state and sync all the labels to disk, removing the 913fa9e4066Sahrens * configuration from the cache afterwards. 914fa9e4066Sahrens */ 915fa9e4066Sahrens static int 916fa9e4066Sahrens spa_export_common(char *pool, int new_state) 917fa9e4066Sahrens { 918fa9e4066Sahrens spa_t *spa; 919fa9e4066Sahrens 920fa9e4066Sahrens if (!(spa_mode & FWRITE)) 921fa9e4066Sahrens return (EROFS); 922fa9e4066Sahrens 923fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 924fa9e4066Sahrens if ((spa = spa_lookup(pool)) == NULL) { 925fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 926fa9e4066Sahrens return (ENOENT); 927fa9e4066Sahrens } 928fa9e4066Sahrens 929*ea8dc4b6Seschrock /* 930*ea8dc4b6Seschrock * Put a hold on the pool, drop the namespace lock, stop async tasks, 931*ea8dc4b6Seschrock * reacquire the namespace lock, and see if we can export. 932*ea8dc4b6Seschrock */ 933*ea8dc4b6Seschrock spa_open_ref(spa, FTAG); 934*ea8dc4b6Seschrock mutex_exit(&spa_namespace_lock); 935*ea8dc4b6Seschrock spa_async_suspend(spa); 936*ea8dc4b6Seschrock mutex_enter(&spa_namespace_lock); 937*ea8dc4b6Seschrock spa_close(spa, FTAG); 938*ea8dc4b6Seschrock 939fa9e4066Sahrens /* 940fa9e4066Sahrens * The pool will be in core if it's openable, 941fa9e4066Sahrens * in which case we can modify its state. 942fa9e4066Sahrens */ 943fa9e4066Sahrens if (spa->spa_state != POOL_STATE_UNINITIALIZED && spa->spa_sync_on) { 944fa9e4066Sahrens /* 945fa9e4066Sahrens * Objsets may be open only because they're dirty, so we 946fa9e4066Sahrens * have to force it to sync before checking spa_refcnt. 947fa9e4066Sahrens */ 948fa9e4066Sahrens spa_scrub_suspend(spa); 949fa9e4066Sahrens txg_wait_synced(spa->spa_dsl_pool, 0); 950fa9e4066Sahrens 951*ea8dc4b6Seschrock /* 952*ea8dc4b6Seschrock * A pool cannot be exported or destroyed if there are active 953*ea8dc4b6Seschrock * references. If we are resetting a pool, allow references by 954*ea8dc4b6Seschrock * fault injection handlers. 955*ea8dc4b6Seschrock */ 956*ea8dc4b6Seschrock if (!spa_refcount_zero(spa) || 957*ea8dc4b6Seschrock (spa->spa_inject_ref != 0 && 958*ea8dc4b6Seschrock new_state != POOL_STATE_UNINITIALIZED)) { 959fa9e4066Sahrens spa_scrub_resume(spa); 960*ea8dc4b6Seschrock spa_async_resume(spa); 961fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 962fa9e4066Sahrens return (EBUSY); 963fa9e4066Sahrens } 964fa9e4066Sahrens 965fa9e4066Sahrens spa_scrub_resume(spa); 966fa9e4066Sahrens VERIFY(spa_scrub(spa, POOL_SCRUB_NONE, B_TRUE) == 0); 967fa9e4066Sahrens 968fa9e4066Sahrens if (spa->spa_root != NULL) 969fa9e4066Sahrens atomic_add_32(&spa_active_count, -1); 970fa9e4066Sahrens 971fa9e4066Sahrens /* 972fa9e4066Sahrens * We want this to be reflected on every label, 973fa9e4066Sahrens * so mark them all dirty. spa_unload() will do the 974fa9e4066Sahrens * final sync that pushes these changes out. 975fa9e4066Sahrens */ 976*ea8dc4b6Seschrock if (new_state != POOL_STATE_UNINITIALIZED) { 977*ea8dc4b6Seschrock spa->spa_state = new_state; 978*ea8dc4b6Seschrock vdev_config_dirty(spa->spa_root_vdev); 979*ea8dc4b6Seschrock } 980fa9e4066Sahrens } 981fa9e4066Sahrens 982fa9e4066Sahrens if (spa->spa_state != POOL_STATE_UNINITIALIZED) { 983fa9e4066Sahrens spa_unload(spa); 984fa9e4066Sahrens spa_deactivate(spa); 985fa9e4066Sahrens } 986fa9e4066Sahrens 987*ea8dc4b6Seschrock if (new_state != POOL_STATE_UNINITIALIZED) { 988*ea8dc4b6Seschrock spa_remove(spa); 989*ea8dc4b6Seschrock spa_config_sync(); 990*ea8dc4b6Seschrock } 991fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 992fa9e4066Sahrens 993fa9e4066Sahrens return (0); 994fa9e4066Sahrens } 995fa9e4066Sahrens 996fa9e4066Sahrens /* 997fa9e4066Sahrens * Destroy a storage pool. 998fa9e4066Sahrens */ 999fa9e4066Sahrens int 1000fa9e4066Sahrens spa_destroy(char *pool) 1001fa9e4066Sahrens { 1002fa9e4066Sahrens return (spa_export_common(pool, POOL_STATE_DESTROYED)); 1003fa9e4066Sahrens } 1004fa9e4066Sahrens 1005fa9e4066Sahrens /* 1006fa9e4066Sahrens * Export a storage pool. 1007fa9e4066Sahrens */ 1008fa9e4066Sahrens int 1009fa9e4066Sahrens spa_export(char *pool) 1010fa9e4066Sahrens { 1011fa9e4066Sahrens return (spa_export_common(pool, POOL_STATE_EXPORTED)); 1012fa9e4066Sahrens } 1013fa9e4066Sahrens 1014*ea8dc4b6Seschrock /* 1015*ea8dc4b6Seschrock * Similar to spa_export(), this unloads the spa_t without actually removing it 1016*ea8dc4b6Seschrock * from the namespace in any way. 1017*ea8dc4b6Seschrock */ 1018*ea8dc4b6Seschrock int 1019*ea8dc4b6Seschrock spa_reset(char *pool) 1020*ea8dc4b6Seschrock { 1021*ea8dc4b6Seschrock return (spa_export_common(pool, POOL_STATE_UNINITIALIZED)); 1022*ea8dc4b6Seschrock } 1023*ea8dc4b6Seschrock 1024*ea8dc4b6Seschrock 1025fa9e4066Sahrens /* 1026fa9e4066Sahrens * ========================================================================== 1027fa9e4066Sahrens * Device manipulation 1028fa9e4066Sahrens * ========================================================================== 1029fa9e4066Sahrens */ 1030fa9e4066Sahrens 1031fa9e4066Sahrens /* 1032fa9e4066Sahrens * Add capacity to a storage pool. 1033fa9e4066Sahrens */ 1034fa9e4066Sahrens int 1035fa9e4066Sahrens spa_vdev_add(spa_t *spa, nvlist_t *nvroot) 1036fa9e4066Sahrens { 1037fa9e4066Sahrens uint64_t txg; 1038fa9e4066Sahrens int c, error; 1039fa9e4066Sahrens vdev_t *rvd = spa->spa_root_vdev; 1040fa9e4066Sahrens vdev_t *vd; 1041fa9e4066Sahrens 1042fa9e4066Sahrens txg = spa_vdev_enter(spa); 1043fa9e4066Sahrens 1044fa9e4066Sahrens vd = spa_config_parse(spa, nvroot, NULL, 0, VDEV_ALLOC_ADD); 1045fa9e4066Sahrens 1046fa9e4066Sahrens if (vd == NULL) 1047fa9e4066Sahrens return (spa_vdev_exit(spa, vd, txg, EINVAL)); 1048fa9e4066Sahrens 1049fa9e4066Sahrens if (rvd == NULL) /* spa_create() */ 1050fa9e4066Sahrens spa->spa_root_vdev = rvd = vd; 1051fa9e4066Sahrens 1052fa9e4066Sahrens if ((error = vdev_create(vd, txg)) != 0) 1053fa9e4066Sahrens return (spa_vdev_exit(spa, vd, txg, error)); 1054fa9e4066Sahrens 1055fa9e4066Sahrens /* 1056fa9e4066Sahrens * Transfer each top-level vdev from the temporary root 1057fa9e4066Sahrens * to the spa's root and initialize its metaslabs. 1058fa9e4066Sahrens */ 1059fa9e4066Sahrens for (c = 0; c < vd->vdev_children; c++) { 1060fa9e4066Sahrens vdev_t *tvd = vd->vdev_child[c]; 1061fa9e4066Sahrens if (vd != rvd) { 1062fa9e4066Sahrens vdev_remove_child(vd, tvd); 1063fa9e4066Sahrens tvd->vdev_id = rvd->vdev_children; 1064fa9e4066Sahrens vdev_add_child(rvd, tvd); 1065fa9e4066Sahrens } 1066*ea8dc4b6Seschrock if ((error = vdev_init(tvd, txg)) != 0) 1067*ea8dc4b6Seschrock return (spa_vdev_exit(spa, vd, txg, error)); 1068fa9e4066Sahrens vdev_config_dirty(tvd); 1069fa9e4066Sahrens } 1070fa9e4066Sahrens 1071fa9e4066Sahrens /* 1072fa9e4066Sahrens * Update the config based on the new in-core state. 1073fa9e4066Sahrens */ 1074fa9e4066Sahrens spa_config_set(spa, spa_config_generate(spa, rvd, txg, 0)); 1075fa9e4066Sahrens 1076fa9e4066Sahrens return (spa_vdev_exit(spa, vd, txg, 0)); 1077fa9e4066Sahrens } 1078fa9e4066Sahrens 1079fa9e4066Sahrens /* 1080fa9e4066Sahrens * Attach a device to a mirror. The arguments are the path to any device 1081fa9e4066Sahrens * in the mirror, and the nvroot for the new device. If the path specifies 1082fa9e4066Sahrens * a device that is not mirrored, we automatically insert the mirror vdev. 1083fa9e4066Sahrens * 1084fa9e4066Sahrens * If 'replacing' is specified, the new device is intended to replace the 1085fa9e4066Sahrens * existing device; in this case the two devices are made into their own 1086fa9e4066Sahrens * mirror using the 'replacing' vdev, which is functionally idendical to 1087fa9e4066Sahrens * the mirror vdev (it actually reuses all the same ops) but has a few 1088fa9e4066Sahrens * extra rules: you can't attach to it after it's been created, and upon 1089fa9e4066Sahrens * completion of resilvering, the first disk (the one being replaced) 1090fa9e4066Sahrens * is automatically detached. 1091fa9e4066Sahrens */ 1092fa9e4066Sahrens int 1093*ea8dc4b6Seschrock spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing) 1094fa9e4066Sahrens { 1095fa9e4066Sahrens uint64_t txg, open_txg; 1096fa9e4066Sahrens int error; 1097fa9e4066Sahrens vdev_t *rvd = spa->spa_root_vdev; 1098fa9e4066Sahrens vdev_t *oldvd, *newvd, *newrootvd, *pvd, *tvd; 1099fa9e4066Sahrens vdev_ops_t *pvops = replacing ? &vdev_replacing_ops : &vdev_mirror_ops; 1100fa9e4066Sahrens 1101fa9e4066Sahrens txg = spa_vdev_enter(spa); 1102fa9e4066Sahrens 1103*ea8dc4b6Seschrock oldvd = vdev_lookup_by_guid(rvd, guid); 1104fa9e4066Sahrens 1105fa9e4066Sahrens if (oldvd == NULL) 1106fa9e4066Sahrens return (spa_vdev_exit(spa, NULL, txg, ENODEV)); 1107fa9e4066Sahrens 1108fa9e4066Sahrens pvd = oldvd->vdev_parent; 1109fa9e4066Sahrens 1110fa9e4066Sahrens /* 1111fa9e4066Sahrens * The parent must be a mirror or the root, unless we're replacing; 1112fa9e4066Sahrens * in that case, the parent can be anything but another replacing vdev. 1113fa9e4066Sahrens */ 1114fa9e4066Sahrens if (pvd->vdev_ops != &vdev_mirror_ops && 1115fa9e4066Sahrens pvd->vdev_ops != &vdev_root_ops && 1116fa9e4066Sahrens (!replacing || pvd->vdev_ops == &vdev_replacing_ops)) 1117fa9e4066Sahrens return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 1118fa9e4066Sahrens 1119fa9e4066Sahrens newrootvd = spa_config_parse(spa, nvroot, NULL, 0, VDEV_ALLOC_ADD); 1120fa9e4066Sahrens 1121fa9e4066Sahrens if (newrootvd == NULL || newrootvd->vdev_children != 1) 1122fa9e4066Sahrens return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); 1123fa9e4066Sahrens 1124fa9e4066Sahrens newvd = newrootvd->vdev_child[0]; 1125fa9e4066Sahrens 1126fa9e4066Sahrens if (!newvd->vdev_ops->vdev_op_leaf) 1127fa9e4066Sahrens return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); 1128fa9e4066Sahrens 1129fa9e4066Sahrens if ((error = vdev_create(newrootvd, txg)) != 0) 1130fa9e4066Sahrens return (spa_vdev_exit(spa, newrootvd, txg, error)); 1131fa9e4066Sahrens 11322a79c5feSlling /* 11332a79c5feSlling * Compare the new device size with the replaceable/attachable 11342a79c5feSlling * device size. 11352a79c5feSlling */ 11362a79c5feSlling if (newvd->vdev_psize < vdev_get_rsize(oldvd)) 1137fa9e4066Sahrens return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW)); 1138fa9e4066Sahrens 1139fa9e4066Sahrens if (newvd->vdev_ashift != oldvd->vdev_ashift && oldvd->vdev_ashift != 0) 1140fa9e4066Sahrens return (spa_vdev_exit(spa, newrootvd, txg, EDOM)); 1141fa9e4066Sahrens 1142fa9e4066Sahrens /* 1143fa9e4066Sahrens * If this is an in-place replacement, update oldvd's path and devid 1144fa9e4066Sahrens * to make it distinguishable from newvd, and unopenable from now on. 1145fa9e4066Sahrens */ 1146fa9e4066Sahrens if (strcmp(oldvd->vdev_path, newvd->vdev_path) == 0) { 1147fa9e4066Sahrens spa_strfree(oldvd->vdev_path); 1148fa9e4066Sahrens oldvd->vdev_path = kmem_alloc(strlen(newvd->vdev_path) + 5, 1149fa9e4066Sahrens KM_SLEEP); 1150fa9e4066Sahrens (void) sprintf(oldvd->vdev_path, "%s/%s", 1151fa9e4066Sahrens newvd->vdev_path, "old"); 1152fa9e4066Sahrens if (oldvd->vdev_devid != NULL) { 1153fa9e4066Sahrens spa_strfree(oldvd->vdev_devid); 1154fa9e4066Sahrens oldvd->vdev_devid = NULL; 1155fa9e4066Sahrens } 1156fa9e4066Sahrens } 1157fa9e4066Sahrens 1158fa9e4066Sahrens /* 1159fa9e4066Sahrens * If the parent is not a mirror, or if we're replacing, 1160fa9e4066Sahrens * insert the new mirror/replacing vdev above oldvd. 1161fa9e4066Sahrens */ 1162fa9e4066Sahrens if (pvd->vdev_ops != pvops) 1163fa9e4066Sahrens pvd = vdev_add_parent(oldvd, pvops); 1164fa9e4066Sahrens 1165fa9e4066Sahrens ASSERT(pvd->vdev_top->vdev_parent == rvd); 1166fa9e4066Sahrens ASSERT(pvd->vdev_ops == pvops); 1167fa9e4066Sahrens ASSERT(oldvd->vdev_parent == pvd); 1168fa9e4066Sahrens 1169fa9e4066Sahrens /* 1170fa9e4066Sahrens * Extract the new device from its root and add it to pvd. 1171fa9e4066Sahrens */ 1172fa9e4066Sahrens vdev_remove_child(newrootvd, newvd); 1173fa9e4066Sahrens newvd->vdev_id = pvd->vdev_children; 1174fa9e4066Sahrens vdev_add_child(pvd, newvd); 1175fa9e4066Sahrens 1176*ea8dc4b6Seschrock /* 1177*ea8dc4b6Seschrock * If newvd is smaller than oldvd, but larger than its rsize, 1178*ea8dc4b6Seschrock * the addition of newvd may have decreased our parent's asize. 1179*ea8dc4b6Seschrock */ 1180*ea8dc4b6Seschrock pvd->vdev_asize = MIN(pvd->vdev_asize, newvd->vdev_asize); 1181*ea8dc4b6Seschrock 1182fa9e4066Sahrens tvd = newvd->vdev_top; 1183fa9e4066Sahrens ASSERT(pvd->vdev_top == tvd); 1184fa9e4066Sahrens ASSERT(tvd->vdev_parent == rvd); 1185fa9e4066Sahrens 1186fa9e4066Sahrens /* 1187fa9e4066Sahrens * Update the config based on the new in-core state. 1188fa9e4066Sahrens */ 1189fa9e4066Sahrens spa_config_set(spa, spa_config_generate(spa, rvd, txg, 0)); 1190fa9e4066Sahrens vdev_config_dirty(tvd); 1191fa9e4066Sahrens 1192fa9e4066Sahrens /* 1193fa9e4066Sahrens * Set newvd's DTL to [TXG_INITIAL, open_txg]. It will propagate 1194fa9e4066Sahrens * upward when spa_vdev_exit() calls vdev_dtl_reassess(). 1195fa9e4066Sahrens */ 1196fa9e4066Sahrens open_txg = txg + TXG_CONCURRENT_STATES - 1; 1197fa9e4066Sahrens 1198fa9e4066Sahrens mutex_enter(&newvd->vdev_dtl_lock); 1199fa9e4066Sahrens space_map_add(&newvd->vdev_dtl_map, TXG_INITIAL, 1200fa9e4066Sahrens open_txg - TXG_INITIAL + 1); 1201fa9e4066Sahrens mutex_exit(&newvd->vdev_dtl_lock); 1202fa9e4066Sahrens 1203*ea8dc4b6Seschrock dprintf("attached %s in txg %llu\n", newvd->vdev_path, txg); 1204*ea8dc4b6Seschrock 1205fa9e4066Sahrens /* 1206fa9e4066Sahrens * Mark newvd's DTL dirty in this txg. 1207fa9e4066Sahrens */ 1208fa9e4066Sahrens vdev_dirty(tvd, VDD_DTL, txg); 1209fa9e4066Sahrens (void) txg_list_add(&tvd->vdev_dtl_list, newvd, txg); 1210fa9e4066Sahrens 1211fa9e4066Sahrens (void) spa_vdev_exit(spa, newrootvd, open_txg, 0); 1212fa9e4066Sahrens 1213fa9e4066Sahrens /* 1214fa9e4066Sahrens * Kick off a resilver to update newvd. 1215fa9e4066Sahrens */ 1216fa9e4066Sahrens VERIFY(spa_scrub(spa, POOL_SCRUB_RESILVER, B_TRUE) == 0); 1217fa9e4066Sahrens 1218fa9e4066Sahrens return (0); 1219fa9e4066Sahrens } 1220fa9e4066Sahrens 1221fa9e4066Sahrens /* 1222fa9e4066Sahrens * Detach a device from a mirror or replacing vdev. 1223fa9e4066Sahrens * If 'replace_done' is specified, only detach if the parent 1224fa9e4066Sahrens * is a replacing vdev. 1225fa9e4066Sahrens */ 1226fa9e4066Sahrens int 1227*ea8dc4b6Seschrock spa_vdev_detach(spa_t *spa, uint64_t guid, int replace_done) 1228fa9e4066Sahrens { 1229fa9e4066Sahrens uint64_t txg; 1230fa9e4066Sahrens int c, t, error; 1231fa9e4066Sahrens vdev_t *rvd = spa->spa_root_vdev; 1232fa9e4066Sahrens vdev_t *vd, *pvd, *cvd, *tvd; 1233fa9e4066Sahrens 1234fa9e4066Sahrens txg = spa_vdev_enter(spa); 1235fa9e4066Sahrens 1236*ea8dc4b6Seschrock vd = vdev_lookup_by_guid(rvd, guid); 1237fa9e4066Sahrens 1238fa9e4066Sahrens if (vd == NULL) 1239fa9e4066Sahrens return (spa_vdev_exit(spa, NULL, txg, ENODEV)); 1240fa9e4066Sahrens 1241fa9e4066Sahrens pvd = vd->vdev_parent; 1242fa9e4066Sahrens 1243fa9e4066Sahrens /* 1244fa9e4066Sahrens * If replace_done is specified, only remove this device if it's 1245fa9e4066Sahrens * the first child of a replacing vdev. 1246fa9e4066Sahrens */ 1247fa9e4066Sahrens if (replace_done && 1248fa9e4066Sahrens (vd->vdev_id != 0 || pvd->vdev_ops != &vdev_replacing_ops)) 1249fa9e4066Sahrens return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 1250fa9e4066Sahrens 1251fa9e4066Sahrens /* 1252fa9e4066Sahrens * Only mirror and replacing vdevs support detach. 1253fa9e4066Sahrens */ 1254fa9e4066Sahrens if (pvd->vdev_ops != &vdev_replacing_ops && 1255fa9e4066Sahrens pvd->vdev_ops != &vdev_mirror_ops) 1256fa9e4066Sahrens return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 1257fa9e4066Sahrens 1258fa9e4066Sahrens /* 1259fa9e4066Sahrens * If there's only one replica, you can't detach it. 1260fa9e4066Sahrens */ 1261fa9e4066Sahrens if (pvd->vdev_children <= 1) 1262fa9e4066Sahrens return (spa_vdev_exit(spa, NULL, txg, EBUSY)); 1263fa9e4066Sahrens 1264fa9e4066Sahrens /* 1265fa9e4066Sahrens * If all siblings have non-empty DTLs, this device may have the only 1266fa9e4066Sahrens * valid copy of the data, which means we cannot safely detach it. 1267fa9e4066Sahrens * 1268fa9e4066Sahrens * XXX -- as in the vdev_offline() case, we really want a more 1269fa9e4066Sahrens * precise DTL check. 1270fa9e4066Sahrens */ 1271fa9e4066Sahrens for (c = 0; c < pvd->vdev_children; c++) { 1272fa9e4066Sahrens uint64_t dirty; 1273fa9e4066Sahrens 1274fa9e4066Sahrens cvd = pvd->vdev_child[c]; 1275fa9e4066Sahrens if (cvd == vd) 1276fa9e4066Sahrens continue; 1277fa9e4066Sahrens if (vdev_is_dead(cvd)) 1278fa9e4066Sahrens continue; 1279fa9e4066Sahrens mutex_enter(&cvd->vdev_dtl_lock); 1280fa9e4066Sahrens dirty = cvd->vdev_dtl_map.sm_space | 1281fa9e4066Sahrens cvd->vdev_dtl_scrub.sm_space; 1282fa9e4066Sahrens mutex_exit(&cvd->vdev_dtl_lock); 1283fa9e4066Sahrens if (!dirty) 1284fa9e4066Sahrens break; 1285fa9e4066Sahrens } 1286fa9e4066Sahrens if (c == pvd->vdev_children) 1287fa9e4066Sahrens return (spa_vdev_exit(spa, NULL, txg, EBUSY)); 1288fa9e4066Sahrens 1289fa9e4066Sahrens /* 1290fa9e4066Sahrens * Erase the disk labels so the disk can be used for other things. 1291fa9e4066Sahrens * This must be done after all other error cases are handled, 1292fa9e4066Sahrens * but before we disembowel vd (so we can still do I/O to it). 1293fa9e4066Sahrens * But if we can't do it, don't treat the error as fatal -- 1294fa9e4066Sahrens * it may be that the unwritability of the disk is the reason 1295fa9e4066Sahrens * it's being detached! 1296fa9e4066Sahrens */ 1297fa9e4066Sahrens error = vdev_label_init(vd, 0); 1298fa9e4066Sahrens if (error) 1299fa9e4066Sahrens dprintf("unable to erase labels on %s\n", vdev_description(vd)); 1300fa9e4066Sahrens 1301fa9e4066Sahrens /* 1302fa9e4066Sahrens * Remove vd from its parent and compact the parent's children. 1303fa9e4066Sahrens */ 1304fa9e4066Sahrens vdev_remove_child(pvd, vd); 1305fa9e4066Sahrens vdev_compact_children(pvd); 1306fa9e4066Sahrens 1307fa9e4066Sahrens /* 1308fa9e4066Sahrens * Remember one of the remaining children so we can get tvd below. 1309fa9e4066Sahrens */ 1310fa9e4066Sahrens cvd = pvd->vdev_child[0]; 1311fa9e4066Sahrens 1312fa9e4066Sahrens /* 1313fa9e4066Sahrens * If the parent mirror/replacing vdev only has one child, 1314fa9e4066Sahrens * the parent is no longer needed. Remove it from the tree. 1315fa9e4066Sahrens */ 1316fa9e4066Sahrens if (pvd->vdev_children == 1) 1317fa9e4066Sahrens vdev_remove_parent(cvd); 1318fa9e4066Sahrens 1319fa9e4066Sahrens /* 1320fa9e4066Sahrens * We don't set tvd until now because the parent we just removed 1321fa9e4066Sahrens * may have been the previous top-level vdev. 1322fa9e4066Sahrens */ 1323fa9e4066Sahrens tvd = cvd->vdev_top; 1324fa9e4066Sahrens ASSERT(tvd->vdev_parent == rvd); 1325fa9e4066Sahrens 1326fa9e4066Sahrens /* 1327fa9e4066Sahrens * Reopen this top-level vdev to reassess health after detach. 1328fa9e4066Sahrens */ 1329*ea8dc4b6Seschrock vdev_reopen(tvd); 1330fa9e4066Sahrens 1331fa9e4066Sahrens /* 1332fa9e4066Sahrens * If the device we just detached was smaller than the others, 1333*ea8dc4b6Seschrock * it may be possible to add metaslabs (i.e. grow the pool). We ignore 1334*ea8dc4b6Seschrock * the error here because the detach still succeeded - we just weren't 1335*ea8dc4b6Seschrock * able to reinitialize the metaslabs. This pool is in for a world of 1336*ea8dc4b6Seschrock * hurt, in any case. 1337fa9e4066Sahrens */ 1338*ea8dc4b6Seschrock (void) vdev_metaslab_init(tvd, txg); 1339fa9e4066Sahrens 1340fa9e4066Sahrens /* 1341fa9e4066Sahrens * Update the config based on the new in-core state. 1342fa9e4066Sahrens */ 1343fa9e4066Sahrens spa_config_set(spa, spa_config_generate(spa, rvd, txg, 0)); 1344fa9e4066Sahrens 1345fa9e4066Sahrens vdev_config_dirty(tvd); 1346fa9e4066Sahrens 1347fa9e4066Sahrens /* 1348fa9e4066Sahrens * Mark vd's DTL as dirty in this txg. 1349fa9e4066Sahrens * vdev_dtl_sync() will see that vd->vdev_detached is set 1350fa9e4066Sahrens * and free vd's DTL object in syncing context. 1351fa9e4066Sahrens * But first make sure we're not on any *other* txg's DTL list, 1352fa9e4066Sahrens * to prevent vd from being accessed after it's freed. 1353fa9e4066Sahrens */ 1354fa9e4066Sahrens vdev_dirty(tvd, VDD_DTL, txg); 1355fa9e4066Sahrens vd->vdev_detached = B_TRUE; 1356fa9e4066Sahrens for (t = 0; t < TXG_SIZE; t++) 1357fa9e4066Sahrens (void) txg_list_remove_this(&tvd->vdev_dtl_list, vd, t); 1358fa9e4066Sahrens (void) txg_list_add(&tvd->vdev_dtl_list, vd, txg); 1359fa9e4066Sahrens 1360*ea8dc4b6Seschrock dprintf("detached %s in txg %llu\n", vd->vdev_path, txg); 1361fa9e4066Sahrens 1362fa9e4066Sahrens return (spa_vdev_exit(spa, vd, txg, 0)); 1363fa9e4066Sahrens } 1364fa9e4066Sahrens 1365fa9e4066Sahrens /* 1366*ea8dc4b6Seschrock * Find any device that's done replacing, so we can detach it. 1367fa9e4066Sahrens */ 1368*ea8dc4b6Seschrock static vdev_t * 1369*ea8dc4b6Seschrock spa_vdev_replace_done_hunt(vdev_t *vd) 1370fa9e4066Sahrens { 1371*ea8dc4b6Seschrock vdev_t *newvd, *oldvd; 1372fa9e4066Sahrens int c; 1373fa9e4066Sahrens 1374*ea8dc4b6Seschrock for (c = 0; c < vd->vdev_children; c++) { 1375*ea8dc4b6Seschrock oldvd = spa_vdev_replace_done_hunt(vd->vdev_child[c]); 1376*ea8dc4b6Seschrock if (oldvd != NULL) 1377*ea8dc4b6Seschrock return (oldvd); 1378*ea8dc4b6Seschrock } 1379fa9e4066Sahrens 1380fa9e4066Sahrens if (vd->vdev_ops == &vdev_replacing_ops && vd->vdev_children == 2) { 1381*ea8dc4b6Seschrock oldvd = vd->vdev_child[0]; 1382*ea8dc4b6Seschrock newvd = vd->vdev_child[1]; 1383*ea8dc4b6Seschrock 1384*ea8dc4b6Seschrock mutex_enter(&newvd->vdev_dtl_lock); 1385*ea8dc4b6Seschrock if (newvd->vdev_dtl_map.sm_space == 0 && 1386*ea8dc4b6Seschrock newvd->vdev_dtl_scrub.sm_space == 0) { 1387*ea8dc4b6Seschrock mutex_exit(&newvd->vdev_dtl_lock); 1388*ea8dc4b6Seschrock return (oldvd); 1389fa9e4066Sahrens } 1390*ea8dc4b6Seschrock mutex_exit(&newvd->vdev_dtl_lock); 1391fa9e4066Sahrens } 1392*ea8dc4b6Seschrock 1393*ea8dc4b6Seschrock return (NULL); 1394fa9e4066Sahrens } 1395fa9e4066Sahrens 1396*ea8dc4b6Seschrock static void 1397fa9e4066Sahrens spa_vdev_replace_done(spa_t *spa) 1398fa9e4066Sahrens { 1399*ea8dc4b6Seschrock vdev_t *vd; 1400*ea8dc4b6Seschrock uint64_t guid; 1401*ea8dc4b6Seschrock 1402*ea8dc4b6Seschrock spa_config_enter(spa, RW_READER, FTAG); 1403*ea8dc4b6Seschrock 1404*ea8dc4b6Seschrock while ((vd = spa_vdev_replace_done_hunt(spa->spa_root_vdev)) != NULL) { 1405*ea8dc4b6Seschrock guid = vd->vdev_guid; 1406*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 1407*ea8dc4b6Seschrock if (spa_vdev_detach(spa, guid, B_TRUE) != 0) 1408*ea8dc4b6Seschrock return; 1409*ea8dc4b6Seschrock spa_config_enter(spa, RW_READER, FTAG); 1410fa9e4066Sahrens } 1411fa9e4066Sahrens 1412*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 1413fa9e4066Sahrens } 1414fa9e4066Sahrens 1415c67d9675Seschrock /* 1416c67d9675Seschrock * Update the stored path for this vdev. Dirty the vdev configuration, relying 1417c67d9675Seschrock * on spa_vdev_enter/exit() to synchronize the labels and cache. 1418c67d9675Seschrock */ 1419c67d9675Seschrock int 1420c67d9675Seschrock spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath) 1421c67d9675Seschrock { 1422c67d9675Seschrock vdev_t *rvd, *vd; 1423c67d9675Seschrock uint64_t txg; 1424c67d9675Seschrock 1425c67d9675Seschrock rvd = spa->spa_root_vdev; 1426c67d9675Seschrock 1427c67d9675Seschrock txg = spa_vdev_enter(spa); 1428c67d9675Seschrock 1429c67d9675Seschrock if ((vd = vdev_lookup_by_guid(rvd, guid)) == NULL) 1430c67d9675Seschrock return (spa_vdev_exit(spa, NULL, txg, ENOENT)); 1431c67d9675Seschrock 1432c67d9675Seschrock spa_strfree(vd->vdev_path); 1433c67d9675Seschrock vd->vdev_path = spa_strdup(newpath); 1434c67d9675Seschrock 1435c67d9675Seschrock spa_config_set(spa, spa_config_generate(spa, rvd, txg, 0)); 1436c67d9675Seschrock 1437c67d9675Seschrock vdev_config_dirty(vd->vdev_top); 1438c67d9675Seschrock 1439c67d9675Seschrock return (spa_vdev_exit(spa, NULL, txg, 0)); 1440c67d9675Seschrock } 1441c67d9675Seschrock 1442fa9e4066Sahrens /* 1443fa9e4066Sahrens * ========================================================================== 1444fa9e4066Sahrens * SPA Scrubbing 1445fa9e4066Sahrens * ========================================================================== 1446fa9e4066Sahrens */ 1447fa9e4066Sahrens 1448*ea8dc4b6Seschrock void 1449*ea8dc4b6Seschrock spa_scrub_throttle(spa_t *spa, int direction) 1450*ea8dc4b6Seschrock { 1451*ea8dc4b6Seschrock mutex_enter(&spa->spa_scrub_lock); 1452*ea8dc4b6Seschrock spa->spa_scrub_throttled += direction; 1453*ea8dc4b6Seschrock ASSERT(spa->spa_scrub_throttled >= 0); 1454*ea8dc4b6Seschrock if (spa->spa_scrub_throttled == 0) 1455*ea8dc4b6Seschrock cv_broadcast(&spa->spa_scrub_io_cv); 1456*ea8dc4b6Seschrock mutex_exit(&spa->spa_scrub_lock); 1457*ea8dc4b6Seschrock } 1458fa9e4066Sahrens 1459fa9e4066Sahrens static void 1460fa9e4066Sahrens spa_scrub_io_done(zio_t *zio) 1461fa9e4066Sahrens { 1462fa9e4066Sahrens spa_t *spa = zio->io_spa; 1463fa9e4066Sahrens 1464fa9e4066Sahrens zio_buf_free(zio->io_data, zio->io_size); 1465fa9e4066Sahrens 1466fa9e4066Sahrens mutex_enter(&spa->spa_scrub_lock); 1467*ea8dc4b6Seschrock if (zio->io_error && !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) { 1468fa9e4066Sahrens vdev_t *vd = zio->io_vd; 1469*ea8dc4b6Seschrock spa->spa_scrub_errors++; 1470fa9e4066Sahrens mutex_enter(&vd->vdev_stat_lock); 1471fa9e4066Sahrens vd->vdev_stat.vs_scrub_errors++; 1472fa9e4066Sahrens mutex_exit(&vd->vdev_stat_lock); 1473fa9e4066Sahrens } 1474*ea8dc4b6Seschrock if (--spa->spa_scrub_inflight == 0) { 1475*ea8dc4b6Seschrock cv_broadcast(&spa->spa_scrub_io_cv); 1476*ea8dc4b6Seschrock ASSERT(spa->spa_scrub_throttled == 0); 1477*ea8dc4b6Seschrock } 1478*ea8dc4b6Seschrock mutex_exit(&spa->spa_scrub_lock); 1479fa9e4066Sahrens } 1480fa9e4066Sahrens 1481fa9e4066Sahrens static void 1482*ea8dc4b6Seschrock spa_scrub_io_start(spa_t *spa, blkptr_t *bp, int priority, int flags, 1483*ea8dc4b6Seschrock zbookmark_t *zb) 1484fa9e4066Sahrens { 1485fa9e4066Sahrens size_t size = BP_GET_LSIZE(bp); 1486fa9e4066Sahrens void *data = zio_buf_alloc(size); 1487fa9e4066Sahrens 1488fa9e4066Sahrens mutex_enter(&spa->spa_scrub_lock); 1489fa9e4066Sahrens spa->spa_scrub_inflight++; 1490fa9e4066Sahrens mutex_exit(&spa->spa_scrub_lock); 1491fa9e4066Sahrens 1492*ea8dc4b6Seschrock if (zb->zb_level == -1 && BP_GET_TYPE(bp) != DMU_OT_OBJSET) 1493*ea8dc4b6Seschrock flags |= ZIO_FLAG_SPECULATIVE; /* intent log block */ 1494*ea8dc4b6Seschrock 1495*ea8dc4b6Seschrock flags |= ZIO_FLAG_CANFAIL; 1496*ea8dc4b6Seschrock 1497fa9e4066Sahrens zio_nowait(zio_read(NULL, spa, bp, data, size, 1498*ea8dc4b6Seschrock spa_scrub_io_done, NULL, priority, flags, zb)); 1499fa9e4066Sahrens } 1500fa9e4066Sahrens 1501fa9e4066Sahrens /* ARGSUSED */ 1502fa9e4066Sahrens static int 1503fa9e4066Sahrens spa_scrub_cb(traverse_blk_cache_t *bc, spa_t *spa, void *a) 1504fa9e4066Sahrens { 1505fa9e4066Sahrens blkptr_t *bp = &bc->bc_blkptr; 1506fa9e4066Sahrens vdev_t *vd = vdev_lookup_top(spa, DVA_GET_VDEV(&bp->blk_dva[0])); 1507fa9e4066Sahrens 1508fa9e4066Sahrens if (bc->bc_errno || vd == NULL) { 1509fa9e4066Sahrens /* 1510fa9e4066Sahrens * We can't scrub this block, but we can continue to scrub 1511fa9e4066Sahrens * the rest of the pool. Note the error and move along. 1512fa9e4066Sahrens */ 1513fa9e4066Sahrens mutex_enter(&spa->spa_scrub_lock); 1514fa9e4066Sahrens spa->spa_scrub_errors++; 1515fa9e4066Sahrens mutex_exit(&spa->spa_scrub_lock); 1516fa9e4066Sahrens 1517fa9e4066Sahrens if (vd != NULL) { 1518fa9e4066Sahrens mutex_enter(&vd->vdev_stat_lock); 1519fa9e4066Sahrens vd->vdev_stat.vs_scrub_errors++; 1520fa9e4066Sahrens mutex_exit(&vd->vdev_stat_lock); 1521fa9e4066Sahrens } 1522fa9e4066Sahrens 1523fa9e4066Sahrens return (ERESTART); 1524fa9e4066Sahrens } 1525fa9e4066Sahrens 1526fa9e4066Sahrens ASSERT(bp->blk_birth < spa->spa_scrub_maxtxg); 1527fa9e4066Sahrens 1528fa9e4066Sahrens /* 1529fa9e4066Sahrens * Keep track of how much data we've examined so that 1530fa9e4066Sahrens * zpool(1M) status can make useful progress reports. 1531fa9e4066Sahrens */ 1532fa9e4066Sahrens mutex_enter(&vd->vdev_stat_lock); 1533fa9e4066Sahrens vd->vdev_stat.vs_scrub_examined += BP_GET_ASIZE(bp); 1534fa9e4066Sahrens mutex_exit(&vd->vdev_stat_lock); 1535fa9e4066Sahrens 1536fa9e4066Sahrens if (spa->spa_scrub_type == POOL_SCRUB_RESILVER) { 1537fa9e4066Sahrens if (DVA_GET_GANG(&bp->blk_dva[0])) { 1538fa9e4066Sahrens /* 1539fa9e4066Sahrens * Gang members may be spread across multiple vdevs, 1540fa9e4066Sahrens * so the best we can do is look at the pool-wide DTL. 1541fa9e4066Sahrens * XXX -- it would be better to change our allocation 1542fa9e4066Sahrens * policy to ensure that this can't happen. 1543fa9e4066Sahrens */ 1544fa9e4066Sahrens vd = spa->spa_root_vdev; 1545fa9e4066Sahrens } 1546fa9e4066Sahrens if (vdev_dtl_contains(&vd->vdev_dtl_map, bp->blk_birth, 1)) { 1547fa9e4066Sahrens spa_scrub_io_start(spa, bp, ZIO_PRIORITY_RESILVER, 1548*ea8dc4b6Seschrock ZIO_FLAG_RESILVER, &bc->bc_bookmark); 1549fa9e4066Sahrens } 1550fa9e4066Sahrens } else { 1551fa9e4066Sahrens spa_scrub_io_start(spa, bp, ZIO_PRIORITY_SCRUB, 1552*ea8dc4b6Seschrock ZIO_FLAG_SCRUB, &bc->bc_bookmark); 1553fa9e4066Sahrens } 1554fa9e4066Sahrens 1555fa9e4066Sahrens return (0); 1556fa9e4066Sahrens } 1557fa9e4066Sahrens 1558fa9e4066Sahrens static void 1559fa9e4066Sahrens spa_scrub_thread(spa_t *spa) 1560fa9e4066Sahrens { 1561fa9e4066Sahrens callb_cpr_t cprinfo; 1562fa9e4066Sahrens traverse_handle_t *th = spa->spa_scrub_th; 1563fa9e4066Sahrens vdev_t *rvd = spa->spa_root_vdev; 1564fa9e4066Sahrens pool_scrub_type_t scrub_type = spa->spa_scrub_type; 1565fa9e4066Sahrens int error = 0; 1566fa9e4066Sahrens boolean_t complete; 1567fa9e4066Sahrens 1568fa9e4066Sahrens CALLB_CPR_INIT(&cprinfo, &spa->spa_scrub_lock, callb_generic_cpr, FTAG); 1569fa9e4066Sahrens 1570f0aa80d4Sbonwick /* 1571f0aa80d4Sbonwick * If we're restarting due to a snapshot create/delete, 1572f0aa80d4Sbonwick * wait for that to complete. 1573f0aa80d4Sbonwick */ 1574f0aa80d4Sbonwick txg_wait_synced(spa_get_dsl(spa), 0); 1575f0aa80d4Sbonwick 1576*ea8dc4b6Seschrock dprintf("start %s mintxg=%llu maxtxg=%llu\n", 1577*ea8dc4b6Seschrock scrub_type == POOL_SCRUB_RESILVER ? "resilver" : "scrub", 1578*ea8dc4b6Seschrock spa->spa_scrub_mintxg, spa->spa_scrub_maxtxg); 1579*ea8dc4b6Seschrock 1580*ea8dc4b6Seschrock spa_config_enter(spa, RW_WRITER, FTAG); 1581*ea8dc4b6Seschrock vdev_reopen(rvd); /* purge all vdev caches */ 1582fa9e4066Sahrens vdev_config_dirty(rvd); /* rewrite all disk labels */ 1583fa9e4066Sahrens vdev_scrub_stat_update(rvd, scrub_type, B_FALSE); 1584*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 1585fa9e4066Sahrens 1586fa9e4066Sahrens mutex_enter(&spa->spa_scrub_lock); 1587fa9e4066Sahrens spa->spa_scrub_errors = 0; 1588fa9e4066Sahrens spa->spa_scrub_active = 1; 1589*ea8dc4b6Seschrock ASSERT(spa->spa_scrub_inflight == 0); 1590*ea8dc4b6Seschrock ASSERT(spa->spa_scrub_throttled == 0); 1591fa9e4066Sahrens 1592fa9e4066Sahrens while (!spa->spa_scrub_stop) { 1593fa9e4066Sahrens CALLB_CPR_SAFE_BEGIN(&cprinfo); 1594*ea8dc4b6Seschrock while (spa->spa_scrub_suspended) { 1595fa9e4066Sahrens spa->spa_scrub_active = 0; 1596fa9e4066Sahrens cv_broadcast(&spa->spa_scrub_cv); 1597fa9e4066Sahrens cv_wait(&spa->spa_scrub_cv, &spa->spa_scrub_lock); 1598fa9e4066Sahrens spa->spa_scrub_active = 1; 1599fa9e4066Sahrens } 1600fa9e4066Sahrens CALLB_CPR_SAFE_END(&cprinfo, &spa->spa_scrub_lock); 1601fa9e4066Sahrens 1602fa9e4066Sahrens if (spa->spa_scrub_restart_txg != 0) 1603fa9e4066Sahrens break; 1604fa9e4066Sahrens 1605fa9e4066Sahrens mutex_exit(&spa->spa_scrub_lock); 1606fa9e4066Sahrens error = traverse_more(th); 1607fa9e4066Sahrens mutex_enter(&spa->spa_scrub_lock); 1608fa9e4066Sahrens if (error != EAGAIN) 1609fa9e4066Sahrens break; 1610*ea8dc4b6Seschrock 1611*ea8dc4b6Seschrock while (spa->spa_scrub_throttled > 0) 1612*ea8dc4b6Seschrock cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock); 1613fa9e4066Sahrens } 1614fa9e4066Sahrens 1615fa9e4066Sahrens while (spa->spa_scrub_inflight) 1616fa9e4066Sahrens cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock); 1617fa9e4066Sahrens 1618fa9e4066Sahrens if (spa->spa_scrub_restart_txg != 0) 1619fa9e4066Sahrens error = ERESTART; 1620fa9e4066Sahrens 1621*ea8dc4b6Seschrock if (spa->spa_scrub_stop) 1622*ea8dc4b6Seschrock error = EINTR; 1623*ea8dc4b6Seschrock 1624fa9e4066Sahrens spa->spa_scrub_active = 0; 1625fa9e4066Sahrens cv_broadcast(&spa->spa_scrub_cv); 1626fa9e4066Sahrens 1627fa9e4066Sahrens /* 1628*ea8dc4b6Seschrock * Even if there were uncorrectable errors, we consider the scrub 1629*ea8dc4b6Seschrock * completed. The downside is that if there is a transient error during 1630*ea8dc4b6Seschrock * a resilver, we won't resilver the data properly to the target. But 1631*ea8dc4b6Seschrock * if the damage is permanent (more likely) we will resilver forever, 1632*ea8dc4b6Seschrock * which isn't really acceptable. Since there is enough information for 1633*ea8dc4b6Seschrock * the user to know what has failed and why, this seems like a more 1634*ea8dc4b6Seschrock * tractable approach. 1635fa9e4066Sahrens */ 1636*ea8dc4b6Seschrock complete = (error == 0); 1637fa9e4066Sahrens 1638*ea8dc4b6Seschrock dprintf("end %s to maxtxg=%llu %s, traverse=%d, %llu errors, stop=%u\n", 1639*ea8dc4b6Seschrock scrub_type == POOL_SCRUB_RESILVER ? "resilver" : "scrub", 1640fa9e4066Sahrens spa->spa_scrub_maxtxg, complete ? "done" : "FAILED", 1641fa9e4066Sahrens error, spa->spa_scrub_errors, spa->spa_scrub_stop); 1642fa9e4066Sahrens 1643fa9e4066Sahrens mutex_exit(&spa->spa_scrub_lock); 1644fa9e4066Sahrens 1645fa9e4066Sahrens /* 1646fa9e4066Sahrens * If the scrub/resilver completed, update all DTLs to reflect this. 1647fa9e4066Sahrens * Whether it succeeded or not, vacate all temporary scrub DTLs. 1648fa9e4066Sahrens */ 1649*ea8dc4b6Seschrock spa_config_enter(spa, RW_WRITER, FTAG); 1650fa9e4066Sahrens vdev_dtl_reassess(rvd, spa_last_synced_txg(spa) + 1, 1651fa9e4066Sahrens complete ? spa->spa_scrub_maxtxg : 0, B_TRUE); 1652fa9e4066Sahrens vdev_scrub_stat_update(rvd, POOL_SCRUB_NONE, complete); 1653*ea8dc4b6Seschrock spa_errlog_rotate(spa); 1654*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 1655fa9e4066Sahrens 1656fa9e4066Sahrens mutex_enter(&spa->spa_scrub_lock); 1657fa9e4066Sahrens 1658*ea8dc4b6Seschrock /* 1659*ea8dc4b6Seschrock * We may have finished replacing a device. 1660*ea8dc4b6Seschrock * Let the async thread assess this and handle the detach. 1661*ea8dc4b6Seschrock */ 1662*ea8dc4b6Seschrock spa_async_request(spa, SPA_ASYNC_REPLACE_DONE); 1663fa9e4066Sahrens 1664fa9e4066Sahrens /* 1665fa9e4066Sahrens * If we were told to restart, our final act is to start a new scrub. 1666fa9e4066Sahrens */ 1667fa9e4066Sahrens if (error == ERESTART) 1668*ea8dc4b6Seschrock spa_async_request(spa, scrub_type == POOL_SCRUB_RESILVER ? 1669*ea8dc4b6Seschrock SPA_ASYNC_RESILVER : SPA_ASYNC_SCRUB); 1670fa9e4066Sahrens 1671*ea8dc4b6Seschrock spa->spa_scrub_type = POOL_SCRUB_NONE; 1672*ea8dc4b6Seschrock spa->spa_scrub_active = 0; 1673*ea8dc4b6Seschrock spa->spa_scrub_thread = NULL; 1674*ea8dc4b6Seschrock cv_broadcast(&spa->spa_scrub_cv); 1675fa9e4066Sahrens CALLB_CPR_EXIT(&cprinfo); /* drops &spa->spa_scrub_lock */ 1676fa9e4066Sahrens thread_exit(); 1677fa9e4066Sahrens } 1678fa9e4066Sahrens 1679fa9e4066Sahrens void 1680fa9e4066Sahrens spa_scrub_suspend(spa_t *spa) 1681fa9e4066Sahrens { 1682fa9e4066Sahrens mutex_enter(&spa->spa_scrub_lock); 1683*ea8dc4b6Seschrock spa->spa_scrub_suspended++; 1684fa9e4066Sahrens while (spa->spa_scrub_active) { 1685fa9e4066Sahrens cv_broadcast(&spa->spa_scrub_cv); 1686fa9e4066Sahrens cv_wait(&spa->spa_scrub_cv, &spa->spa_scrub_lock); 1687fa9e4066Sahrens } 1688fa9e4066Sahrens while (spa->spa_scrub_inflight) 1689fa9e4066Sahrens cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock); 1690fa9e4066Sahrens mutex_exit(&spa->spa_scrub_lock); 1691fa9e4066Sahrens } 1692fa9e4066Sahrens 1693fa9e4066Sahrens void 1694fa9e4066Sahrens spa_scrub_resume(spa_t *spa) 1695fa9e4066Sahrens { 1696fa9e4066Sahrens mutex_enter(&spa->spa_scrub_lock); 1697*ea8dc4b6Seschrock ASSERT(spa->spa_scrub_suspended != 0); 1698*ea8dc4b6Seschrock if (--spa->spa_scrub_suspended == 0) 1699fa9e4066Sahrens cv_broadcast(&spa->spa_scrub_cv); 1700fa9e4066Sahrens mutex_exit(&spa->spa_scrub_lock); 1701fa9e4066Sahrens } 1702fa9e4066Sahrens 1703fa9e4066Sahrens void 1704fa9e4066Sahrens spa_scrub_restart(spa_t *spa, uint64_t txg) 1705fa9e4066Sahrens { 1706fa9e4066Sahrens /* 1707fa9e4066Sahrens * Something happened (e.g. snapshot create/delete) that means 1708fa9e4066Sahrens * we must restart any in-progress scrubs. The itinerary will 1709fa9e4066Sahrens * fix this properly. 1710fa9e4066Sahrens */ 1711fa9e4066Sahrens mutex_enter(&spa->spa_scrub_lock); 1712fa9e4066Sahrens spa->spa_scrub_restart_txg = txg; 1713fa9e4066Sahrens mutex_exit(&spa->spa_scrub_lock); 1714fa9e4066Sahrens } 1715fa9e4066Sahrens 1716*ea8dc4b6Seschrock int 1717*ea8dc4b6Seschrock spa_scrub(spa_t *spa, pool_scrub_type_t type, boolean_t force) 1718fa9e4066Sahrens { 1719fa9e4066Sahrens space_seg_t *ss; 1720fa9e4066Sahrens uint64_t mintxg, maxtxg; 1721fa9e4066Sahrens vdev_t *rvd = spa->spa_root_vdev; 1722*ea8dc4b6Seschrock int advance = ADVANCE_PRE | ADVANCE_ZIL; 1723fa9e4066Sahrens 1724fa9e4066Sahrens if ((uint_t)type >= POOL_SCRUB_TYPES) 1725fa9e4066Sahrens return (ENOTSUP); 1726fa9e4066Sahrens 1727*ea8dc4b6Seschrock mutex_enter(&spa->spa_scrub_lock); 1728*ea8dc4b6Seschrock 1729fa9e4066Sahrens /* 1730fa9e4066Sahrens * If there's a scrub or resilver already in progress, stop it. 1731fa9e4066Sahrens */ 1732fa9e4066Sahrens while (spa->spa_scrub_thread != NULL) { 1733fa9e4066Sahrens /* 1734fa9e4066Sahrens * Don't stop a resilver unless forced. 1735fa9e4066Sahrens */ 1736*ea8dc4b6Seschrock if (spa->spa_scrub_type == POOL_SCRUB_RESILVER && !force) { 1737*ea8dc4b6Seschrock mutex_exit(&spa->spa_scrub_lock); 1738fa9e4066Sahrens return (EBUSY); 1739*ea8dc4b6Seschrock } 1740fa9e4066Sahrens spa->spa_scrub_stop = 1; 1741fa9e4066Sahrens cv_broadcast(&spa->spa_scrub_cv); 1742fa9e4066Sahrens cv_wait(&spa->spa_scrub_cv, &spa->spa_scrub_lock); 1743fa9e4066Sahrens } 1744fa9e4066Sahrens 1745fa9e4066Sahrens /* 1746fa9e4066Sahrens * Terminate the previous traverse. 1747fa9e4066Sahrens */ 1748fa9e4066Sahrens if (spa->spa_scrub_th != NULL) { 1749fa9e4066Sahrens traverse_fini(spa->spa_scrub_th); 1750fa9e4066Sahrens spa->spa_scrub_th = NULL; 1751fa9e4066Sahrens } 1752fa9e4066Sahrens 1753*ea8dc4b6Seschrock if (rvd == NULL) { 1754*ea8dc4b6Seschrock ASSERT(spa->spa_scrub_stop == 0); 1755*ea8dc4b6Seschrock ASSERT(spa->spa_scrub_type == type); 1756*ea8dc4b6Seschrock ASSERT(spa->spa_scrub_restart_txg == 0); 1757*ea8dc4b6Seschrock mutex_exit(&spa->spa_scrub_lock); 1758*ea8dc4b6Seschrock return (0); 1759*ea8dc4b6Seschrock } 1760fa9e4066Sahrens 1761fa9e4066Sahrens mintxg = TXG_INITIAL - 1; 1762fa9e4066Sahrens maxtxg = spa_last_synced_txg(spa) + 1; 1763fa9e4066Sahrens 1764*ea8dc4b6Seschrock mutex_enter(&rvd->vdev_dtl_lock); 1765fa9e4066Sahrens 1766*ea8dc4b6Seschrock if (rvd->vdev_dtl_map.sm_space == 0) { 1767*ea8dc4b6Seschrock /* 1768*ea8dc4b6Seschrock * The pool-wide DTL is empty. 1769*ea8dc4b6Seschrock * If this is a resilver, there's nothing to do. 1770*ea8dc4b6Seschrock */ 1771*ea8dc4b6Seschrock if (type == POOL_SCRUB_RESILVER) 1772*ea8dc4b6Seschrock type = POOL_SCRUB_NONE; 1773*ea8dc4b6Seschrock } else { 1774*ea8dc4b6Seschrock /* 1775*ea8dc4b6Seschrock * The pool-wide DTL is non-empty. 1776*ea8dc4b6Seschrock * If this is a normal scrub, upgrade to a resilver instead. 1777*ea8dc4b6Seschrock */ 1778*ea8dc4b6Seschrock if (type == POOL_SCRUB_EVERYTHING) 1779*ea8dc4b6Seschrock type = POOL_SCRUB_RESILVER; 1780*ea8dc4b6Seschrock } 1781fa9e4066Sahrens 1782*ea8dc4b6Seschrock if (type == POOL_SCRUB_RESILVER) { 1783fa9e4066Sahrens /* 1784fa9e4066Sahrens * Determine the resilvering boundaries. 1785fa9e4066Sahrens * 1786fa9e4066Sahrens * Note: (mintxg, maxtxg) is an open interval, 1787fa9e4066Sahrens * i.e. mintxg and maxtxg themselves are not included. 1788fa9e4066Sahrens * 1789fa9e4066Sahrens * Note: for maxtxg, we MIN with spa_last_synced_txg(spa) + 1 1790fa9e4066Sahrens * so we don't claim to resilver a txg that's still changing. 1791fa9e4066Sahrens */ 1792fa9e4066Sahrens ss = avl_first(&rvd->vdev_dtl_map.sm_root); 1793*ea8dc4b6Seschrock mintxg = ss->ss_start - 1; 1794fa9e4066Sahrens ss = avl_last(&rvd->vdev_dtl_map.sm_root); 1795*ea8dc4b6Seschrock maxtxg = MIN(ss->ss_end, maxtxg); 1796fa9e4066Sahrens 1797*ea8dc4b6Seschrock advance |= ADVANCE_PRUNE; 1798fa9e4066Sahrens } 1799fa9e4066Sahrens 1800*ea8dc4b6Seschrock mutex_exit(&rvd->vdev_dtl_lock); 1801*ea8dc4b6Seschrock 1802*ea8dc4b6Seschrock spa->spa_scrub_stop = 0; 1803*ea8dc4b6Seschrock spa->spa_scrub_type = type; 1804*ea8dc4b6Seschrock spa->spa_scrub_restart_txg = 0; 1805*ea8dc4b6Seschrock 1806*ea8dc4b6Seschrock if (type != POOL_SCRUB_NONE) { 1807*ea8dc4b6Seschrock spa->spa_scrub_mintxg = mintxg; 1808fa9e4066Sahrens spa->spa_scrub_maxtxg = maxtxg; 1809fa9e4066Sahrens spa->spa_scrub_th = traverse_init(spa, spa_scrub_cb, NULL, 1810fa9e4066Sahrens advance, ZIO_FLAG_CANFAIL); 1811fa9e4066Sahrens traverse_add_pool(spa->spa_scrub_th, mintxg, maxtxg); 1812fa9e4066Sahrens spa->spa_scrub_thread = thread_create(NULL, 0, 1813fa9e4066Sahrens spa_scrub_thread, spa, 0, &p0, TS_RUN, minclsyspri); 1814fa9e4066Sahrens } 1815fa9e4066Sahrens 1816*ea8dc4b6Seschrock mutex_exit(&spa->spa_scrub_lock); 1817*ea8dc4b6Seschrock 1818fa9e4066Sahrens return (0); 1819fa9e4066Sahrens } 1820fa9e4066Sahrens 1821*ea8dc4b6Seschrock /* 1822*ea8dc4b6Seschrock * ========================================================================== 1823*ea8dc4b6Seschrock * SPA async task processing 1824*ea8dc4b6Seschrock * ========================================================================== 1825*ea8dc4b6Seschrock */ 1826*ea8dc4b6Seschrock 1827*ea8dc4b6Seschrock static void 1828*ea8dc4b6Seschrock spa_async_reopen(spa_t *spa) 1829fa9e4066Sahrens { 1830*ea8dc4b6Seschrock vdev_t *rvd = spa->spa_root_vdev; 1831*ea8dc4b6Seschrock vdev_t *tvd; 1832*ea8dc4b6Seschrock int c; 1833fa9e4066Sahrens 1834*ea8dc4b6Seschrock spa_config_enter(spa, RW_WRITER, FTAG); 1835*ea8dc4b6Seschrock 1836*ea8dc4b6Seschrock for (c = 0; c < rvd->vdev_children; c++) { 1837*ea8dc4b6Seschrock tvd = rvd->vdev_child[c]; 1838*ea8dc4b6Seschrock if (tvd->vdev_reopen_wanted) { 1839*ea8dc4b6Seschrock tvd->vdev_reopen_wanted = 0; 1840*ea8dc4b6Seschrock vdev_reopen(tvd); 1841*ea8dc4b6Seschrock } 1842*ea8dc4b6Seschrock } 1843*ea8dc4b6Seschrock 1844*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 1845*ea8dc4b6Seschrock } 1846fa9e4066Sahrens 1847*ea8dc4b6Seschrock static void 1848*ea8dc4b6Seschrock spa_async_thread(spa_t *spa) 1849*ea8dc4b6Seschrock { 1850*ea8dc4b6Seschrock int tasks; 1851*ea8dc4b6Seschrock 1852*ea8dc4b6Seschrock ASSERT(spa->spa_sync_on); 1853*ea8dc4b6Seschrock 1854*ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 1855*ea8dc4b6Seschrock tasks = spa->spa_async_tasks; 1856*ea8dc4b6Seschrock spa->spa_async_tasks = 0; 1857*ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 1858*ea8dc4b6Seschrock 1859*ea8dc4b6Seschrock /* 1860*ea8dc4b6Seschrock * See if any devices need to be reopened. 1861*ea8dc4b6Seschrock */ 1862*ea8dc4b6Seschrock if (tasks & SPA_ASYNC_REOPEN) 1863*ea8dc4b6Seschrock spa_async_reopen(spa); 1864*ea8dc4b6Seschrock 1865*ea8dc4b6Seschrock /* 1866*ea8dc4b6Seschrock * If any devices are done replacing, detach them. 1867*ea8dc4b6Seschrock */ 1868*ea8dc4b6Seschrock if (tasks & SPA_ASYNC_REPLACE_DONE) 1869fa9e4066Sahrens spa_vdev_replace_done(spa); 1870fa9e4066Sahrens 1871*ea8dc4b6Seschrock /* 1872*ea8dc4b6Seschrock * Kick off a scrub. 1873*ea8dc4b6Seschrock */ 1874*ea8dc4b6Seschrock if (tasks & SPA_ASYNC_SCRUB) 1875*ea8dc4b6Seschrock VERIFY(spa_scrub(spa, POOL_SCRUB_EVERYTHING, B_TRUE) == 0); 1876*ea8dc4b6Seschrock 1877*ea8dc4b6Seschrock /* 1878*ea8dc4b6Seschrock * Kick off a resilver. 1879*ea8dc4b6Seschrock */ 1880*ea8dc4b6Seschrock if (tasks & SPA_ASYNC_RESILVER) 1881*ea8dc4b6Seschrock VERIFY(spa_scrub(spa, POOL_SCRUB_RESILVER, B_TRUE) == 0); 1882*ea8dc4b6Seschrock 1883*ea8dc4b6Seschrock /* 1884*ea8dc4b6Seschrock * Let the world know that we're done. 1885*ea8dc4b6Seschrock */ 1886*ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 1887*ea8dc4b6Seschrock spa->spa_async_thread = NULL; 1888*ea8dc4b6Seschrock cv_broadcast(&spa->spa_async_cv); 1889*ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 1890*ea8dc4b6Seschrock thread_exit(); 1891*ea8dc4b6Seschrock } 1892*ea8dc4b6Seschrock 1893*ea8dc4b6Seschrock void 1894*ea8dc4b6Seschrock spa_async_suspend(spa_t *spa) 1895*ea8dc4b6Seschrock { 1896*ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 1897*ea8dc4b6Seschrock spa->spa_async_suspended++; 1898*ea8dc4b6Seschrock while (spa->spa_async_thread != NULL) 1899*ea8dc4b6Seschrock cv_wait(&spa->spa_async_cv, &spa->spa_async_lock); 1900*ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 1901*ea8dc4b6Seschrock } 1902*ea8dc4b6Seschrock 1903*ea8dc4b6Seschrock void 1904*ea8dc4b6Seschrock spa_async_resume(spa_t *spa) 1905*ea8dc4b6Seschrock { 1906*ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 1907*ea8dc4b6Seschrock ASSERT(spa->spa_async_suspended != 0); 1908*ea8dc4b6Seschrock spa->spa_async_suspended--; 1909*ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 1910*ea8dc4b6Seschrock } 1911*ea8dc4b6Seschrock 1912*ea8dc4b6Seschrock static void 1913*ea8dc4b6Seschrock spa_async_dispatch(spa_t *spa) 1914*ea8dc4b6Seschrock { 1915*ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 1916*ea8dc4b6Seschrock if (spa->spa_async_tasks && !spa->spa_async_suspended && 1917*ea8dc4b6Seschrock spa->spa_async_thread == NULL) 1918*ea8dc4b6Seschrock spa->spa_async_thread = thread_create(NULL, 0, 1919*ea8dc4b6Seschrock spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri); 1920*ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 1921*ea8dc4b6Seschrock } 1922*ea8dc4b6Seschrock 1923*ea8dc4b6Seschrock void 1924*ea8dc4b6Seschrock spa_async_request(spa_t *spa, int task) 1925*ea8dc4b6Seschrock { 1926*ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 1927*ea8dc4b6Seschrock spa->spa_async_tasks |= task; 1928*ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 1929fa9e4066Sahrens } 1930fa9e4066Sahrens 1931fa9e4066Sahrens /* 1932fa9e4066Sahrens * ========================================================================== 1933fa9e4066Sahrens * SPA syncing routines 1934fa9e4066Sahrens * ========================================================================== 1935fa9e4066Sahrens */ 1936fa9e4066Sahrens 1937fa9e4066Sahrens static void 1938fa9e4066Sahrens spa_sync_deferred_frees(spa_t *spa, uint64_t txg) 1939fa9e4066Sahrens { 1940fa9e4066Sahrens bplist_t *bpl = &spa->spa_sync_bplist; 1941fa9e4066Sahrens dmu_tx_t *tx; 1942fa9e4066Sahrens blkptr_t blk; 1943fa9e4066Sahrens uint64_t itor = 0; 1944fa9e4066Sahrens zio_t *zio; 1945fa9e4066Sahrens int error; 1946fa9e4066Sahrens uint8_t c = 1; 1947fa9e4066Sahrens 1948fa9e4066Sahrens zio = zio_root(spa, NULL, NULL, ZIO_FLAG_CONFIG_HELD); 1949fa9e4066Sahrens 1950fa9e4066Sahrens while (bplist_iterate(bpl, &itor, &blk) == 0) 1951fa9e4066Sahrens zio_nowait(zio_free(zio, spa, txg, &blk, NULL, NULL)); 1952fa9e4066Sahrens 1953fa9e4066Sahrens error = zio_wait(zio); 1954fa9e4066Sahrens ASSERT3U(error, ==, 0); 1955fa9e4066Sahrens 1956fa9e4066Sahrens tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg); 1957fa9e4066Sahrens bplist_vacate(bpl, tx); 1958fa9e4066Sahrens 1959fa9e4066Sahrens /* 1960fa9e4066Sahrens * Pre-dirty the first block so we sync to convergence faster. 1961fa9e4066Sahrens * (Usually only the first block is needed.) 1962fa9e4066Sahrens */ 1963fa9e4066Sahrens dmu_write(spa->spa_meta_objset, spa->spa_sync_bplist_obj, 0, 1, &c, tx); 1964fa9e4066Sahrens dmu_tx_commit(tx); 1965fa9e4066Sahrens } 1966fa9e4066Sahrens 1967fa9e4066Sahrens static void 1968fa9e4066Sahrens spa_sync_config_object(spa_t *spa, dmu_tx_t *tx) 1969fa9e4066Sahrens { 1970fa9e4066Sahrens nvlist_t *config; 1971fa9e4066Sahrens char *packed = NULL; 1972fa9e4066Sahrens size_t nvsize = 0; 1973fa9e4066Sahrens dmu_buf_t *db; 1974fa9e4066Sahrens 1975fa9e4066Sahrens if (list_is_empty(&spa->spa_dirty_list)) 1976fa9e4066Sahrens return; 1977fa9e4066Sahrens 1978fa9e4066Sahrens config = spa_config_generate(spa, NULL, dmu_tx_get_txg(tx), B_FALSE); 1979fa9e4066Sahrens 1980fa9e4066Sahrens spa_config_set(spa, config); 1981fa9e4066Sahrens 1982fa9e4066Sahrens VERIFY(nvlist_size(config, &nvsize, NV_ENCODE_XDR) == 0); 1983fa9e4066Sahrens 1984fa9e4066Sahrens packed = kmem_alloc(nvsize, KM_SLEEP); 1985fa9e4066Sahrens 1986*ea8dc4b6Seschrock VERIFY(nvlist_pack(config, &packed, &nvsize, NV_ENCODE_XDR, 1987*ea8dc4b6Seschrock KM_SLEEP) == 0); 1988fa9e4066Sahrens 1989fa9e4066Sahrens dmu_write(spa->spa_meta_objset, spa->spa_config_object, 0, nvsize, 1990fa9e4066Sahrens packed, tx); 1991fa9e4066Sahrens 1992fa9e4066Sahrens kmem_free(packed, nvsize); 1993fa9e4066Sahrens 1994*ea8dc4b6Seschrock VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, 1995*ea8dc4b6Seschrock spa->spa_config_object, FTAG, &db)); 1996fa9e4066Sahrens dmu_buf_will_dirty(db, tx); 1997fa9e4066Sahrens *(uint64_t *)db->db_data = nvsize; 1998*ea8dc4b6Seschrock dmu_buf_rele(db, FTAG); 1999fa9e4066Sahrens } 2000fa9e4066Sahrens 2001fa9e4066Sahrens /* 2002fa9e4066Sahrens * Sync the specified transaction group. New blocks may be dirtied as 2003fa9e4066Sahrens * part of the process, so we iterate until it converges. 2004fa9e4066Sahrens */ 2005fa9e4066Sahrens void 2006fa9e4066Sahrens spa_sync(spa_t *spa, uint64_t txg) 2007fa9e4066Sahrens { 2008fa9e4066Sahrens dsl_pool_t *dp = spa->spa_dsl_pool; 2009fa9e4066Sahrens objset_t *mos = spa->spa_meta_objset; 2010fa9e4066Sahrens bplist_t *bpl = &spa->spa_sync_bplist; 2011fa9e4066Sahrens vdev_t *vd; 2012fa9e4066Sahrens dmu_tx_t *tx; 2013fa9e4066Sahrens int dirty_vdevs; 2014fa9e4066Sahrens 2015fa9e4066Sahrens /* 2016fa9e4066Sahrens * Lock out configuration changes. 2017fa9e4066Sahrens */ 2018*ea8dc4b6Seschrock spa_config_enter(spa, RW_READER, FTAG); 2019fa9e4066Sahrens 2020fa9e4066Sahrens spa->spa_syncing_txg = txg; 2021fa9e4066Sahrens spa->spa_sync_pass = 0; 2022fa9e4066Sahrens 2023*ea8dc4b6Seschrock VERIFY(0 == bplist_open(bpl, mos, spa->spa_sync_bplist_obj)); 2024fa9e4066Sahrens 2025fa9e4066Sahrens /* 2026fa9e4066Sahrens * If anything has changed in this txg, push the deferred frees 2027fa9e4066Sahrens * from the previous txg. If not, leave them alone so that we 2028fa9e4066Sahrens * don't generate work on an otherwise idle system. 2029fa9e4066Sahrens */ 2030fa9e4066Sahrens if (!txg_list_empty(&dp->dp_dirty_datasets, txg) || 2031fa9e4066Sahrens !txg_list_empty(&dp->dp_dirty_dirs, txg)) 2032fa9e4066Sahrens spa_sync_deferred_frees(spa, txg); 2033fa9e4066Sahrens 2034fa9e4066Sahrens /* 2035fa9e4066Sahrens * Iterate to convergence. 2036fa9e4066Sahrens */ 2037fa9e4066Sahrens do { 2038fa9e4066Sahrens spa->spa_sync_pass++; 2039fa9e4066Sahrens 2040fa9e4066Sahrens tx = dmu_tx_create_assigned(dp, txg); 2041fa9e4066Sahrens spa_sync_config_object(spa, tx); 2042fa9e4066Sahrens dmu_tx_commit(tx); 2043fa9e4066Sahrens 2044*ea8dc4b6Seschrock spa_errlog_sync(spa, txg); 2045*ea8dc4b6Seschrock 2046fa9e4066Sahrens dsl_pool_sync(dp, txg); 2047fa9e4066Sahrens 2048fa9e4066Sahrens dirty_vdevs = 0; 2049fa9e4066Sahrens while (vd = txg_list_remove(&spa->spa_vdev_txg_list, txg)) { 2050fa9e4066Sahrens vdev_sync(vd, txg); 2051fa9e4066Sahrens dirty_vdevs++; 2052fa9e4066Sahrens } 2053fa9e4066Sahrens 2054fa9e4066Sahrens tx = dmu_tx_create_assigned(dp, txg); 2055fa9e4066Sahrens bplist_sync(bpl, tx); 2056fa9e4066Sahrens dmu_tx_commit(tx); 2057fa9e4066Sahrens 2058fa9e4066Sahrens } while (dirty_vdevs); 2059fa9e4066Sahrens 2060fa9e4066Sahrens bplist_close(bpl); 2061fa9e4066Sahrens 2062fa9e4066Sahrens dprintf("txg %llu passes %d\n", txg, spa->spa_sync_pass); 2063fa9e4066Sahrens 2064fa9e4066Sahrens /* 2065fa9e4066Sahrens * Rewrite the vdev configuration (which includes the uberblock) 2066fa9e4066Sahrens * to commit the transaction group. 2067fa9e4066Sahrens */ 2068*ea8dc4b6Seschrock VERIFY(0 == spa_sync_labels(spa, txg)); 2069fa9e4066Sahrens 2070fa9e4066Sahrens /* 2071fa9e4066Sahrens * Make a stable copy of the fully synced uberblock. 2072fa9e4066Sahrens * We use this as the root for pool traversals. 2073fa9e4066Sahrens */ 2074fa9e4066Sahrens spa->spa_traverse_wanted = 1; /* tells traverse_more() to stop */ 2075fa9e4066Sahrens 2076fa9e4066Sahrens spa_scrub_suspend(spa); /* stop scrubbing and finish I/Os */ 2077fa9e4066Sahrens 2078fa9e4066Sahrens rw_enter(&spa->spa_traverse_lock, RW_WRITER); 2079fa9e4066Sahrens spa->spa_traverse_wanted = 0; 2080fa9e4066Sahrens spa->spa_ubsync = spa->spa_uberblock; 2081fa9e4066Sahrens rw_exit(&spa->spa_traverse_lock); 2082fa9e4066Sahrens 2083fa9e4066Sahrens spa_scrub_resume(spa); /* resume scrub with new ubsync */ 2084fa9e4066Sahrens 2085fa9e4066Sahrens /* 2086fa9e4066Sahrens * Clean up the ZIL records for the synced txg. 2087fa9e4066Sahrens */ 2088fa9e4066Sahrens dsl_pool_zil_clean(dp); 2089fa9e4066Sahrens 2090fa9e4066Sahrens /* 2091fa9e4066Sahrens * Update usable space statistics. 2092fa9e4066Sahrens */ 2093fa9e4066Sahrens while (vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg))) 2094fa9e4066Sahrens vdev_sync_done(vd, txg); 2095fa9e4066Sahrens 2096fa9e4066Sahrens /* 2097fa9e4066Sahrens * It had better be the case that we didn't dirty anything 2098fa9e4066Sahrens * since spa_sync_labels(). 2099fa9e4066Sahrens */ 2100fa9e4066Sahrens ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg)); 2101fa9e4066Sahrens ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg)); 2102fa9e4066Sahrens ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg)); 2103fa9e4066Sahrens ASSERT(bpl->bpl_queue == NULL); 2104fa9e4066Sahrens 2105*ea8dc4b6Seschrock spa_config_exit(spa, FTAG); 2106*ea8dc4b6Seschrock 2107*ea8dc4b6Seschrock /* 2108*ea8dc4b6Seschrock * If any async tasks have been requested, kick them off. 2109*ea8dc4b6Seschrock */ 2110*ea8dc4b6Seschrock spa_async_dispatch(spa); 2111fa9e4066Sahrens } 2112fa9e4066Sahrens 2113fa9e4066Sahrens /* 2114fa9e4066Sahrens * Sync all pools. We don't want to hold the namespace lock across these 2115fa9e4066Sahrens * operations, so we take a reference on the spa_t and drop the lock during the 2116fa9e4066Sahrens * sync. 2117fa9e4066Sahrens */ 2118fa9e4066Sahrens void 2119fa9e4066Sahrens spa_sync_allpools(void) 2120fa9e4066Sahrens { 2121fa9e4066Sahrens spa_t *spa = NULL; 2122fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 2123fa9e4066Sahrens while ((spa = spa_next(spa)) != NULL) { 2124fa9e4066Sahrens if (spa_state(spa) != POOL_STATE_ACTIVE) 2125fa9e4066Sahrens continue; 2126fa9e4066Sahrens spa_open_ref(spa, FTAG); 2127fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 2128fa9e4066Sahrens txg_wait_synced(spa_get_dsl(spa), 0); 2129fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 2130fa9e4066Sahrens spa_close(spa, FTAG); 2131fa9e4066Sahrens } 2132fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 2133fa9e4066Sahrens } 2134fa9e4066Sahrens 2135fa9e4066Sahrens /* 2136fa9e4066Sahrens * ========================================================================== 2137fa9e4066Sahrens * Miscellaneous routines 2138fa9e4066Sahrens * ========================================================================== 2139fa9e4066Sahrens */ 2140fa9e4066Sahrens 2141fa9e4066Sahrens int 2142fa9e4066Sahrens spa_busy(void) 2143fa9e4066Sahrens { 2144fa9e4066Sahrens return (spa_active_count != 0); 2145fa9e4066Sahrens } 2146fa9e4066Sahrens 2147fa9e4066Sahrens /* 2148fa9e4066Sahrens * Remove all pools in the system. 2149fa9e4066Sahrens */ 2150fa9e4066Sahrens void 2151fa9e4066Sahrens spa_evict_all(void) 2152fa9e4066Sahrens { 2153fa9e4066Sahrens spa_t *spa; 2154fa9e4066Sahrens 2155fa9e4066Sahrens /* 2156fa9e4066Sahrens * Remove all cached state. All pools should be closed now, 2157fa9e4066Sahrens * so every spa in the AVL tree should be unreferenced. 2158fa9e4066Sahrens */ 2159fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 2160fa9e4066Sahrens while ((spa = spa_next(NULL)) != NULL) { 2161fa9e4066Sahrens /* 2162*ea8dc4b6Seschrock * Stop async tasks. The async thread may need to detach 2163*ea8dc4b6Seschrock * a device that's been replaced, which requires grabbing 2164*ea8dc4b6Seschrock * spa_namespace_lock, so we must drop it here. 2165fa9e4066Sahrens */ 2166fa9e4066Sahrens spa_open_ref(spa, FTAG); 2167fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 2168*ea8dc4b6Seschrock spa_async_suspend(spa); 2169fa9e4066Sahrens VERIFY(spa_scrub(spa, POOL_SCRUB_NONE, B_TRUE) == 0); 2170fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 2171fa9e4066Sahrens spa_close(spa, FTAG); 2172fa9e4066Sahrens 2173fa9e4066Sahrens if (spa->spa_state != POOL_STATE_UNINITIALIZED) { 2174fa9e4066Sahrens spa_unload(spa); 2175fa9e4066Sahrens spa_deactivate(spa); 2176fa9e4066Sahrens } 2177fa9e4066Sahrens spa_remove(spa); 2178fa9e4066Sahrens } 2179fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 2180fa9e4066Sahrens } 2181*ea8dc4b6Seschrock 2182*ea8dc4b6Seschrock vdev_t * 2183*ea8dc4b6Seschrock spa_lookup_by_guid(spa_t *spa, uint64_t guid) 2184*ea8dc4b6Seschrock { 2185*ea8dc4b6Seschrock return (vdev_lookup_by_guid(spa->spa_root_vdev, guid)); 2186*ea8dc4b6Seschrock } 2187