Lines Matching defs:spa
93 * spa_refcount (per-spa zfs_refcount_t protected by mutex)
101 * spa_config_lock[] (per-spa array of rwlocks)
106 * - RW_READER to perform I/O to the spa
174 * The spa config locks cannot be normal rwlocks because we need the
253 * Everything except dprintf, set_error, spa, and indirect_remap is on
394 * Number of allocators to use, per spa instance
406 spa_load_failed(spa_t *spa, const char *fmt, ...)
415 zfs_dbgmsg("spa_load(%s, config %s): FAILED: %s", spa->spa_name,
416 spa->spa_trust_config ? "trusted" : "untrusted", buf);
420 spa_load_note(spa_t *spa, const char *fmt, ...)
429 zfs_dbgmsg("spa_load(%s, config %s): %s", spa->spa_name,
430 spa->spa_trust_config ? "trusted" : "untrusted", buf);
432 spa_import_progress_set_notes_nolog(spa, "%s", buf);
454 spa_config_lock_init(spa_t *spa)
457 spa_config_lock_t *scl = &spa->spa_config_lock[i];
467 spa_config_lock_destroy(spa_t *spa)
470 spa_config_lock_t *scl = &spa->spa_config_lock[i];
480 spa_config_tryenter(spa_t *spa, int locks, const void *tag, krw_t rw)
483 spa_config_lock_t *scl = &spa->spa_config_lock[i];
490 spa_config_exit(spa, locks & ((1 << i) - 1),
498 spa_config_exit(spa, locks & ((1 << i) - 1),
511 spa_config_enter_impl(spa_t *spa, int locks, const void *tag, krw_t rw,
520 spa_config_lock_t *scl = &spa->spa_config_lock[i];
547 spa_config_enter(spa_t *spa, int locks, const void *tag, krw_t rw)
549 spa_config_enter_impl(spa, locks, tag, rw, 0);
562 spa_config_enter_mmp(spa_t *spa, int locks, const void *tag, krw_t rw)
564 spa_config_enter_impl(spa, locks, tag, rw, 1);
568 spa_config_exit(spa_t *spa, int locks, const void *tag)
572 spa_config_lock_t *scl = &spa->spa_config_lock[i];
588 spa_config_held(spa_t *spa, int locks, krw_t rw)
593 spa_config_lock_t *scl = &spa->spa_config_lock[i];
618 spa_t *spa;
635 spa = avl_find(&spa_namespace_avl, &search, &where);
636 if (spa == NULL)
643 if ((spa->spa_load_thread != NULL &&
644 spa->spa_load_thread != curthread) ||
645 (spa->spa_export_thread != NULL &&
646 spa->spa_export_thread != curthread)) {
651 return (spa);
662 spa_t *spa = arg;
665 if (spa_suspended(spa))
669 (gethrtime() - spa->spa_sync_starttime) / NANOSEC,
670 (u_longlong_t)++spa->spa_deadman_calls);
672 vdev_deadman(spa->spa_root_vdev, FTAG);
674 spa->spa_deadman_tqid = taskq_dispatch_delay(system_delay_taskq,
675 spa_deadman, spa, TQ_SLEEP, ddi_get_lbolt() +
696 spa_t *spa;
701 spa = kmem_zalloc(sizeof (spa_t), KM_SLEEP);
703 mutex_init(&spa->spa_async_lock, NULL, MUTEX_DEFAULT, NULL);
704 mutex_init(&spa->spa_errlist_lock, NULL, MUTEX_DEFAULT, NULL);
705 mutex_init(&spa->spa_errlog_lock, NULL, MUTEX_DEFAULT, NULL);
706 mutex_init(&spa->spa_evicting_os_lock, NULL, MUTEX_DEFAULT, NULL);
707 mutex_init(&spa->spa_history_lock, NULL, MUTEX_DEFAULT, NULL);
708 mutex_init(&spa->spa_proc_lock, NULL, MUTEX_DEFAULT, NULL);
709 mutex_init(&spa->spa_props_lock, NULL, MUTEX_DEFAULT, NULL);
710 mutex_init(&spa->spa_cksum_tmpls_lock, NULL, MUTEX_DEFAULT, NULL);
711 mutex_init(&spa->spa_scrub_lock, NULL, MUTEX_DEFAULT, NULL);
712 mutex_init(&spa->spa_suspend_lock, NULL, MUTEX_DEFAULT, NULL);
713 mutex_init(&spa->spa_vdev_top_lock, NULL, MUTEX_DEFAULT, NULL);
714 mutex_init(&spa->spa_feat_stats_lock, NULL, MUTEX_DEFAULT, NULL);
715 mutex_init(&spa->spa_flushed_ms_lock, NULL, MUTEX_DEFAULT, NULL);
716 mutex_init(&spa->spa_activities_lock, NULL, MUTEX_DEFAULT, NULL);
718 cv_init(&spa->spa_async_cv, NULL, CV_DEFAULT, NULL);
719 cv_init(&spa->spa_evicting_os_cv, NULL, CV_DEFAULT, NULL);
720 cv_init(&spa->spa_proc_cv, NULL, CV_DEFAULT, NULL);
721 cv_init(&spa->spa_scrub_io_cv, NULL, CV_DEFAULT, NULL);
722 cv_init(&spa->spa_suspend_cv, NULL, CV_DEFAULT, NULL);
723 cv_init(&spa->spa_activities_cv, NULL, CV_DEFAULT, NULL);
724 cv_init(&spa->spa_waiters_cv, NULL, CV_DEFAULT, NULL);
727 bplist_create(&spa->spa_free_bplist[t]);
729 (void) strlcpy(spa->spa_name, name, sizeof (spa->spa_name));
730 spa->spa_state = POOL_STATE_UNINITIALIZED;
731 spa->spa_freeze_txg = UINT64_MAX;
732 spa->spa_final_txg = UINT64_MAX;
733 spa->spa_load_max_txg = UINT64_MAX;
734 spa->spa_proc = &p0;
735 spa->spa_proc_state = SPA_PROC_NONE;
736 spa->spa_trust_config = B_TRUE;
737 spa->spa_hostid = zone_get_hostid(NULL);
739 spa->spa_deadman_synctime = MSEC2NSEC(zfs_deadman_synctime_ms);
740 spa->spa_deadman_ziotime = MSEC2NSEC(zfs_deadman_ziotime_ms);
741 spa_set_deadman_failmode(spa, zfs_deadman_failmode);
742 spa_set_allocator(spa, zfs_active_allocator);
744 zfs_refcount_create(&spa->spa_refcount);
745 spa_config_lock_init(spa);
746 spa_stats_init(spa);
749 avl_add(&spa_namespace_avl, spa);
755 spa->spa_root = spa_strdup(altroot);
758 spa->spa_alloc_count = MAX(MIN(spa_num_allocators,
761 spa->spa_allocs = kmem_zalloc(spa->spa_alloc_count *
763 for (int i = 0; i < spa->spa_alloc_count; i++) {
764 mutex_init(&spa->spa_allocs[i].spaa_lock, NULL, MUTEX_DEFAULT,
766 avl_create(&spa->spa_allocs[i].spaa_tree, zio_bookmark_compare,
769 if (spa->spa_alloc_count > 1) {
770 spa->spa_allocs_use = kmem_zalloc(offsetof(spa_allocs_use_t,
771 sau_inuse[spa->spa_alloc_count]), KM_SLEEP);
772 mutex_init(&spa->spa_allocs_use->sau_lock, NULL, MUTEX_DEFAULT,
776 avl_create(&spa->spa_metaslabs_by_flushed, metaslab_sort_by_flushed,
778 avl_create(&spa->spa_sm_logs_by_txg, spa_log_sm_sort_by_txg,
780 list_create(&spa->spa_log_summary, sizeof (log_summary_entry_t),
786 list_create(&spa->spa_config_list, sizeof (spa_config_dirent_t),
791 list_insert_head(&spa->spa_config_list, dp);
793 VERIFY(nvlist_alloc(&spa->spa_load_info, NV_UNIQUE_NAME,
801 VERIFY(nvlist_dup(features, &spa->spa_label_features,
805 VERIFY(nvlist_dup(config, &spa->spa_config, 0) == 0);
808 if (spa->spa_label_features == NULL) {
809 VERIFY(nvlist_alloc(&spa->spa_label_features, NV_UNIQUE_NAME,
813 spa->spa_min_ashift = INT_MAX;
814 spa->spa_max_ashift = 0;
815 spa->spa_min_alloc = INT_MAX;
816 spa->spa_gcd_alloc = INT_MAX;
819 spa->spa_dedup_dspace = ~0ULL;
827 spa->spa_feat_refcount_cache[i] = SPA_FEATURE_DISABLED;
830 list_create(&spa->spa_leaf_list, sizeof (vdev_t),
833 return (spa);
842 spa_remove(spa_t *spa)
847 ASSERT(spa_state(spa) == POOL_STATE_UNINITIALIZED);
848 ASSERT3U(zfs_refcount_count(&spa->spa_refcount), ==, 0);
849 ASSERT0(spa->spa_waiters);
851 nvlist_free(spa->spa_config_splitting);
853 avl_remove(&spa_namespace_avl, spa);
855 if (spa->spa_root)
856 spa_strfree(spa->spa_root);
858 while ((dp = list_remove_head(&spa->spa_config_list)) != NULL) {
864 for (int i = 0; i < spa->spa_alloc_count; i++) {
865 avl_destroy(&spa->spa_allocs[i].spaa_tree);
866 mutex_destroy(&spa->spa_allocs[i].spaa_lock);
868 kmem_free(spa->spa_allocs, spa->spa_alloc_count *
870 if (spa->spa_alloc_count > 1) {
871 mutex_destroy(&spa->spa_allocs_use->sau_lock);
872 kmem_free(spa->spa_allocs_use, offsetof(spa_allocs_use_t,
873 sau_inuse[spa->spa_alloc_count]));
876 avl_destroy(&spa->spa_metaslabs_by_flushed);
877 avl_destroy(&spa->spa_sm_logs_by_txg);
878 list_destroy(&spa->spa_log_summary);
879 list_destroy(&spa->spa_config_list);
880 list_destroy(&spa->spa_leaf_list);
882 nvlist_free(spa->spa_label_features);
883 nvlist_free(spa->spa_load_info);
884 nvlist_free(spa->spa_feat_stats);
885 spa_config_set(spa, NULL);
887 zfs_refcount_destroy(&spa->spa_refcount);
889 spa_stats_destroy(spa);
890 spa_config_lock_destroy(spa);
893 bplist_destroy(&spa->spa_free_bplist[t]);
895 zio_checksum_templates_free(spa);
897 cv_destroy(&spa->spa_async_cv);
898 cv_destroy(&spa->spa_evicting_os_cv);
899 cv_destroy(&spa->spa_proc_cv);
900 cv_destroy(&spa->spa_scrub_io_cv);
901 cv_destroy(&spa->spa_suspend_cv);
902 cv_destroy(&spa->spa_activities_cv);
903 cv_destroy(&spa->spa_waiters_cv);
905 mutex_destroy(&spa->spa_flushed_ms_lock);
906 mutex_destroy(&spa->spa_async_lock);
907 mutex_destroy(&spa->spa_errlist_lock);
908 mutex_destroy(&spa->spa_errlog_lock);
909 mutex_destroy(&spa->spa_evicting_os_lock);
910 mutex_destroy(&spa->spa_history_lock);
911 mutex_destroy(&spa->spa_proc_lock);
912 mutex_destroy(&spa->spa_props_lock);
913 mutex_destroy(&spa->spa_cksum_tmpls_lock);
914 mutex_destroy(&spa->spa_scrub_lock);
915 mutex_destroy(&spa->spa_suspend_lock);
916 mutex_destroy(&spa->spa_vdev_top_lock);
917 mutex_destroy(&spa->spa_feat_stats_lock);
918 mutex_destroy(&spa->spa_activities_lock);
920 kmem_free(spa, sizeof (spa_t));
949 spa_open_ref(spa_t *spa, const void *tag)
951 ASSERT(zfs_refcount_count(&spa->spa_refcount) >= spa->spa_minref ||
953 spa->spa_load_thread == curthread);
954 (void) zfs_refcount_add(&spa->spa_refcount, tag);
962 spa_close(spa_t *spa, const void *tag)
964 ASSERT(zfs_refcount_count(&spa->spa_refcount) > spa->spa_minref ||
966 spa->spa_load_thread == curthread ||
967 spa->spa_export_thread == curthread);
968 (void) zfs_refcount_remove(&spa->spa_refcount, tag);
980 spa_async_close(spa_t *spa, const void *tag)
982 (void) zfs_refcount_remove(&spa->spa_refcount, tag);
986 * Check to see if the spa refcount is zero. Must be called with
987 * spa_namespace_lock held or be the spa export thread. We really
992 spa_refcount_zero(spa_t *spa)
995 spa->spa_export_thread == curthread);
997 return (zfs_refcount_count(&spa->spa_refcount) == spa->spa_minref);
1234 * Grabs the global spa_namespace_lock plus the spa config lock for writing.
1238 spa_vdev_enter(spa_t *spa)
1240 mutex_enter(&spa->spa_vdev_top_lock);
1243 ASSERT0(spa->spa_export_thread);
1245 vdev_autotrim_stop_all(spa);
1247 return (spa_vdev_config_enter(spa));
1257 spa_vdev_detach_enter(spa_t *spa, uint64_t guid)
1259 mutex_enter(&spa->spa_vdev_top_lock);
1262 ASSERT0(spa->spa_export_thread);
1264 vdev_autotrim_stop_all(spa);
1267 vdev_t *vd = spa_lookup_by_guid(spa, guid, B_FALSE);
1273 return (spa_vdev_config_enter(spa));
1282 spa_vdev_config_enter(spa_t *spa)
1286 spa_config_enter(spa, SCL_ALL, spa, RW_WRITER);
1288 return (spa_last_synced_txg(spa) + 1);
1296 spa_vdev_config_exit(spa_t *spa, vdev_t *vd, uint64_t txg, int error,
1303 ASSERT(txg > spa_last_synced_txg(spa));
1305 spa->spa_pending_vdev = NULL;
1310 vdev_dtl_reassess(spa->spa_root_vdev, 0, 0, B_FALSE, B_FALSE);
1312 if (error == 0 && !list_is_empty(&spa->spa_config_dirty_list)) {
1314 spa->spa_config_generation++;
1320 ASSERT(metaslab_class_validate(spa_normal_class(spa)) == 0);
1321 ASSERT(metaslab_class_validate(spa_log_class(spa)) == 0);
1322 ASSERT(metaslab_class_validate(spa_embedded_log_class(spa)) == 0);
1323 ASSERT(metaslab_class_validate(spa_special_class(spa)) == 0);
1324 ASSERT(metaslab_class_validate(spa_dedup_class(spa)) == 0);
1326 spa_config_exit(spa, SCL_ALL, spa);
1334 zio_handle_panic_injection(spa, tag, 0);
1342 txg_wait_synced(spa->spa_dsl_pool, txg);
1362 spa_config_enter(spa, SCL_STATE_ALL, spa, RW_WRITER);
1364 spa_config_exit(spa, SCL_STATE_ALL, spa);
1371 spa_write_cachefile(spa, B_FALSE, B_TRUE, B_TRUE);
1381 spa_vdev_exit(spa_t *spa, vdev_t *vd, uint64_t txg, int error)
1383 vdev_autotrim_restart(spa);
1384 vdev_rebuild_restart(spa);
1386 spa_vdev_config_exit(spa, vd, txg, error, FTAG);
1388 mutex_exit(&spa->spa_vdev_top_lock);
1397 spa_vdev_state_enter(spa_t *spa, int oplocks)
1410 if (spa_is_root(spa)) {
1414 spa_config_enter(spa, high, spa, RW_WRITER);
1415 vdev_hold(spa->spa_root_vdev);
1416 spa_config_enter(spa, low, spa, RW_WRITER);
1418 spa_config_enter(spa, locks, spa, RW_WRITER);
1420 spa->spa_vdev_locks = locks;
1424 spa_vdev_state_exit(spa_t *spa, vdev_t *vd, int error)
1429 if (vd == NULL || vd == spa->spa_root_vdev) {
1430 vdev_top = spa->spa_root_vdev;
1439 if (vd != spa->spa_root_vdev)
1443 spa->spa_config_generation++;
1446 if (spa_is_root(spa))
1447 vdev_rele(spa->spa_root_vdev);
1449 ASSERT3U(spa->spa_vdev_locks, >=, SCL_STATE_ALL);
1450 spa_config_exit(spa, spa->spa_vdev_locks, spa);
1459 txg_wait_synced(spa->spa_dsl_pool, 0);
1466 spa_write_cachefile(spa, B_FALSE, B_TRUE, B_FALSE);
1480 spa_activate_mos_feature(spa_t *spa, const char *feature, dmu_tx_t *tx)
1482 if (!nvlist_exists(spa->spa_label_features, feature)) {
1483 fnvlist_add_boolean(spa->spa_label_features, feature);
1492 vdev_config_dirty(spa->spa_root_vdev);
1497 spa_deactivate_mos_feature(spa_t *spa, const char *feature)
1499 if (nvlist_remove_all(spa->spa_label_features, feature) == 0)
1500 vdev_config_dirty(spa->spa_root_vdev);
1511 spa_t *spa;
1516 for (spa = avl_first(t); spa != NULL; spa = AVL_NEXT(t, spa)) {
1517 if (spa->spa_state == POOL_STATE_UNINITIALIZED)
1519 if (spa->spa_root_vdev == NULL)
1521 if (spa_guid(spa) == pool_guid) {
1525 if (vdev_lookup_by_guid(spa->spa_root_vdev,
1532 if (spa->spa_pending_vdev) {
1533 if (vdev_lookup_by_guid(spa->spa_pending_vdev,
1540 return (spa);
1572 spa_generate_guid(spa_t *spa)
1576 if (spa != NULL) {
1580 } while (guid == 0 || spa_guid_exists(spa_guid(spa), guid));
1598 for (spa_t *spa = avl_first(t); spa != NULL; spa = AVL_NEXT(t, spa)) {
1599 if (spa_load_guid(spa) == guid)
1650 spa_freeze(spa_t *spa)
1654 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1655 if (spa->spa_freeze_txg == UINT64_MAX) {
1656 freeze_txg = spa_last_synced_txg(spa) + TXG_SIZE;
1657 spa->spa_freeze_txg = freeze_txg;
1659 spa_config_exit(spa, SCL_ALL, FTAG);
1661 txg_wait_synced(spa_get_dsl(spa), freeze_txg);
1706 spa_activate_allocation_classes(spa_t *spa, dmu_tx_t *tx)
1711 ASSERT(spa_feature_is_enabled(spa, SPA_FEATURE_ALLOCATION_CLASSES));
1712 spa_feature_incr(spa, SPA_FEATURE_ALLOCATION_CLASSES, tx);
1722 spa_shutting_down(spa_t *spa)
1724 return (spa->spa_async_suspended);
1728 spa_get_dsl(spa_t *spa)
1730 return (spa->spa_dsl_pool);
1734 spa_is_initializing(spa_t *spa)
1736 return (spa->spa_is_initializing);
1740 spa_indirect_vdevs_loaded(spa_t *spa)
1742 return (spa->spa_indirect_vdevs_loaded);
1746 spa_get_rootblkptr(spa_t *spa)
1748 return (&spa->spa_ubsync.ub_rootbp);
1752 spa_set_rootblkptr(spa_t *spa, const blkptr_t *bp)
1754 spa->spa_uberblock.ub_rootbp = *bp;
1758 spa_altroot(spa_t *spa, char *buf, size_t buflen)
1760 if (spa->spa_root == NULL)
1763 (void) strlcpy(buf, spa->spa_root, buflen);
1767 spa_sync_pass(spa_t *spa)
1769 return (spa->spa_sync_pass);
1773 spa_name(spa_t *spa)
1775 return (spa->spa_name);
1779 spa_guid(spa_t *spa)
1781 dsl_pool_t *dp = spa_get_dsl(spa);
1790 if (spa->spa_root_vdev == NULL)
1791 return (spa->spa_config_guid);
1793 guid = spa->spa_last_synced_guid != 0 ?
1794 spa->spa_last_synced_guid : spa->spa_root_vdev->vdev_guid;
1801 return (spa->spa_root_vdev->vdev_guid);
1807 spa_load_guid(spa_t *spa)
1814 return (spa->spa_load_guid);
1818 spa_last_synced_txg(spa_t *spa)
1820 return (spa->spa_ubsync.ub_txg);
1824 spa_first_txg(spa_t *spa)
1826 return (spa->spa_first_txg);
1830 spa_syncing_txg(spa_t *spa)
1832 return (spa->spa_syncing_txg);
1840 spa_final_dirty_txg(spa_t *spa)
1842 return (spa->spa_final_txg - TXG_DEFER_SIZE);
1846 spa_state(spa_t *spa)
1848 return (spa->spa_state);
1852 spa_load_state(spa_t *spa)
1854 return (spa->spa_load_state);
1858 spa_freeze_txg(spa_t *spa)
1860 return (spa->spa_freeze_txg);
1871 spa_get_worst_case_asize(spa_t *spa, uint64_t lsize)
1875 return (MAX(lsize, 1 << spa->spa_max_ashift) * spa_asize_inflation);
1890 spa_get_slop_space(spa_t *spa)
1898 if (spa->spa_dedup_dspace == ~0ULL)
1899 spa_update_dspace(spa);
1901 space = spa->spa_rdspace;
1911 metaslab_class_get_dspace(spa_embedded_log_class(spa));
1923 spa_get_dspace(spa_t *spa)
1925 return (spa->spa_dspace);
1929 spa_get_checkpoint_space(spa_t *spa)
1931 return (spa->spa_checkpoint_info.sci_dspace);
1935 spa_update_dspace(spa_t *spa)
1937 spa->spa_rdspace = metaslab_class_get_dspace(spa_normal_class(spa));
1938 if (spa->spa_nonallocating_dspace > 0) {
1957 ASSERT3U(spa->spa_rdspace, >=, spa->spa_nonallocating_dspace);
1958 spa->spa_rdspace -= spa->spa_nonallocating_dspace;
1960 spa->spa_dspace = spa->spa_rdspace + ddt_get_dedup_dspace(spa) +
1961 brt_get_dspace(spa);
1969 spa_get_failmode(spa_t *spa)
1971 return (spa->spa_failmode);
1975 spa_suspended(spa_t *spa)
1977 return (spa->spa_suspended != ZIO_SUSPEND_NONE);
1981 spa_version(spa_t *spa)
1983 return (spa->spa_ubsync.ub_version);
1987 spa_deflate(spa_t *spa)
1989 return (spa->spa_deflate);
1993 spa_normal_class(spa_t *spa)
1995 return (spa->spa_normal_class);
1999 spa_log_class(spa_t *spa)
2001 return (spa->spa_log_class);
2005 spa_embedded_log_class(spa_t *spa)
2007 return (spa->spa_embedded_log_class);
2011 spa_special_class(spa_t *spa)
2013 return (spa->spa_special_class);
2017 spa_dedup_class(spa_t *spa)
2019 return (spa->spa_dedup_class);
2023 spa_special_has_ddt(spa_t *spa)
2026 spa->spa_special_class->mc_groups != 0);
2033 spa_preferred_class(spa_t *spa, const zio_t *zio)
2052 boolean_t has_special_class = spa->spa_special_class->mc_groups != 0;
2055 if (spa->spa_dedup_class->mc_groups != 0)
2056 return (spa_dedup_class(spa));
2058 return (spa_special_class(spa));
2060 return (spa_normal_class(spa));
2067 return (spa_special_class(spa));
2069 return (spa_normal_class(spa));
2074 return (spa_special_class(spa));
2076 return (spa_normal_class(spa));
2086 metaslab_class_t *special = spa_special_class(spa);
2097 return (spa_normal_class(spa));
2101 spa_evicting_os_register(spa_t *spa, objset_t *os)
2103 mutex_enter(&spa->spa_evicting_os_lock);
2104 list_insert_head(&spa->spa_evicting_os_list, os);
2105 mutex_exit(&spa->spa_evicting_os_lock);
2109 spa_evicting_os_deregister(spa_t *spa, objset_t *os)
2111 mutex_enter(&spa->spa_evicting_os_lock);
2112 list_remove(&spa->spa_evicting_os_list, os);
2113 cv_broadcast(&spa->spa_evicting_os_cv);
2114 mutex_exit(&spa->spa_evicting_os_lock);
2118 spa_evicting_os_wait(spa_t *spa)
2120 mutex_enter(&spa->spa_evicting_os_lock);
2121 while (!list_is_empty(&spa->spa_evicting_os_list))
2122 cv_wait(&spa->spa_evicting_os_cv, &spa->spa_evicting_os_lock);
2123 mutex_exit(&spa->spa_evicting_os_lock);
2129 spa_max_replication(spa_t *spa)
2136 if (spa_version(spa) < SPA_VERSION_DITTO_BLOCKS)
2142 spa_prev_software_version(spa_t *spa)
2144 return (spa->spa_prev_software_version);
2148 spa_deadman_synctime(spa_t *spa)
2150 return (spa->spa_deadman_synctime);
2154 spa_get_autotrim(spa_t *spa)
2156 return (spa->spa_autotrim);
2160 spa_deadman_ziotime(spa_t *spa)
2162 return (spa->spa_deadman_ziotime);
2166 spa_get_deadman_failmode(spa_t *spa)
2168 return (spa->spa_deadman_failmode);
2172 spa_set_deadman_failmode(spa_t *spa, const char *failmode)
2175 spa->spa_deadman_failmode = ZIO_FAILURE_MODE_WAIT;
2177 spa->spa_deadman_failmode = ZIO_FAILURE_MODE_CONTINUE;
2179 spa->spa_deadman_failmode = ZIO_FAILURE_MODE_PANIC;
2181 spa->spa_deadman_failmode = ZIO_FAILURE_MODE_WAIT;
2187 spa_t *spa = NULL;
2191 while ((spa = spa_next(spa)) != NULL)
2192 spa->spa_deadman_ziotime = ns;
2200 spa_t *spa = NULL;
2204 while ((spa = spa_next(spa)) != NULL)
2205 spa->spa_deadman_synctime = ns;
2211 dva_get_dsize_sync(spa_t *spa, const dva_t *dva)
2216 ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);
2218 if (asize != 0 && spa->spa_deflate) {
2219 vdev_t *vd = vdev_lookup_top(spa, DVA_GET_VDEV(dva));
2229 bp_get_dsize_sync(spa_t *spa, const blkptr_t *bp)
2234 dsize += dva_get_dsize_sync(spa, &bp->blk_dva[d]);
2240 bp_get_dsize(spa_t *spa, const blkptr_t *bp)
2244 spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
2247 dsize += dva_get_dsize_sync(spa, &bp->blk_dva[d]);
2249 spa_config_exit(spa, SCL_VDEV, FTAG);
2255 spa_dirty_data(spa_t *spa)
2257 return (spa->spa_dsl_pool->dp_dirty_total);
2382 spa_import_progress_set_notes_impl(spa_t *spa, boolean_t log_dbgmsg,
2387 uint64_t pool_guid = spa_guid(spa);
2415 spa_import_progress_set_notes(spa_t *spa, const char *fmt, ...)
2420 spa_import_progress_set_notes_impl(spa, B_TRUE, fmt, adx);
2425 spa_import_progress_set_notes_nolog(spa_t *spa, const char *fmt, ...)
2430 spa_import_progress_set_notes_impl(spa, B_FALSE, fmt, adx);
2487 spa_import_progress_add(spa_t *spa)
2494 sip->pool_guid = spa_guid(spa);
2496 (void) nvlist_lookup_string(spa->spa_config, ZPOOL_CONFIG_POOL_NAME,
2499 poolname = spa_name(spa);
2501 sip->spa_load_state = spa_load_state(spa);
2661 spa_has_slogs(spa_t *spa)
2663 return (spa->spa_log_class->mc_groups != 0);
2667 spa_get_log_state(spa_t *spa)
2669 return (spa->spa_log_state);
2673 spa_set_log_state(spa_t *spa, spa_log_state_t state)
2675 spa->spa_log_state = state;
2679 spa_is_root(spa_t *spa)
2681 return (spa->spa_is_root);
2685 spa_writeable(spa_t *spa)
2687 return (!!(spa->spa_mode & SPA_MODE_WRITE) && spa->spa_trust_config);
2695 spa_has_pending_synctask(spa_t *spa)
2697 return (!txg_all_lists_empty(&spa->spa_dsl_pool->dp_sync_tasks) ||
2698 !txg_all_lists_empty(&spa->spa_dsl_pool->dp_early_sync_tasks));
2702 spa_mode(spa_t *spa)
2704 return (spa->spa_mode);
2708 spa_get_last_scrubbed_txg(spa_t *spa)
2710 return (spa->spa_scrubbed_last_txg);
2714 spa_bootfs(spa_t *spa)
2716 return (spa->spa_bootfs);
2720 spa_delegation(spa_t *spa)
2722 return (spa->spa_delegation);
2726 spa_meta_objset(spa_t *spa)
2728 return (spa->spa_meta_objset);
2732 spa_dedup_checksum(spa_t *spa)
2734 return (spa->spa_dedup_checksum);
2741 spa_scan_stat_init(spa_t *spa)
2744 spa->spa_scan_pass_start = gethrestime_sec();
2745 if (dsl_scan_is_paused_scrub(spa->spa_dsl_pool->dp_scan))
2746 spa->spa_scan_pass_scrub_pause = spa->spa_scan_pass_start;
2748 spa->spa_scan_pass_scrub_pause = 0;
2750 if (dsl_errorscrub_is_paused(spa->spa_dsl_pool->dp_scan))
2751 spa->spa_scan_pass_errorscrub_pause = spa->spa_scan_pass_start;
2753 spa->spa_scan_pass_errorscrub_pause = 0;
2755 spa->spa_scan_pass_scrub_spent_paused = 0;
2756 spa->spa_scan_pass_exam = 0;
2757 spa->spa_scan_pass_issued = 0;
2760 spa->spa_scan_pass_errorscrub_spent_paused = 0;
2767 spa_scan_get_stats(spa_t *spa, pool_scan_stat_t *ps)
2769 dsl_scan_t *scn = spa->spa_dsl_pool ? spa->spa_dsl_pool->dp_scan : NULL;
2789 ps->pss_pass_exam = spa->spa_scan_pass_exam;
2790 ps->pss_pass_start = spa->spa_scan_pass_start;
2791 ps->pss_pass_scrub_pause = spa->spa_scan_pass_scrub_pause;
2792 ps->pss_pass_scrub_spent_paused = spa->spa_scan_pass_scrub_spent_paused;
2793 ps->pss_pass_issued = spa->spa_scan_pass_issued;
2795 scn->scn_issued_before_pass + spa->spa_scan_pass_issued;
2807 ps->pss_pass_error_scrub_pause = spa->spa_scan_pass_errorscrub_pause;
2813 spa_maxblocksize(spa_t *spa)
2815 if (spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_BLOCKS))
2827 spa_get_last_removal_txg(spa_t *spa)
2832 spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
2838 vdevid = spa->spa_removing_phys.sr_prev_indirect_vdev;
2841 vdev_t *vd = vdev_lookup_top(spa, vdevid);
2856 spa_config_exit(spa, SCL_VDEV, FTAG);
2859 spa_feature_is_active(spa, SPA_FEATURE_DEVICE_REMOVAL));
2865 spa_maxdnodesize(spa_t *spa)
2867 if (spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_DNODE))
2874 spa_multihost(spa_t *spa)
2876 return (spa->spa_multihost ? B_TRUE : B_FALSE);
2880 spa_get_hostid(spa_t *spa)
2882 return (spa->spa_hostid);
2886 spa_trust_config(spa_t *spa)
2888 return (spa->spa_trust_config);
2892 spa_missing_tvds_allowed(spa_t *spa)
2894 return (spa->spa_missing_tvds_allowed);
2898 spa_syncing_log_sm(spa_t *spa)
2900 return (spa->spa_syncing_log_sm);
2904 spa_set_missing_tvds(spa_t *spa, uint64_t missing)
2906 spa->spa_missing_tvds = missing;
2913 spa_state_to_name(spa_t *spa)
2915 ASSERT3P(spa, !=, NULL);
2918 * it is possible for the spa to exist, without root vdev
2919 * as the spa transitions during import/export
2921 vdev_t *rvd = spa->spa_root_vdev;
2928 if (spa_suspended(spa))
2958 spa_top_vdevs_spacemap_addressable(spa_t *spa)
2960 vdev_t *rvd = spa->spa_root_vdev;
2969 spa_has_checkpoint(spa_t *spa)
2971 return (spa->spa_checkpoint_txg != 0);
2975 spa_importing_readonly_checkpoint(spa_t *spa)
2977 return ((spa->spa_import_flags & ZFS_IMPORT_CHECKPOINT) &&
2978 spa->spa_mode == SPA_MODE_READ);
2982 spa_min_claim_txg(spa_t *spa)
2984 uint64_t checkpoint_txg = spa->spa_uberblock.ub_checkpoint_txg;
2989 return (spa->spa_first_txg);
2999 spa_suspend_async_destroy(spa_t *spa)
3001 dsl_pool_t *dp = spa_get_dsl(spa);
3008 if (spa_has_checkpoint(spa) && avail == 0)
3019 spa_t *spa = NULL;
3034 while ((spa = spa_next(spa)) != NULL)
3035 spa_set_deadman_failmode(spa, val);
3174 "Number of allocators per spa");