Lines Matching defs:spa

195 static boolean_t spa_has_active_shared_spare(spa_t *spa);
196 static int spa_load_impl(spa_t *spa, spa_import_type_t type,
198 static void spa_vdev_resilver_done(spa_t *spa);
341 spa_prop_add(spa_t *spa, const char *propname, nvlist_t *outnvl)
350 	 * the spa props lock, so they must explicitly grab it here.
354 		err = ddt_get_pool_dedup_cached(spa, &intval);
368 spa_prop_get_nvlist(spa_t *spa, char **props, unsigned int n_props,
377 		err = spa_prop_add(spa, props[i], outnvl);
400  * Get property values from the spa configuration.
403 spa_prop_get_config(spa_t *spa, nvlist_t *nv)
405 	vdev_t *rvd = spa->spa_root_vdev;
406 	dsl_pool_t *pool = spa->spa_dsl_pool;
410 	metaslab_class_t *mc = spa_normal_class(spa);
412 	ASSERT(MUTEX_HELD(&spa->spa_props_lock));
416 		alloc += metaslab_class_get_alloc(spa_special_class(spa));
417 		alloc += metaslab_class_get_alloc(spa_dedup_class(spa));
418 		alloc += metaslab_class_get_alloc(spa_embedded_log_class(spa));
421 		size += metaslab_class_get_space(spa_special_class(spa));
422 		size += metaslab_class_get_space(spa_dedup_class(spa));
423 		size += metaslab_class_get_space(spa_embedded_log_class(spa));
425 		spa_prop_add_list(nv, ZPOOL_PROP_NAME, spa_name(spa), 0, src);
431 		    spa->spa_checkpoint_info.sci_dspace, src);
438 		    (spa_mode(spa) == SPA_MODE_READ), src);
444 		    ddt_get_pool_dedup_ratio(spa), src);
446 		    brt_get_used(spa), src);
448 		    brt_get_saved(spa), src);
450 		    brt_get_ratio(spa), src);
453 		    ddt_get_ddt_dsize(spa), src);
457 		    spa_get_last_scrubbed_txg(spa), src);
459 		version = spa_version(spa);
468 		    NULL, spa_load_guid(spa), src);
495 	spa_prop_add_list(nv, ZPOOL_PROP_GUID, NULL, spa_guid(spa), src);
497 	if (spa->spa_comment != NULL) {
498 		spa_prop_add_list(nv, ZPOOL_PROP_COMMENT, spa->spa_comment,
502 	if (spa->spa_compatibility != NULL) {
504 		    spa->spa_compatibility, 0, ZPROP_SRC_LOCAL);
507 	if (spa->spa_root != NULL)
508 		spa_prop_add_list(nv, ZPOOL_PROP_ALTROOT, spa->spa_root,
511 	if (spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_BLOCKS)) {
519 	if (spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_DNODE)) {
527 	if ((dp = list_head(&spa->spa_config_list)) != NULL) {
542 spa_prop_get(spa_t *spa, nvlist_t *nv)
544 	objset_t *mos = spa->spa_meta_objset;
550 	dp = spa_get_dsl(spa);
553 	mutex_enter(&spa->spa_props_lock);
556 	 * Get properties from the spa config.
558 	spa_prop_get_config(spa, nv);
561 	if (mos == NULL || spa->spa_pool_props_object == 0)
567 	for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object);
613 			err = zap_lookup(mos, spa->spa_pool_props_object,
635 	mutex_exit(&spa->spa_props_lock);
650 spa_prop_validate(spa_t *spa, nvlist_t *props)
712 			    (intval < spa_version(spa) ||
740 					spa->spa_hostid = hostid;
753 			if (spa_version(spa) < SPA_VERSION_BOOTFS) {
761 			if (!vdev_is_bootable(spa->spa_root_vdev)) {
808 			if (!error && spa_suspended(spa)) {
809 				spa->spa_failmode = intval;
875 spa_configfile_set(spa_t *spa, nvlist_t *nvp, boolean_t need_sync)
894 	list_insert_head(&spa->spa_config_list, dp);
896 		spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
900 spa_prop_set(spa_t *spa, nvlist_t *nvp)
906 	if ((error = spa_prop_validate(spa, nvp)) != 0)
935 			if (ver == spa_version(spa))
944 			error = dsl_sync_task(spa->spa_name, NULL,
957 		return (dsl_sync_task(spa->spa_name, NULL, spa_sync_props,
968 spa_prop_clear_bootfs(spa_t *spa, uint64_t dsobj, dmu_tx_t *tx)
970 	if (spa->spa_bootfs == dsobj && spa->spa_pool_props_object != 0) {
971 		VERIFY(zap_remove(spa->spa_meta_objset,
972 		    spa->spa_pool_props_object,
974 		spa->spa_bootfs = 0;
982 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
983 	vdev_t *rvd = spa->spa_root_vdev;
986 	if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) {
987 		int error = (spa_has_checkpoint(spa)) ?
992 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
994 	spa_config_exit(spa, SCL_STATE, FTAG);
999 	ASSERT3U(spa_guid(spa), !=, *newguid);
1008 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
1010 	vdev_t *rvd = spa->spa_root_vdev;
1012 	oldguid = spa_guid(spa);
1014 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
1018 	spa_config_exit(spa, SCL_STATE, FTAG);
1020 	spa_history_log_internal(spa, "guid change", tx, "old=%llu new=%llu",
1038 spa_change_guid(spa_t *spa, const uint64_t *guidp)
1043 	mutex_enter(&spa->spa_vdev_top_lock);
1061 	error = dsl_sync_task(spa->spa_name, spa_change_guid_check,
1070 		vdev_clear_kobj_evt(spa->spa_root_vdev);
1071 		for (int i = 0; i < spa->spa_l2cache.sav_count; i++)
1072 			vdev_clear_kobj_evt(spa->spa_l2cache.sav_vdevs[i]);
1074 		spa_write_cachefile(spa, B_FALSE, B_TRUE, B_TRUE);
1075 		spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_REGUID);
1080 	mutex_exit(&spa->spa_vdev_top_lock);
1109 spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub)
1111 	ASSERT(MUTEX_HELD(&spa->spa_errlist_lock));
1113 	memcpy(last, &spa->spa_errlist_last, sizeof (avl_tree_t));
1114 	memcpy(scrub, &spa->spa_errlist_scrub, sizeof (avl_tree_t));
1116 	avl_create(&spa->spa_errlist_scrub,
1119 	avl_create(&spa->spa_errlist_last,
1125 spa_taskqs_init(spa_t *spa, zio_type_t t, zio_taskq_type_t q)
1131 	spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
1143 		 * not to exceed the number of spa allocators, and align to it.
1148 		count = MIN(count, spa->spa_alloc_count);
1149 		while (spa->spa_alloc_count % count != 0 &&
1150 		    spa->spa_alloc_count < count * 2)
1227 		if (zio_taskq_sysdc && spa->spa_proc != &p0) {
1230 			    spa->spa_proc, zio_taskq_basedc, flags);
1257 			    INT_MAX, spa->spa_proc, flags);
1267 spa_taskqs_fini(spa_t *spa, zio_type_t t, zio_taskq_type_t q)
1269 	spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
1560 spa_taskq_dispatch(spa_t *spa, zio_type_t t, zio_taskq_type_t q,
1563 	spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
1591 spa_create_zio_taskqs(spa_t *spa)
1595 			spa_taskqs_init(spa, t, q);
1607 	spa_t *spa = arg;
1610 	CALLB_CPR_INIT(&cprinfo, &spa->spa_proc_lock, callb_generic_cpr,
1611 	    spa->spa_name);
1615 	    "zpool-%s", spa->spa_name);
1631 			    "pset %d\n", spa->spa_name, zio_taskq_psrset_bind);
1646 	spa->spa_proc = curproc;
1647 	spa->spa_did = curthread->t_did;
1649 	spa_create_zio_taskqs(spa);
1651 	mutex_enter(&spa->spa_proc_lock);
1652 	ASSERT(spa->spa_proc_state == SPA_PROC_CREATED);
1654 	spa->spa_proc_state = SPA_PROC_ACTIVE;
1655 	cv_broadcast(&spa->spa_proc_cv);
1658 	while (spa->spa_proc_state == SPA_PROC_ACTIVE)
1659 		cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock);
1660 	CALLB_CPR_SAFE_END(&cprinfo, &spa->spa_proc_lock);
1662 	ASSERT(spa->spa_proc_state == SPA_PROC_DEACTIVATE);
1663 	spa->spa_proc_state = SPA_PROC_GONE;
1664 	spa->spa_proc = &p0;
1665 	cv_broadcast(&spa->spa_proc_cv);
1673 extern metaslab_ops_t *metaslab_allocator(spa_t *spa);
1679 spa_activate(spa_t *spa, spa_mode_t mode)
1681 	metaslab_ops_t *msp = metaslab_allocator(spa);
1682 	ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED);
1684 	spa->spa_state = POOL_STATE_ACTIVE;
1685 	spa->spa_mode = mode;
1686 	spa->spa_read_spacemaps = spa_mode_readable_spacemaps;
1688 	spa->spa_normal_class = metaslab_class_create(spa, msp);
1689 	spa->spa_log_class = metaslab_class_create(spa, msp);
1690 	spa->spa_embedded_log_class = metaslab_class_create(spa, msp);
1691 	spa->spa_special_class = metaslab_class_create(spa, msp);
1692 	spa->spa_dedup_class = metaslab_class_create(spa, msp);
1695 	mutex_enter(&spa->spa_proc_lock);
1696 	ASSERT(spa->spa_proc_state == SPA_PROC_NONE);
1697 	ASSERT(spa->spa_proc == &p0);
1698 	spa->spa_did = 0;
1702 	if (spa_create_process && strcmp(spa->spa_name, TRYIMPORT_NAME) != 0) {
1703 		if (newproc(spa_thread, (caddr_t)spa, syscid, maxclsyspri,
1705 			spa->spa_proc_state = SPA_PROC_CREATED;
1706 			while (spa->spa_proc_state == SPA_PROC_CREATED) {
1707 				cv_wait(&spa->spa_proc_cv,
1708 				    &spa->spa_proc_lock);
1710 			ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE);
1711 			ASSERT(spa->spa_proc != &p0);
1712 			ASSERT(spa->spa_did != 0);
1717 			    spa->spa_name);
1722 	mutex_exit(&spa->spa_proc_lock);
1725 	if (spa->spa_proc == &p0) {
1726 		spa_create_zio_taskqs(spa);
1730 		spa->spa_txg_zio[i] = zio_root(spa, NULL, NULL,
1734 	list_create(&spa->spa_config_dirty_list, sizeof (vdev_t),
1736 	list_create(&spa->spa_evicting_os_list, sizeof (objset_t),
1738 	list_create(&spa->spa_state_dirty_list, sizeof (vdev_t),
1741 	txg_list_create(&spa->spa_vdev_txg_list, spa,
1744 	avl_create(&spa->spa_errlist_scrub,
1747 	avl_create(&spa->spa_errlist_last,
1750 	avl_create(&spa->spa_errlist_healed,
1754 	spa_activate_os(spa);
1756 	spa_keystore_init(&spa->spa_keystore);
1773 	spa->spa_zvol_taskq = taskq_create("z_zvol", 1, defclsyspri,
1779 	spa->spa_metaslab_taskq = taskq_create("z_metaslab",
1788 	spa->spa_prefetch_taskq = taskq_create("z_prefetch", 100,
1795 	spa->spa_upgrade_taskq = taskq_create("z_upgrade", 100,
1803 spa_deactivate(spa_t *spa)
1805 	ASSERT(spa->spa_sync_on == B_FALSE);
1806 	ASSERT(spa->spa_dsl_pool == NULL);
1807 	ASSERT(spa->spa_root_vdev == NULL);
1808 	ASSERT(spa->spa_async_zio_root == NULL);
1809 	ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED);
1811 	spa_evicting_os_wait(spa);
1813 	if (spa->spa_zvol_taskq) {
1814 		taskq_destroy(spa->spa_zvol_taskq);
1815 		spa->spa_zvol_taskq = NULL;
1818 	if (spa->spa_metaslab_taskq) {
1819 		taskq_destroy(spa->spa_metaslab_taskq);
1820 		spa->spa_metaslab_taskq = NULL;
1823 	if (spa->spa_prefetch_taskq) {
1824 		taskq_destroy(spa->spa_prefetch_taskq);
1825 		spa->spa_prefetch_taskq = NULL;
1828 	if (spa->spa_upgrade_taskq) {
1829 		taskq_destroy(spa->spa_upgrade_taskq);
1830 		spa->spa_upgrade_taskq = NULL;
1833 	txg_list_destroy(&spa->spa_vdev_txg_list);
1835 	list_destroy(&spa->spa_config_dirty_list);
1836 	list_destroy(&spa->spa_evicting_os_list);
1837 	list_destroy(&spa->spa_state_dirty_list);
1839 	taskq_cancel_id(system_delay_taskq, spa->spa_deadman_tqid);
1843 			spa_taskqs_fini(spa, t, q);
1848 		ASSERT3P(spa->spa_txg_zio[i], !=, NULL);
1849 		VERIFY0(zio_wait(spa->spa_txg_zio[i]));
1850 		spa->spa_txg_zio[i] = NULL;
1853 	metaslab_class_destroy(spa->spa_normal_class);
1854 	spa->spa_normal_class = NULL;
1856 	metaslab_class_destroy(spa->spa_log_class);
1857 	spa->spa_log_class = NULL;
1859 	metaslab_class_destroy(spa->spa_embedded_log_class);
1860 	spa->spa_embedded_log_class = NULL;
1862 	metaslab_class_destroy(spa->spa_special_class);
1863 	spa->spa_special_class = NULL;
1865 	metaslab_class_destroy(spa->spa_dedup_class);
1866 	spa->spa_dedup_class = NULL;
1872 	spa_errlog_drain(spa);
1873 	avl_destroy(&spa->spa_errlist_scrub);
1874 	avl_destroy(&spa->spa_errlist_last);
1875 	avl_destroy(&spa->spa_errlist_healed);
1877 	spa_keystore_fini(&spa->spa_keystore);
1879 	spa->spa_state = POOL_STATE_UNINITIALIZED;
1881 	mutex_enter(&spa->spa_proc_lock);
1882 	if (spa->spa_proc_state != SPA_PROC_NONE) {
1883 		ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE);
1884 		spa->spa_proc_state = SPA_PROC_DEACTIVATE;
1885 		cv_broadcast(&spa->spa_proc_cv);
1886 		while (spa->spa_proc_state == SPA_PROC_DEACTIVATE) {
1887 			ASSERT(spa->spa_proc != &p0);
1888 			cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock);
1890 		ASSERT(spa->spa_proc_state == SPA_PROC_GONE);
1891 		spa->spa_proc_state = SPA_PROC_NONE;
1893 	ASSERT(spa->spa_proc == &p0);
1894 	mutex_exit(&spa->spa_proc_lock);
1901 	if (spa->spa_did != 0) {
1902 		thread_join(spa->spa_did);
1903 		spa->spa_did = 0;
1906 	spa_deactivate_os(spa);
1917 spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent,
1924 	if ((error = vdev_alloc(spa, vdp, nv, parent, id, atype)) != 0)
1944 		if ((error = spa_config_parse(spa, &vd, child[c], *vdp, c,
1958 spa_should_flush_logs_on_unload(spa_t *spa)
1960 	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
1963 	if (!spa_writeable(spa))
1966 	if (!spa->spa_sync_on)
1969 	if (spa_state(spa) != POOL_STATE_EXPORTED)
1983 spa_unload_log_sm_flush_all(spa_t *spa)
1985 	dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
1988 	ASSERT3U(spa->spa_log_flushall_txg, ==, 0);
1989 	spa->spa_log_flushall_txg = dmu_tx_get_txg(tx);
1992 	txg_wait_synced(spa_get_dsl(spa), spa->spa_log_flushall_txg);
1996 spa_unload_log_sm_metadata(spa_t *spa)
2002 	while ((sls = avl_destroy_nodes(&spa->spa_sm_logs_by_txg,
2008 	while ((e = list_remove_head(&spa->spa_log_summary)) != NULL) {
2013 	spa->spa_unflushed_stats.sus_nblocks = 0;
2014 	spa->spa_unflushed_stats.sus_memused = 0;
2015 	spa->spa_unflushed_stats.sus_blocklimit = 0;
2019 spa_destroy_aux_threads(spa_t *spa)
2021 	if (spa->spa_condense_zthr != NULL) {
2022 		zthr_destroy(spa->spa_condense_zthr);
2023 		spa->spa_condense_zthr = NULL;
2025 	if (spa->spa_checkpoint_discard_zthr != NULL) {
2026 		zthr_destroy(spa->spa_checkpoint_discard_zthr);
2027 		spa->spa_checkpoint_discard_zthr = NULL;
2029 	if (spa->spa_livelist_delete_zthr != NULL) {
2030 		zthr_destroy(spa->spa_livelist_delete_zthr);
2031 		spa->spa_livelist_delete_zthr = NULL;
2033 	if (spa->spa_livelist_condense_zthr != NULL) {
2034 		zthr_destroy(spa->spa_livelist_condense_zthr);
2035 		spa->spa_livelist_condense_zthr = NULL;
2037 	if (spa->spa_raidz_expand_zthr != NULL) {
2038 		zthr_destroy(spa->spa_raidz_expand_zthr);
2039 		spa->spa_raidz_expand_zthr = NULL;
2047 spa_unload(spa_t *spa)
2050 	    spa->spa_export_thread == curthread);
2051 	ASSERT(spa_state(spa) != POOL_STATE_UNINITIALIZED);
2053 	spa_import_progress_remove(spa_guid(spa));
2054 	spa_load_note(spa, "UNLOADING");
2056 	spa_wake_waiters(spa);
2063 	if (spa->spa_final_txg == UINT64_MAX) {
2070 		if (spa_should_flush_logs_on_unload(spa))
2071 			spa_unload_log_sm_flush_all(spa);
2076 		spa_async_suspend(spa);
2078 		if (spa->spa_root_vdev) {
2079 			vdev_t *root_vdev = spa->spa_root_vdev;
2083 			vdev_autotrim_stop_all(spa);
2084 			vdev_rebuild_stop_all(spa);
2085 			l2arc_spa_rebuild_stop(spa);
2092 	if (spa->spa_sync_on) {
2093 		txg_sync_stop(spa->spa_dsl_pool);
2094 		spa->spa_sync_on = B_FALSE;
2099 	 * while we attempt to unload the spa.
2101 	taskq_wait(spa->spa_metaslab_taskq);
2103 	if (spa->spa_mmp.mmp_thread)
2104 		mmp_thread_stop(spa);
2109 	if (spa->spa_async_zio_root != NULL) {
2111 			(void) zio_wait(spa->spa_async_zio_root[i]);
2112 		kmem_free(spa->spa_async_zio_root, max_ncpus * sizeof (void *));
2113 		spa->spa_async_zio_root = NULL;
2116 	if (spa->spa_vdev_removal != NULL) {
2117 		spa_vdev_removal_destroy(spa->spa_vdev_removal);
2118 		spa->spa_vdev_removal = NULL;
2121 	spa_destroy_aux_threads(spa);
2123 	spa_condense_fini(spa);
2125 	bpobj_close(&spa->spa_deferred_bpobj);
2127 	spa_config_enter(spa, SCL_ALL, spa, RW_WRITER);
2132 	if (spa->spa_root_vdev)
2133 		vdev_free(spa->spa_root_vdev);
2134 	ASSERT(spa->spa_root_vdev == NULL);
2139 	if (spa->spa_dsl_pool) {
2140 		dsl_pool_close(spa->spa_dsl_pool);
2141 		spa->spa_dsl_pool = NULL;
2142 		spa->spa_meta_objset = NULL;
2145 	ddt_unload(spa);
2146 	brt_unload(spa);
2147 	spa_unload_log_sm_metadata(spa);
2152 	spa_l2cache_drop(spa);
2154 	if (spa->spa_spares.sav_vdevs) {
2155 		for (int i = 0; i < spa->spa_spares.sav_count; i++)
2156 			vdev_free(spa->spa_spares.sav_vdevs[i]);
2157 		kmem_free(spa->spa_spares.sav_vdevs,
2158 		    spa->spa_spares.sav_count * sizeof (void *));
2159 		spa->spa_spares.sav_vdevs = NULL;
2161 	if (spa->spa_spares.sav_config) {
2162 		nvlist_free(spa->spa_spares.sav_config);
2163 		spa->spa_spares.sav_config = NULL;
2165 	spa->spa_spares.sav_count = 0;
2167 	if (spa->spa_l2cache.sav_vdevs) {
2168 		for (int i = 0; i < spa->spa_l2cache.sav_count; i++) {
2169 			vdev_clear_stats(spa->spa_l2cache.sav_vdevs[i]);
2170 			vdev_free(spa->spa_l2cache.sav_vdevs[i]);
2172 		kmem_free(spa->spa_l2cache.sav_vdevs,
2173 		    spa->spa_l2cache.sav_count * sizeof (void *));
2174 		spa->spa_l2cache.sav_vdevs = NULL;
2176 	if (spa->spa_l2cache.sav_config) {
2177 		nvlist_free(spa->spa_l2cache.sav_config);
2178 		spa->spa_l2cache.sav_config = NULL;
2180 	spa->spa_l2cache.sav_count = 0;
2182 	spa->spa_async_suspended = 0;
2184 	spa->spa_indirect_vdevs_loaded = B_FALSE;
2186 	if (spa->spa_comment != NULL) {
2187 		spa_strfree(spa->spa_comment);
2188 		spa->spa_comment = NULL;
2190 	if (spa->spa_compatibility != NULL) {
2191 		spa_strfree(spa->spa_compatibility);
2192 		spa->spa_compatibility = NULL;
2195 	spa->spa_raidz_expand = NULL;
2197 	spa_config_exit(spa, SCL_ALL, spa);
2207 spa_load_spares(spa_t *spa)
2222 	if (!spa_writeable(spa))
2226 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
2231 	if (spa->spa_spares.sav_vdevs) {
2232 		for (i = 0; i < spa->spa_spares.sav_count; i++) {
2233 			vd = spa->spa_spares.sav_vdevs[i];
2236 			if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
2243 		kmem_free(spa->spa_spares.sav_vdevs,
2244 		    spa->spa_spares.sav_count * sizeof (void *));
2247 	if (spa->spa_spares.sav_config == NULL)
2250 		VERIFY0(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
2253 	spa->spa_spares.sav_count = (int)nspares;
2254 	spa->spa_spares.sav_vdevs = NULL;
2268 	spa->spa_spares.sav_vdevs = kmem_zalloc(nspares * sizeof (void *),
2270 	for (i = 0; i < spa->spa_spares.sav_count; i++) {
2271 		VERIFY(spa_config_parse(spa, &vd, spares[i], NULL, 0,
2275 		spa->spa_spares.sav_vdevs[i] = vd;
2277 		if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
2300 		vd->vdev_aux = &spa->spa_spares;
2313 	fnvlist_remove(spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES);
2315 	spares = kmem_alloc(spa->spa_spares.sav_count * sizeof (void *),
2317 	for (i = 0; i < spa->spa_spares.sav_count; i++)
2318 		spares[i] = vdev_config_generate(spa,
2319 		    spa->spa_spares.sav_vdevs[i], B_TRUE, VDEV_CONFIG_SPARE);
2320 	fnvlist_add_nvlist_array(spa->spa_spares.sav_config,
2322 	    spa->spa_spares.sav_count);
2323 	for (i = 0; i < spa->spa_spares.sav_count; i++)
2325 	kmem_free(spares, spa->spa_spares.sav_count * sizeof (void *));
2337 spa_load_l2cache(spa_t *spa)
2344 	spa_aux_vdev_t *sav = &spa->spa_l2cache;
2355 	if (!spa_writeable(spa))
2359 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
2399 			VERIFY(spa_config_parse(spa, &vd, l2cache[i], NULL, 0,
2421 				l2arc_add_vdev(spa, vd);
2430 			spa_async_request(spa, SPA_ASYNC_L2CACHE_TRIM);
2447 		l2cache[i] = vdev_config_generate(spa,
2482 load_nvlist(spa_t *spa, uint64_t obj, nvlist_t **value)
2490 	error = dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db);
2498 	error = dmu_read(spa->spa_meta_objset, obj, 0, nvsize, packed,
2512 spa_healthy_core_tvds(spa_t *spa)
2514 	vdev_t *rvd = spa->spa_root_vdev;
2546 spa_check_for_missing_logs(spa_t *spa)
2548 	vdev_t *rvd = spa->spa_root_vdev;
2555 	if (!(spa->spa_import_flags & ZFS_IMPORT_MISSING_LOG)) {
2573 				child[idx++] = vdev_config_generate(spa, tvd,
2581 			fnvlist_add_nvlist(spa->spa_load_info,
2591 			spa_load_failed(spa, "some log devices are missing");
2601 				spa_set_log_state(spa, SPA_LOG_CLEAR);
2602 				spa_load_note(spa, "some log devices are "
2617 spa_check_logs(spa_t *spa)
2620 	dsl_pool_t *dp = spa_get_dsl(spa);
2622 	switch (spa->spa_log_state) {
2631 			spa_set_log_state(spa, SPA_LOG_MISSING);
2641 spa_passivate_log(spa_t *spa)
2643 	vdev_t *rvd = spa->spa_root_vdev;
2646 	ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER));
2665 spa_activate_log(spa_t *spa)
2667 	vdev_t *rvd = spa->spa_root_vdev;
2669 	ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER));
2682 spa_reset_logs(spa_t *spa)
2686 	error = dmu_objset_find(spa_name(spa), zil_reset,
2694 		txg_wait_synced(spa->spa_dsl_pool, 0);
2709 	spa_t *spa = zio->io_spa;
2714 	mutex_enter(&spa->spa_props_lock);	/* any mutex will do */
2715 	if (spa->spa_claim_max_txg < BP_GET_LOGICAL_BIRTH(zio->io_bp))
2716 		spa->spa_claim_max_txg = BP_GET_LOGICAL_BIRTH(zio->io_bp);
2717 	mutex_exit(&spa->spa_props_lock);
2733 	spa_t *spa = zio->io_spa;
2744 	mutex_enter(&spa->spa_scrub_lock);
2745 	spa->spa_load_verify_bytes -= BP_GET_PSIZE(bp);
2746 	cv_broadcast(&spa->spa_scrub_io_cv);
2747 	mutex_exit(&spa->spa_scrub_lock);
2759 spa_load_verify_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
2781 	if (!zfs_blkptr_verify(spa, bp, BLK_CONFIG_NEEDED, BLK_VERIFY_LOG)) {
2798 	mutex_enter(&spa->spa_scrub_lock);
2799 	while (spa->spa_load_verify_bytes >= maxinflight_bytes)
2800 		cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
2801 	spa->spa_load_verify_bytes += size;
2802 	mutex_exit(&spa->spa_scrub_lock);
2804 	zio_nowait(zio_read(rio, spa, bp, abd_alloc_for_io(size, B_FALSE), size,
2823 spa_load_verify(spa_t *spa)
2831 	zpool_get_load_policy(spa->spa_config, &policy);
2837 	dsl_pool_config_enter(spa->spa_dsl_pool, FTAG);
2838 	error = dmu_objset_find_dp(spa->spa_dsl_pool,
2839 	    spa->spa_dsl_pool->dp_root_dir_obj, verify_dataset_name_len, NULL,
2841 	dsl_pool_config_exit(spa->spa_dsl_pool, FTAG);
2852 	rio = zio_root(spa, NULL, &sle,
2856 		if (spa->spa_extreme_rewind) {
2857 			spa_load_note(spa, "performing a complete scan of the "
2864 		error = traverse_pool(spa, spa->spa_verify_min_txg,
2870 	ASSERT0(spa->spa_load_verify_bytes);
2872 	spa->spa_load_meta_errors = sle.sle_meta_count;
2873 	spa->spa_load_data_errors = sle.sle_data_count;
2876 		spa_load_note(spa, "spa_load_verify found %llu metadata errors "
2887 		spa->spa_load_txg = spa->spa_uberblock.ub_txg;
2888 		spa->spa_load_txg_ts = spa->spa_uberblock.ub_timestamp;
2890 		loss = spa->spa_last_ubsync_txg_ts - spa->spa_load_txg_ts;
2891 		fnvlist_add_uint64(spa->spa_load_info, ZPOOL_CONFIG_LOAD_TIME,
2892 		    spa->spa_load_txg_ts);
2893 		fnvlist_add_int64(spa->spa_load_info, ZPOOL_CONFIG_REWIND_TIME,
2895 		fnvlist_add_uint64(spa->spa_load_info,
2897 		fnvlist_add_uint64(spa->spa_load_info,
2900 		spa->spa_load_max_txg = spa->spa_uberblock.ub_txg;
2919 spa_prop_find(spa_t *spa, zpool_prop_t prop, uint64_t *val)
2921 	(void) zap_lookup(spa->spa_meta_objset, spa->spa_pool_props_object,
2929 spa_dir_prop(spa_t *spa, const char *name, uint64_t *val, boolean_t log_enoent)
2931 	int error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
2935 		spa_load_failed(spa, "couldn't get '%s' value in MOS directory "
2950 spa_livelist_delete_check(spa_t *spa)
2952 	return (spa->spa_livelists_to_delete != 0);
2959 	spa_t *spa = arg;
2960 	return (spa_livelist_delete_check(spa));
2966 	spa_t *spa = arg;
2967 	zio_free(spa, tx->tx_txg, bp);
2969 	    -bp_get_dsize_sync(spa, bp),
2995 	spa_t *spa;
3005 	spa_t *spa = sda->spa;
3010 	bplist_iterate(to_free, delete_blkptr_cb, spa, tx);
3015 	spa_t *spa;
3024 	spa_t *spa = lda->spa;
3027 	objset_t *mos = spa->spa_meta_objset;
3033 	spa_feature_decr(spa, SPA_FEATURE_LIVELIST, tx);
3040 		spa->spa_livelists_to_delete = 0;
3041 		spa_notify_waiters(spa);
3054 	spa_t *spa = arg;
3056 	objset_t *mos = spa->spa_meta_objset;
3057 	uint64_t zap_obj = spa->spa_livelists_to_delete;
3077 			    .spa = spa,
3086 			VERIFY0(dsl_sync_task(spa_name(spa), NULL,
3098 		    .spa = spa,
3104 		VERIFY0(dsl_sync_task(spa_name(spa), NULL, livelist_delete_sync,
3110 spa_start_livelist_destroy_thread(spa_t *spa)
3112 	ASSERT3P(spa->spa_livelist_delete_zthr, ==, NULL);
3113 	spa->spa_livelist_delete_zthr =
3115 	    spa_livelist_delete_cb_check, spa_livelist_delete_cb, spa,
3140 	spa_t *spa;
3150 	spa_t *spa = lca->spa;
3152 	dsl_dataset_t *ds = spa->spa_to_condense.ds;
3155 	if (spa->spa_to_condense.cancelled) {
3160 	dsl_deadlist_entry_t *first = spa->spa_to_condense.first;
3161 	dsl_deadlist_entry_t *next = spa->spa_to_condense.next;
3211 	dmu_buf_rele(ds->ds_dbuf, spa);
3212 	spa->spa_to_condense.ds = NULL;
3216 	spa->spa_to_condense.syncing = B_FALSE;
3226 	spa_t *spa = arg;
3227 	dsl_deadlist_entry_t *first = spa->spa_to_condense.first;
3228 	dsl_deadlist_entry_t *next = spa->spa_to_condense.next;
3261 		dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
3270 			spa->spa_to_condense.syncing = B_TRUE;
3271 			lca->spa = spa;
3274 			dsl_sync_task_nowait(spa_get_dsl(spa),
3290 	dmu_buf_rele(spa->spa_to_condense.ds->ds_dbuf, spa);
3291 	spa->spa_to_condense.ds = NULL;
3304 	spa_t *spa = arg;
3305 	if ((spa->spa_to_condense.ds != NULL) &&
3306 	    (spa->spa_to_condense.syncing == B_FALSE) &&
3307 	    (spa->spa_to_condense.cancelled == B_FALSE)) {
3314 spa_start_livelist_condensing_thread(spa_t *spa)
3316 	spa->spa_to_condense.ds = NULL;
3317 	spa->spa_to_condense.first = NULL;
3318 	spa->spa_to_condense.next = NULL;
3319 	spa->spa_to_condense.syncing = B_FALSE;
3320 	spa->spa_to_condense.cancelled = B_FALSE;
3322 	ASSERT3P(spa->spa_livelist_condense_zthr, ==, NULL);
3323 	spa->spa_livelist_condense_zthr =
3326 	    spa_livelist_condense_cb, spa, minclsyspri);
3330 spa_spawn_aux_threads(spa_t *spa)
3332 	ASSERT(spa_writeable(spa));
3334 	spa_start_raidz_expansion_thread(spa);
3335 	spa_start_indirect_condensing_thread(spa);
3336 	spa_start_livelist_destroy_thread(spa);
3337 	spa_start_livelist_condensing_thread(spa);
3339 	ASSERT3P(spa->spa_checkpoint_discard_zthr, ==, NULL);
3340 	spa->spa_checkpoint_discard_zthr =
3343 	    spa_checkpoint_discard_thread, spa, minclsyspri);
3363 spa_try_repair(spa_t *spa, nvlist_t *config)
3388 		vd[i] = spa_lookup_by_guid(spa, glist[i], B_FALSE);
3402 		vdev_reopen(spa->spa_root_vdev);
3422 		vdev_reopen(spa->spa_root_vdev);
3429 spa_load(spa_t *spa, spa_load_state_t state, spa_import_type_t type)
3434 	spa->spa_load_state = state;
3435 	(void) spa_import_progress_set_state(spa_guid(spa),
3436 	    spa_load_state(spa));
3437 	spa_import_progress_set_notes(spa, "spa_load()");
3439 	gethrestime(&spa->spa_loaded_ts);
3440 	error = spa_load_impl(spa, type, &ereport);
3446 	spa_evicting_os_wait(spa);
3447 	spa->spa_minref = zfs_refcount_count(&spa->spa_refcount);
3450 			spa->spa_loaded_ts.tv_sec = 0;
3451 			spa->spa_loaded_ts.tv_nsec = 0;
3454 			(void) zfs_ereport_post(ereport, spa,
3458 	spa->spa_load_state = error ? SPA_LOAD_ERROR : SPA_LOAD_NONE;
3459 	spa->spa_ena = 0;
3461 	(void) spa_import_progress_set_state(spa_guid(spa),
3462 	    spa_load_state(spa));
3471  * spa's per-vdev ZAP list.
3476 	spa_t *spa = vd->vdev_spa;
3482 		ASSERT0(zap_lookup_int(spa->spa_meta_objset,
3483 		    spa->spa_all_vdev_zaps, vd->vdev_root_zap));
3487 		ASSERT0(zap_lookup_int(spa->spa_meta_objset,
3488 		    spa->spa_all_vdev_zaps, vd->vdev_top_zap));
3492 		ASSERT0(zap_lookup_int(spa->spa_meta_objset,
3493 		    spa->spa_all_vdev_zaps, vd->vdev_leaf_zap));
3510 spa_activity_check_required(spa_t *spa, uberblock_t *ub, nvlist_t *label,
3536 	if (spa->spa_import_flags & ZFS_IMPORT_SKIP_MMP)
3565 	if (hostid == spa_get_hostid(spa))
3581 spa_activity_check_duration(spa_t *spa, uberblock_t *ub)
3641 		    vdev_count_leaves(spa));
3663 spa_activity_check(spa_t *spa, uberblock_t *ub, nvlist_t *config,
3673 	vdev_t *rvd = spa->spa_root_vdev;
3702 	import_delay = spa_activity_check_duration(spa, ub);
3710 		spa_import_progress_set_notes(spa, "Checking MMP activity, "
3717 			spa_import_progress_set_notes(spa, "Checking MMP "
3723 			(void) spa_import_progress_set_mmp_check(spa_guid(spa),
3765 	 * spa->spa_load_info nvlist.  If the remote hostname or hostid are
3781 				fnvlist_add_string(spa->spa_load_info,
3788 				fnvlist_add_uint64(spa->spa_load_info,
3793 		fnvlist_add_uint64(spa->spa_load_info,
3795 		fnvlist_add_uint64(spa->spa_load_info,
3812 spa_mmp_remote_host_activity(spa_t *spa)
3814 	ASSERT(spa_multihost(spa) && spa_suspended(spa));
3822 	vdev_uberblock_load(spa->spa_root_vdev, &best_ub, &best_label);
3828 		    spa_get_hostid(spa) !=
3844 	if (best_ub.ub_txg != spa->spa_uberblock.ub_txg ||
3845 	    best_ub.ub_timestamp != spa->spa_uberblock.ub_timestamp) {
3848 		    (u_longlong_t)spa->spa_uberblock.ub_txg,
3850 		    (u_longlong_t)spa->spa_uberblock.ub_timestamp,
3858 	return (spa_activity_check(spa, &spa->spa_uberblock, spa->spa_config,
3863 spa_verify_host(spa_t *spa, nvlist_t *mos_config)
3869 	if (!spa_is_root(spa) && nvlist_lookup_uint64(mos_config,
3882 			    spa_name(spa), hostname, (u_longlong_t)hostid);
3883 			spa_load_failed(spa, "hostid verification failed: pool "
3894 spa_ld_parse_config(spa_t *spa, spa_import_type_t type)
3897 	nvlist_t *nvtree, *nvl, *config = spa->spa_config;
3909 	    &spa->spa_ubsync.ub_version) != 0)
3910 		spa->spa_ubsync.ub_version = SPA_VERSION_INITIAL;
3913 		spa_load_failed(spa, "invalid config provided: '%s' missing",
3921 	 * spa namespace.
3928 	if ((spa->spa_load_state == SPA_LOAD_IMPORT ||
3929 	    spa->spa_load_state == SPA_LOAD_TRYIMPORT) &&
3932 	if ((spa->spa_load_state == SPA_LOAD_IMPORT ||
3933 	    spa->spa_load_state == SPA_LOAD_TRYIMPORT) &&
3935 	    !spa_importing_readonly_checkpoint(spa)) {
3937 		spa_load_failed(spa, "a pool with guid %llu is already open",
3942 	spa->spa_config_guid = pool_guid;
3944 	nvlist_free(spa->spa_load_info);
3945 	spa->spa_load_info = fnvlist_alloc();
3947 	ASSERT(spa->spa_comment == NULL);
3949 		spa->spa_comment = spa_strdup(comment);
3951 	ASSERT(spa->spa_compatibility == NULL);
3954 		spa->spa_compatibility = spa_strdup(compatibility);
3957 	    &spa->spa_config_txg);
3960 		spa->spa_config_splitting = fnvlist_dup(nvl);
3963 		spa_load_failed(spa, "invalid config provided: '%s' missing",
3971 	spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *),
3974 		spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
3984 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3987 	error = spa_config_parse(spa, &rvd, nvtree, NULL, 0, parse);
3988 	spa_config_exit(spa, SCL_ALL, FTAG);
3991 		spa_load_failed(spa, "unable to parse config [error=%d]",
3996 	ASSERT(spa->spa_root_vdev == rvd);
3997 	ASSERT3U(spa->spa_min_ashift, >=, SPA_MINBLOCKSHIFT);
3998 	ASSERT3U(spa->spa_max_ashift, <=, SPA_MAXBLOCKSHIFT);
4001 		ASSERT(spa_guid(spa) == pool_guid);
4012 spa_ld_open_vdevs(spa_t *spa)
4020 	if (spa->spa_trust_config) {
4021 		spa->spa_missing_tvds_allowed = zfs_max_missing_tvds;
4022 	} else if (spa->spa_config_source == SPA_CONFIG_SRC_CACHEFILE) {
4023 		spa->spa_missing_tvds_allowed = zfs_max_missing_tvds_cachefile;
4024 	} else if (spa->spa_config_source == SPA_CONFIG_SRC_SCAN) {
4025 		spa->spa_missing_tvds_allowed = zfs_max_missing_tvds_scan;
4027 		spa->spa_missing_tvds_allowed = 0;
4030 	spa->spa_missing_tvds_allowed =
4031 	    MAX(zfs_max_missing_tvds, spa->spa_missing_tvds_allowed);
4033 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4034 	error = vdev_open(spa->spa_root_vdev);
4035 	spa_config_exit(spa, SCL_ALL, FTAG);
4037 	if (spa->spa_missing_tvds != 0) {
4038 		spa_load_note(spa, "vdev tree has %lld missing top-level "
4039 		    "vdevs.", (u_longlong_t)spa->spa_missing_tvds);
4040 		if (spa->spa_trust_config && (spa->spa_mode & SPA_MODE_WRITE)) {
4050 			spa_load_note(spa, "pools with missing top-level "
4054 			spa_load_note(spa, "current settings allow for maximum "
4056 			    (u_longlong_t)spa->spa_missing_tvds_allowed);
4060 		spa_load_failed(spa, "unable to open vdev tree [error=%d]",
4063 	if (spa->spa_missing_tvds != 0 || error != 0)
4064 		vdev_dbgmsg_print_tree(spa->spa_root_vdev, 2);
4076 spa_ld_validate_vdevs(spa_t *spa)
4079 	vdev_t *rvd = spa->spa_root_vdev;
4081 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4083 	spa_config_exit(spa, SCL_ALL, FTAG);
4086 		spa_load_failed(spa, "vdev_validate failed [error=%d]", error);
4091 		spa_load_failed(spa, "cannot open vdev tree after invalidating "
4101 spa_ld_select_uberblock_done(spa_t *spa, uberblock_t *ub)
4103 	spa->spa_state = POOL_STATE_ACTIVE;
4104 	spa->spa_ubsync = spa->spa_uberblock;
4105 	spa->spa_verify_min_txg = spa->spa_extreme_rewind ?
4106 	    TXG_INITIAL - 1 : spa_last_synced_txg(spa) - TXG_DEFER_SIZE - 1;
4107 	spa->spa_first_txg = spa->spa_last_ubsync_txg ?
4108 	    spa->spa_last_ubsync_txg : spa_last_synced_txg(spa) + 1;
4109 	spa->spa_claim_max_txg = spa->spa_first_txg;
4110 	spa->spa_prev_software_version = ub->ub_software_version;
4114 spa_ld_select_uberblock(spa_t *spa, spa_import_type_t type)
4116 	vdev_t *rvd = spa->spa_root_vdev;
4118 	uberblock_t *ub = &spa->spa_uberblock;
4139 	    spa_importing_readonly_checkpoint(spa)) {
4140 		spa_ld_select_uberblock_done(spa, ub);
4154 		spa_load_failed(spa, "no valid uberblock found");
4158 	if (spa->spa_load_max_txg != UINT64_MAX) {
4159 		(void) spa_import_progress_set_max_txg(spa_guid(spa),
4160 		    (u_longlong_t)spa->spa_load_max_txg);
4162 	spa_load_note(spa, "using uberblock with txg=%llu",
4165 		spa_load_note(spa, "uberblock raidz_reflow_info: "
4177 	activity_check = spa_activity_check_required(spa, ub, label,
4178 	    spa->spa_config);
4181 		    spa_get_hostid(spa) == 0) {
4183 			fnvlist_add_uint64(spa->spa_load_info,
4189 		    spa_activity_check(spa, ub, spa->spa_config, B_TRUE);
4195 		fnvlist_add_uint64(spa->spa_load_info,
4197 		fnvlist_add_uint64(spa->spa_load_info,
4199 		fnvlist_add_uint16(spa->spa_load_info,
4209 		spa_load_failed(spa, "version %llu is not supported",
4222 			spa_load_failed(spa, "label config unavailable");
4230 			spa_load_failed(spa, "invalid label: '%s' missing",
4240 		nvlist_free(spa->spa_label_features);
4241 		spa->spa_label_features = fnvlist_dup(features);
4256 		for (nvpair_t *nvp = nvlist_next_nvpair(spa->spa_label_features,
4258 		    nvp = nvlist_next_nvpair(spa->spa_label_features, nvp)) {
4266 			fnvlist_add_nvlist(spa->spa_load_info,
4269 			spa_load_failed(spa, "some features are unsupported");
4277 	if (type != SPA_IMPORT_ASSEMBLE && spa->spa_config_splitting) {
4278 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4279 		spa_try_repair(spa, spa->spa_config);
4280 		spa_config_exit(spa, SCL_ALL, FTAG);
4281 		nvlist_free(spa->spa_config_splitting);
4282 		spa->spa_config_splitting = NULL;
4288 	spa_ld_select_uberblock_done(spa, ub);
4294 spa_ld_open_rootbp(spa_t *spa)
4297 	vdev_t *rvd = spa->spa_root_vdev;
4299 	error = dsl_pool_init(spa, spa->spa_first_txg, &spa->spa_dsl_pool);
4301 		spa_load_failed(spa, "unable to open rootbp in dsl_pool_init "
4305 	spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset;
4311 spa_ld_trusted_config(spa_t *spa, spa_import_type_t type,
4314 	vdev_t *mrvd, *rvd = spa->spa_root_vdev;
4320 	if (spa_dir_prop(spa, DMU_POOL_CONFIG, &spa->spa_config_object, B_TRUE)
4331 	healthy_tvds = spa_healthy_core_tvds(spa);
4333 	if (load_nvlist(spa, spa->spa_config_object, &mos_config)
4335 		spa_load_failed(spa, "unable to retrieve MOS config");
4343 	if (spa->spa_load_state == SPA_LOAD_OPEN) {
4344 		error = spa_verify_host(spa, mos_config);
4353 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4358 	error = spa_config_parse(spa, &mrvd, nv, NULL, 0, VDEV_ALLOC_LOAD);
4361 		spa_config_exit(spa, SCL_ALL, FTAG);
4362 		spa_load_failed(spa, "spa_config_parse failed [error=%d]",
4378 		spa_load_note(spa, "provided vdev tree:");
4380 		spa_load_note(spa, "MOS vdev tree:");
4384 		spa_load_note(spa, "vdev_copy_path_strict failed, falling "
4391 	spa->spa_root_vdev = mrvd;
4393 	spa_config_exit(spa, SCL_ALL, FTAG);
4407 		fnvlist_add_uint64(spa->spa_load_info, ZPOOL_CONFIG_HOSTID,
4410 		fnvlist_add_string(spa->spa_load_info, ZPOOL_CONFIG_HOSTNAME,
4414 	 * We will use spa_config if we decide to reload the spa or if spa_load
4423 	mos_config = spa_config_generate(spa, NULL, mos_config_txg, B_FALSE);
4424 	if (nvlist_lookup_nvlist(spa->spa_config, ZPOOL_LOAD_POLICY,
4427 	spa_config_set(spa, mos_config);
4428 	spa->spa_config_source = SPA_CONFIG_SRC_MOS;
4436 	spa->spa_trust_config = B_TRUE;
4441 	error = spa_ld_open_vdevs(spa);
4445 	error = spa_ld_validate_vdevs(spa);
4450 		spa_load_note(spa, "final vdev tree:");
4454 	if (spa->spa_load_state != SPA_LOAD_TRYIMPORT &&
4455 	    !spa->spa_extreme_rewind && zfs_max_missing_tvds == 0) {
4463 		healthy_tvds_mos = spa_healthy_core_tvds(spa);
4466 			spa_load_note(spa, "config provided misses too many "
4470 			spa_load_note(spa, "vdev tree:");
4473 				spa_load_failed(spa, "config was already "
4478 			spa_load_note(spa, "spa must be reloaded using MOS "
4484 	error = spa_check_for_missing_logs(spa);
4488 	if (rvd->vdev_guid_sum != spa->spa_uberblock.ub_guid_sum) {
4489 		spa_load_failed(spa, "uberblock guid sum doesn't match MOS "
4491 		    (u_longlong_t)spa->spa_uberblock.ub_guid_sum,
4501 spa_ld_open_indirect_vdev_metadata(spa_t *spa)
4504 	vdev_t *rvd = spa->spa_root_vdev;
4510 	error = spa_remove_init(spa);
4512 		spa_load_failed(spa, "spa_remove_init failed [error=%d]",
4520 	error = spa_condense_init(spa);
4522 		spa_load_failed(spa, "spa_condense_init failed [error=%d]",
4531 spa_ld_check_features(spa_t *spa, boolean_t *missing_feat_writep)
4534 	vdev_t *rvd = spa->spa_root_vdev;
4536 	if (spa_version(spa) >= SPA_VERSION_FEATURES) {
4540 		if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_READ,
4541 		    &spa->spa_feat_for_read_obj, B_TRUE) != 0) {
4545 		if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_WRITE,
4546 		    &spa->spa_feat_for_write_obj, B_TRUE) != 0) {
4550 		if (spa_dir_prop(spa, DMU_POOL_FEATURE_DESCRIPTIONS,
4551 		    &spa->spa_feat_desc_obj, B_TRUE) != 0) {
4558 		if (!spa_features_check(spa, B_FALSE,
4562 		if (spa_writeable(spa) ||
4563 		    spa->spa_load_state == SPA_LOAD_TRYIMPORT) {
4564 			if (!spa_features_check(spa, B_TRUE,
4570 		fnvlist_add_nvlist(spa->spa_load_info,
4574 			fnvlist_add_nvlist(spa->spa_load_info,
4582 			fnvlist_add_boolean(spa->spa_load_info,
4606 		    spa_writeable(spa))) {
4607 			spa_load_failed(spa, "pool uses unsupported features");
4619 			error = feature_get_refcount_from_disk(spa,
4622 				spa->spa_feat_refcount_cache[i] = refcount;
4624 				spa->spa_feat_refcount_cache[i] =
4627 				spa_load_failed(spa, "error getting refcount "
4636 	if (spa_feature_is_active(spa, SPA_FEATURE_ENABLED_TXG)) {
4637 		if (spa_dir_prop(spa, DMU_POOL_FEATURE_ENABLED_TXG,
4638 		    &spa->spa_feat_enabled_txg_obj, B_TRUE) != 0)
4647 	if (spa_feature_is_enabled(spa, SPA_FEATURE_ENCRYPTION) &&
4648 	    !spa_feature_is_enabled(spa, SPA_FEATURE_BOOKMARK_V2)) {
4649 		spa->spa_errata = ZPOOL_ERRATA_ZOL_8308_ENCRYPTION;
4656 spa_ld_load_special_directories(spa_t *spa)
4659 	vdev_t *rvd = spa->spa_root_vdev;
4661 	spa->spa_is_initializing = B_TRUE;
4662 	error = dsl_pool_open(spa->spa_dsl_pool);
4663 	spa->spa_is_initializing = B_FALSE;
4665 		spa_load_failed(spa, "dsl_pool_open failed [error=%d]", error);
4673 spa_ld_get_props(spa_t *spa)
4677 	vdev_t *rvd = spa->spa_root_vdev;
4680 	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
4682 	    sizeof (spa->spa_cksum_salt.zcs_bytes),
4683 	    spa->spa_cksum_salt.zcs_bytes);
4686 		(void) random_get_pseudo_bytes(spa->spa_cksum_salt.zcs_bytes,
4687 		    sizeof (spa->spa_cksum_salt.zcs_bytes));
4689 		spa_load_failed(spa, "unable to retrieve checksum salt from "
4694 	if (spa_dir_prop(spa, DMU_POOL_SYNC_BPOBJ, &obj, B_TRUE) != 0)
4696 	error = bpobj_open(&spa->spa_deferred_bpobj, spa->spa_meta_objset, obj);
4698 		spa_load_failed(spa, "error opening deferred-frees bpobj "
4708 	error = spa_dir_prop(spa, DMU_POOL_DEFLATE, &spa->spa_deflate, B_FALSE);
4712 	error = spa_dir_prop(spa, DMU_POOL_CREATION_VERSION,
4713 	    &spa->spa_creation_version, B_FALSE);
4721 	error = spa_dir_prop(spa, DMU_POOL_ERRLOG_LAST, &spa->spa_errlog_last,
4726 	error = spa_dir_prop(spa, DMU_POOL_ERRLOG_SCRUB,
4727 	    &spa->spa_errlog_scrub, B_FALSE);
4732 	error = spa_dir_prop(spa, DMU_POOL_LAST_SCRUBBED_TXG,
4733 	    &spa->spa_scrubbed_last_txg, B_FALSE);
4739 	 * deletion, indicate that in the spa
4741 	error = spa_dir_prop(spa, DMU_POOL_DELETED_CLONES,
4742 	    &spa->spa_livelists_to_delete, B_FALSE);
4750 	error = spa_dir_prop(spa, DMU_POOL_HISTORY, &spa->spa_history, B_FALSE);
4763 	if (load_nvlist(spa, spa->spa_config_object, &mos_config) != 0) {
4764 		spa_load_failed(spa, "unable to retrieve MOS config");
4768 	error = spa_dir_prop(spa, DMU_POOL_VDEV_ZAP_MAP,
4769 	    &spa->spa_all_vdev_zaps, B_FALSE);
4774 		spa->spa_avz_action = AVZ_ACTION_INITIALIZE;
4775 		ASSERT0(vdev_count_verify_zaps(spa->spa_root_vdev));
4785 		spa->spa_avz_action = AVZ_ACTION_DESTROY;
4790 		ASSERT0(vdev_count_verify_zaps(spa->spa_root_vdev));
4794 	spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);
4796 	error = spa_dir_prop(spa, DMU_POOL_PROPS, &spa->spa_pool_props_object,
4804 		spa_prop_find(spa, ZPOOL_PROP_BOOTFS, &spa->spa_bootfs);
4805 		spa_prop_find(spa, ZPOOL_PROP_AUTOREPLACE, &autoreplace);
4806 		spa_prop_find(spa, ZPOOL_PROP_DELEGATION, &spa->spa_delegation);
4807 		spa_prop_find(spa, ZPOOL_PROP_FAILUREMODE, &spa->spa_failmode);
4808 		spa_prop_find(spa, ZPOOL_PROP_AUTOEXPAND, &spa->spa_autoexpand);
4809 		spa_prop_find(spa, ZPOOL_PROP_DEDUP_TABLE_QUOTA,
4810 		    &spa->spa_dedup_table_quota);
4811 		spa_prop_find(spa, ZPOOL_PROP_MULTIHOST, &spa->spa_multihost);
4812 		spa_prop_find(spa, ZPOOL_PROP_AUTOTRIM, &spa->spa_autotrim);
4813 		spa->spa_autoreplace = (autoreplace != 0);
4821 	if (spa->spa_missing_tvds > 0 &&
4822 	    spa->spa_failmode != ZIO_FAILURE_MODE_CONTINUE &&
4823 	    spa->spa_load_state != SPA_LOAD_TRYIMPORT) {
4824 		spa_load_note(spa, "forcing failmode to 'continue' "
4826 		spa->spa_failmode = ZIO_FAILURE_MODE_CONTINUE;
4833 spa_ld_open_aux_vdevs(spa_t *spa, spa_import_type_t type)
4836 	vdev_t *rvd = spa->spa_root_vdev;
4847 	error = spa_dir_prop(spa, DMU_POOL_SPARES, &spa->spa_spares.sav_object,
4852 		ASSERT(spa_version(spa) >= SPA_VERSION_SPARES);
4853 		if (load_nvlist(spa, spa->spa_spares.sav_object,
4854 		    &spa->spa_spares.sav_config) != 0) {
4855 			spa_load_failed(spa, "error loading spares nvlist");
4859 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4860 		spa_load_spares(spa);
4861 		spa_config_exit(spa, SCL_ALL, FTAG);
4863 		spa->spa_spares.sav_sync = B_TRUE;
4869 	error = spa_dir_prop(spa, DMU_POOL_L2CACHE,
4870 	    &spa->spa_l2cache.sav_object, B_FALSE);
4874 		ASSERT(spa_version(spa) >= SPA_VERSION_L2CACHE);
4875 		if (load_nvlist(spa, spa->spa_l2cache.sav_object,
4876 		    &spa->spa_l2cache.sav_config) != 0) {
4877 			spa_load_failed(spa, "error loading l2cache nvlist");
4881 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4882 		spa_load_l2cache(spa);
4883 		spa_config_exit(spa, SCL_ALL, FTAG);
4885 		spa->spa_l2cache.sav_sync = B_TRUE;
4892 spa_ld_load_vdev_metadata(spa_t *spa)
4895 	vdev_t *rvd = spa->spa_root_vdev;
4902 	if (spa_multihost(spa) && spa_get_hostid(spa) == 0 &&
4903 	    (spa->spa_import_flags & ZFS_IMPORT_SKIP_MMP) == 0) {
4904 		fnvlist_add_uint64(spa->spa_load_info,
4916 	if (spa->spa_autoreplace && spa->spa_load_state != SPA_LOAD_TRYIMPORT) {
4917 		spa_check_removed(spa->spa_root_vdev);
4923 		if (spa->spa_load_state != SPA_LOAD_IMPORT) {
4924 			spa_aux_check_removed(&spa->spa_spares);
4925 			spa_aux_check_removed(&spa->spa_l2cache);
4934 		spa_load_failed(spa, "vdev_load failed [error=%d]", error);
4938 	error = spa_ld_log_spacemaps(spa);
4940 		spa_load_failed(spa, "spa_ld_log_spacemaps failed [error=%d]",
4948 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4950 	spa_config_exit(spa, SCL_ALL, FTAG);
4956 spa_ld_load_dedup_tables(spa_t *spa)
4959 	vdev_t *rvd = spa->spa_root_vdev;
4961 	error = ddt_load(spa);
4963 		spa_load_failed(spa, "ddt_load failed [error=%d]", error);
4971 spa_ld_load_brt(spa_t *spa)
4974 	vdev_t *rvd = spa->spa_root_vdev;
4976 	error = brt_load(spa);
4978 		spa_load_failed(spa, "brt_load failed [error=%d]", error);
4986 spa_ld_verify_logs(spa_t *spa, spa_import_type_t type, const char **ereport)
4988 	vdev_t *rvd = spa->spa_root_vdev;
4990 	if (type != SPA_IMPORT_ASSEMBLE && spa_writeable(spa)) {
4991 		boolean_t missing = spa_check_logs(spa);
4993 			if (spa->spa_missing_tvds != 0) {
4994 				spa_load_note(spa, "spa_check_logs failed "
4998 				spa_load_failed(spa, "spa_check_logs failed");
5009 spa_ld_verify_pool_data(spa_t *spa)
5012 	vdev_t *rvd = spa->spa_root_vdev;
5018 	if (spa->spa_load_state != SPA_LOAD_TRYIMPORT) {
5019 		error = spa_load_verify(spa);
5021 			spa_load_failed(spa, "spa_load_verify failed "
5032 spa_ld_claim_log_blocks(spa_t *spa)
5035 	dsl_pool_t *dp = spa_get_dsl(spa);
5044 	spa->spa_claiming = B_TRUE;
5046 	tx = dmu_tx_create_assigned(dp, spa_first_txg(spa));
5051 	spa->spa_claiming = B_FALSE;
5053 	spa_set_log_state(spa, SPA_LOG_GOOD);
5057 spa_ld_check_for_config_update(spa_t *spa, uint64_t config_cache_txg,
5060 	vdev_t *rvd = spa->spa_root_vdev;
5070 	if (update_config_cache || config_cache_txg != spa->spa_config_txg ||
5071 	    spa->spa_load_state == SPA_LOAD_IMPORT ||
5072 	    spa->spa_load_state == SPA_LOAD_RECOVER ||
5073 	    (spa->spa_import_flags & ZFS_IMPORT_VERBATIM))
5085 		spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
5089 spa_ld_prepare_for_reload(spa_t *spa)
5091 	spa_mode_t mode = spa->spa_mode;
5092 	int async_suspended = spa->spa_async_suspended;
5094 	spa_unload(spa);
5095 	spa_deactivate(spa);
5096 	spa_activate(spa, mode);
5103 	spa->spa_async_suspended = async_suspended;
5107 spa_ld_read_checkpoint_txg(spa_t *spa)
5112 	ASSERT0(spa->spa_checkpoint_txg);
5114 	    spa->spa_load_thread == curthread);
5116 	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
5129 	spa->spa_checkpoint_txg = checkpoint.ub_txg;
5130 	spa->spa_checkpoint_info.sci_timestamp = checkpoint.ub_timestamp;
5136 spa_ld_mos_init(spa_t *spa, spa_import_type_t type)
5141 	ASSERT(spa->spa_config_source != SPA_CONFIG_SRC_NONE);
5147 	 * also effectively puts the spa in read-only mode since
5152 		spa->spa_trust_config = B_FALSE;
5157 	error = spa_ld_parse_config(spa, type);
5161 	spa_import_progress_add(spa);
5170 	error = spa_ld_open_vdevs(spa);
5182 		error = spa_ld_validate_vdevs(spa);
5194 	error = spa_ld_select_uberblock(spa, type);
5203 	error = spa_ld_open_rootbp(spa);
5211 spa_ld_checkpoint_rewind(spa_t *spa)
5217 	ASSERT(spa->spa_import_flags & ZFS_IMPORT_CHECKPOINT);
5219 	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
5224 		spa_load_failed(spa, "unable to retrieve checkpointed "
5233 	ASSERT3U(checkpoint.ub_txg, <, spa->spa_uberblock.ub_txg);
5243 	checkpoint.ub_txg = spa->spa_uberblock.ub_txg + 1;
5249 	spa->spa_uberblock = checkpoint;
5263 	if (spa_writeable(spa)) {
5264 		vdev_t *rvd = spa->spa_root_vdev;
5266 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
5287 		error = vdev_config_sync(svd, svdcount, spa->spa_first_txg);
5289 			spa->spa_last_synced_guid = rvd->vdev_guid;
5290 		spa_config_exit(spa, SCL_ALL, FTAG);
5293 			spa_load_failed(spa, "failed to write checkpointed "
5303 spa_ld_mos_with_trusted_config(spa_t *spa, spa_import_type_t type,
5313 	error = spa_ld_mos_init(spa, type);
5321 	error = spa_ld_trusted_config(spa, type, B_FALSE);
5330 		spa_ld_prepare_for_reload(spa);
5331 		spa_load_note(spa, "RELOADING");
5332 		error = spa_ld_mos_init(spa, type);
5336 		error = spa_ld_trusted_config(spa, type, B_TRUE);
5354 spa_load_impl(spa_t *spa, spa_import_type_t type, const char **ereport)
5359 	    (spa->spa_import_flags & ZFS_IMPORT_CHECKPOINT);
5364 	ASSERT(spa->spa_config_source != SPA_CONFIG_SRC_NONE);
5366 	spa_load_note(spa, "LOADING");
5368 	error = spa_ld_mos_with_trusted_config(spa, type, &update_config_cache);
5391 		error = spa_ld_checkpoint_rewind(spa);
5399 		spa_ld_prepare_for_reload(spa);
5400 		spa_load_note(spa, "LOADING checkpointed uberblock");
5401 		error = spa_ld_mos_with_trusted_config(spa, type, NULL);
5409 	spa->spa_load_thread = curthread;
5415 	spa_import_progress_set_notes(spa, "Loading checkpoint txg");
5416 	error = spa_ld_read_checkpoint_txg(spa);
5428 	spa_import_progress_set_notes(spa, "Loading indirect vdev metadata");
5429 	error = spa_ld_open_indirect_vdev_metadata(spa);
5437 	spa_import_progress_set_notes(spa, "Checking feature flags");
5438 	error = spa_ld_check_features(spa, &missing_feat_write);
5446 	spa_import_progress_set_notes(spa, "Loading special MOS directories");
5447 	error = spa_ld_load_special_directories(spa);
5454 	spa_import_progress_set_notes(spa, "Loading properties");
5455 	error = spa_ld_get_props(spa);
5463 	spa_import_progress_set_notes(spa, "Loading AUX vdevs");
5464 	error = spa_ld_open_aux_vdevs(spa, type);
5472 	spa_import_progress_set_notes(spa, "Loading vdev metadata");
5473 	error = spa_ld_load_vdev_metadata(spa);
5477 	spa_import_progress_set_notes(spa, "Loading dedup tables");
5478 	error = spa_ld_load_dedup_tables(spa);
5482 	spa_import_progress_set_notes(spa, "Loading BRT");
5483 	error = spa_ld_load_brt(spa);
5491 	spa_import_progress_set_notes(spa, "Verifying Log Devices");
5492 	error = spa_ld_verify_logs(spa, type, ereport);
5497 		ASSERT(spa->spa_load_state == SPA_LOAD_TRYIMPORT);
5504 		error = spa_vdev_err(spa->spa_root_vdev, VDEV_AUX_UNSUP_FEAT,
5514 	spa_import_progress_set_notes(spa, "Verifying pool data");
5515 	error = spa_ld_verify_pool_data(spa);
5524 	spa_import_progress_set_notes(spa, "Calculating deflated space");
5525 	spa_update_dspace(spa);
5532 	spa_import_progress_set_notes(spa, "Starting import");
5533 	if (spa_writeable(spa) && (spa->spa_load_state == SPA_LOAD_RECOVER ||
5534 	    spa->spa_load_max_txg == UINT64_MAX)) {
5535 		uint64_t config_cache_txg = spa->spa_config_txg;
5537 		ASSERT(spa->spa_load_state != SPA_LOAD_TRYIMPORT);
5543 		if (RRSS_GET_STATE(&spa->spa_uberblock) == RRSS_SCRATCH_VALID)
5544 			vdev_raidz_reflow_copy_scratch(spa);
5551 			spa_history_log_internal(spa, "checkpoint rewind",
5553 			    (u_longlong_t)spa->spa_uberblock.ub_checkpoint_txg);
5556 		spa_import_progress_set_notes(spa, "Claiming ZIL blocks");
5560 		spa_ld_claim_log_blocks(spa);
5565 		spa->spa_sync_on = B_TRUE;
5566 		txg_sync_start(spa->spa_dsl_pool);
5567 		mmp_thread_start(spa);
5576 		spa_import_progress_set_notes(spa, "Syncing ZIL claims");
5577 		txg_wait_synced(spa->spa_dsl_pool, spa->spa_claim_max_txg);
5584 		spa_import_progress_set_notes(spa, "Updating configs");
5585 		spa_ld_check_for_config_update(spa, config_cache_txg,
5593 		spa_import_progress_set_notes(spa, "Starting resilvers");
5594 		if (vdev_rebuild_active(spa->spa_root_vdev)) {
5595 			vdev_rebuild_restart(spa);
5596 		} else if (!dsl_scan_resilvering(spa->spa_dsl_pool) &&
5597 		    vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) {
5598 			spa_async_request(spa, SPA_ASYNC_RESILVER);
5605 		spa_history_log_version(spa, "open", NULL);
5607 		spa_import_progress_set_notes(spa,
5609 		spa_restart_removal(spa);
5610 		spa_spawn_aux_threads(spa);
5621 		spa_import_progress_set_notes(spa,
5623 		(void) dmu_objset_find(spa_name(spa),
5629 		spa_import_progress_set_notes(spa,
5631 		dsl_pool_clean_tmp_userrefs(spa->spa_dsl_pool);
5633 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
5634 		spa_import_progress_set_notes(spa, "Restarting initialize");
5635 		vdev_initialize_restart(spa->spa_root_vdev);
5636 		spa_import_progress_set_notes(spa, "Restarting TRIM");
5637 		vdev_trim_restart(spa->spa_root_vdev);
5638 		vdev_autotrim_restart(spa);
5639 		spa_config_exit(spa, SCL_CONFIG, FTAG);
5640 		spa_import_progress_set_notes(spa, "Finished importing");
5642 	zio_handle_import_delay(spa, gethrtime() - load_start);
5644 	spa_import_progress_remove(spa_guid(spa));
5645 	spa_async_request(spa, SPA_ASYNC_L2CACHE_REBUILD);
5647 	spa_load_note(spa, "LOADED");
5650 	spa->spa_load_thread = NULL;
5658 spa_load_retry(spa_t *spa, spa_load_state_t state)
5660 	spa_mode_t mode = spa->spa_mode;
5662 	spa_unload(spa);
5663 	spa_deactivate(spa);
5665 	spa->spa_load_max_txg = spa->spa_uberblock.ub_txg - 1;
5667 	spa_activate(spa, mode);
5668 	spa_async_suspend(spa);
5670 	spa_load_note(spa, "spa_load_retry: rewind, max txg: %llu",
5671 	    (u_longlong_t)spa->spa_load_max_txg);
5673 	return (spa_load(spa, state, SPA_IMPORT_EXISTING));
5684 spa_load_best(spa_t *spa, spa_load_state_t state, uint64_t max_request,
5693 	if (spa->spa_load_txg && state == SPA_LOAD_RECOVER) {
5694 		spa->spa_load_max_txg = spa->spa_load_txg;
5695 		spa_set_log_state(spa, SPA_LOG_CLEAR);
5697 		spa->spa_load_max_txg = max_request;
5699 			spa->spa_extreme_rewind = B_TRUE;
5702 	load_error = rewind_error = spa_load(spa, state, SPA_IMPORT_EXISTING);
5711 		ASSERT(spa->spa_import_flags & ZFS_IMPORT_CHECKPOINT);
5712 		spa_import_progress_remove(spa_guid(spa));
5716 	if (spa->spa_root_vdev != NULL)
5717 		config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
5719 	spa->spa_last_ubsync_txg = spa->spa_uberblock.ub_txg;
5720 	spa->spa_last_ubsync_txg_ts = spa->spa_uberblock.ub_timestamp;
5724 		spa_import_progress_remove(spa_guid(spa));
5730 		spa_set_log_state(spa, SPA_LOG_CLEAR);
5737 		loadinfo = spa->spa_load_info;
5738 		spa->spa_load_info = fnvlist_alloc();
5741 	spa->spa_load_max_txg = spa->spa_last_ubsync_txg;
5742 	safe_rewind_txg = spa->spa_last_ubsync_txg - TXG_DEFER_SIZE;
5750 	while (rewind_error && spa->spa_uberblock.ub_txg >= min_txg &&
5751 	    spa->spa_uberblock.ub_txg <= spa->spa_load_max_txg) {
5752 		if (spa->spa_load_max_txg < safe_rewind_txg)
5753 			spa->spa_extreme_rewind = B_TRUE;
5754 		rewind_error = spa_load_retry(spa, state);
5757 	spa->spa_extreme_rewind = B_FALSE;
5758 	spa->spa_load_max_txg = UINT64_MAX;
5761 		spa_config_set(spa, config);
5767 		spa_import_progress_remove(spa_guid(spa));
5772 		    spa->spa_load_info);
5775 		fnvlist_free(spa->spa_load_info);
5776 		spa->spa_load_info = loadinfo;
5778 		spa_import_progress_remove(spa_guid(spa));
5799 	spa_t *spa;
5818 	if ((spa = spa_lookup(pool)) == NULL) {
5824 	if (spa->spa_state == POOL_STATE_UNINITIALIZED) {
5829 		zpool_get_load_policy(nvpolicy ? nvpolicy : spa->spa_config,
5834 		spa_activate(spa, spa_mode_global);
5837 			spa->spa_last_ubsync_txg = spa->spa_load_txg = 0;
5838 		spa->spa_config_source = SPA_CONFIG_SRC_CACHEFILE;
5841 		error = spa_load_best(spa, state, policy.zlp_txg,
5852 			spa_unload(spa);
5853 			spa_deactivate(spa);
5854 			spa_write_cachefile(spa, B_TRUE, B_TRUE, B_FALSE);
5855 			spa_remove(spa);
5867 			if (config != NULL && spa->spa_config) {
5868 				*config = fnvlist_dup(spa->spa_config);
5871 				    spa->spa_load_info);
5873 			spa_unload(spa);
5874 			spa_deactivate(spa);
5875 			spa->spa_last_open_failed = error;
5883 	spa_open_ref(spa, tag);
5886 		*config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
5894 		    spa->spa_load_info);
5898 		spa->spa_last_open_failed = 0;
5899 		spa->spa_last_ubsync_txg = 0;
5900 		spa->spa_load_txg = 0;
5905 		zvol_create_minors_recursive(spa_name(spa));
5907 	*spapp = spa;
5932 	spa_t *spa;
5935 	if ((spa = spa_lookup(name)) == NULL) {
5939 	spa->spa_inject_ref++;
5942 	return (spa);
5946 spa_inject_delref(spa_t *spa)
5949 	spa->spa_inject_ref--;
5957 spa_add_spares(spa_t *spa, nvlist_t *config)
5967 	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));
5969 	if (spa->spa_spares.sav_count == 0)
5973 	VERIFY0(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
5997 				    spa->spa_spares.sav_vdevs[i]->vdev_state;
6007 spa_add_l2cache(spa_t *spa, nvlist_t *config)
6017 	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));
6019 	if (spa->spa_l2cache.sav_count == 0)
6023 	VERIFY0(nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
6040 			for (j = 0; j < spa->spa_l2cache.sav_count; j++) {
6042 				    spa->spa_l2cache.sav_vdevs[j]->vdev_guid) {
6043 					vd = spa->spa_l2cache.sav_vdevs[j];
6059 spa_feature_stats_from_disk(spa_t *spa, nvlist_t *features)
6064 	if (spa->spa_feat_for_read_obj != 0) {
6065 		for (zap_cursor_init(&zc, spa->spa_meta_objset,
6066 		    spa->spa_feat_for_read_obj);
6077 	if (spa->spa_feat_for_write_obj != 0) {
6078 		for (zap_cursor_init(&zc, spa->spa_meta_objset,
6079 		    spa->spa_feat_for_write_obj);
6093 spa_feature_stats_from_cache(spa_t *spa, nvlist_t *features)
6101 		if (feature_get_refcount(spa, &feature, &refcount) != 0)
6112  * The first time this is called on a spa, allocate a new nvlist, fetch
6114  * in the spa. In subsequent calls on the same spa use the saved nvlist
6120 spa_add_feature_stats(spa_t *spa, nvlist_t *config)
6124 	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));
6126 	mutex_enter(&spa->spa_feat_stats_lock);
6127 	features = spa->spa_feat_stats;
6130 		spa_feature_stats_from_cache(spa, features);
6133 		spa->spa_feat_stats = features;
6134 		spa_feature_stats_from_disk(spa, features);
6140 	mutex_exit(&spa->spa_feat_stats_lock);
6148 	spa_t *spa;
6151 	error = spa_open_common(name, &spa, FTAG, NULL, config);
6153 	if (spa != NULL) {
6159 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
6164 			loadtimes[0] = spa->spa_loaded_ts.tv_sec;
6165 			loadtimes[1] = spa->spa_loaded_ts.tv_nsec;
6171 			    spa_approx_errlog_size(spa));
6173 			if (spa_suspended(spa)) {
6176 				    spa->spa_failmode);
6179 				    spa->spa_suspended);
6182 			spa_add_spares(spa, *config);
6183 			spa_add_l2cache(spa, *config);
6184 			spa_add_feature_stats(spa, *config);
6193 		if (spa == NULL) {
6195 			spa = spa_lookup(name);
6196 			if (spa)
6197 				spa_altroot(spa, altroot, buflen);
6200 			spa = NULL;
6203 			spa_altroot(spa, altroot, buflen);
6207 	if (spa != NULL) {
6208 		spa_config_exit(spa, SCL_CONFIG, FTAG);
6209 		spa_close(spa, FTAG);
6222 spa_validate_aux_devs(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode,
6231 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
6246 	if (spa_version(spa) < version)
6257 		if ((error = spa_config_parse(spa, &vd, dev[i], NULL, 0,
6291 spa_validate_aux(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode)
6295 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
6297 	if ((error = spa_validate_aux_devs(spa, nvroot, crtxg, mode,
6298 	    &spa->spa_spares, ZPOOL_CONFIG_SPARES, SPA_VERSION_SPARES,
6303 	return (spa_validate_aux_devs(spa, nvroot, crtxg, mode,
6304 	    &spa->spa_l2cache, ZPOOL_CONFIG_L2CACHE, SPA_VERSION_L2CACHE,
6354 spa_l2cache_drop(spa_t *spa)
6358 	spa_aux_vdev_t *sav = &spa->spa_l2cache;
6373  * Verify encryption parameters for spa creation. If we are encrypting, we must
6395 	spa_t *spa;
6434 	spa = spa_add(poolname, nvl, altroot);
6436 	spa_activate(spa, spa_mode_global);
6438 	if (props && (error = spa_prop_validate(spa, props))) {
6439 		spa_deactivate(spa);
6440 		spa_remove(spa);
6449 		spa->spa_import_flags |= ZFS_IMPORT_TEMP_NAME;
6472 			spa_deactivate(spa);
6473 			spa_remove(spa);
6479 		spa_deactivate(spa);
6480 		spa_remove(spa);
6491 	spa->spa_first_txg = txg;
6492 	spa->spa_uberblock.ub_txg = txg - 1;
6493 	spa->spa_uberblock.ub_version = version;
6494 	spa->spa_ubsync = spa->spa_uberblock;
6495 	spa->spa_load_state = SPA_LOAD_CREATE;
6496 	spa->spa_removing_phys.sr_state = DSS_NONE;
6497 	spa->spa_removing_phys.sr_removing_vdev = -1;
6498 	spa->spa_removing_phys.sr_prev_indirect_vdev = -1;
6499 	spa->spa_indirect_vdevs_loaded = B_TRUE;
6504 	spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *),
6507 		spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
6515 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
6517 	error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_ADD);
6520 	ASSERT(error != 0 || spa->spa_root_vdev == rvd);
6528 	    (error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) == 0) {
6541 	spa_config_exit(spa, SCL_ALL, FTAG);
6544 		spa_unload(spa);
6545 		spa_deactivate(spa);
6546 		spa_remove(spa);
6556 		spa->spa_spares.sav_config = fnvlist_alloc();
6557 		fnvlist_add_nvlist_array(spa->spa_spares.sav_config,
6560 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
6561 		spa_load_spares(spa);
6562 		spa_config_exit(spa, SCL_ALL, FTAG);
6563 		spa->spa_spares.sav_sync = B_TRUE;
6571 		VERIFY0(nvlist_alloc(&spa->spa_l2cache.sav_config,
6573 		fnvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
6576 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
6577 		spa_load_l2cache(spa);
6578 		spa_config_exit(spa, SCL_ALL, FTAG);
6579 		spa->spa_l2cache.sav_sync = B_TRUE;
6582 	spa->spa_is_initializing = B_TRUE;
6583 	spa->spa_dsl_pool = dp = dsl_pool_create(spa, zplprops, dcp, txg);
6584 	spa->spa_is_initializing = B_FALSE;
6589 	ddt_create(spa);
6593 	brt_create(spa);
6595 	spa_update_dspace(spa);
6602 	if (version >= SPA_VERSION_ZPOOL_HISTORY && !spa->spa_history)
6603 		spa_history_create_obj(spa, tx);
6605 	spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_CREATE);
6606 	spa_history_log_version(spa, "create", tx);
6611 	spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset,
6615 	if (zap_add(spa->spa_meta_objset,
6617 	    sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) {
6621 	if (zap_add(spa->spa_meta_objset,
6629 		spa->spa_deflate = TRUE;
6630 		if (zap_add(spa->spa_meta_objset,
6632 		    sizeof (uint64_t), 1, &spa->spa_deflate, tx) != 0) {
6642 	obj = bpobj_alloc(spa->spa_meta_objset, 1 << 14, tx);
6643 	dmu_object_set_compress(spa->spa_meta_objset, obj,
6645 	if (zap_add(spa->spa_meta_objset,
6650 	VERIFY3U(0, ==, bpobj_open(&spa->spa_deferred_bpobj,
6651 	    spa->spa_meta_objset, obj));
6656 	(void) random_get_pseudo_bytes(spa->spa_cksum_salt.zcs_bytes,
6657 	    sizeof (spa->spa_cksum_salt.zcs_bytes));
6662 	spa->spa_bootfs = zpool_prop_default_numeric(ZPOOL_PROP_BOOTFS);
6663 	spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);
6664 	spa->spa_failmode = zpool_prop_default_numeric(ZPOOL_PROP_FAILUREMODE);
6665 	spa->spa_autoexpand = zpool_prop_default_numeric(ZPOOL_PROP_AUTOEXPAND);
6666 	spa->spa_multihost = zpool_prop_default_numeric(ZPOOL_PROP_MULTIHOST);
6667 	spa->spa_autotrim = zpool_prop_default_numeric(ZPOOL_PROP_AUTOTRIM);
6668 	spa->spa_dedup_table_quota =
6672 		spa_configfile_set(spa, props, B_FALSE);
6677 		spa_feature_incr(spa, SPA_FEATURE_DRAID, tx);
6681 	spa->spa_sync_on = B_TRUE;
6683 	mmp_thread_start(spa);
6686 	spa_spawn_aux_threads(spa);
6688 	spa_write_cachefile(spa, B_FALSE, B_TRUE, B_TRUE);
6694 	spa_evicting_os_wait(spa);
6695 	spa->spa_minref = zfs_refcount_count(&spa->spa_refcount);
6696 	spa->spa_load_state = SPA_LOAD_NONE;
6698 	spa_import_os(spa);
6711 	spa_t *spa;
6732 	 * Create and initialize the spa structure.
6740 	spa = spa_add(pool, config, altroot);
6741 	spa->spa_import_flags = flags;
6747 	if (spa->spa_import_flags & ZFS_IMPORT_VERBATIM) {
6749 			spa_configfile_set(spa, props, B_FALSE);
6751 		spa_write_cachefile(spa, B_FALSE, B_TRUE, B_FALSE);
6752 		spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_IMPORT);
6758 	spa_activate(spa, mode);
6763 	spa_async_suspend(spa);
6769 	spa->spa_config_source = SPA_CONFIG_SRC_TRYIMPORT;
6772 		spa->spa_last_ubsync_txg = spa->spa_load_txg = 0;
6778 	error = spa_load_best(spa, state, policy.zlp_txg, policy.zlp_rewind);
6784 	fnvlist_add_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, spa->spa_load_info);
6786 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
6791 	if (spa->spa_spares.sav_config) {
6792 		nvlist_free(spa->spa_spares.sav_config);
6793 		spa->spa_spares.sav_config = NULL;
6794 		spa_load_spares(spa);
6796 	if (spa->spa_l2cache.sav_config) {
6797 		nvlist_free(spa->spa_l2cache.sav_config);
6798 		spa->spa_l2cache.sav_config = NULL;
6799 		spa_load_l2cache(spa);
6803 	spa_config_exit(spa, SCL_ALL, FTAG);
6806 		spa_configfile_set(spa, props, B_FALSE);
6808 	if (error != 0 || (props && spa_writeable(spa) &&
6809 	    (error = spa_prop_set(spa, props)))) {
6810 		spa_unload(spa);
6811 		spa_deactivate(spa);
6812 		spa_remove(spa);
6817 	spa_async_resume(spa);
6825 		if (spa->spa_spares.sav_config)
6826 			fnvlist_remove(spa->spa_spares.sav_config,
6829 			spa->spa_spares.sav_config = fnvlist_alloc();
6830 		fnvlist_add_nvlist_array(spa->spa_spares.sav_config,
6833 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
6834 		spa_load_spares(spa);
6835 		spa_config_exit(spa, SCL_ALL, FTAG);
6836 		spa->spa_spares.sav_sync = B_TRUE;
6837 		spa->spa_spares.sav_label_sync = B_TRUE;
6841 		if (spa->spa_l2cache.sav_config)
6842 			fnvlist_remove(spa->spa_l2cache.sav_config,
6845 			spa->spa_l2cache.sav_config = fnvlist_alloc();
6846 		fnvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
6849 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
6850 		spa_load_l2cache(spa);
6851 		spa_config_exit(spa, SCL_ALL, FTAG);
6852 		spa->spa_l2cache.sav_sync = B_TRUE;
6853 		spa->spa_l2cache.sav_label_sync = B_TRUE;
6859 	if (spa->spa_autoreplace) {
6860 		spa_aux_check_removed(&spa->spa_spares);
6861 		spa_aux_check_removed(&spa->spa_l2cache);
6864 	if (spa_writeable(spa)) {
6868 		spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
6875 	spa_async_request(spa, SPA_ASYNC_AUTOEXPAND);
6877 	spa_history_log_version(spa, "import", NULL);
6879 	spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_IMPORT);
6885 	spa_import_os(spa);
6895 	spa_t *spa;
6907 	 * Create and initialize the spa structure.
6914 	spa = spa_add(name, tryconfig, NULL);
6915 	spa_activate(spa, SPA_MODE_READ);
6921 	zpool_get_load_policy(spa->spa_config, &policy);
6923 		spa->spa_load_max_txg = policy.zlp_txg;
6924 		spa->spa_extreme_rewind = B_TRUE;
6934 		spa->spa_config_source = SPA_CONFIG_SRC_CACHEFILE;
6936 		spa->spa_config_source = SPA_CONFIG_SRC_SCAN;
6947 	spa->spa_import_flags |= ZFS_IMPORT_MISSING_LOG;
6949 	error = spa_load(spa, SPA_LOAD_TRYIMPORT, SPA_IMPORT_EXISTING);
6954 	if (spa->spa_root_vdev != NULL) {
6955 		config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
6959 		    spa->spa_uberblock.ub_timestamp);
6961 		    spa->spa_load_info);
6963 		    spa->spa_errata);
6970 		if ((!error || error == EEXIST) && spa->spa_bootfs) {
6977 			if (dsl_dsobj_to_dsname(spa_name(spa),
6978 			    spa->spa_bootfs, tmpname) == 0) {
7002 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
7003 		spa_add_spares(spa, config);
7004 		spa_add_l2cache(spa, config);
7005 		spa_config_exit(spa, SCL_CONFIG, FTAG);
7008 	spa_unload(spa);
7009 	spa_deactivate(spa);
7010 	spa_remove(spa);
7030 	spa_t *spa;
7040 	if ((spa = spa_lookup(pool)) == NULL) {
7045 	if (spa->spa_is_exporting) {
7050 	spa->spa_is_exporting = B_TRUE;
7056 	spa_open_ref(spa, FTAG);
7058 	spa_async_suspend(spa);
7059 	if (spa->spa_zvol_taskq) {
7060 		zvol_remove_minors(spa, spa_name(spa), B_TRUE);
7061 		taskq_wait(spa->spa_zvol_taskq);
7064 	spa->spa_export_thread = curthread;
7065 	spa_close(spa, FTAG);
7067 	if (spa->spa_state == POOL_STATE_UNINITIALIZED) {
7077 	if (spa->spa_sync_on) {
7078 		txg_wait_synced(spa->spa_dsl_pool, 0);
7079 		spa_evicting_os_wait(spa);
7087 	if (!spa_refcount_zero(spa) || (spa->spa_inject_ref != 0)) {
7095 	 * there were no references on the spa. Future spa_lookups will
7096 	 * notice the spa->spa_export_thread and wait until we signal
7100 	if (spa->spa_sync_on) {
7101 		vdev_t *rvd = spa->spa_root_vdev;
7109 		    spa_has_active_shared_spare(spa)) {
7124 		vdev_autotrim_stop_all(spa);
7125 		vdev_rebuild_stop_all(spa);
7126 		l2arc_spa_rebuild_stop(spa);
7134 			spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
7135 			spa->spa_state = new_state;
7137 			spa_config_exit(spa, SCL_ALL, FTAG);
7150 		if (spa_should_flush_logs_on_unload(spa))
7151 			spa_unload_log_sm_flush_all(spa);
7154 			spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
7155 			spa->spa_final_txg = spa_last_synced_txg(spa) +
7157 			spa_config_exit(spa, SCL_ALL, FTAG);
7162 	spa_export_os(spa);
7165 		spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_DESTROY);
7167 		spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_EXPORT);
7169 	if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
7170 		spa_unload(spa);
7171 		spa_deactivate(spa);
7174 	if (oldconfig && spa->spa_config)
7175 		*oldconfig = fnvlist_dup(spa->spa_config);
7178 		zio_handle_export_delay(spa, gethrtime() - export_start);
7186 			spa_write_cachefile(spa, B_TRUE, B_TRUE, B_FALSE);
7187 		spa_remove(spa);
7194 		spa->spa_is_exporting = B_FALSE;
7195 		spa->spa_export_thread = NULL;
7206 	spa->spa_is_exporting = B_FALSE;
7207 	spa->spa_export_thread = NULL;
7209 	spa_async_resume(spa);
7262 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
7266 		spa_feature_incr(spa, SPA_FEATURE_DRAID, tx);
7273 spa_vdev_add(spa_t *spa, nvlist_t *nvroot, boolean_t check_ashift)
7277 	vdev_t *rvd = spa->spa_root_vdev;
7282 	ASSERT(spa_writeable(spa));
7284 	txg = spa_vdev_enter(spa);
7286 	if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0,
7288 		return (spa_vdev_exit(spa, NULL, txg, error));
7290 	spa->spa_pending_vdev = vd;	/* spa_vdev_exit() will clear this */
7301 		return (spa_vdev_exit(spa, vd, txg, EINVAL));
7305 		return (spa_vdev_exit(spa, vd, txg, error));
7319 		return (spa_vdev_exit(spa, vd, txg, error));
7326 	if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0)
7327 		return (spa_vdev_exit(spa, vd, txg, error));
7335 	if (spa->spa_vdev_removal != NULL ||
7336 	    spa->spa_removing_phys.sr_prev_indirect_vdev != -1) {
7339 			if (spa->spa_vdev_removal != NULL &&
7340 			    tvd->vdev_ashift != spa->spa_max_ashift) {
7341 				return (spa_vdev_exit(spa, vd, txg, EINVAL));
7345 				return (spa_vdev_exit(spa, vd, txg, EINVAL));
7356 						return (spa_vdev_exit(spa, vd,
7364 	if (check_ashift && spa->spa_max_ashift == spa->spa_min_ashift) {
7367 			if (tvd->vdev_ashift != spa->spa_max_ashift) {
7368 				return (spa_vdev_exit(spa, vd, txg,
7383 		spa_set_aux_vdevs(&spa->spa_spares, spares, nspares,
7385 		spa_load_spares(spa);
7386 		spa->spa_spares.sav_sync = B_TRUE;
7390 		spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache,
7392 		spa_load_l2cache(spa);
7393 		spa->spa_l2cache.sav_sync = B_TRUE;
7403 		tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg);
7404 		dsl_sync_task_nowait(spa->spa_dsl_pool, spa_draid_feature_incr,
7422 	(void) spa_vdev_exit(spa, vd, txg, 0);
7425 	spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
7426 	spa_event_notify(spa, NULL, NULL, ESC_ZFS_VDEV_ADD);
7451 spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing,
7455 	vdev_t *rvd = spa->spa_root_vdev;
7462 	ASSERT(spa_writeable(spa));
7464 	txg = spa_vdev_enter(spa);
7466 	oldvd = spa_lookup_by_guid(spa, guid, B_FALSE);
7469 	if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) {
7470 		error = (spa_has_checkpoint(spa)) ?
7472 		return (spa_vdev_exit(spa, NULL, txg, error));
7476 		if (!spa_feature_is_enabled(spa, SPA_FEATURE_DEVICE_REBUILD))
7477 			return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
7479 		if (dsl_scan_resilvering(spa_get_dsl(spa)) ||
7480 		    dsl_scan_resilver_scheduled(spa_get_dsl(spa))) {
7481 			return (spa_vdev_exit(spa, NULL, txg,
7486 			return (spa_vdev_exit(spa, NULL, txg,
7490 	if (spa->spa_vdev_removal != NULL) {
7491 		return (spa_vdev_exit(spa, NULL, txg,
7496 		return (spa_vdev_exit(spa, NULL, txg, ENODEV));
7501 		if (!spa_feature_is_enabled(spa, SPA_FEATURE_RAIDZ_EXPANSION))
7502 			return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
7507 		if (spa->spa_raidz_expand != NULL) {
7508 			return (spa_vdev_exit(spa, NULL, txg,
7512 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
7520 	if (spa_config_parse(spa, &newrootvd, nvroot, NULL, 0,
7522 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
7525 		return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
7530 		return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
7533 		return (spa_vdev_exit(spa, newrootvd, txg, error));
7540 		return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
7548 		return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
7564 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
7577 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
7587 		    !spa_has_spare(spa, newvd->vdev_guid))
7588 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
7599 		    spa_version(spa) < SPA_VERSION_MULTI_REPLACE) {
7600 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
7603 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
7617 		return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW));
7624 		return (spa_vdev_exit(spa, newrootvd, txg,
7633 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
7641 				return (spa_vdev_exit(spa, newrootvd, txg,
7645 			if (vdev_check_boot_reserve(spa, oldvd->vdev_child[i])
7647 				return (spa_vdev_exit(spa, newrootvd, txg,
7729 		spa_vdev_config_exit(spa, NULL,
7736 		dtl_max_txg = spa_vdev_config_enter(spa);
7743 		dmu_tx_t *tx = dmu_tx_create_assigned(spa->spa_dsl_pool,
7745 		dsl_sync_task_nowait(spa->spa_dsl_pool, vdev_raidz_attach_sync,
7754 			spa_event_notify(spa, newvd, NULL, ESC_ZFS_VDEV_SPARE);
7776 			if (dsl_scan_resilvering(spa_get_dsl(spa)) &&
7777 			    spa_feature_is_enabled(spa,
7781 				dsl_scan_restart_resilver(spa->spa_dsl_pool,
7787 	if (spa->spa_bootfs)
7788 		spa_event_notify(spa, newvd, NULL, ESC_ZFS_BOOTFS_VDEV_ATTACH);
7790 	spa_event_notify(spa, newvd, NULL, ESC_ZFS_VDEV_ATTACH);
7795 	(void) spa_vdev_exit(spa, newrootvd, dtl_max_txg, 0);
7797 	spa_history_log_internal(spa, "vdev attach", NULL,
7816 spa_vdev_detach(spa_t *spa, uint64_t guid, uint64_t pguid, int replace_done)
7820 	vdev_t *rvd __maybe_unused = spa->spa_root_vdev;
7826 	ASSERT(spa_writeable(spa));
7828 	txg = spa_vdev_detach_enter(spa, guid);
7830 	vd = spa_lookup_by_guid(spa, guid, B_FALSE);
7847 	if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) {
7848 		error = (spa_has_checkpoint(spa)) ?
7850 		return (spa_vdev_exit(spa, NULL, txg, error));
7854 		return (spa_vdev_exit(spa, NULL, txg, ENODEV));
7857 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
7875 		return (spa_vdev_exit(spa, NULL, txg, EBUSY));
7882 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
7885 	    spa_version(spa) >= SPA_VERSION_SPARES);
7893 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
7900 		return (spa_vdev_exit(spa, NULL, txg, EBUSY));
7978 		(void) spa_vdev_remove(spa, unspare_guid, B_TRUE);
8011 	if (spa->spa_autoexpand) {
8030 	spa_event_notify(spa, vd, NULL, ESC_ZFS_VDEV_REMOVE);
8031 	spa_notify_waiters(spa);
8033 	/* hang on to the spa before we release the lock */
8034 	spa_open_ref(spa, FTAG);
8036 	error = spa_vdev_exit(spa, vd, txg, 0);
8038 	spa_history_log_internal(spa, "detach", NULL,
8053 			    altspa == spa)
8065 		spa_vdev_resilver_done(spa);
8068 	/* all done with the spa; OK to release */
8070 	spa_close(spa, FTAG);
8077 spa_vdev_initialize_impl(spa_t *spa, uint64_t guid, uint64_t cmd_type,
8082 	spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER);
8085 	vdev_t *vd = spa_lookup_by_guid(spa, guid, B_FALSE);
8087 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
8090 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
8093 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
8097 	spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
8148 spa_vdev_initialize(spa_t *spa, nvlist_t *nv, uint64_t cmd_type,
8170 		int error = spa_vdev_initialize_impl(spa, vdev_guid, cmd_type,
8183 	vdev_initialize_stop_wait(spa, &vd_list);
8186 	txg_wait_synced(spa->spa_dsl_pool, 0);
8195 spa_vdev_trim_impl(spa_t *spa, uint64_t guid, uint64_t cmd_type,
8200 	spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER);
8203 	vdev_t *vd = spa_lookup_by_guid(spa, guid, B_FALSE);
8205 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
8208 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
8211 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
8214 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
8217 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
8221 	spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
8269 spa_vdev_trim(spa_t *spa, nvlist_t *nv, uint64_t cmd_type, uint64_t rate,
8291 		int error = spa_vdev_trim_impl(spa, vdev_guid, cmd_type,
8304 	vdev_trim_stop_wait(spa, &vd_list);
8307 	txg_wait_synced(spa->spa_dsl_pool, 0);
8319 spa_vdev_split_mirror(spa_t *spa, const char *newname, nvlist_t *config,
8332 	ASSERT(spa_writeable(spa));
8334 	txg = spa_vdev_enter(spa);
8337 	if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) {
8338 		error = (spa_has_checkpoint(spa)) ?
8340 		return (spa_vdev_exit(spa, NULL, txg, error));
8344 	activate_slog = spa_passivate_log(spa);
8345 	(void) spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
8346 	error = spa_reset_logs(spa);
8347 	txg = spa_vdev_config_enter(spa);
8350 		spa_activate_log(spa);
8353 		return (spa_vdev_exit(spa, NULL, txg, error));
8355 	/* check new spa name before going any further */
8357 		return (spa_vdev_exit(spa, NULL, txg, EEXIST));
8365 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
8368 	rvd = spa->spa_root_vdev;
8384 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
8389 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
8402 			if (spa->spa_root_vdev->vdev_child[c]->vdev_ishole ||
8403 			    spa->spa_root_vdev->vdev_child[c]->vdev_islog) {
8412 		if (spa->spa_root_vdev->vdev_child[c]->vdev_ops ==
8423 		/* look it up in the spa */
8424 		vml[c] = spa_lookup_by_guid(spa, glist[c], B_FALSE);
8439 		    c != spa->spa_root_vdev->vdev_child[c]->vdev_id) {
8474 		return (spa_vdev_exit(spa, NULL, txg, error));
8482 	vdev_reopen(spa->spa_root_vdev);
8485 	 * Temporarily record the splitting vdevs in the spa config.  This
8492 	mutex_enter(&spa->spa_props_lock);
8493 	fnvlist_add_nvlist(spa->spa_config, ZPOOL_CONFIG_SPLIT, nvl);
8494 	mutex_exit(&spa->spa_props_lock);
8495 	spa->spa_config_splitting = nvl;
8496 	vdev_config_dirty(spa->spa_root_vdev);
8502 	fnvlist_add_uint64(config, ZPOOL_CONFIG_VERSION, spa_version(spa));
8503 	fnvlist_add_uint64(config, ZPOOL_CONFIG_POOL_TXG, spa->spa_config_txg);
8513 	newspa->spa_config_txg = spa->spa_config_txg;
8516 	/* release the spa config lock, retaining the namespace lock */
8517 	spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
8520 		zio_handle_panic_injection(spa, FTAG, 1);
8551 	vdev_initialize_stop_wait(spa, &vd_initialize_list);
8552 	vdev_trim_stop_wait(spa, &vd_trim_list);
8569 		    ZPOOL_CONFIG_SPLIT_GUID, spa_guid(spa));
8588 		zio_handle_panic_injection(spa, FTAG, 2);
8593 	txg = spa_vdev_config_enter(spa);
8594 	tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
8614 				spa_history_log_internal(spa, "detach", tx,
8620 	spa->spa_avz_action = AVZ_ACTION_REBUILD;
8621 	vdev_config_dirty(spa->spa_root_vdev);
8622 	spa->spa_config_splitting = NULL;
8626 	(void) spa_vdev_exit(spa, NULL, txg, 0);
8629 		zio_handle_panic_injection(spa, FTAG, 3);
8633 	    "from pool %s", spa_name(spa));
8650 	txg = spa_vdev_config_enter(spa);
8659 	spa_async_request(spa, SPA_ASYNC_INITIALIZE_RESTART);
8660 	spa_async_request(spa, SPA_ASYNC_TRIM_RESTART);
8661 	spa_async_request(spa, SPA_ASYNC_AUTOTRIM_RESTART);
8663 	vdev_reopen(spa->spa_root_vdev);
8665 	nvlist_free(spa->spa_config_splitting);
8666 	spa->spa_config_splitting = NULL;
8667 	(void) spa_vdev_exit(spa, NULL, txg, error);
8756 spa_vdev_resilver_done(spa_t *spa)
8761 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
8763 	while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) {
8782 		spa_config_exit(spa, SCL_ALL, FTAG);
8783 		if (spa_vdev_detach(spa, guid, pguid, B_TRUE) != 0)
8785 		if (sguid && spa_vdev_detach(spa, sguid, ppguid, B_TRUE) != 0)
8787 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
8790 	spa_config_exit(spa, SCL_ALL, FTAG);
8796 	spa_notify_waiters(spa);
8803 spa_vdev_set_common(spa_t *spa, uint64_t guid, const char *value,
8809 	ASSERT(spa_writeable(spa));
8811 	spa_vdev_state_enter(spa, SCL_ALL);
8813 	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
8814 		return (spa_vdev_state_exit(spa, NULL, ENOENT));
8817 		return (spa_vdev_state_exit(spa, NULL, ENOTSUP));
8836 	return (spa_vdev_state_exit(spa, sync ? vd : NULL, 0));
8840 spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath)
8842 	return (spa_vdev_set_common(spa, guid, newpath, B_TRUE));
8846 spa_vdev_setfru(spa_t *spa, uint64_t guid, const char *newfru)
8848 	return (spa_vdev_set_common(spa, guid, newfru, B_FALSE));
8857 spa_scrub_pause_resume(spa_t *spa, pool_scrub_cmd_t cmd)
8859 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
8861 	if (dsl_scan_resilvering(spa->spa_dsl_pool))
8864 	return (dsl_scrub_set_pause_resume(spa->spa_dsl_pool, cmd));
8868 spa_scan_stop(spa_t *spa)
8870 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
8871 	if (dsl_scan_resilvering(spa->spa_dsl_pool))
8874 	return (dsl_scan_cancel(spa->spa_dsl_pool));
8878 spa_scan(spa_t *spa, pool_scan_func_t func)
8880 	return (spa_scan_range(spa, func, 0, 0));
8884 spa_scan_range(spa_t *spa, pool_scan_func_t func, uint64_t txgstart,
8887 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
8893 	    !spa_feature_is_enabled(spa, SPA_FEATURE_RESILVER_DEFER))
8904 	    !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) {
8905 		spa_async_request(spa, SPA_ASYNC_RESILVER_DONE);
8910 	    !spa_feature_is_enabled(spa, SPA_FEATURE_HEAD_ERRLOG))
8913 	return (dsl_scan(spa->spa_dsl_pool, func, txgstart, txgend));
8923 spa_async_remove(spa_t *spa, vdev_t *vd)
8943 		zfs_post_remove(spa, vd);
8947 		spa_async_remove(spa, vd->vdev_child[c]);
8974 spa_async_autoexpand(spa_t *spa, vdev_t *vd)
8976 	if (!spa->spa_autoexpand)
8981 		spa_async_autoexpand(spa, cvd);
8993 	spa_t *spa = (spa_t *)arg;
8994 	dsl_pool_t *dp = spa->spa_dsl_pool;
8997 	ASSERT(spa->spa_sync_on);
8999 	mutex_enter(&spa->spa_async_lock);
9000 	tasks = spa->spa_async_tasks;
9001 	spa->spa_async_tasks = 0;
9002 	mutex_exit(&spa->spa_async_lock);
9011 		old_space = metaslab_class_get_space(spa_normal_class(spa));
9012 		old_space += metaslab_class_get_space(spa_special_class(spa));
9013 		old_space += metaslab_class_get_space(spa_dedup_class(spa));
9015 		    spa_embedded_log_class(spa));
9017 		spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
9019 		new_space = metaslab_class_get_space(spa_normal_class(spa));
9020 		new_space += metaslab_class_get_space(spa_special_class(spa));
9021 		new_space += metaslab_class_get_space(spa_dedup_class(spa));
9023 		    spa_embedded_log_class(spa));
9031 			spa_history_log_internal(spa, "vdev online", NULL,
9033 			    spa_name(spa), (u_longlong_t)new_space,
9042 		spa_vdev_state_enter(spa, SCL_NONE);
9043 		spa_async_remove(spa, spa->spa_root_vdev);
9044 		for (int i = 0; i < spa->spa_l2cache.sav_count; i++)
9045 			spa_async_remove(spa, spa->spa_l2cache.sav_vdevs[i]);
9046 		for (int i = 0; i < spa->spa_spares.sav_count; i++)
9047 			spa_async_remove(spa, spa->spa_spares.sav_vdevs[i]);
9048 		(void) spa_vdev_state_exit(spa, NULL, 0);
9051 	if ((tasks & SPA_ASYNC_AUTOEXPAND) && !spa_suspended(spa)) {
9052 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
9053 		spa_async_autoexpand(spa, spa->spa_root_vdev);
9054 		spa_config_exit(spa, SCL_CONFIG, FTAG);
9061 		spa_vdev_state_enter(spa, SCL_NONE);
9063 		spa_async_fault_vdev(spa->spa_root_vdev, &suspend);
9064 		(void) spa_vdev_state_exit(spa, NULL, 0);
9066 			zio_suspend(spa, NULL, ZIO_SUSPEND_IOERR);
9075 		spa_vdev_resilver_done(spa);
9082 	    !vdev_rebuild_active(spa->spa_root_vdev) &&
9089 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
9090 		vdev_initialize_restart(spa->spa_root_vdev);
9091 		spa_config_exit(spa, SCL_CONFIG, FTAG);
9097 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
9098 		vdev_trim_restart(spa->spa_root_vdev);
9099 		spa_config_exit(spa, SCL_CONFIG, FTAG);
9105 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
9106 		vdev_autotrim_restart(spa);
9107 		spa_config_exit(spa, SCL_CONFIG, FTAG);
9116 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
9117 		vdev_trim_l2arc(spa);
9118 		spa_config_exit(spa, SCL_CONFIG, FTAG);
9127 		spa_config_enter(spa, SCL_L2ARC, FTAG, RW_READER);
9128 		l2arc_spa_rebuild_start(spa);
9129 		spa_config_exit(spa, SCL_L2ARC, FTAG);
9136 	mutex_enter(&spa->spa_async_lock);
9137 	spa->spa_async_thread = NULL;
9138 	cv_broadcast(&spa->spa_async_cv);
9139 	mutex_exit(&spa->spa_async_lock);
9144 spa_async_suspend(spa_t *spa)
9146 	mutex_enter(&spa->spa_async_lock);
9147 	spa->spa_async_suspended++;
9148 	while (spa->spa_async_thread != NULL)
9149 		cv_wait(&spa->spa_async_cv, &spa->spa_async_lock);
9150 	mutex_exit(&spa->spa_async_lock);
9152 	spa_vdev_remove_suspend(spa);
9154 	zthr_t *condense_thread = spa->spa_condense_zthr;
9158 	zthr_t *raidz_expand_thread = spa->spa_raidz_expand_zthr;
9162 	zthr_t *discard_thread = spa->spa_checkpoint_discard_zthr;
9166 	zthr_t *ll_delete_thread = spa->spa_livelist_delete_zthr;
9170 	zthr_t *ll_condense_thread = spa->spa_livelist_condense_zthr;
9176 spa_async_resume(spa_t *spa)
9178 	mutex_enter(&spa->spa_async_lock);
9179 	ASSERT(spa->spa_async_suspended != 0);
9180 	spa->spa_async_suspended--;
9181 	mutex_exit(&spa->spa_async_lock);
9182 	spa_restart_removal(spa);
9184 	zthr_t *condense_thread = spa->spa_condense_zthr;
9188 	zthr_t *raidz_expand_thread = spa->spa_raidz_expand_zthr;
9192 	zthr_t *discard_thread = spa->spa_checkpoint_discard_zthr;
9196 	zthr_t *ll_delete_thread = spa->spa_livelist_delete_zthr;
9200 	zthr_t *ll_condense_thread = spa->spa_livelist_condense_zthr;
9206 spa_async_tasks_pending(spa_t *spa)
9212 	non_config_tasks = spa->spa_async_tasks & ~SPA_ASYNC_CONFIG_UPDATE;
9213 	config_task = spa->spa_async_tasks & SPA_ASYNC_CONFIG_UPDATE;
9214 	if (spa->spa_ccw_fail_time == 0) {
9218 		    (gethrtime() - spa->spa_ccw_fail_time) <
9226 spa_async_dispatch(spa_t *spa)
9228 	mutex_enter(&spa->spa_async_lock);
9229 	if (spa_async_tasks_pending(spa) &&
9230 	    !spa->spa_async_suspended &&
9231 	    spa->spa_async_thread == NULL)
9232 		spa->spa_async_thread = thread_create(NULL, 0,
9233 		    spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri);
9234 	mutex_exit(&spa->spa_async_lock);
9238 spa_async_request(spa_t *spa, int task)
9240 	zfs_dbgmsg("spa=%s async request task=%u", spa->spa_name, task);
9241 	mutex_enter(&spa->spa_async_lock);
9242 	spa->spa_async_tasks |= task;
9243 	mutex_exit(&spa->spa_async_lock);
9247 spa_async_tasks(spa_t *spa)
9249 	return (spa->spa_async_tasks);
9303 spa_sync_frees(spa_t *spa, bplist_t *bpl, dmu_tx_t *tx)
9305 	zio_t *zio = zio_root(spa, NULL, NULL, 0);
9315 spa_sync_deferred_frees(spa_t *spa, dmu_tx_t *tx)
9317 	if (spa_sync_pass(spa) != 1)
9332 	zio_t *zio = zio_root(spa, NULL, NULL, 0);
9333 	VERIFY3U(bpobj_iterate(&spa->spa_deferred_bpobj,
9339 spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx)
9360 	dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx);
9364 	VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db));
9371 spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx,
9387 		sav->sav_object = dmu_object_alloc(spa->spa_meta_objset,
9390 		VERIFY(zap_update(spa->spa_meta_objset,
9402 			list[i] = vdev_config_generate(spa, sav->sav_vdevs[i],
9411 	spa_sync_nvlist(spa, sav->sav_object, nvroot, tx);
9418  * Rebuild spa's all-vdev ZAP from the vdev ZAPs indicated in each vdev_t.
9424 	spa_t *spa = vd->vdev_spa;
9427 	    spa_feature_is_active(spa, SPA_FEATURE_AVZ_V2)) {
9428 		VERIFY0(zap_add_int(spa->spa_meta_objset, avz,
9432 		VERIFY0(zap_add_int(spa->spa_meta_objset, avz,
9436 		VERIFY0(zap_add_int(spa->spa_meta_objset, avz,
9445 spa_sync_config_object(spa_t *spa, dmu_tx_t *tx)
9455 	if (list_is_empty(&spa->spa_config_dirty_list) &&
9456 	    spa->spa_avz_action == AVZ_ACTION_NONE)
9459 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
9461 	ASSERT(spa->spa_avz_action == AVZ_ACTION_NONE ||
9462 	    spa->spa_avz_action == AVZ_ACTION_INITIALIZE ||
9463 	    spa->spa_all_vdev_zaps != 0);
9465 	if (spa->spa_avz_action == AVZ_ACTION_REBUILD) {
9467 		uint64_t new_avz = zap_create(spa->spa_meta_objset,
9469 		spa_avz_build(spa->spa_root_vdev, new_avz, tx);
9475 		for (zap_cursor_init(&zc, spa->spa_meta_objset,
9476 		    spa->spa_all_vdev_zaps);
9480 			if (zap_lookup_int(spa->spa_meta_objset, new_avz,
9486 				VERIFY0(zap_destroy(spa->spa_meta_objset, vdzap,
9495 		VERIFY0(zap_destroy(spa->spa_meta_objset,
9496 		    spa->spa_all_vdev_zaps, tx));
9499 		VERIFY0(zap_update(spa->spa_meta_objset,
9503 		spa->spa_all_vdev_zaps = new_avz;
9504 	} else if (spa->spa_avz_action == AVZ_ACTION_DESTROY) {
9509 		for (zap_cursor_init(&zc, spa->spa_meta_objset,
9510 		    spa->spa_all_vdev_zaps);
9514 			VERIFY0(zap_destroy(spa->spa_meta_objset, zap, tx));
9521 		VERIFY0(zap_destroy(spa->spa_meta_objset,
9522 		    spa->spa_all_vdev_zaps, tx));
9523 		VERIFY0(zap_remove(spa->spa_meta_objset,
9525 		spa->spa_all_vdev_zaps = 0;
9528 	if (spa->spa_all_vdev_zaps == 0) {
9529 		spa->spa_all_vdev_zaps = zap_create_link(spa->spa_meta_objset,
9533 	spa->spa_avz_action = AVZ_ACTION_NONE;
9536 	vdev_construct_zaps(spa->spa_root_vdev, tx);
9538 	config = spa_config_generate(spa, spa->spa_root_vdev,
9542 	 * If we're upgrading the spa version then make sure that
9545 	if (spa->spa_ubsync.ub_version < spa->spa_uberblock.ub_version)
9547 		    spa->spa_uberblock.ub_version);
9549 	spa_config_exit(spa, SCL_STATE, FTAG);
9551 	nvlist_free(spa->spa_config_syncing);
9552 	spa->spa_config_syncing = config;
9554 	spa_sync_nvlist(spa, spa->spa_config_object, config, tx);
9562 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
9570 	ASSERT(version >= spa_version(spa));
9572 	spa->spa_uberblock.ub_version = version;
9573 	vdev_config_dirty(spa->spa_root_vdev);
9574 	spa_history_log_internal(spa, "set", tx, "version=%lld",
9585 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
9586 	objset_t *mos = spa->spa_meta_objset;
9589 	mutex_enter(&spa->spa_props_lock);
9607 			ASSERT3U(spa_version(spa), >=, intval);
9615 			ASSERT(spa->spa_root != NULL);
9627 			if (spa->spa_comment != NULL)
9628 				spa_strfree(spa->spa_comment);
9629 			spa->spa_comment = spa_strdup(strval);
9639 				vdev_config_dirty(spa->spa_root_vdev);
9640 				spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
9642 			spa_history_log_internal(spa, "set", tx,
9647 			if (spa->spa_compatibility != NULL)
9648 				spa_strfree(spa->spa_compatibility);
9649 			spa->spa_compatibility = spa_strdup(strval);
9654 				vdev_config_dirty(spa->spa_root_vdev);
9655 				spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
9658 			spa_history_log_internal(spa, "set", tx,
9667 				spa_feature_enable(spa, fid, tx);
9668 				spa_history_log_internal(spa, "set", tx,
9680 			if (spa->spa_pool_props_object == 0) {
9681 				spa->spa_pool_props_object =
9702 					    spa->spa_pool_props_object,
9706 					    spa->spa_pool_props_object,
9710 				spa_history_log_internal(spa, "set", tx,
9721 				    spa->spa_pool_props_object, propname,
9723 				spa_history_log_internal(spa, "set", tx,
9729 					spa->spa_delegation = intval;
9732 					spa->spa_bootfs = intval;
9735 					spa->spa_failmode = intval;
9738 					spa->spa_autotrim = intval;
9739 					spa_async_request(spa,
9743 					spa->spa_autoexpand = intval;
9745 						spa_async_request(spa,
9749 					spa->spa_multihost = intval;
9752 					spa->spa_dedup_table_quota = intval;
9764 	mutex_exit(&spa->spa_props_lock);
9775 spa_sync_upgrades(spa_t *spa, dmu_tx_t *tx)
9777 	if (spa_sync_pass(spa) != 1)
9780 	dsl_pool_t *dp = spa->spa_dsl_pool;
9783 	if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN &&
9784 	    spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) {
9788 		spa->spa_minref += 3;
9791 	if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES &&
9792 	    spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) {
9796 	if (spa->spa_ubsync.ub_version < SPA_VERSION_DIR_CLONES &&
9797 	    spa->spa_uberblock.ub_version >= SPA_VERSION_DIR_CLONES) {
9801 		spa->spa_minref += 3;
9804 	if (spa->spa_ubsync.ub_version < SPA_VERSION_FEATURES &&
9805 	    spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) {
9806 		spa_feature_create_zap_objects(spa, tx);
9815 	if (spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) {
9816 		boolean_t lz4_en = spa_feature_is_enabled(spa,
9818 		boolean_t lz4_ac = spa_feature_is_active(spa,
9822 			spa_feature_incr(spa, SPA_FEATURE_LZ4_COMPRESS, tx);
9830 	if (zap_contains(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
9832 		VERIFY0(zap_add(spa->spa_meta_objset,
9834 		    sizeof (spa->spa_cksum_salt.zcs_bytes),
9835 		    spa->spa_cksum_salt.zcs_bytes, tx));
9881 spa_sync_adjust_vdev_max_queue_depth(spa_t *spa)
9883 	ASSERT(spa_writeable(spa));
9885 	vdev_t *rvd = spa->spa_root_vdev;
9888 	metaslab_class_t *normal = spa_normal_class(spa);
9889 	metaslab_class_t *special = spa_special_class(spa);
9890 	metaslab_class_t *dedup = spa_dedup_class(spa);
9922 	for (int i = 0; i < spa->spa_alloc_count; i++) {
9942 spa_sync_condense_indirect(spa_t *spa, dmu_tx_t *tx)
9944 	ASSERT(spa_writeable(spa));
9946 	vdev_t *rvd = spa->spa_root_vdev;
9959 spa_sync_iterate_to_convergence(spa_t *spa, dmu_tx_t *tx)
9961 	objset_t *mos = spa->spa_meta_objset;
9962 	dsl_pool_t *dp = spa->spa_dsl_pool;
9964 	bplist_t *free_bpl = &spa->spa_free_bplist[txg & TXG_MASK];
9967 		int pass = ++spa->spa_sync_pass;
9969 		spa_sync_config_object(spa, tx);
9970 		spa_sync_aux_dev(spa, &spa->spa_spares, tx,
9972 		spa_sync_aux_dev(spa, &spa->spa_l2cache, tx,
9974 		spa_errlog_sync(spa, txg);
9978 		    spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP)) {
9985 			spa_sync_frees(spa, free_bpl, tx);
9993 			    &spa->spa_deferred_bpobj, tx);
9996 		brt_sync(spa, txg);
9997 		ddt_sync(spa, txg);
10000 		svr_sync(spa, tx);
10001 		spa_sync_upgrades(spa, tx);
10003 		spa_flush_metaslabs(spa, tx);
10006 		while ((vd = txg_list_remove(&spa->spa_vdev_txg_list, txg))
10028 			spa_sync_config_object(spa, tx);
10041 		    BP_GET_LOGICAL_BIRTH(&spa->spa_uberblock.ub_rootbp) < txg &&
10055 		spa_sync_deferred_frees(spa, tx);
10069 spa_sync_rewrite_vdev_config(spa_t *spa, dmu_tx_t *tx)
10071 	vdev_t *rvd = spa->spa_root_vdev;
10081 		spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
10083 		if (list_is_empty(&spa->spa_config_dirty_list)) {
10113 			spa->spa_last_synced_guid = rvd->vdev_guid;
10115 		spa_config_exit(spa, SCL_STATE, FTAG);
10119 		zio_suspend(spa, NULL, ZIO_SUSPEND_IOERR);
10120 		zio_resume_wait(spa);
10129 spa_sync(spa_t *spa, uint64_t txg)
10133 	VERIFY(spa_writeable(spa));
10139 	(void) zio_wait(spa->spa_txg_zio[txg & TXG_MASK]);
10140 	spa->spa_txg_zio[txg & TXG_MASK] = zio_root(spa, NULL, NULL,
10148 	brt_pending_apply(spa, txg);
10153 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
10155 	spa->spa_syncing_txg = txg;
10156 	spa->spa_sync_pass = 0;
10158 	for (int i = 0; i < spa->spa_alloc_count; i++) {
10159 		mutex_enter(&spa->spa_allocs[i].spaa_lock);
10160 		VERIFY0(avl_numnodes(&spa->spa_allocs[i].spaa_tree));
10161 		mutex_exit(&spa->spa_allocs[i].spaa_lock);
10168 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
10169 	while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) {
10183 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
10184 		spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_WRITER);
10185 		while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) {
10189 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
10190 		spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER);
10192 	spa_config_exit(spa, SCL_STATE, FTAG);
10194 	dsl_pool_t *dp = spa->spa_dsl_pool;
10197 	spa->spa_sync_starttime = gethrtime();
10198 	taskq_cancel_id(system_delay_taskq, spa->spa_deadman_tqid);
10199 	spa->spa_deadman_tqid = taskq_dispatch_delay(system_delay_taskq,
10200 	    spa_deadman, spa, TQ_SLEEP, ddi_get_lbolt() +
10201 	    NSEC_TO_TICK(spa->spa_deadman_synctime));
10207 	if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE &&
10208 	    spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) {
10209 		vdev_t *rvd = spa->spa_root_vdev;
10218 			spa->spa_deflate = TRUE;
10219 			VERIFY0(zap_add(spa->spa_meta_objset,
10221 			    sizeof (uint64_t), 1, &spa->spa_deflate, tx));
10225 	spa_sync_adjust_vdev_max_queue_depth(spa);
10227 	spa_sync_condense_indirect(spa, tx);
10229 	spa_sync_iterate_to_convergence(spa, tx);
10232 	if (!list_is_empty(&spa->spa_config_dirty_list)) {
10241 		ASSERT0(zap_count(spa->spa_meta_objset,
10242 		    spa->spa_all_vdev_zaps, &all_vdev_zap_entry_count));
10243 		ASSERT3U(vdev_count_verify_zaps(spa->spa_root_vdev), ==,
10248 	if (spa->spa_vdev_removal != NULL) {
10249 		ASSERT0(spa->spa_vdev_removal->svr_bytes_done[txg & TXG_MASK]);
10252 	spa_sync_rewrite_vdev_config(spa, tx);
10255 	taskq_cancel_id(system_delay_taskq, spa->spa_deadman_tqid);
10256 	spa->spa_deadman_tqid = 0;
10261 	while ((vd = list_head(&spa->spa_config_dirty_list)) != NULL)
10268 	if (spa->spa_config_syncing != NULL) {
10269 		spa_config_set(spa, spa->spa_config_syncing);
10270 		spa->spa_config_txg = txg;
10271 		spa->spa_config_syncing = NULL;
10276 	for (int i = 0; i < spa->spa_alloc_count; i++) {
10277 		mutex_enter(&spa->spa_allocs[i].spaa_lock);
10278 		VERIFY0(avl_numnodes(&spa->spa_allocs[i].spaa_tree));
10279 		mutex_exit(&spa->spa_allocs[i].spaa_lock);
10285 	while ((vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)))
10289 	metaslab_class_evict_old(spa->spa_normal_class, txg);
10290 	metaslab_class_evict_old(spa->spa_log_class, txg);
10292 	metaslab_class_evict_old(spa->spa_special_class, txg);
10293 	metaslab_class_evict_old(spa->spa_dedup_class, txg);
10295 	spa_sync_close_syncing_log_sm(spa);
10297 	spa_update_dspace(spa);
10299 	if (spa_get_autotrim(spa) == SPA_AUTOTRIM_ON)
10300 		vdev_autotrim_kick(spa);
10308 	ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg));
10313 	spa->spa_sync_pass = 0;
10321 	spa->spa_ubsync = spa->spa_uberblock;
10322 	spa_config_exit(spa, SCL_CONFIG, FTAG);
10324 	spa_handle_ignored_writes(spa);
10329 	spa_async_dispatch(spa);
10340 	spa_t *spa = NULL;
10342 	while ((spa = spa_next(spa)) != NULL) {
10343 		if (spa_state(spa) != POOL_STATE_ACTIVE ||
10344 		    !spa_writeable(spa) || spa_suspended(spa))
10346 		spa_open_ref(spa, FTAG);
10348 		txg_wait_synced(spa_get_dsl(spa), 0);
10350 		spa_close(spa, FTAG);
10356 spa_sync_tq_create(spa_t *spa, const char *name)
10360 	ASSERT(spa->spa_sync_tq == NULL);
10361 	ASSERT3S(spa->spa_alloc_count, <=, boot_ncpus);
10368 	int nthreads = spa->spa_alloc_count;
10369 	spa->spa_syncthreads = kmem_zalloc(sizeof (spa_syncthread_info_t) *
10372 	spa->spa_sync_tq = taskq_create_synced(name, nthreads, minclsyspri,
10374 	VERIFY(spa->spa_sync_tq != NULL);
10377 	spa_syncthread_info_t *ti = spa->spa_syncthreads;
10384 	return (spa->spa_sync_tq);
10388 spa_sync_tq_destroy(spa_t *spa)
10390 	ASSERT(spa->spa_sync_tq != NULL);
10392 	taskq_wait(spa->spa_sync_tq);
10393 	taskq_destroy(spa->spa_sync_tq);
10394 	kmem_free(spa->spa_syncthreads,
10395 	    sizeof (spa_syncthread_info_t) * spa->spa_alloc_count);
10396 	spa->spa_sync_tq = NULL;
10400 spa_acq_allocator(spa_t *spa)
10404 	if (spa->spa_alloc_count == 1)
10407 	mutex_enter(&spa->spa_allocs_use->sau_lock);
10408 	uint_t r = spa->spa_allocs_use->sau_rotor;
10410 		if (++r == spa->spa_alloc_count)
10412 	} while (spa->spa_allocs_use->sau_inuse[r]);
10413 	spa->spa_allocs_use->sau_inuse[r] = B_TRUE;
10414 	spa->spa_allocs_use->sau_rotor = r;
10415 	mutex_exit(&spa->spa_allocs_use->sau_lock);
10417 	spa_syncthread_info_t *ti = spa->spa_syncthreads;
10418 	for (i = 0; i < spa->spa_alloc_count; i++, ti++) {
10424 	ASSERT3S(i, <, spa->spa_alloc_count);
10429 spa_rel_allocator(spa_t *spa, uint_t allocator)
10431 	if (spa->spa_alloc_count > 1)
10432 		spa->spa_allocs_use->sau_inuse[allocator] = B_FALSE;
10439 	spa_t *spa = zio->io_spa;
10450 	ASSERT(spa != NULL);
10458 	if (spa->spa_sync_tq != NULL) {
10459 		spa_syncthread_info_t *ti = spa->spa_syncthreads;
10460 		for (int i = 0; i < spa->spa_alloc_count; i++, ti++) {
10478 	zio->io_allocator = (uint_t)hv % spa->spa_alloc_count;
10493 	spa_t *spa;
10497 	 * so every spa in the AVL tree should be unreferenced.
10500 	while ((spa = spa_next(NULL)) != NULL) {
10506 		spa_open_ref(spa, FTAG);
10508 		spa_async_suspend(spa);
10510 		spa_close(spa, FTAG);
10512 		if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
10513 			spa_unload(spa);
10514 			spa_deactivate(spa);
10516 		spa_remove(spa);
10522 spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t aux)
10527 	if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL)
10531 		for (i = 0; i < spa->spa_l2cache.sav_count; i++) {
10532 			vd = spa->spa_l2cache.sav_vdevs[i];
10537 		for (i = 0; i < spa->spa_spares.sav_count; i++) {
10538 			vd = spa->spa_spares.sav_vdevs[i];
10548 spa_upgrade(spa_t *spa, uint64_t version)
10550 	ASSERT(spa_writeable(spa));
10552 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
10559 	ASSERT(SPA_VERSION_IS_SUPPORTED(spa->spa_uberblock.ub_version));
10560 	ASSERT3U(version, >=, spa->spa_uberblock.ub_version);
10562 	spa->spa_uberblock.ub_version = version;
10563 	vdev_config_dirty(spa->spa_root_vdev);
10565 	spa_config_exit(spa, SCL_ALL, FTAG);
10567 	txg_wait_synced(spa_get_dsl(spa), 0);
10571 spa_has_aux_vdev(spa_t *spa, uint64_t guid, spa_aux_vdev_t *sav)
10573 	(void) spa;
10591 spa_has_l2cache(spa_t *spa, uint64_t guid)
10593 	return (spa_has_aux_vdev(spa, guid, &spa->spa_l2cache));
10597 spa_has_spare(spa_t *spa, uint64_t guid)
10599 	return (spa_has_aux_vdev(spa, guid, &spa->spa_spares));
10607 spa_has_active_shared_spare(spa_t *spa)
10611 	spa_aux_vdev_t *sav = &spa->spa_spares;
10615 		    &refcnt) && pool != 0ULL && pool == spa_guid(spa) &&
10624 spa_total_metaslabs(spa_t *spa)
10626 	vdev_t *rvd = spa->spa_root_vdev;
10644 spa_notify_waiters(spa_t *spa)
10650 	mutex_enter(&spa->spa_activities_lock);
10651 	cv_broadcast(&spa->spa_activities_cv);
10652 	mutex_exit(&spa->spa_activities_lock);
10660 spa_wake_waiters(spa_t *spa)
10662 	mutex_enter(&spa->spa_activities_lock);
10663 	spa->spa_waiters_cancel = B_TRUE;
10664 	cv_broadcast(&spa->spa_activities_cv);
10665 	while (spa->spa_waiters != 0)
10666 		cv_wait(&spa->spa_waiters_cv, &spa->spa_activities_lock);
10667 	spa->spa_waiters_cancel = B_FALSE;
10668 	mutex_exit(&spa->spa_activities_lock);
10675 	spa_t *spa = vd->vdev_spa;
10677 	ASSERT(spa_config_held(spa, SCL_CONFIG | SCL_STATE, RW_READER));
10678 	ASSERT(MUTEX_HELD(&spa->spa_activities_lock));
10685 	mutex_exit(&spa->spa_activities_lock);
10687 	mutex_enter(&spa->spa_activities_lock);
10713 spa_vdev_activity_in_progress(spa_t *spa, boolean_t use_guid, uint64_t guid,
10716 	mutex_exit(&spa->spa_activities_lock);
10717 	spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER);
10718 	mutex_enter(&spa->spa_activities_lock);
10722 		vd = spa_lookup_by_guid(spa, guid, B_FALSE);
10724 			spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
10728 		vd = spa->spa_root_vdev;
10733 	spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
10780 spa_activity_in_progress(spa_t *spa, zpool_wait_activity_t activity,
10785 	ASSERT(MUTEX_HELD(&spa->spa_activities_lock));
10790 		    (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT) &&
10791 		    zap_contains(spa_meta_objset(spa),
10796 		*in_progress = ((spa_version(spa) >= SPA_VERSION_DEADLISTS &&
10797 		    !bpobj_is_empty(&spa->spa_dsl_pool->dp_free_bpobj)) ||
10798 		    spa_feature_is_active(spa, SPA_FEATURE_ASYNC_DESTROY) ||
10799 		    spa_livelist_delete_check(spa));
10803 		error = spa_vdev_activity_in_progress(spa, use_tag, tag,
10807 		mutex_exit(&spa->spa_activities_lock);
10808 		spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER);
10809 		mutex_enter(&spa->spa_activities_lock);
10811 		*in_progress = vdev_replace_in_progress(spa->spa_root_vdev);
10812 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
10815 		*in_progress = (spa->spa_removing_phys.sr_state ==
10819 		*in_progress = vdev_rebuild_active(spa->spa_root_vdev);
10826 		dsl_scan_t *scn =  spa->spa_dsl_pool->dp_scan;
10837 		vdev_raidz_expand_t *vre = spa->spa_raidz_expand;
10869 	spa_t *spa;
10870 	int error = spa_open(pool, &spa, FTAG);
10875 	 * Increment the spa's waiter count so that we can call spa_close and
10882 	mutex_enter(&spa->spa_activities_lock);
10883 	spa->spa_waiters++;
10884 	spa_close(spa, FTAG);
10889 		error = spa_activity_in_progress(spa, activity, use_tag, tag,
10892 		if (error || !in_progress || spa->spa_waiters_cancel)
10897 		if (cv_wait_sig(&spa->spa_activities_cv,
10898 		    &spa->spa_activities_lock) == 0) {
10904 	spa->spa_waiters--;
10905 	cv_signal(&spa->spa_waiters_cv);
10906 	mutex_exit(&spa->spa_activities_lock);
10933 spa_event_create(spa_t *spa, vdev_t *vd, nvlist_t *hist_nvl, const char *name)
10939 	resource = zfs_event_create(spa, vd, FM_SYSEVENT_CLASS, name, hist_nvl);
10945 	(void) spa, (void) vd, (void) hist_nvl, (void) name;
10966  * filled in from the spa and (optionally) the vdev.  This doesn't do anything
10971 spa_event_notify(spa_t *spa, vdev_t *vd, nvlist_t *hist_nvl, const char *name)
10973 	spa_event_post(spa_event_create(spa, vd, hist_nvl, name));
11020 /* spa syncing */