Lines Matching defs:spa
145 static boolean_t spa_has_active_shared_spare(spa_t *spa);
146 static int spa_load_impl(spa_t *spa, uint64_t, nvlist_t *config,
149 static void spa_vdev_resilver_done(spa_t *spa);
194 * Get property values from the spa configuration.
197 spa_prop_get_config(spa_t *spa, nvlist_t **nvp)
199 vdev_t *rvd = spa->spa_root_vdev;
200 dsl_pool_t *pool = spa->spa_dsl_pool;
204 metaslab_class_t *mc = spa_normal_class(spa);
206 ASSERT(MUTEX_HELD(&spa->spa_props_lock));
209 alloc = metaslab_class_get_alloc(spa_normal_class(spa));
210 size = metaslab_class_get_space(spa_normal_class(spa));
211 spa_prop_add_list(*nvp, ZPOOL_PROP_NAME, spa_name(spa), 0, src);
222 (spa_mode(spa) == FREAD), src);
228 ddt_get_pool_dedup_ratio(spa), src);
233 version = spa_version(spa);
265 spa_prop_add_list(*nvp, ZPOOL_PROP_GUID, NULL, spa_guid(spa), src);
267 if (spa->spa_comment != NULL) {
268 spa_prop_add_list(*nvp, ZPOOL_PROP_COMMENT, spa->spa_comment,
272 if (spa->spa_root != NULL)
273 spa_prop_add_list(*nvp, ZPOOL_PROP_ALTROOT, spa->spa_root,
276 if (spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_BLOCKS)) {
284 if ((dp = list_head(&spa->spa_config_list)) != NULL) {
299 spa_prop_get(spa_t *spa, nvlist_t **nvp)
301 objset_t *mos = spa->spa_meta_objset;
308 mutex_enter(&spa->spa_props_lock);
311 * Get properties from the spa config.
313 spa_prop_get_config(spa, nvp);
316 if (mos == NULL || spa->spa_pool_props_object == 0) {
317 mutex_exit(&spa->spa_props_lock);
324 for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object);
346 dp = spa_get_dsl(spa);
374 err = zap_lookup(mos, spa->spa_pool_props_object,
389 mutex_exit(&spa->spa_props_lock);
405 spa_prop_validate(spa_t *spa, nvlist_t *props)
456 (intval < spa_version(spa) ||
477 if (spa_version(spa) < SPA_VERSION_BOOTFS) {
485 if (!vdev_is_bootable(spa->spa_root_vdev)) {
544 if (!error && spa_suspended(spa)) {
545 spa->spa_failmode = intval;
593 if (spa_version(spa) < SPA_VERSION_DEDUP)
621 spa_configfile_set(spa_t *spa, nvlist_t *nvp, boolean_t need_sync)
640 list_insert_head(&spa->spa_config_list, dp);
642 spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
646 spa_prop_set(spa_t *spa, nvlist_t *nvp)
652 if ((error = spa_prop_validate(spa, nvp)) != 0)
675 if (ver == spa_version(spa))
684 error = dsl_sync_task(spa->spa_name, NULL,
697 return (dsl_sync_task(spa->spa_name, NULL, spa_sync_props,
708 spa_prop_clear_bootfs(spa_t *spa, uint64_t dsobj, dmu_tx_t *tx)
710 if (spa->spa_bootfs == dsobj && spa->spa_pool_props_object != 0) {
711 VERIFY(zap_remove(spa->spa_meta_objset,
712 spa->spa_pool_props_object,
714 spa->spa_bootfs = 0;
723 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
724 vdev_t *rvd = spa->spa_root_vdev;
727 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
729 spa_config_exit(spa, SCL_STATE, FTAG);
734 ASSERT3U(spa_guid(spa), !=, *newguid);
743 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
745 vdev_t *rvd = spa->spa_root_vdev;
747 oldguid = spa_guid(spa);
749 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
753 spa_config_exit(spa, SCL_STATE, FTAG);
755 spa_history_log_internal(spa, "guid change", tx, "old=%llu new=%llu",
769 spa_change_guid(spa_t *spa)
774 mutex_enter(&spa->spa_vdev_top_lock);
778 error = dsl_sync_task(spa->spa_name, spa_change_guid_check,
782 spa_config_sync(spa, B_FALSE, B_TRUE);
783 spa_event_notify(spa, NULL, ESC_ZFS_POOL_REGUID);
787 mutex_exit(&spa->spa_vdev_top_lock);
821 spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub)
823 ASSERT(MUTEX_HELD(&spa->spa_errlist_lock));
825 bcopy(&spa->spa_errlist_last, last, sizeof (avl_tree_t));
826 bcopy(&spa->spa_errlist_scrub, scrub, sizeof (avl_tree_t));
828 avl_create(&spa->spa_errlist_scrub,
831 avl_create(&spa->spa_errlist_last,
837 spa_taskqs_init(spa_t *spa, zio_type_t t, zio_taskq_type_t q)
843 spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
889 if (zio_taskq_sysdc && spa->spa_proc != &p0) {
894 spa->spa_proc, zio_taskq_basedc, flags);
906 INT_MAX, spa->spa_proc, flags);
914 spa_taskqs_fini(spa_t *spa, zio_type_t t, zio_taskq_type_t q)
916 spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
939 spa_taskq_dispatch_ent(spa_t *spa, zio_type_t t, zio_taskq_type_t q,
942 spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
958 spa_create_zio_taskqs(spa_t *spa)
962 spa_taskqs_init(spa, t, q);
973 spa_t *spa = arg;
976 CALLB_CPR_INIT(&cprinfo, &spa->spa_proc_lock, callb_generic_cpr,
977 spa->spa_name);
981 "zpool-%s", spa->spa_name);
997 "pset %d\n", spa->spa_name, zio_taskq_psrset_bind);
1010 spa->spa_proc = curproc;
1011 spa->spa_did = curthread->t_did;
1013 spa_create_zio_taskqs(spa);
1015 mutex_enter(&spa->spa_proc_lock);
1016 ASSERT(spa->spa_proc_state == SPA_PROC_CREATED);
1018 spa->spa_proc_state = SPA_PROC_ACTIVE;
1019 cv_broadcast(&spa->spa_proc_cv);
1022 while (spa->spa_proc_state == SPA_PROC_ACTIVE)
1023 cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock);
1024 CALLB_CPR_SAFE_END(&cprinfo, &spa->spa_proc_lock);
1026 ASSERT(spa->spa_proc_state == SPA_PROC_DEACTIVATE);
1027 spa->spa_proc_state = SPA_PROC_GONE;
1028 spa->spa_proc = &p0;
1029 cv_broadcast(&spa->spa_proc_cv);
1041 spa_activate(spa_t *spa, int mode)
1043 ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED);
1045 spa->spa_state = POOL_STATE_ACTIVE;
1046 spa->spa_mode = mode;
1048 spa->spa_normal_class = metaslab_class_create(spa, zfs_metaslab_ops);
1049 spa->spa_log_class = metaslab_class_create(spa, zfs_metaslab_ops);
1052 mutex_enter(&spa->spa_proc_lock);
1053 ASSERT(spa->spa_proc_state == SPA_PROC_NONE);
1054 ASSERT(spa->spa_proc == &p0);
1055 spa->spa_did = 0;
1058 if (spa_create_process && strcmp(spa->spa_name, TRYIMPORT_NAME) != 0) {
1059 if (newproc(spa_thread, (caddr_t)spa, syscid, maxclsyspri,
1061 spa->spa_proc_state = SPA_PROC_CREATED;
1062 while (spa->spa_proc_state == SPA_PROC_CREATED) {
1063 cv_wait(&spa->spa_proc_cv,
1064 &spa->spa_proc_lock);
1066 ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE);
1067 ASSERT(spa->spa_proc != &p0);
1068 ASSERT(spa->spa_did != 0);
1073 spa->spa_name);
1077 mutex_exit(&spa->spa_proc_lock);
1080 if (spa->spa_proc == &p0) {
1081 spa_create_zio_taskqs(spa);
1084 list_create(&spa->spa_config_dirty_list, sizeof (vdev_t),
1086 list_create(&spa->spa_evicting_os_list, sizeof (objset_t),
1088 list_create(&spa->spa_state_dirty_list, sizeof (vdev_t),
1091 txg_list_create(&spa->spa_vdev_txg_list,
1094 avl_create(&spa->spa_errlist_scrub,
1097 avl_create(&spa->spa_errlist_last,
1106 spa_deactivate(spa_t *spa)
1108 ASSERT(spa->spa_sync_on == B_FALSE);
1109 ASSERT(spa->spa_dsl_pool == NULL);
1110 ASSERT(spa->spa_root_vdev == NULL);
1111 ASSERT(spa->spa_async_zio_root == NULL);
1112 ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED);
1114 spa_evicting_os_wait(spa);
1116 txg_list_destroy(&spa->spa_vdev_txg_list);
1118 list_destroy(&spa->spa_config_dirty_list);
1119 list_destroy(&spa->spa_evicting_os_list);
1120 list_destroy(&spa->spa_state_dirty_list);
1124 spa_taskqs_fini(spa, t, q);
1128 metaslab_class_destroy(spa->spa_normal_class);
1129 spa->spa_normal_class = NULL;
1131 metaslab_class_destroy(spa->spa_log_class);
1132 spa->spa_log_class = NULL;
1138 spa_errlog_drain(spa);
1140 avl_destroy(&spa->spa_errlist_scrub);
1141 avl_destroy(&spa->spa_errlist_last);
1143 spa->spa_state = POOL_STATE_UNINITIALIZED;
1145 mutex_enter(&spa->spa_proc_lock);
1146 if (spa->spa_proc_state != SPA_PROC_NONE) {
1147 ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE);
1148 spa->spa_proc_state = SPA_PROC_DEACTIVATE;
1149 cv_broadcast(&spa->spa_proc_cv);
1150 while (spa->spa_proc_state == SPA_PROC_DEACTIVATE) {
1151 ASSERT(spa->spa_proc != &p0);
1152 cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock);
1154 ASSERT(spa->spa_proc_state == SPA_PROC_GONE);
1155 spa->spa_proc_state = SPA_PROC_NONE;
1157 ASSERT(spa->spa_proc == &p0);
1158 mutex_exit(&spa->spa_proc_lock);
1165 if (spa->spa_did != 0) {
1166 thread_join(spa->spa_did);
1167 spa->spa_did = 0;
1178 spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent,
1185 if ((error = vdev_alloc(spa, vdp, nv, parent, id, atype)) != 0)
1205 if ((error = spa_config_parse(spa, &vd, child[c], *vdp, c,
1222 spa_unload(spa_t *spa)
1231 spa_async_suspend(spa);
1236 if (spa->spa_sync_on) {
1237 txg_sync_stop(spa->spa_dsl_pool);
1238 spa->spa_sync_on = B_FALSE;
1244 if (spa->spa_async_zio_root != NULL) {
1246 (void) zio_wait(spa->spa_async_zio_root[i]);
1247 kmem_free(spa->spa_async_zio_root, max_ncpus * sizeof (void *));
1248 spa->spa_async_zio_root = NULL;
1251 bpobj_close(&spa->spa_deferred_bpobj);
1253 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1258 if (spa->spa_root_vdev)
1259 vdev_free(spa->spa_root_vdev);
1260 ASSERT(spa->spa_root_vdev == NULL);
1265 if (spa->spa_dsl_pool) {
1266 dsl_pool_close(spa->spa_dsl_pool);
1267 spa->spa_dsl_pool = NULL;
1268 spa->spa_meta_objset = NULL;
1271 ddt_unload(spa);
1277 spa_l2cache_drop(spa);
1279 for (i = 0; i < spa->spa_spares.sav_count; i++)
1280 vdev_free(spa->spa_spares.sav_vdevs[i]);
1281 if (spa->spa_spares.sav_vdevs) {
1282 kmem_free(spa->spa_spares.sav_vdevs,
1283 spa->spa_spares.sav_count * sizeof (void *));
1284 spa->spa_spares.sav_vdevs = NULL;
1286 if (spa->spa_spares.sav_config) {
1287 nvlist_free(spa->spa_spares.sav_config);
1288 spa->spa_spares.sav_config = NULL;
1290 spa->spa_spares.sav_count = 0;
1292 for (i = 0; i < spa->spa_l2cache.sav_count; i++) {
1293 vdev_clear_stats(spa->spa_l2cache.sav_vdevs[i]);
1294 vdev_free(spa->spa_l2cache.sav_vdevs[i]);
1296 if (spa->spa_l2cache.sav_vdevs) {
1297 kmem_free(spa->spa_l2cache.sav_vdevs,
1298 spa->spa_l2cache.sav_count * sizeof (void *));
1299 spa->spa_l2cache.sav_vdevs = NULL;
1301 if (spa->spa_l2cache.sav_config) {
1302 nvlist_free(spa->spa_l2cache.sav_config);
1303 spa->spa_l2cache.sav_config = NULL;
1305 spa->spa_l2cache.sav_count = 0;
1307 spa->spa_async_suspended = 0;
1309 if (spa->spa_comment != NULL) {
1310 spa_strfree(spa->spa_comment);
1311 spa->spa_comment = NULL;
1314 spa_config_exit(spa, SCL_ALL, FTAG);
1324 spa_load_spares(spa_t *spa)
1331 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
1336 for (i = 0; i < spa->spa_spares.sav_count; i++) {
1337 vd = spa->spa_spares.sav_vdevs[i];
1340 if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
1347 if (spa->spa_spares.sav_vdevs)
1348 kmem_free(spa->spa_spares.sav_vdevs,
1349 spa->spa_spares.sav_count * sizeof (void *));
1351 if (spa->spa_spares.sav_config == NULL)
1354 VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
1357 spa->spa_spares.sav_count = (int)nspares;
1358 spa->spa_spares.sav_vdevs = NULL;
1372 spa->spa_spares.sav_vdevs = kmem_alloc(nspares * sizeof (void *),
1374 for (i = 0; i < spa->spa_spares.sav_count; i++) {
1375 VERIFY(spa_config_parse(spa, &vd, spares[i], NULL, 0,
1379 spa->spa_spares.sav_vdevs[i] = vd;
1381 if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
1404 vd->vdev_aux = &spa->spa_spares;
1417 VERIFY(nvlist_remove(spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES,
1420 spares = kmem_alloc(spa->spa_spares.sav_count * sizeof (void *),
1422 for (i = 0; i < spa->spa_spares.sav_count; i++)
1423 spares[i] = vdev_config_generate(spa,
1424 spa->spa_spares.sav_vdevs[i], B_TRUE, VDEV_CONFIG_SPARE);
1425 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
1426 ZPOOL_CONFIG_SPARES, spares, spa->spa_spares.sav_count) == 0);
1427 for (i = 0; i < spa->spa_spares.sav_count; i++)
1429 kmem_free(spares, spa->spa_spares.sav_count * sizeof (void *));
1441 spa_load_l2cache(spa_t *spa)
1448 spa_aux_vdev_t *sav = &spa->spa_l2cache;
1450 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
1490 VERIFY(spa_config_parse(spa, &vd, l2cache[i], NULL, 0,
1512 l2arc_add_vdev(spa, vd);
1552 l2cache[i] = vdev_config_generate(spa,
1564 load_nvlist(spa_t *spa, uint64_t obj, nvlist_t **value)
1572 error = dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db);
1580 error = dmu_read(spa->spa_meta_objset, obj, 0, nvsize, packed,
1610 spa_config_valid(spa_t *spa, nvlist_t *config)
1612 vdev_t *mrvd, *rvd = spa->spa_root_vdev;
1617 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1618 VERIFY(spa_config_parse(spa, &mrvd, nv, NULL, 0, VDEV_ALLOC_LOAD) == 0);
1627 if (!(spa->spa_import_flags & ZFS_IMPORT_MISSING_LOG)) {
1642 child[idx++] = vdev_config_generate(spa, mtvd,
1649 VERIFY(nvlist_add_nvlist(spa->spa_load_info,
1676 if (!(spa->spa_import_flags & ZFS_IMPORT_MISSING_LOG))
1683 spa_set_log_state(spa, SPA_LOG_CLEAR);
1704 spa_config_exit(spa, SCL_ALL, FTAG);
1706 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1720 spa_config_exit(spa, SCL_ALL, FTAG);
1725 return (rvd->vdev_guid_sum == spa->spa_uberblock.ub_guid_sum);
1732 spa_check_logs(spa_t *spa)
1735 dsl_pool_t *dp = spa_get_dsl(spa);
1737 switch (spa->spa_log_state) {
1744 spa_set_log_state(spa, SPA_LOG_MISSING);
1751 spa_passivate_log(spa_t *spa)
1753 vdev_t *rvd = spa->spa_root_vdev;
1756 ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER));
1758 if (!spa_has_slogs(spa))
1775 spa_activate_log(spa_t *spa)
1777 vdev_t *rvd = spa->spa_root_vdev;
1779 ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER));
1791 spa_offline_log(spa_t *spa)
1795 error = dmu_objset_find(spa_name(spa), zil_vdev_offline,
1803 txg_wait_synced(spa->spa_dsl_pool, 0);
1818 spa_t *spa = zio->io_spa;
1823 mutex_enter(&spa->spa_props_lock); /* any mutex will do */
1824 if (spa->spa_claim_max_txg < zio->io_bp->blk_birth)
1825 spa->spa_claim_max_txg = zio->io_bp->blk_birth;
1826 mutex_exit(&spa->spa_props_lock);
1841 spa_t *spa = zio->io_spa;
1852 mutex_enter(&spa->spa_scrub_lock);
1853 spa->spa_scrub_inflight--;
1854 cv_broadcast(&spa->spa_scrub_io_cv);
1855 mutex_exit(&spa->spa_scrub_lock);
1868 spa_load_verify_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
1887 mutex_enter(&spa->spa_scrub_lock);
1888 while (spa->spa_scrub_inflight >= spa_load_verify_maxinflight)
1889 cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
1890 spa->spa_scrub_inflight++;
1891 mutex_exit(&spa->spa_scrub_lock);
1893 zio_nowait(zio_read(rio, spa, bp, data, size,
1901 spa_load_verify(spa_t *spa)
1909 zpool_get_rewind_policy(spa->spa_config, &policy);
1914 rio = zio_root(spa, NULL, &sle,
1918 error = traverse_pool(spa, spa->spa_verify_min_txg,
1925 spa->spa_load_meta_errors = sle.sle_meta_count;
1926 spa->spa_load_data_errors = sle.sle_data_count;
1933 spa->spa_load_txg = spa->spa_uberblock.ub_txg;
1934 spa->spa_load_txg_ts = spa->spa_uberblock.ub_timestamp;
1936 loss = spa->spa_last_ubsync_txg_ts - spa->spa_load_txg_ts;
1937 VERIFY(nvlist_add_uint64(spa->spa_load_info,
1938 ZPOOL_CONFIG_LOAD_TIME, spa->spa_load_txg_ts) == 0);
1939 VERIFY(nvlist_add_int64(spa->spa_load_info,
1941 VERIFY(nvlist_add_uint64(spa->spa_load_info,
1944 spa->spa_load_max_txg = spa->spa_uberblock.ub_txg;
1960 spa_prop_find(spa_t *spa, zpool_prop_t prop, uint64_t *val)
1962 (void) zap_lookup(spa->spa_meta_objset, spa->spa_pool_props_object,
1970 spa_dir_prop(spa_t *spa, const char *name, uint64_t *val)
1972 return (zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
2000 spa_try_repair(spa_t *spa, nvlist_t *config)
2025 vd[i] = spa_lookup_by_guid(spa, glist[i], B_FALSE);
2039 vdev_reopen(spa->spa_root_vdev);
2059 vdev_reopen(spa->spa_root_vdev);
2066 spa_load(spa_t *spa, spa_load_state_t state, spa_import_type_t type,
2069 nvlist_t *config = spa->spa_config;
2079 ASSERT(spa->spa_comment == NULL);
2081 spa->spa_comment = spa_strdup(comment);
2088 &spa->spa_ubsync.ub_version) != 0)
2089 spa->spa_ubsync.ub_version = SPA_VERSION_INITIAL;
2092 &spa->spa_config_txg);
2098 spa->spa_config_guid = pool_guid;
2102 VERIFY(nvlist_dup(nvl, &spa->spa_config_splitting,
2106 nvlist_free(spa->spa_load_info);
2107 spa->spa_load_info = fnvlist_alloc();
2109 gethrestime(&spa->spa_loaded_ts);
2110 error = spa_load_impl(spa, pool_guid, config, state, type,
2118 spa_evicting_os_wait(spa);
2119 spa->spa_minref = refcount_count(&spa->spa_refcount);
2122 spa->spa_loaded_ts.tv_sec = 0;
2123 spa->spa_loaded_ts.tv_nsec = 0;
2126 zfs_ereport_post(ereport, spa, NULL, NULL, 0, 0);
2129 spa->spa_load_state = error ? SPA_LOAD_ERROR : SPA_LOAD_NONE;
2130 spa->spa_ena = 0;
2140 spa_load_impl(spa_t *spa, uint64_t pool_guid, nvlist_t *config,
2148 uberblock_t *ub = &spa->spa_uberblock;
2149 uint64_t children, config_cache_txg = spa->spa_config_txg;
2150 int orig_mode = spa->spa_mode;
2160 spa->spa_mode = FREAD;
2164 spa->spa_load_state = state;
2175 spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *),
2178 spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
2188 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2189 error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, parse);
2190 spa_config_exit(spa, SCL_ALL, FTAG);
2195 ASSERT(spa->spa_root_vdev == rvd);
2196 ASSERT3U(spa->spa_min_ashift, >=, SPA_MINBLOCKSHIFT);
2197 ASSERT3U(spa->spa_max_ashift, <=, SPA_MAXBLOCKSHIFT);
2200 ASSERT(spa_guid(spa) == pool_guid);
2206 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2208 spa_config_exit(spa, SCL_ALL, FTAG);
2226 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2228 spa_config_exit(spa, SCL_ALL, FTAG);
2276 nvlist_free(spa->spa_label_features);
2277 VERIFY(nvlist_dup(features, &spa->spa_label_features, 0) == 0);
2293 for (nvpair_t *nvp = nvlist_next_nvpair(spa->spa_label_features,
2295 nvp = nvlist_next_nvpair(spa->spa_label_features, nvp)) {
2303 VERIFY(nvlist_add_nvlist(spa->spa_load_info,
2325 if (type != SPA_IMPORT_ASSEMBLE && spa->spa_config_splitting) {
2326 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2327 spa_try_repair(spa, config);
2328 spa_config_exit(spa, SCL_ALL, FTAG);
2329 nvlist_free(spa->spa_config_splitting);
2330 spa->spa_config_splitting = NULL;
2336 spa->spa_state = POOL_STATE_ACTIVE;
2337 spa->spa_ubsync = spa->spa_uberblock;
2338 spa->spa_verify_min_txg = spa->spa_extreme_rewind ?
2339 TXG_INITIAL - 1 : spa_last_synced_txg(spa) - TXG_DEFER_SIZE - 1;
2340 spa->spa_first_txg = spa->spa_last_ubsync_txg ?
2341 spa->spa_last_ubsync_txg : spa_last_synced_txg(spa) + 1;
2342 spa->spa_claim_max_txg = spa->spa_first_txg;
2343 spa->spa_prev_software_version = ub->ub_software_version;
2345 error = dsl_pool_init(spa, spa->spa_first_txg, &spa->spa_dsl_pool);
2348 spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset;
2350 if (spa_dir_prop(spa, DMU_POOL_CONFIG, &spa->spa_config_object) != 0)
2353 if (spa_version(spa) >= SPA_VERSION_FEATURES) {
2357 if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_READ,
2358 &spa->spa_feat_for_read_obj) != 0) {
2362 if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_WRITE,
2363 &spa->spa_feat_for_write_obj) != 0) {
2367 if (spa_dir_prop(spa, DMU_POOL_FEATURE_DESCRIPTIONS,
2368 &spa->spa_feat_desc_obj) != 0) {
2375 if (!spa_features_check(spa, B_FALSE,
2379 if (spa_writeable(spa) || state == SPA_LOAD_TRYIMPORT) {
2380 if (!spa_features_check(spa, B_TRUE,
2386 fnvlist_add_nvlist(spa->spa_load_info,
2390 fnvlist_add_nvlist(spa->spa_load_info,
2398 fnvlist_add_boolean(spa->spa_load_info,
2422 spa_writeable(spa))) {
2434 error = feature_get_refcount_from_disk(spa,
2437 spa->spa_feat_refcount_cache[i] = refcount;
2439 spa->spa_feat_refcount_cache[i] =
2448 if (spa_feature_is_active(spa, SPA_FEATURE_ENABLED_TXG)) {
2449 if (spa_dir_prop(spa, DMU_POOL_FEATURE_ENABLED_TXG,
2450 &spa->spa_feat_enabled_txg_obj) != 0)
2454 spa->spa_is_initializing = B_TRUE;
2455 error = dsl_pool_open(spa->spa_dsl_pool);
2456 spa->spa_is_initializing = B_FALSE;
2464 if (load_nvlist(spa, spa->spa_config_object, &nvconfig) != 0)
2467 if (!spa_is_root(spa) && nvlist_lookup_uint64(nvconfig,
2491 spa_name(spa), hostname,
2496 if (nvlist_lookup_nvlist(spa->spa_config,
2501 spa_config_set(spa, nvconfig);
2502 spa_unload(spa);
2503 spa_deactivate(spa);
2504 spa_activate(spa, orig_mode);
2506 return (spa_load(spa, state, SPA_IMPORT_EXISTING, B_TRUE));
2510 error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
2512 sizeof (spa->spa_cksum_salt.zcs_bytes),
2513 spa->spa_cksum_salt.zcs_bytes);
2516 (void) random_get_pseudo_bytes(spa->spa_cksum_salt.zcs_bytes,
2517 sizeof (spa->spa_cksum_salt.zcs_bytes));
2522 if (spa_dir_prop(spa, DMU_POOL_SYNC_BPOBJ, &obj) != 0)
2524 error = bpobj_open(&spa->spa_deferred_bpobj, spa->spa_meta_objset, obj);
2533 error = spa_dir_prop(spa, DMU_POOL_DEFLATE, &spa->spa_deflate);
2537 error = spa_dir_prop(spa, DMU_POOL_CREATION_VERSION,
2538 &spa->spa_creation_version);
2546 error = spa_dir_prop(spa, DMU_POOL_ERRLOG_LAST, &spa->spa_errlog_last);
2550 error = spa_dir_prop(spa, DMU_POOL_ERRLOG_SCRUB,
2551 &spa->spa_errlog_scrub);
2559 error = spa_dir_prop(spa, DMU_POOL_HISTORY, &spa->spa_history);
2572 error = spa_dir_prop(spa, DMU_POOL_SPARES, &spa->spa_spares.sav_object);
2576 ASSERT(spa_version(spa) >= SPA_VERSION_SPARES);
2577 if (load_nvlist(spa, spa->spa_spares.sav_object,
2578 &spa->spa_spares.sav_config) != 0)
2581 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2582 spa_load_spares(spa);
2583 spa_config_exit(spa, SCL_ALL, FTAG);
2585 spa->spa_spares.sav_sync = B_TRUE;
2591 error = spa_dir_prop(spa, DMU_POOL_L2CACHE,
2592 &spa->spa_l2cache.sav_object);
2596 ASSERT(spa_version(spa) >= SPA_VERSION_L2CACHE);
2597 if (load_nvlist(spa, spa->spa_l2cache.sav_object,
2598 &spa->spa_l2cache.sav_config) != 0)
2601 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2602 spa_load_l2cache(spa);
2603 spa_config_exit(spa, SCL_ALL, FTAG);
2605 spa->spa_l2cache.sav_sync = B_TRUE;
2608 spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);
2610 error = spa_dir_prop(spa, DMU_POOL_PROPS, &spa->spa_pool_props_object);
2617 spa_prop_find(spa, ZPOOL_PROP_BOOTFS, &spa->spa_bootfs);
2618 spa_prop_find(spa, ZPOOL_PROP_AUTOREPLACE, &autoreplace);
2619 spa_prop_find(spa, ZPOOL_PROP_DELEGATION, &spa->spa_delegation);
2620 spa_prop_find(spa, ZPOOL_PROP_FAILUREMODE, &spa->spa_failmode);
2621 spa_prop_find(spa, ZPOOL_PROP_AUTOEXPAND, &spa->spa_autoexpand);
2622 spa_prop_find(spa, ZPOOL_PROP_DEDUPDITTO,
2623 &spa->spa_dedup_ditto);
2625 spa->spa_autoreplace = (autoreplace != 0);
2635 if (spa->spa_autoreplace && state != SPA_LOAD_TRYIMPORT) {
2636 spa_check_removed(spa->spa_root_vdev);
2643 spa_aux_check_removed(&spa->spa_spares);
2644 spa_aux_check_removed(&spa->spa_l2cache);
2656 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2658 spa_config_exit(spa, SCL_ALL, FTAG);
2663 error = ddt_load(spa);
2667 spa_update_dspace(spa);
2679 if (load_nvlist(spa, spa->spa_config_object, &nvconfig) != 0)
2682 if (!spa_config_valid(spa, nvconfig)) {
2697 if (spa_writeable(spa) && spa_check_logs(spa)) {
2719 if (error = spa_load_verify(spa))
2724 if (spa_writeable(spa) && (state == SPA_LOAD_RECOVER ||
2725 spa->spa_load_max_txg == UINT64_MAX)) {
2728 dsl_pool_t *dp = spa_get_dsl(spa);
2739 spa->spa_claiming = B_TRUE;
2741 tx = dmu_tx_create_assigned(dp, spa_first_txg(spa));
2746 spa->spa_claiming = B_FALSE;
2748 spa_set_log_state(spa, SPA_LOG_GOOD);
2749 spa->spa_sync_on = B_TRUE;
2750 txg_sync_start(spa->spa_dsl_pool);
2759 txg_wait_synced(spa->spa_dsl_pool, spa->spa_claim_max_txg);
2768 if (config_cache_txg != spa->spa_config_txg ||
2771 (spa->spa_import_flags & ZFS_IMPORT_VERBATIM))
2783 spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
2788 if (!dsl_scan_resilvering(spa->spa_dsl_pool) &&
2790 spa_async_request(spa, SPA_ASYNC_RESILVER);
2796 spa_history_log_version(spa, "open");
2801 (void) dmu_objset_find(spa_name(spa),
2807 dsl_pool_clean_tmp_userrefs(spa->spa_dsl_pool);
2814 spa_load_retry(spa_t *spa, spa_load_state_t state, int mosconfig)
2816 int mode = spa->spa_mode;
2818 spa_unload(spa);
2819 spa_deactivate(spa);
2821 spa->spa_load_max_txg = spa->spa_uberblock.ub_txg - 1;
2823 spa_activate(spa, mode);
2824 spa_async_suspend(spa);
2826 return (spa_load(spa, state, SPA_IMPORT_EXISTING, mosconfig));
2837 spa_load_best(spa_t *spa, spa_load_state_t state, int mosconfig,
2846 if (spa->spa_load_txg && state == SPA_LOAD_RECOVER) {
2847 spa->spa_load_max_txg = spa->spa_load_txg;
2848 spa_set_log_state(spa, SPA_LOG_CLEAR);
2850 spa->spa_load_max_txg = max_request;
2852 spa->spa_extreme_rewind = B_TRUE;
2855 load_error = rewind_error = spa_load(spa, state, SPA_IMPORT_EXISTING,
2860 if (spa->spa_root_vdev != NULL)
2861 config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
2863 spa->spa_last_ubsync_txg = spa->spa_uberblock.ub_txg;
2864 spa->spa_last_ubsync_txg_ts = spa->spa_uberblock.ub_timestamp;
2873 spa_set_log_state(spa, SPA_LOG_CLEAR);
2880 loadinfo = spa->spa_load_info;
2881 spa->spa_load_info = fnvlist_alloc();
2884 spa->spa_load_max_txg = spa->spa_last_ubsync_txg;
2885 safe_rewind_txg = spa->spa_last_ubsync_txg - TXG_DEFER_SIZE;
2893 while (rewind_error && spa->spa_uberblock.ub_txg >= min_txg &&
2894 spa->spa_uberblock.ub_txg <= spa->spa_load_max_txg) {
2895 if (spa->spa_load_max_txg < safe_rewind_txg)
2896 spa->spa_extreme_rewind = B_TRUE;
2897 rewind_error = spa_load_retry(spa, state, mosconfig);
2900 spa->spa_extreme_rewind = B_FALSE;
2901 spa->spa_load_max_txg = UINT64_MAX;
2904 spa_config_set(spa, config);
2912 spa->spa_load_info);
2915 fnvlist_free(spa->spa_load_info);
2916 spa->spa_load_info = loadinfo;
2938 spa_t *spa;
2956 if ((spa = spa_lookup(pool)) == NULL) {
2962 if (spa->spa_state == POOL_STATE_UNINITIALIZED) {
2965 zpool_get_rewind_policy(nvpolicy ? nvpolicy : spa->spa_config,
2970 spa_activate(spa, spa_mode_global);
2973 spa->spa_last_ubsync_txg = spa->spa_load_txg = 0;
2975 error = spa_load_best(spa, state, B_FALSE, policy.zrp_txg,
2986 spa_unload(spa);
2987 spa_deactivate(spa);
2988 spa_config_sync(spa, B_TRUE, B_TRUE);
2989 spa_remove(spa);
3001 if (config != NULL && spa->spa_config) {
3002 VERIFY(nvlist_dup(spa->spa_config, config,
3006 spa->spa_load_info) == 0);
3008 spa_unload(spa);
3009 spa_deactivate(spa);
3010 spa->spa_last_open_failed = error;
3018 spa_open_ref(spa, tag);
3021 *config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
3029 spa->spa_load_info) == 0);
3033 spa->spa_last_open_failed = 0;
3034 spa->spa_last_ubsync_txg = 0;
3035 spa->spa_load_txg = 0;
3039 *spapp = spa;
3064 spa_t *spa;
3067 if ((spa = spa_lookup(name)) == NULL) {
3071 spa->spa_inject_ref++;
3074 return (spa);
3078 spa_inject_delref(spa_t *spa)
3081 spa->spa_inject_ref--;
3089 spa_add_spares(spa_t *spa, nvlist_t *config)
3099 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));
3101 if (spa->spa_spares.sav_count == 0)
3106 VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
3138 spa_add_l2cache(spa_t *spa, nvlist_t *config)
3148 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));
3150 if (spa->spa_l2cache.sav_count == 0)
3155 VERIFY(nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
3172 for (j = 0; j < spa->spa_l2cache.sav_count; j++) {
3174 spa->spa_l2cache.sav_vdevs[j]->vdev_guid) {
3175 vd = spa->spa_l2cache.sav_vdevs[j];
3190 spa_add_feature_stats(spa_t *spa, nvlist_t *config)
3196 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));
3199 if (spa->spa_feat_for_read_obj != 0) {
3200 for (zap_cursor_init(&zc, spa->spa_meta_objset,
3201 spa->spa_feat_for_read_obj);
3212 if (spa->spa_feat_for_write_obj != 0) {
3213 for (zap_cursor_init(&zc, spa->spa_meta_objset,
3214 spa->spa_feat_for_write_obj);
3235 spa_t *spa;
3238 error = spa_open_common(name, &spa, FTAG, NULL, config);
3240 if (spa != NULL) {
3246 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
3251 loadtimes[0] = spa->spa_loaded_ts.tv_sec;
3252 loadtimes[1] = spa->spa_loaded_ts.tv_nsec;
3258 spa_get_errlog_size(spa)) == 0);
3260 if (spa_suspended(spa))
3263 spa->spa_failmode) == 0);
3265 spa_add_spares(spa, *config);
3266 spa_add_l2cache(spa, *config);
3267 spa_add_feature_stats(spa, *config);
3276 if (spa == NULL) {
3278 spa = spa_lookup(name);
3279 if (spa)
3280 spa_altroot(spa, altroot, buflen);
3283 spa = NULL;
3286 spa_altroot(spa, altroot, buflen);
3290 if (spa != NULL) {
3291 spa_config_exit(spa, SCL_CONFIG, FTAG);
3292 spa_close(spa, FTAG);
3305 spa_validate_aux_devs(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode,
3314 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
3329 if (spa_version(spa) < version)
3340 if ((error = spa_config_parse(spa, &vd, dev[i], NULL, 0,
3386 spa_validate_aux(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode)
3390 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
3392 if ((error = spa_validate_aux_devs(spa, nvroot, crtxg, mode,
3393 &spa->spa_spares, ZPOOL_CONFIG_SPARES, SPA_VERSION_SPARES,
3398 return (spa_validate_aux_devs(spa, nvroot, crtxg, mode,
3399 &spa->spa_l2cache, ZPOOL_CONFIG_L2CACHE, SPA_VERSION_L2CACHE,
3453 spa_l2cache_drop(spa_t *spa)
3457 spa_aux_vdev_t *sav = &spa->spa_l2cache;
3478 spa_t *spa;
3504 spa = spa_add(pool, NULL, altroot);
3505 spa_activate(spa, spa_mode_global);
3507 if (props && (error = spa_prop_validate(spa, props))) {
3508 spa_deactivate(spa);
3509 spa_remove(spa);
3527 spa->spa_first_txg = txg;
3528 spa->spa_uberblock.ub_txg = txg - 1;
3529 spa->spa_uberblock.ub_version = version;
3530 spa->spa_ubsync = spa->spa_uberblock;
3535 spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *),
3538 spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
3546 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3548 error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_ADD);
3551 ASSERT(error != 0 || spa->spa_root_vdev == rvd);
3558 (error = spa_validate_aux(spa, nvroot, txg,
3566 spa_config_exit(spa, SCL_ALL, FTAG);
3569 spa_unload(spa);
3570 spa_deactivate(spa);
3571 spa_remove(spa);
3581 VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, NV_UNIQUE_NAME,
3583 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
3585 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3586 spa_load_spares(spa);
3587 spa_config_exit(spa, SCL_ALL, FTAG);
3588 spa->spa_spares.sav_sync = B_TRUE;
3596 VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config,
3598 VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
3600 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3601 spa_load_l2cache(spa);
3602 spa_config_exit(spa, SCL_ALL, FTAG);
3603 spa->spa_l2cache.sav_sync = B_TRUE;
3606 spa->spa_is_initializing = B_TRUE;
3607 spa->spa_dsl_pool = dp = dsl_pool_create(spa, zplprops, txg);
3608 spa->spa_meta_objset = dp->dp_meta_objset;
3609 spa->spa_is_initializing = B_FALSE;
3614 ddt_create(spa);
3616 spa_update_dspace(spa);
3623 spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset,
3627 if (zap_add(spa->spa_meta_objset,
3629 sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) {
3633 if (spa_version(spa) >= SPA_VERSION_FEATURES)
3634 spa_feature_create_zap_objects(spa, tx);
3636 if (zap_add(spa->spa_meta_objset,
3644 spa->spa_deflate = TRUE;
3645 if (zap_add(spa->spa_meta_objset,
3647 sizeof (uint64_t), 1, &spa->spa_deflate, tx) != 0) {
3657 obj = bpobj_alloc(spa->spa_meta_objset, 1 << 14, tx);
3658 dmu_object_set_compress(spa->spa_meta_objset, obj,
3660 if (zap_add(spa->spa_meta_objset,
3665 VERIFY3U(0, ==, bpobj_open(&spa->spa_deferred_bpobj,
3666 spa->spa_meta_objset, obj));
3672 spa_history_create_obj(spa, tx);
3677 (void) random_get_pseudo_bytes(spa->spa_cksum_salt.zcs_bytes,
3678 sizeof (spa->spa_cksum_salt.zcs_bytes));
3683 spa->spa_bootfs = zpool_prop_default_numeric(ZPOOL_PROP_BOOTFS);
3684 spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);
3685 spa->spa_failmode = zpool_prop_default_numeric(ZPOOL_PROP_FAILUREMODE);
3686 spa->spa_autoexpand = zpool_prop_default_numeric(ZPOOL_PROP_AUTOEXPAND);
3689 spa_configfile_set(spa, props, B_FALSE);
3695 spa->spa_sync_on = B_TRUE;
3696 txg_sync_start(spa->spa_dsl_pool);
3702 txg_wait_synced(spa->spa_dsl_pool, txg);
3704 spa_config_sync(spa, B_FALSE, B_TRUE);
3705 spa_event_notify(spa, NULL, ESC_ZFS_POOL_CREATE);
3707 spa_history_log_version(spa, "create");
3713 spa_evicting_os_wait(spa);
3714 spa->spa_minref = refcount_count(&spa->spa_refcount);
3815 spa_t *spa;
3846 if ((spa = spa_lookup(pname)) != NULL) {
3851 spa_remove(spa);
3854 spa = spa_add(pname, config, NULL);
3855 spa->spa_is_root = B_TRUE;
3856 spa->spa_import_flags = ZFS_IMPORT_VERBATIM;
3863 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3864 error = spa_config_parse(spa, &rvd, nvtop, NULL, 0,
3866 spa_config_exit(spa, SCL_ALL, FTAG);
3913 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3915 spa_config_exit(spa, SCL_ALL, FTAG);
3930 spa_t *spa;
3951 * Create and initialize the spa structure.
3959 spa = spa_add(pool, config, altroot);
3960 spa->spa_import_flags = flags;
3966 if (spa->spa_import_flags & ZFS_IMPORT_VERBATIM) {
3968 spa_configfile_set(spa, props, B_FALSE);
3970 spa_config_sync(spa, B_FALSE, B_TRUE);
3971 spa_event_notify(spa, NULL, ESC_ZFS_POOL_IMPORT);
3977 spa_activate(spa, mode);
3982 spa_async_suspend(spa);
3994 spa->spa_last_ubsync_txg = spa->spa_load_txg = 0;
3996 error = spa_load_best(spa, state, B_TRUE, policy.zrp_txg,
4004 spa->spa_load_info) == 0);
4006 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4011 if (spa->spa_spares.sav_config) {
4012 nvlist_free(spa->spa_spares.sav_config);
4013 spa->spa_spares.sav_config = NULL;
4014 spa_load_spares(spa);
4016 if (spa->spa_l2cache.sav_config) {
4017 nvlist_free(spa->spa_l2cache.sav_config);
4018 spa->spa_l2cache.sav_config = NULL;
4019 spa_load_l2cache(spa);
4025 error = spa_validate_aux(spa, nvroot, -1ULL,
4028 error = spa_validate_aux(spa, nvroot, -1ULL,
4030 spa_config_exit(spa, SCL_ALL, FTAG);
4033 spa_configfile_set(spa, props, B_FALSE);
4035 if (error != 0 || (props && spa_writeable(spa) &&
4036 (error = spa_prop_set(spa, props)))) {
4037 spa_unload(spa);
4038 spa_deactivate(spa);
4039 spa_remove(spa);
4044 spa_async_resume(spa);
4052 if (spa->spa_spares.sav_config)
4053 VERIFY(nvlist_remove(spa->spa_spares.sav_config,
4056 VERIFY(nvlist_alloc(&spa->spa_spares.sav_config,
4058 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
4060 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4061 spa_load_spares(spa);
4062 spa_config_exit(spa, SCL_ALL, FTAG);
4063 spa->spa_spares.sav_sync = B_TRUE;
4067 if (spa->spa_l2cache.sav_config)
4068 VERIFY(nvlist_remove(spa->spa_l2cache.sav_config,
4071 VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config,
4073 VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
4075 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4076 spa_load_l2cache(spa);
4077 spa_config_exit(spa, SCL_ALL, FTAG);
4078 spa->spa_l2cache.sav_sync = B_TRUE;
4084 if (spa->spa_autoreplace) {
4085 spa_aux_check_removed(&spa->spa_spares);
4086 spa_aux_check_removed(&spa->spa_l2cache);
4089 if (spa_writeable(spa)) {
4093 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
4100 spa_async_request(spa, SPA_ASYNC_AUTOEXPAND);
4102 spa_history_log_version(spa, "import");
4104 spa_event_notify(spa, NULL, ESC_ZFS_POOL_IMPORT);
4116 spa_t *spa;
4127 * Create and initialize the spa structure.
4130 spa = spa_add(TRYIMPORT_NAME, tryconfig, NULL);
4131 spa_activate(spa, FREAD);
4138 error = spa_load(spa, SPA_LOAD_TRYIMPORT, SPA_IMPORT_EXISTING, B_TRUE);
4143 if (spa->spa_root_vdev != NULL) {
4144 config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
4150 spa->spa_uberblock.ub_timestamp) == 0);
4152 spa->spa_load_info) == 0);
4159 if ((!error || error == EEXIST) && spa->spa_bootfs) {
4166 if (dsl_dsobj_to_dsname(spa_name(spa),
4167 spa->spa_bootfs, tmpname) == 0) {
4189 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
4190 spa_add_spares(spa, config);
4191 spa_add_l2cache(spa, config);
4192 spa_config_exit(spa, SCL_CONFIG, FTAG);
4195 spa_unload(spa);
4196 spa_deactivate(spa);
4197 spa_remove(spa);
4216 spa_t *spa;
4225 if ((spa = spa_lookup(pool)) == NULL) {
4234 spa_open_ref(spa, FTAG);
4236 spa_async_suspend(spa);
4238 spa_close(spa, FTAG);
4244 if (spa->spa_state != POOL_STATE_UNINITIALIZED && spa->spa_sync_on) {
4249 txg_wait_synced(spa->spa_dsl_pool, 0);
4250 spa_evicting_os_wait(spa);
4257 if (!spa_refcount_zero(spa) ||
4258 (spa->spa_inject_ref != 0 &&
4260 spa_async_resume(spa);
4272 spa_has_active_shared_spare(spa)) {
4273 spa_async_resume(spa);
4284 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4285 spa->spa_state = new_state;
4286 spa->spa_final_txg = spa_last_synced_txg(spa) +
4288 vdev_config_dirty(spa->spa_root_vdev);
4289 spa_config_exit(spa, SCL_ALL, FTAG);
4293 spa_event_notify(spa, NULL, ESC_ZFS_POOL_DESTROY);
4295 if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
4296 spa_unload(spa);
4297 spa_deactivate(spa);
4300 if (oldconfig && spa->spa_config)
4301 VERIFY(nvlist_dup(spa->spa_config, oldconfig, 0) == 0);
4305 spa_config_sync(spa, B_TRUE, B_TRUE);
4306 spa_remove(spa);
4355 spa_vdev_add(spa_t *spa, nvlist_t *nvroot)
4359 vdev_t *rvd = spa->spa_root_vdev;
4364 ASSERT(spa_writeable(spa));
4366 txg = spa_vdev_enter(spa);
4368 if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0,
4370 return (spa_vdev_exit(spa, NULL, txg, error));
4372 spa->spa_pending_vdev = vd; /* spa_vdev_exit() will clear this */
4383 return (spa_vdev_exit(spa, vd, txg, EINVAL));
4387 return (spa_vdev_exit(spa, vd, txg, error));
4393 if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0)
4394 return (spa_vdev_exit(spa, vd, txg, error));
4418 spa_set_aux_vdevs(&spa->spa_spares, spares, nspares,
4420 spa_load_spares(spa);
4421 spa->spa_spares.sav_sync = B_TRUE;
4425 spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache,
4427 spa_load_l2cache(spa);
4428 spa->spa_l2cache.sav_sync = B_TRUE;
4444 (void) spa_vdev_exit(spa, vd, txg, 0);
4447 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
4448 spa_event_notify(spa, NULL, ESC_ZFS_VDEV_ADD);
4468 spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing)
4471 vdev_t *rvd = spa->spa_root_vdev;
4478 ASSERT(spa_writeable(spa));
4480 txg = spa_vdev_enter(spa);
4482 oldvd = spa_lookup_by_guid(spa, guid, B_FALSE);
4485 return (spa_vdev_exit(spa, NULL, txg, ENODEV));
4488 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
4492 if ((error = spa_config_parse(spa, &newrootvd, nvroot, NULL, 0,
4494 return (spa_vdev_exit(spa, NULL, txg, EINVAL));
4497 return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
4502 return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
4505 return (spa_vdev_exit(spa, newrootvd, txg, error));
4511 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
4520 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
4530 !spa_has_spare(spa, newvd->vdev_guid))
4531 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
4542 spa_version(spa) < SPA_VERSION_MULTI_REPLACE) {
4543 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
4546 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
4559 return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW));
4566 return (spa_vdev_exit(spa, newrootvd, txg, EDOM));
4624 spa_event_notify(spa, newvd, ESC_ZFS_VDEV_SPARE);
4641 dsl_resilver_restart(spa->spa_dsl_pool, dtl_max_txg);
4643 if (spa->spa_bootfs)
4644 spa_event_notify(spa, newvd, ESC_ZFS_BOOTFS_VDEV_ATTACH);
4646 spa_event_notify(spa, newvd, ESC_ZFS_VDEV_ATTACH);
4651 (void) spa_vdev_exit(spa, newrootvd, dtl_max_txg, 0);
4653 spa_history_log_internal(spa, "vdev attach", NULL,
4672 spa_vdev_detach(spa_t *spa, uint64_t guid, uint64_t pguid, int replace_done)
4676 vdev_t *rvd = spa->spa_root_vdev;
4682 ASSERT(spa_writeable(spa));
4684 txg = spa_vdev_enter(spa);
4686 vd = spa_lookup_by_guid(spa, guid, B_FALSE);
4689 return (spa_vdev_exit(spa, NULL, txg, ENODEV));
4692 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
4710 return (spa_vdev_exit(spa, NULL, txg, EBUSY));
4717 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
4720 spa_version(spa) >= SPA_VERSION_SPARES);
4728 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
4735 return (spa_vdev_exit(spa, NULL, txg, EBUSY));
4807 (void) spa_vdev_remove(spa, unspare_guid, B_TRUE);
4841 if (spa->spa_autoexpand) {
4860 spa_event_notify(spa, vd, ESC_ZFS_VDEV_REMOVE);
4862 /* hang on to the spa before we release the lock */
4863 spa_open_ref(spa, FTAG);
4865 error = spa_vdev_exit(spa, vd, txg, 0);
4867 spa_history_log_internal(spa, "detach", NULL,
4882 altspa == spa)
4894 spa_vdev_resilver_done(spa);
4897 /* all done with the spa; OK to release */
4899 spa_close(spa, FTAG);
4909 spa_vdev_split_mirror(spa_t *spa, char *newname, nvlist_t *config,
4922 ASSERT(spa_writeable(spa));
4924 txg = spa_vdev_enter(spa);
4927 activate_slog = spa_passivate_log(spa);
4928 (void) spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
4929 error = spa_offline_log(spa);
4930 txg = spa_vdev_config_enter(spa);
4933 spa_activate_log(spa);
4936 return (spa_vdev_exit(spa, NULL, txg, error));
4938 /* check new spa name before going any further */
4940 return (spa_vdev_exit(spa, NULL, txg, EEXIST));
4948 return (spa_vdev_exit(spa, NULL, txg, EINVAL));
4951 rvd = spa->spa_root_vdev;
4966 return (spa_vdev_exit(spa, NULL, txg, EINVAL));
4971 return (spa_vdev_exit(spa, NULL, txg, EINVAL));
4984 if (spa->spa_root_vdev->vdev_child[c]->vdev_ishole ||
4985 spa->spa_root_vdev->vdev_child[c]->vdev_islog) {
5000 /* look it up in the spa */
5001 vml[c] = spa_lookup_by_guid(spa, glist[c], B_FALSE);
5016 c != spa->spa_root_vdev->vdev_child[c]->vdev_id) {
5040 return (spa_vdev_exit(spa, NULL, txg, error));
5048 vdev_reopen(spa->spa_root_vdev);
5051 * Temporarily record the splitting vdevs in the spa config. This
5059 mutex_enter(&spa->spa_props_lock);
5060 VERIFY(nvlist_add_nvlist(spa->spa_config, ZPOOL_CONFIG_SPLIT,
5062 mutex_exit(&spa->spa_props_lock);
5063 spa->spa_config_splitting = nvl;
5064 vdev_config_dirty(spa->spa_root_vdev);
5071 spa_version(spa)) == 0);
5073 spa->spa_config_txg) == 0);
5081 newspa->spa_config_txg = spa->spa_config_txg;
5084 /* release the spa config lock, retaining the namespace lock */
5085 spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
5088 zio_handle_panic_injection(spa, FTAG, 1);
5103 ZPOOL_CONFIG_SPLIT_GUID, spa_guid(spa)) == 0);
5122 zio_handle_panic_injection(spa, FTAG, 2);
5127 txg = spa_vdev_config_enter(spa);
5128 tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
5136 spa_history_log_internal(spa, "detach", tx,
5141 vdev_config_dirty(spa->spa_root_vdev);
5142 spa->spa_config_splitting = NULL;
5146 (void) spa_vdev_exit(spa, NULL, txg, 0);
5149 zio_handle_panic_injection(spa, FTAG, 3);
5153 "from pool %s", spa_name(spa));
5169 txg = spa_vdev_config_enter(spa);
5176 vdev_reopen(spa->spa_root_vdev);
5178 nvlist_free(spa->spa_config_splitting);
5179 spa->spa_config_splitting = NULL;
5180 (void) spa_vdev_exit(spa, NULL, txg, error);
5231 spa_vdev_remove_evacuate(spa_t *spa, vdev_t *vd)
5237 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
5248 error = spa_offline_log(spa);
5261 txg = spa_vdev_config_enter(spa);
5265 spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
5274 spa_vdev_remove_from_namespace(spa_t *spa, vdev_t *vd)
5276 vdev_t *rvd = spa->spa_root_vdev;
5281 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
5302 vd = vdev_alloc_common(spa, id, 0, &vdev_hole_ops);
5326 spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare)
5336 ASSERT(spa_writeable(spa));
5339 txg = spa_vdev_enter(spa);
5341 vd = spa_lookup_by_guid(spa, guid, B_FALSE);
5343 if (spa->spa_spares.sav_vdevs != NULL &&
5344 nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
5352 spa_vdev_remove_aux(spa->spa_spares.sav_config,
5354 spa_load_spares(spa);
5355 spa->spa_spares.sav_sync = B_TRUE;
5359 } else if (spa->spa_l2cache.sav_vdevs != NULL &&
5360 nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
5366 spa_vdev_remove_aux(spa->spa_l2cache.sav_config,
5368 spa_load_l2cache(spa);
5369 spa->spa_l2cache.sav_sync = B_TRUE;
5385 spa_vdev_config_exit(spa, NULL,
5391 error = spa_vdev_remove_evacuate(spa, vd);
5393 txg = spa_vdev_config_enter(spa);
5400 return (spa_vdev_exit(spa, NULL, txg, error));
5406 spa_vdev_remove_from_namespace(spa, vd);
5421 return (spa_vdev_exit(spa, NULL, txg, error));
5506 spa_vdev_resilver_done(spa_t *spa)
5511 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
5513 while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) {
5532 spa_config_exit(spa, SCL_ALL, FTAG);
5533 if (spa_vdev_detach(spa, guid, pguid, B_TRUE) != 0)
5535 if (sguid && spa_vdev_detach(spa, sguid, ppguid, B_TRUE) != 0)
5537 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
5540 spa_config_exit(spa, SCL_ALL, FTAG);
5547 spa_vdev_set_common(spa_t *spa, uint64_t guid, const char *value,
5553 ASSERT(spa_writeable(spa));
5555 spa_vdev_state_enter(spa, SCL_ALL);
5557 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
5558 return (spa_vdev_state_exit(spa, NULL, ENOENT));
5561 return (spa_vdev_state_exit(spa, NULL, ENOTSUP));
5580 return (spa_vdev_state_exit(spa, sync ? vd : NULL, 0));
5584 spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath)
5586 return (spa_vdev_set_common(spa, guid, newpath, B_TRUE));
5590 spa_vdev_setfru(spa_t *spa, uint64_t guid, const char *newfru)
5592 return (spa_vdev_set_common(spa, guid, newfru, B_FALSE));
5602 spa_scan_stop(spa_t *spa)
5604 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
5605 if (dsl_scan_resilvering(spa->spa_dsl_pool))
5607 return (dsl_scan_cancel(spa->spa_dsl_pool));
5611 spa_scan(spa_t *spa, pool_scan_func_t func)
5613 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
5623 !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) {
5624 spa_async_request(spa, SPA_ASYNC_RESILVER_DONE);
5628 return (dsl_scan(spa->spa_dsl_pool, func));
5638 spa_async_remove(spa_t *spa, vdev_t *vd)
5659 spa_async_remove(spa, vd->vdev_child[c]);
5663 spa_async_probe(spa_t *spa, vdev_t *vd)
5671 spa_async_probe(spa, vd->vdev_child[c]);
5675 spa_async_autoexpand(spa_t *spa, vdev_t *vd)
5681 if (!spa->spa_autoexpand)
5686 spa_async_autoexpand(spa, cvd);
5706 spa_async_thread(spa_t *spa)
5710 ASSERT(spa->spa_sync_on);
5712 mutex_enter(&spa->spa_async_lock);
5713 tasks = spa->spa_async_tasks;
5714 spa->spa_async_tasks = 0;
5715 mutex_exit(&spa->spa_async_lock);
5724 old_space = metaslab_class_get_space(spa_normal_class(spa));
5725 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
5726 new_space = metaslab_class_get_space(spa_normal_class(spa));
5734 spa_history_log_internal(spa, "vdev online", NULL,
5736 spa_name(spa), new_space, new_space - old_space);
5744 spa_vdev_state_enter(spa, SCL_NONE);
5745 spa_async_remove(spa, spa->spa_root_vdev);
5746 for (int i = 0; i < spa->spa_l2cache.sav_count; i++)
5747 spa_async_remove(spa, spa->spa_l2cache.sav_vdevs[i]);
5748 for (int i = 0; i < spa->spa_spares.sav_count; i++)
5749 spa_async_remove(spa, spa->spa_spares.sav_vdevs[i]);
5750 (void) spa_vdev_state_exit(spa, NULL, 0);
5753 if ((tasks & SPA_ASYNC_AUTOEXPAND) && !spa_suspended(spa)) {
5754 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
5755 spa_async_autoexpand(spa, spa->spa_root_vdev);
5756 spa_config_exit(spa, SCL_CONFIG, FTAG);
5763 spa_vdev_state_enter(spa, SCL_NONE);
5764 spa_async_probe(spa, spa->spa_root_vdev);
5765 (void) spa_vdev_state_exit(spa, NULL, 0);
5772 spa_vdev_resilver_done(spa);
5778 dsl_resilver_restart(spa->spa_dsl_pool, 0);
5783 mutex_enter(&spa->spa_async_lock);
5784 spa->spa_async_thread = NULL;
5785 cv_broadcast(&spa->spa_async_cv);
5786 mutex_exit(&spa->spa_async_lock);
5791 spa_async_suspend(spa_t *spa)
5793 mutex_enter(&spa->spa_async_lock);
5794 spa->spa_async_suspended++;
5795 while (spa->spa_async_thread != NULL)
5796 cv_wait(&spa->spa_async_cv, &spa->spa_async_lock);
5797 mutex_exit(&spa->spa_async_lock);
5801 spa_async_resume(spa_t *spa)
5803 mutex_enter(&spa->spa_async_lock);
5804 ASSERT(spa->spa_async_suspended != 0);
5805 spa->spa_async_suspended--;
5806 mutex_exit(&spa->spa_async_lock);
5810 spa_async_tasks_pending(spa_t *spa)
5816 non_config_tasks = spa->spa_async_tasks & ~SPA_ASYNC_CONFIG_UPDATE;
5817 config_task = spa->spa_async_tasks & SPA_ASYNC_CONFIG_UPDATE;
5818 if (spa->spa_ccw_fail_time == 0) {
5822 (gethrtime() - spa->spa_ccw_fail_time) <
5830 spa_async_dispatch(spa_t *spa)
5832 mutex_enter(&spa->spa_async_lock);
5833 if (spa_async_tasks_pending(spa) &&
5834 !spa->spa_async_suspended &&
5835 spa->spa_async_thread == NULL &&
5837 spa->spa_async_thread = thread_create(NULL, 0,
5838 spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri);
5839 mutex_exit(&spa->spa_async_lock);
5843 spa_async_request(spa_t *spa, int task)
5845 zfs_dbgmsg("spa=%s async request task=%u", spa->spa_name, task);
5846 mutex_enter(&spa->spa_async_lock);
5847 spa->spa_async_tasks |= task;
5848 mutex_exit(&spa->spa_async_lock);
5880 spa_sync_frees(spa_t *spa, bplist_t *bpl, dmu_tx_t *tx)
5882 zio_t *zio = zio_root(spa, NULL, NULL, 0);
5892 spa_sync_deferred_frees(spa_t *spa, dmu_tx_t *tx)
5894 zio_t *zio = zio_root(spa, NULL, NULL, 0);
5895 VERIFY3U(bpobj_iterate(&spa->spa_deferred_bpobj,
5902 spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx)
5923 dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx);
5927 VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db));
5934 spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx,
5950 sav->sav_object = dmu_object_alloc(spa->spa_meta_objset,
5953 VERIFY(zap_update(spa->spa_meta_objset,
5964 list[i] = vdev_config_generate(spa, sav->sav_vdevs[i],
5973 spa_sync_nvlist(spa, sav->sav_object, nvroot, tx);
5980 spa_sync_config_object(spa_t *spa, dmu_tx_t *tx)
5984 if (list_is_empty(&spa->spa_config_dirty_list))
5987 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
5989 config = spa_config_generate(spa, spa->spa_root_vdev,
5993 * If we're upgrading the spa version then make sure that
5996 if (spa->spa_ubsync.ub_version < spa->spa_uberblock.ub_version)
5998 spa->spa_uberblock.ub_version);
6000 spa_config_exit(spa, SCL_STATE, FTAG);
6002 nvlist_free(spa->spa_config_syncing);
6003 spa->spa_config_syncing = config;
6005 spa_sync_nvlist(spa, spa->spa_config_object, config, tx);
6013 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
6021 ASSERT(version >= spa_version(spa));
6023 spa->spa_uberblock.ub_version = version;
6024 vdev_config_dirty(spa->spa_root_vdev);
6025 spa_history_log_internal(spa, "set", tx, "version=%lld", version);
6035 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
6036 objset_t *mos = spa->spa_meta_objset;
6039 mutex_enter(&spa->spa_props_lock);
6059 spa_feature_enable(spa, fid, tx);
6060 spa_history_log_internal(spa, "set", tx,
6070 ASSERT3U(spa_version(spa), >=, intval);
6078 ASSERT(spa->spa_root != NULL);
6090 if (spa->spa_comment != NULL)
6091 spa_strfree(spa->spa_comment);
6092 spa->spa_comment = spa_strdup(strval);
6100 vdev_config_dirty(spa->spa_root_vdev);
6101 spa_history_log_internal(spa, "set", tx,
6108 if (spa->spa_pool_props_object == 0) {
6109 spa->spa_pool_props_object =
6123 spa->spa_pool_props_object, propname,
6125 spa_history_log_internal(spa, "set", tx,
6136 spa->spa_pool_props_object, propname,
6138 spa_history_log_internal(spa, "set", tx,
6146 spa->spa_delegation = intval;
6149 spa->spa_bootfs = intval;
6152 spa->spa_failmode = intval;
6155 spa->spa_autoexpand = intval;
6157 spa_async_request(spa,
6161 spa->spa_dedup_ditto = intval;
6170 mutex_exit(&spa->spa_props_lock);
6181 spa_sync_upgrades(spa_t *spa, dmu_tx_t *tx)
6183 dsl_pool_t *dp = spa->spa_dsl_pool;
6185 ASSERT(spa->spa_sync_pass == 1);
6189 if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN &&
6190 spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) {
6194 spa->spa_minref += 3;
6197 if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES &&
6198 spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) {
6202 if (spa->spa_ubsync.ub_version < SPA_VERSION_DIR_CLONES &&
6203 spa->spa_uberblock.ub_version >= SPA_VERSION_DIR_CLONES) {
6207 spa->spa_minref += 3;
6210 if (spa->spa_ubsync.ub_version < SPA_VERSION_FEATURES &&
6211 spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) {
6212 spa_feature_create_zap_objects(spa, tx);
6221 if (spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) {
6222 boolean_t lz4_en = spa_feature_is_enabled(spa,
6224 boolean_t lz4_ac = spa_feature_is_active(spa,
6228 spa_feature_incr(spa, SPA_FEATURE_LZ4_COMPRESS, tx);
6236 if (zap_contains(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
6238 VERIFY0(zap_add(spa->spa_meta_objset,
6240 sizeof (spa->spa_cksum_salt.zcs_bytes),
6241 spa->spa_cksum_salt.zcs_bytes, tx));
6252 spa_sync(spa_t *spa, uint64_t txg)
6254 dsl_pool_t *dp = spa->spa_dsl_pool;
6255 objset_t *mos = spa->spa_meta_objset;
6256 bplist_t *free_bpl = &spa->spa_free_bplist[txg & TXG_MASK];
6257 vdev_t *rvd = spa->spa_root_vdev;
6262 VERIFY(spa_writeable(spa));
6267 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
6269 spa->spa_syncing_txg = txg;
6270 spa->spa_sync_pass = 0;
6276 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
6277 while (list_head(&spa->spa_state_dirty_list) != NULL) {
6285 spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
6286 spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_WRITER);
6287 while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) {
6291 spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
6292 spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER);
6294 spa_config_exit(spa, SCL_STATE, FTAG);
6298 spa->spa_sync_starttime = gethrtime();
6299 VERIFY(cyclic_reprogram(spa->spa_deadman_cycid,
6300 spa->spa_sync_starttime + spa->spa_deadman_synctime));
6306 if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE &&
6307 spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) {
6316 spa->spa_deflate = TRUE;
6317 VERIFY(0 == zap_add(spa->spa_meta_objset,
6319 sizeof (uint64_t), 1, &spa->spa_deflate, tx));
6327 int pass = ++spa->spa_sync_pass;
6329 spa_sync_config_object(spa, tx);
6330 spa_sync_aux_dev(spa, &spa->spa_spares, tx,
6332 spa_sync_aux_dev(spa, &spa->spa_l2cache, tx,
6334 spa_errlog_sync(spa, txg);
6338 spa_sync_frees(spa, free_bpl, tx);
6346 &spa->spa_deferred_bpobj, tx);
6349 ddt_sync(spa, txg);
6352 while (vd = txg_list_remove(&spa->spa_vdev_txg_list, txg))
6356 spa_sync_upgrades(spa, tx);
6358 spa->spa_uberblock.ub_rootbp.blk_birth);
6370 if (spa->spa_uberblock.ub_rootbp.blk_birth < txg &&
6384 spa_sync_deferred_frees(spa, tx);
6403 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
6405 if (list_is_empty(&spa->spa_config_dirty_list)) {
6426 spa->spa_last_synced_guid = rvd->vdev_guid;
6428 spa_config_exit(spa, SCL_STATE, FTAG);
6432 zio_suspend(spa, NULL);
6433 zio_resume_wait(spa);
6437 VERIFY(cyclic_reprogram(spa->spa_deadman_cycid, CY_INFINITY));
6442 while ((vd = list_head(&spa->spa_config_dirty_list)) != NULL)
6449 if (spa->spa_config_syncing != NULL) {
6450 spa_config_set(spa, spa->spa_config_syncing);
6451 spa->spa_config_txg = txg;
6452 spa->spa_config_syncing = NULL;
6455 spa->spa_ubsync = spa->spa_uberblock;
6462 while (vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)))
6465 spa_update_dspace(spa);
6473 ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg));
6475 spa->spa_sync_pass = 0;
6477 spa_config_exit(spa, SCL_CONFIG, FTAG);
6479 spa_handle_ignored_writes(spa);
6484 spa_async_dispatch(spa);
6495 spa_t *spa = NULL;
6497 while ((spa = spa_next(spa)) != NULL) {
6498 if (spa_state(spa) != POOL_STATE_ACTIVE ||
6499 !spa_writeable(spa) || spa_suspended(spa))
6501 spa_open_ref(spa, FTAG);
6503 txg_wait_synced(spa_get_dsl(spa), 0);
6505 spa_close(spa, FTAG);
6522 spa_t *spa;
6526 * so every spa in the AVL tree should be unreferenced.
6529 while ((spa = spa_next(NULL)) != NULL) {
6535 spa_open_ref(spa, FTAG);
6537 spa_async_suspend(spa);
6539 spa_close(spa, FTAG);
6541 if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
6542 spa_unload(spa);
6543 spa_deactivate(spa);
6545 spa_remove(spa);
6551 spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t aux)
6556 if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL)
6560 for (i = 0; i < spa->spa_l2cache.sav_count; i++) {
6561 vd = spa->spa_l2cache.sav_vdevs[i];
6566 for (i = 0; i < spa->spa_spares.sav_count; i++) {
6567 vd = spa->spa_spares.sav_vdevs[i];
6577 spa_upgrade(spa_t *spa, uint64_t version)
6579 ASSERT(spa_writeable(spa));
6581 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
6588 ASSERT(SPA_VERSION_IS_SUPPORTED(spa->spa_uberblock.ub_version));
6589 ASSERT3U(version, >=, spa->spa_uberblock.ub_version);
6591 spa->spa_uberblock.ub_version = version;
6592 vdev_config_dirty(spa->spa_root_vdev);
6594 spa_config_exit(spa, SCL_ALL, FTAG);
6596 txg_wait_synced(spa_get_dsl(spa), 0);
6600 spa_has_spare(spa_t *spa, uint64_t guid)
6604 spa_aux_vdev_t *sav = &spa->spa_spares;
6624 spa_has_active_shared_spare(spa_t *spa)
6628 spa_aux_vdev_t *sav = &spa->spa_spares;
6632 &refcnt) && pool != 0ULL && pool == spa_guid(spa) &&
6643 * filled in from the spa and (optionally) the vdev. This doesn't do anything
6648 spa_event_notify(spa_t *spa, vdev_t *vd, const char *name)
6660 value.value.sv_string = spa_name(spa);
6665 value.value.sv_uint64 = spa_guid(spa);