Lines Matching +full:we +full:- +full:on +full:- +full:ns
1 .\" SPDX-License-Identifier: CDDL-1.0
10 .\" usr/src/OPENSOLARIS.LICENSE or https://opensource.org/licenses/CDDL-1.0.
30 .Bl -tag -width Ds
31 .It Sy dbuf_cache_max_bytes Ns = Ns Sy UINT64_MAX Ns B Pq u64
34 .No 1/2^ Ns Sy dbuf_cache_shift Pq 1/32nd
41 .It Sy dbuf_metadata_cache_max_bytes Ns = Ns Sy UINT64_MAX Ns B Pq u64
44 .No 1/2^ Ns Sy dbuf_metadata_cache_shift Pq 1/64th
51 .It Sy dbuf_cache_hiwater_pct Ns = Ns Sy 10 Ns % Pq uint
56 .It Sy dbuf_cache_lowater_pct Ns = Ns Sy 10 Ns % Pq uint
61 .It Sy dbuf_cache_shift Ns = Ns Sy 5 Pq uint
66 .It Sy dbuf_metadata_cache_shift Ns = Ns Sy 6 Pq uint
71 .It Sy dbuf_mutex_cache_shift Ns = Ns Sy 0 Pq uint
75 the array is dynamically sized based on total system memory.
77 .It Sy dmu_object_alloc_chunk_shift Ns = Ns Sy 7 Po 128 Pc Pq uint
81 .It Sy dmu_ddt_copies Ns = Ns Sy 3 Pq uint
92 .It Sy dmu_prefetch_max Ns = Ns Sy 134217728 Ns B Po 128 MiB Pc Pq uint
93 Limit the amount we can prefetch with one call to this amount in bytes.
96 .It Sy l2arc_feed_again Ns = Ns Sy 1 Ns | Ns 0 Pq int
97 Turbo L2ARC warm-up.
100 .It Sy l2arc_feed_min_ms Ns = Ns Sy 200 Pq u64
103 .Sy l2arc_feed_again Ns = Ns Ar 1
106 .It Sy l2arc_feed_secs Ns = Ns Sy 1 Pq u64
109 .It Sy l2arc_headroom Ns = Ns Sy 8 Pq u64
118 .It Sy l2arc_headroom_boost Ns = Ns Sy 200 Ns % Pq u64
127 .It Sy l2arc_exclude_special Ns = Ns Sy 0 Ns | Ns 1 Pq int
128 Controls whether buffers present on special vdevs are eligible for caching
130 If set to 1, exclude dbufs on special vdevs from being cached to L2ARC.
132 .It Sy l2arc_mfuonly Ns = Ns Sy 0 Ns | Ns 1 Ns | Ns 2 Pq int
134 This may be desired to avoid wasting space on L2ARC when reading/writing large
140 still be present in ARC and eventually cached on L2ARC.
141 .No If Sy l2arc_noprefetch Ns = Ns Sy 0 ,
155 accessed later on as prefetches and transition to MRU as prefetches.
173 .It Sy l2arc_meta_percent Ns = Ns Sy 33 Ns % Pq uint
174 Percent of ARC size allowed for L2ARC-only headers.
175 Since L2ARC buffers are not evicted on memory pressure,
176 too many headers on a system with an irrationally large L2ARC
180 .It Sy l2arc_trim_ahead Ns = Ns Sy 0 Ns % Pq u64
183 on L2ARC devices by this percentage of write size if we have filled the device.
195 disables TRIM on L2ARC altogether and is the default as it can put significant
196 stress on the underlying storage devices.
199 .It Sy l2arc_noprefetch Ns = Ns Sy 1 Ns | Ns 0 Pq int
203 is later set, we do not read the prefetched buffers from L2ARC.
205 disks to L2ARC and serve those reads from L2ARC later on.
215 .It Sy l2arc_norw Ns = Ns Sy 0 Ns | Ns 1 Pq int
218 .It Sy l2arc_write_boost Ns = Ns Sy 33554432 Ns B Po 32 MiB Pc Pq u64
223 .It Sy l2arc_write_max Ns = Ns Sy 33554432 Ns B Po 32 MiB Pc Pq u64
226 .It Sy l2arc_rebuild_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
233 .It Sy l2arc_rebuild_blocks_min_l2size Ns = Ns Sy 1073741824 Ns B Po 1 GiB Pc Pq u64
242 .It Sy metaslab_aliquot Ns = Ns Sy 2097152 Ns B Po 2 MiB Pc Pq u64
247 of a top-level vdev before moving on to the next top-level vdev.
249 .It Sy metaslab_bias_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
250 Enable metaslab groups biasing based on their over- or under-utilization
255 .It Sy metaslab_perf_bias Ns = Ns Sy 1 Ns | Ns 0 Ns | Ns 2 Pq int
256 Controls metaslab groups biasing based on their write performance.
259 Setting to 1 equals to 2 if the pool is write-bound or 0 otherwise.
263 .It Sy metaslab_force_ganging Ns = Ns Sy 16777217 Ns B Po 16 MiB + 1 B Pc Pq u64
267 .It Sy metaslab_force_ganging_pct Ns = Ns Sy 3 Ns % Pq uint
272 .It Sy brt_zap_prefetch Ns = Ns Sy 1 Ns | Ns 0 Pq int
275 .It Sy brt_zap_default_bs Ns = Ns Sy 12 Po 4 KiB Pc Pq int
277 creating a BRT on the pool will not affect existing BRTs, only newly created
280 .It Sy brt_zap_default_ibs Ns = Ns Sy 12 Po 4 KiB Pc Pq int
282 after creating a BRT on the pool will not affect existing BRTs, only newly
285 .It Sy ddt_zap_default_bs Ns = Ns Sy 15 Po 32 KiB Pc Pq int
287 creating a DDT on the pool will not affect existing DDTs, only newly created
290 .It Sy ddt_zap_default_ibs Ns = Ns Sy 15 Po 32 KiB Pc Pq int
292 after creating a DDT on the pool will not affect existing DDTs, only newly
295 .It Sy zfs_default_bs Ns = Ns Sy 9 Po 512 B Pc Pq int
298 .It Sy zfs_default_ibs Ns = Ns Sy 17 Po 128 KiB Pc Pq int
301 .It Sy zfs_dio_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
309 .It Sy zfs_dio_strict Ns = Ns Sy 0 Ns | Ns 1 Pq int
312 if not page-aligned instead of silently falling back to uncached I/O.
314 .It Sy zfs_history_output_max Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq u64
315 When attempting to log an output nvlist of an ioctl in the on-disk history,
320 .Fn zfs_ioc_channel_program Pq cf. Xr zfs-program 8 .
322 .It Sy zfs_keep_log_spacemaps_at_export Ns = Ns Sy 0 Ns | Ns 1 Pq int
325 .It Sy zfs_metaslab_segment_weight_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
326 Enable/disable segment-based metaslab selection.
328 .It Sy zfs_metaslab_switch_threshold Ns = Ns Sy 2 Pq int
329 When using segment-based metaslab selection, continue allocating
333 .It Sy metaslab_debug_load Ns = Ns Sy 0 Ns | Ns 1 Pq int
336 .It Sy metaslab_debug_unload Ns = Ns Sy 0 Ns | Ns 1 Pq int
339 .It Sy metaslab_fragmentation_factor_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
342 .It Sy metaslab_df_max_search Ns = Ns Sy 16777216 Ns B Po 16 MiB Pc Pq uint
348 becomes the performance limiting factor on high-performance storage.
355 .Sy ashift Ns = Ns Sy 9
362 .Em 16*1024 Pq with Sy ashift Ns = Ns Sy 9
364 .Em 2*1024 Pq with Sy ashift Ns = Ns Sy 12 .
366 .It Sy metaslab_df_use_largest_segment Ns = Ns Sy 0 Ns | Ns 1 Pq int
371 If set, we will use the largest free segment.
372 If unset, we will use a segment of at least the requested size.
374 .It Sy zfs_metaslab_max_size_cache_sec Ns = Ns Sy 3600 Ns s Po 1 hour Pc Pq u64
375 When we unload a metaslab, we cache the size of the largest free chunk.
384 .It Sy zfs_metaslab_mem_limit Ns = Ns Sy 25 Ns % Pq uint
385 When we are loading a new metaslab, we check the amount of memory being used
387 If it is over a threshold, we attempt to unload the least recently used metaslab
391 .It Sy zfs_metaslab_try_hard_before_gang Ns = Ns Sy 0 Ns | Ns 1 Pq int
392 .Bl -item -compact
394 If unset, we will first try normal allocation.
396 If that fails then we will do a gang allocation.
398 If that fails then we will do a "try hard" gang allocation.
400 If that fails then we will have a multi-layer gang block.
403 .Bl -item -compact
405 If set, we will first try normal allocation.
407 If that fails then we will do a "try hard" allocation.
409 If that fails we will do a gang allocation.
411 If that fails we will do a "try hard" gang allocation.
413 If that fails then we will have a multi-layer gang block.
416 .It Sy zfs_metaslab_find_max_tries Ns = Ns Sy 100 Pq uint
417 When not trying hard, we only consider this number of the best metaslabs.
420 (so we would otherwise iterate all metaslabs).
422 .It Sy zfs_vdev_default_ms_count Ns = Ns Sy 200 Pq uint
423 When a vdev is added, target this number of metaslabs per top-level vdev.
425 .It Sy zfs_vdev_default_ms_shift Ns = Ns Sy 29 Po 512 MiB Pc Pq uint
428 .It Sy zfs_vdev_max_ms_shift Ns = Ns Sy 34 Po 16 GiB Pc Pq uint
431 .It Sy zfs_vdev_max_auto_ashift Ns = Ns Sy 14 Pq uint
432 Maximum ashift used when optimizing for logical \[->] physical sector size on
434 top-level vdevs.
439 .It Sy zfs_vdev_direct_write_verify Ns = Ns Sy Linux 1 | FreeBSD 0 Pq uint
440 If non-zero, then a Direct I/O write's checksum will be verified every
453 The default value for this is 1 on Linux, but is 0 for
459 .It Sy zfs_vdev_min_auto_ashift Ns = Ns Sy ASHIFT_MIN Po 9 Pc Pq uint
460 Minimum ashift used when creating new top-level vdevs.
462 .It Sy zfs_vdev_min_ms_count Ns = Ns Sy 16 Pq uint
463 Minimum number of metaslabs to create in a top-level vdev.
465 .It Sy vdev_validate_skip Ns = Ns Sy 0 Ns | Ns 1 Pq int
470 .It Sy zfs_vdev_ms_count_limit Ns = Ns Sy 131072 Po 128k Pc Pq uint
471 Practical upper limit of total metaslabs per top-level vdev.
473 .It Sy metaslab_preload_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
476 .It Sy metaslab_preload_limit Ns = Ns Sy 10 Pq uint
479 .It Sy metaslab_preload_pct Ns = Ns Sy 50 Pq uint
482 .It Sy metaslab_lba_weighting_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
485 as is typically the case on a modern constant angular velocity disk drive.
487 .It Sy metaslab_unload_delay Ns = Ns Sy 32 Pq uint
488 After a metaslab is used, we keep it loaded for this many TXGs, to attempt to
494 .It Sy metaslab_unload_delay_ms Ns = Ns Sy 600000 Ns ms Po 10 min Pc Pq uint
495 After a metaslab is used, we keep it loaded for this many milliseconds,
501 .It Sy reference_history Ns = Ns Sy 3 Pq uint
504 .It Sy raidz_expand_max_copy_bytes Ns = Ns Sy 160MB Pq ulong
505 Max amount of memory to use for RAID-Z expansion I/O.
508 .It Sy raidz_expand_max_reflow_bytes Ns = Ns Sy 0 Pq ulong
509 For testing, pause RAID-Z expansion when reflow amount reaches this value.
511 .It Sy raidz_io_aggregate_rows Ns = Ns Sy 4 Pq ulong
512 For expanded RAID-Z, aggregate reads that have more rows than this.
514 .It Sy reference_history Ns = Ns Sy 3 Pq int
518 .It Sy reference_tracking_enable Ns = Ns Sy 0 Ns | Ns 1 Pq int
523 .It Sy send_holes_without_birth_time Ns = Ns Sy 1 Ns | Ns 0 Pq int
531 .It Sy spa_config_path Ns = Ns Pa /etc/zfs/zpool.cache Pq charp
534 .It Sy spa_asize_inflation Ns = Ns Sy 24 Pq uint
538 but lower values may be valid for a given pool depending on its configuration.
543 .It Sy spa_load_print_vdev_tree Ns = Ns Sy 0 Ns | Ns 1 Pq int
547 .It Sy spa_load_verify_data Ns = Ns Sy 1 Ns | Ns 0 Pq int
554 If this parameter is unset, the traversal skips non-metadata blocks.
556 import has started to stop or start the traversal of non-metadata blocks.
558 .It Sy spa_load_verify_metadata Ns = Ns Sy 1 Ns | Ns 0 Pq int
568 .It Sy spa_load_verify_shift Ns = Ns Sy 4 Po 1/16th Pc Pq uint
572 .It Sy spa_slop_shift Ns = Ns Sy 5 Po 1/32nd Pc Pq int
573 Normally, we don't allow the last
576 This ensures that we don't run the pool completely out of space,
578 It also limits the worst-case time to allocate space.
579 If we have less than this amount of free space,
583 .It Sy spa_num_allocators Ns = Ns Sy 4 Pq int
592 .It Sy spa_cpus_per_allocator Ns = Ns Sy 4 Pq int
597 .It Sy spa_upgrade_errlog_limit Ns = Ns Sy 0 Pq uint
598 Limits the number of on-disk error log entries that will be converted to the
604 .It Sy vdev_removal_max_span Ns = Ns Sy 32768 Ns B Po 32 KiB Pc Pq uint
605 During top-level vdev removal, chunks of data are copied from the vdev
615 .It Sy vdev_file_logical_ashift Ns = Ns Sy 9 Po 512 B Pc Pq u64
616 Logical ashift for file-based devices.
618 .It Sy vdev_file_physical_ashift Ns = Ns Sy 9 Po 512 B Pc Pq u64
619 Physical ashift for file-based devices.
621 .It Sy zap_iterate_prefetch Ns = Ns Sy 1 Ns | Ns 0 Pq int
622 If set, when we start iterating over a ZAP object,
627 .It Sy zap_micro_max_size Ns = Ns Sy 131072 Ns B Po 128 KiB Pc Pq int
635 .It Sy zap_shrink_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
638 .It Sy zfetch_min_distance Ns = Ns Sy 4194304 Ns B Po 4 MiB Pc Pq uint
641 this value, doubling on each hit.
646 .It Sy zfetch_max_distance Ns = Ns Sy 67108864 Ns B Po 64 MiB Pc Pq uint
649 .It Sy zfetch_max_idistance Ns = Ns Sy 67108864 Ns B Po 64 MiB Pc Pq uint
652 .It Sy zfetch_max_reorder Ns = Ns Sy 16777216 Ns B Po 16 MiB Pc Pq uint
659 .It Sy zfetch_max_streams Ns = Ns Sy 8 Pq uint
662 .It Sy zfetch_min_sec_reap Ns = Ns Sy 1 Pq uint
665 .It Sy zfetch_max_sec_reap Ns = Ns Sy 2 Pq uint
668 .It Sy zfs_abd_scatter_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
674 .It Sy zfs_abd_scatter_max_order Ns = Ns Sy MAX_ORDER\-1 Pq uint
680 depends on kernel configuration.
682 .It Sy zfs_abd_scatter_min_size Ns = Ns Sy 1536 Ns B Po 1.5 KiB Pc Pq uint
683 This is the minimum allocation size that will use scatter (page-based) ABDs.
686 .It Sy zfs_arc_dnode_limit Ns = Ns Sy 0 Ns B Pq u64
688 bytes, try to unpin some of it in response to demand for non-metadata.
691 which indicates that a percent which is based on
694 .It Sy zfs_arc_dnode_limit_percent Ns = Ns Sy 10 Ns % Pq u64
701 .It Sy zfs_arc_dnode_reduce_percent Ns = Ns Sy 10 Ns % Pq u64
702 Percentage of ARC dnodes to try to scan in response to demand for non-metadata
706 .It Sy zfs_arc_average_blocksize Ns = Ns Sy 8192 Ns B Po 8 KiB Pc Pq uint
707 The ARC's buffer hash table is sized based on the assumption of an average
710 with 8-byte pointers.
714 .It Sy zfs_arc_eviction_pct Ns = Ns Sy 200 Ns % Pq uint
725 .Sy 100 Ns % ,
732 .It Sy zfs_arc_evict_batch_limit Ns = Ns Sy 10 Pq uint
733 Number ARC headers to evict per sub-list before proceeding to another sub-list.
734 This batch-style operation prevents entire sub-lists from being evicted at once
737 .It Sy zfs_arc_evict_threads Ns = Ns Sy 0 Pq int
742 Each thread will process one sub-list at a time,
743 until the eviction target is reached or all sub-lists have been processed.
751 1-4 1
752 5-8 2
753 9-15 3
754 16-31 4
755 32-63 6
756 64-95 8
757 96-127 9
758 128-160 11
759 160-191 12
760 192-223 13
761 224-255 14
771 .It Sy zfs_arc_grow_retry Ns = Ns Sy 0 Ns s Pq uint
777 .No value Pq default Sy 5 Ns s
781 .It Sy zfs_arc_lotsfree_percent Ns = Ns Sy 10 Ns % Pq int
788 .It Sy zfs_arc_max Ns = Ns Sy 0 Ns B Pq u64
794 .Sy all_system_memory No \- Sy 1 GiB
799 .Sy 67108864 Ns B Pq 64 MiB .
807 .It Sy zfs_arc_meta_balance Ns = Ns Sy 500 Pq uint
808 Balance between metadata and data on ghost hits.
810 of ghost data hits on target data/metadata rate.
812 .It Sy zfs_arc_min Ns = Ns Sy 0 Ns B Pq u64
820 .It Sy zfs_arc_min_prefetch_ms Ns = Ns Sy 0 Ns ms Ns Po Ns ≡ Ns 1s Pc Pq uint
823 .It Sy zfs_arc_min_prescient_prefetch_ms Ns = Ns Sy 0 Ns ms Ns Po Ns ≡ Ns 6s Pc Pq uint
828 .It Sy zfs_arc_prune_task_threads Ns = Ns Sy 1 Pq int
835 .It Sy zfs_max_missing_tvds Ns = Ns Sy 0 Pq int
836 Number of missing top-level vdevs which will be allowed during
837 pool import (only in read-only mode).
839 .It Sy zfs_max_nvlist_src_size Ns = Sy 0 Pq u64
842 for ioctls on
849 .Pa zfs-dbgmsg
854 equivalent to a quarter of the user-wired memory limit under
857 .Sy 134217728 Ns B Pq 128 MiB
860 .It Sy zfs_multilist_num_sublists Ns = Ns Sy 0 Pq uint
861 To allow more fine-grained locking, each ARC state contains a series
863 Locking is performed at the level of these "sub-lists".
864 This parameters controls the number of sub-lists per ARC state,
872 .It Sy zfs_arc_overflow_shift Ns = Ns Sy 8 Pq int
893 .It Sy zfs_arc_shrink_shift Ns = Ns Sy 0 Pq uint
898 .It Sy zfs_arc_pc_percent Ns = Ns Sy 0 Ns % Po off Pc Pq uint
904 pressure on the pagecache, yet still allows the ARC to be reclaimed down to
916 .It Sy zfs_arc_shrinker_limit Ns = Ns Sy 0 Pq int
917 This is a limit on how many pages the ARC shrinker makes available for
930 and only applies on Linux.
932 .It Sy zfs_arc_shrinker_seeks Ns = Ns Sy 2 Pq int
933 Relative cost of ARC eviction on Linux, AKA number of seeks needed to
939 .It Sy zfs_arc_sys_free Ns = Ns Sy 0 Ns B Pq u64
940 The target number of bytes the ARC should leave as free memory on the system.
944 .It Sy zfs_autoimport_disable Ns = Ns Sy 1 Ns | Ns 0 Pq int
948 .It Sy zfs_checksum_events_per_second Ns = Ns Sy 20 Ns /s Pq uint
954 .It Sy zfs_commit_timeout_pct Ns = Ns Sy 10 Ns % Pq uint
958 The timeout is scaled based on a percentage of the last lwb
962 .It Sy zfs_condense_indirect_commit_entry_delay_ms Ns = Ns Sy 0 Ns ms Pq int
967 .It Sy zfs_condense_indirect_obsolete_pct Ns = Ns Sy 25 Ns % Pq uint
974 .It Sy zfs_condense_indirect_vdevs_enable Ns = Ns Sy 1 Ns | Ns 0 Pq int
981 bytes on-disk.
985 .It Sy zfs_condense_max_obsolete_bytes Ns = Ns Sy 1073741824 Ns B Po 1 GiB Pc Pq u64
986 Only attempt to condense indirect vdev mappings if the on-disk size
990 .It Sy zfs_condense_min_mapping_bytes Ns = Ns Sy 131072 Ns B Po 128 KiB Pc Pq u64
994 .It Sy zfs_dbgmsg_enable Ns = Ns Sy 1 Ns | Ns 0 Pq int
1006 .It Sy zfs_dbgmsg_maxsize Ns = Ns Sy 4194304 Ns B Po 4 MiB Pc Pq uint
1009 .It Sy zfs_dbuf_state_index Ns = Ns Sy 0 Pq int
1014 .It Sy zfs_deadman_checktime_ms Ns = Ns Sy 60000 Ns ms Po 1 min Pc Pq u64
1016 This defines the frequency at which we check for hung I/O requests
1021 .It Sy zfs_deadman_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
1036 .It Sy zfs_deadman_events_per_second Ns = Ns Sy 1 Ns /s Pq int
1040 .It Sy zfs_deadman_failmode Ns = Ns Sy wait Pq charp
1043 .Bl -tag -compact -offset 4n -width "continue"
1049 Attempt to recover from a "hung" operation by re-dispatching it
1053 This can be used to facilitate automatic fail-over
1054 to a properly configured fail-over partner.
1057 .It Sy zfs_deadman_synctime_ms Ns = Ns Sy 600000 Ns ms Po 10 min Pc Pq u64
1064 .It Sy zfs_deadman_ziotime_ms Ns = Ns Sy 300000 Ns ms Po 5 min Pc Pq u64
1072 .It Sy zfs_dedup_prefetch Ns = Ns Sy 0 Ns | Ns 1 Pq int
1073 Enable prefetching dedup-ed blocks which are going to be freed.
1075 .It Sy zfs_dedup_log_flush_min_time_ms Ns = Ns Sy 1000 Ns Pq uint
1076 Minimum time to spend on dedup log flush each transaction.
1084 .It Sy zfs_dedup_log_flush_entries_min Ns = Ns Sy 100 Ns Pq uint
1096 .It Sy zfs_dedup_log_flush_entries_max Ns = Ns Sy UINT_MAX Ns Pq uint
1100 .It Sy zfs_dedup_log_flush_txgs Ns = Ns Sy 100 Ns Pq uint
1112 .It Sy zfs_dedup_log_cap Ns = Ns Sy UINT_MAX Ns Pq uint
1115 If the log is larger than this size, we increase the aggressiveness of
1120 .It Sy zfs_dedup_log_hard_cap Ns = Ns Sy 0 Ns | Ns 1 Pq uint
1125 will increase the maximum number of log entries we flush in a given txg.
1129 also increase the minimum number of log entries we flush per TXG.
1130 Enabling it will reduce worst-case import times, at the cost of increased TXG
1132 .It Sy zfs_dedup_log_flush_flow_rate_txgs Ns = Ns Sy 10 Ns Pq uint
1145 .It Sy zfs_dedup_log_txg_max Ns = Ns Sy 8 Ns Pq uint
1152 .It Sy zfs_dedup_log_mem_max Ns = Ns Sy 0 Ns Pq u64
1155 OpenZFS will spend no more than this much memory on maintaining the in-memory
1157 Flushing will begin when around half this amount is being spent on logs.
1164 .It Sy zfs_dedup_log_mem_max_percent Ns = Ns Sy 1 Ns % Pq uint
1172 .It Sy zfs_delay_min_dirty_percent Ns = Ns Sy 60 Ns % Pq uint
1180 .It Sy zfs_delay_scale Ns = Ns Sy 500000 Pq int
1191 .It Sy zfs_dio_write_verify_events_per_second Ns = Ns Sy 20 Ns /s Pq uint
1194 .It Sy zfs_disable_ivset_guid_check Ns = Ns Sy 0 Ns | Ns 1 Pq int
1198 OpenZFS pre-release versions and now have compatibility issues.
1200 .It Sy zfs_key_max_salt_uses Ns = Ns Sy 400000000 Po 4*10^8 Pc Pq ulong
1205 .It Sy zfs_object_mutex_size Ns = Ns Sy 64 Pq uint
1208 Due to the need to hold locks on objects that may not exist yet, kernel mutexes
1209 are not created per-object and instead a hashtable is used where collisions
1210 will result in objects waiting when there is not actually contention on the
1213 .It Sy zfs_slow_io_events_per_second Ns = Ns Sy 20 Ns /s Pq int
1217 .It Sy zfs_unflushed_max_mem_amt Ns = Ns Sy 1073741824 Ns B Po 1 GiB Pc Pq u64
1218 Upper-bound limit for unflushed metadata changes to be held by the
1221 .It Sy zfs_unflushed_max_mem_ppm Ns = Ns Sy 1000 Ns ppm Po 0.1% Pc Pq u64
1225 .It Sy zfs_unflushed_log_block_max Ns = Ns Sy 131072 Po 128k Pc Pq u64
1236 This tunable is important because it involves a trade-off between import
1238 The higher this number is, the more log blocks we allow when the pool is
1239 active which means that we flush metaslabs less often and thus decrease
1253 .It Sy zfs_unflushed_log_block_min Ns = Ns Sy 1000 Pq u64
1255 we could get into a situation that we are flushing all our metaslabs every TXG.
1256 Thus we always allow at least this many log blocks.
1258 .It Sy zfs_unflushed_log_block_pct Ns = Ns Sy 400 Ns % Pq u64
1263 .It Sy zfs_unflushed_log_txg_max Ns = Ns Sy 1000 Pq u64
1265 It effectively limits maximum number of unflushed per-TXG spacemap logs
1268 .It Sy zfs_unlink_suspend_progress Ns = Ns Sy 0 Ns | Ns 1 Pq uint
1275 .It Sy zfs_delete_blocks Ns = Ns Sy 20480 Pq ulong
1284 This only applies on Linux.
1286 .It Sy zfs_dirty_data_max Ns = Pq int
1298 .It Sy zfs_dirty_data_max_max Ns = Pq int
1313 for 32-bit systems.
1315 .It Sy zfs_dirty_data_max_max_percent Ns = Ns Sy 25 Ns % Pq uint
1327 .It Sy zfs_dirty_data_max_percent Ns = Ns Sy 10 Ns % Pq uint
1338 .It Sy zfs_dirty_data_sync_percent Ns = Ns Sy 20 Ns % Pq uint
1344 .It Sy zfs_wrlog_data_max Ns = Pq int
1345 The upper limit of write-transaction ZIL log data size in bytes.
1356 .It Sy zfs_fallocate_reserve_percent Ns = Ns Sy 110 Ns % Pq uint
1357 Since ZFS is a copy-on-write filesystem with snapshots, blocks cannot be
1375 .It Sy zfs_fletcher_4_impl Ns = Ns Sy fastest Pq string
1390 results in the original CPU-based calculation being used.
1396 .It Sy zfs_bclone_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
1402 .It Sy zfs_bclone_wait_dirty Ns = Ns Sy 0 Ns | Ns 1 Pq int
1411 .It Sy zfs_blake3_impl Ns = Ns Sy fastest Pq string
1425 .It Sy zfs_free_bpobj_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
1428 .It Sy zfs_async_block_max_blocks Ns = Ns Sy UINT64_MAX Po unlimited Pc Pq u64
1431 .It Sy zfs_max_async_dedup_frees Ns = Ns Sy 100000 Po 10^5 Pc Pq u64
1434 .It Sy zfs_vdev_async_read_max_active Ns = Ns Sy 3 Pq uint
1438 .It Sy zfs_vdev_async_read_min_active Ns = Ns Sy 1 Pq uint
1442 .It Sy zfs_vdev_async_write_active_max_dirty_percent Ns = Ns Sy 60 Ns % Pq uint
1450 .It Sy zfs_vdev_async_write_active_min_dirty_percent Ns = Ns Sy 30 Ns % Pq uint
1459 .It Sy zfs_vdev_async_write_max_active Ns = Ns Sy 10 Pq uint
1463 .It Sy zfs_vdev_async_write_min_active Ns = Ns Sy 2 Pq uint
1467 Lower values are associated with better latency on rotational media but poorer
1477 .It Sy zfs_vdev_initializing_max_active Ns = Ns Sy 1 Pq uint
1481 .It Sy zfs_vdev_initializing_min_active Ns = Ns Sy 1 Pq uint
1485 .It Sy zfs_vdev_max_active Ns = Ns Sy 1000 Pq uint
1491 .It Sy zfs_vdev_open_timeout_ms Ns = Ns Sy 1000 Pq uint
1498 .It Sy zfs_vdev_rebuild_max_active Ns = Ns Sy 3 Pq uint
1502 .It Sy zfs_vdev_rebuild_min_active Ns = Ns Sy 1 Pq uint
1506 .It Sy zfs_vdev_removal_max_active Ns = Ns Sy 2 Pq uint
1510 .It Sy zfs_vdev_removal_min_active Ns = Ns Sy 1 Pq uint
1514 .It Sy zfs_vdev_scrub_max_active Ns = Ns Sy 2 Pq uint
1518 .It Sy zfs_vdev_scrub_min_active Ns = Ns Sy 1 Pq uint
1522 .It Sy zfs_vdev_sync_read_max_active Ns = Ns Sy 10 Pq uint
1526 .It Sy zfs_vdev_sync_read_min_active Ns = Ns Sy 10 Pq uint
1530 .It Sy zfs_vdev_sync_write_max_active Ns = Ns Sy 10 Pq uint
1534 .It Sy zfs_vdev_sync_write_min_active Ns = Ns Sy 10 Pq uint
1538 .It Sy zfs_vdev_trim_max_active Ns = Ns Sy 2 Pq uint
1542 .It Sy zfs_vdev_trim_min_active Ns = Ns Sy 1 Pq uint
1546 .It Sy zfs_vdev_nia_delay Ns = Ns Sy 5 Pq uint
1547 For non-interactive I/O (scrub, resilver, removal, initialize and rebuild),
1548 the number of concurrently-active I/O operations is limited to
1556 and the number of concurrently-active non-interactive operations is increased to
1560 .It Sy zfs_vdev_nia_credit Ns = Ns Sy 5 Pq uint
1565 .Sy zfs_*_max_active Ns = Sy 1
1567 To prevent non-interactive I/O, like scrub,
1575 .It Sy zfs_vdev_failfast_mask Ns = Ns Sy 1 Pq uint
1576 Defines if the driver should retire on a given error type.
1577 The following options may be bitwise-ored together:
1583 1 Device No driver retries on device errors
1584 2 Transport No driver retries on transport errors.
1585 4 Driver No driver retries on driver errors.
1588 .It Sy zfs_vdev_disk_max_segs Ns = Ns Sy 0 Pq uint
1593 This parameter only applies on Linux.
1595 .It Sy zfs_expire_snapshot Ns = Ns Sy 300 Ns s Pq int
1599 .It Sy zfs_admin_snapshot Ns = Ns Sy 0 Ns | Ns 1 Pq int
1608 .It Sy zfs_snapshot_no_setuid Ns = Ns Sy 0 Ns | Ns 1 Pq int
1617 .It Sy zfs_flags Ns = Ns Sy 0 Pq int
1619 The following flags may be bitwise-ored together:
1632 256 ZFS_DEBUG_METASLAB_VERIFY Verify space accounting on disk matches in-memory \fBrange_trees\fP.
1639 16384 ZFS_DEBUG_BRT Enable BRT-related debugging messages.
1641 65536 ZFS_DEBUG_DDT Enable DDT-related debugging messages.
1645 .It Sy zfs_btree_verify_intensity Ns = Ns Sy 0 Pq uint
1661 .It Sy zfs_free_leak_on_eio Ns = Ns Sy 0 Ns | Ns 1 Pq int
1669 from the error-encountering filesystem is "temporarily leaked".
1677 In this case, we will be able to continue pool operations while it is
1678 partially failed, and when it recovers, we can continue to free the
1683 .Bl -enum -compact -offset 4n -width "1."
1686 e.g. due to a top-level vdev going offline), or
1694 In the latter, because the error is permanent, the best we can do
1698 but we chose the more conservative approach of not setting it,
1702 .It Sy zfs_free_min_time_ms Ns = Ns Sy 1000 Ns ms Po 1s Pc Pq uint
1708 a minimum of this much time will be spent working on freeing blocks per TXG.
1710 .It Sy zfs_obsolete_min_time_ms Ns = Ns Sy 500 Ns ms Pq uint
1715 .It Sy zfs_immediate_write_sz Ns = Ns Sy 32768 Ns B Po 32 KiB Pc Pq s64
1718 .Sy logbias Ns = Ns Sy throughput
1721 .It Sy zfs_initialize_value Ns = Ns Sy 16045690984833335022 Po 0xDEADBEEFDEADBEEE Pc Pq u64
1723 .Xr zpool-initialize 8 .
1725 .It Sy zfs_initialize_chunk_size Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq u64
1727 .Xr zpool-initialize 8 .
1730 .It Sy zfs_livelist_max_entries Ns = Ns Sy 500000 Po 5*10^5 Pc Pq u64
1731 The threshold size (in block pointers) at which we create a new sub-livelist.
1735 .It Sy zfs_livelist_min_percent_shared Ns = Ns Sy 75 Ns % Pq int
1742 .It Sy zfs_livelist_condense_new_alloc Ns = Ns Sy 0 Pq int
1747 .It Sy zfs_livelist_condense_sync_cancel Ns = Ns Sy 0 Pq int
1752 .It Sy zfs_livelist_condense_sync_pause Ns = Ns Sy 0 Ns | Ns 1 Pq int
1758 .It Sy zfs_livelist_condense_zthr_cancel Ns = Ns Sy 0 Pq int
1763 .It Sy zfs_livelist_condense_zthr_pause Ns = Ns Sy 0 Ns | Ns 1 Pq int
1769 .It Sy zfs_lua_max_instrlimit Ns = Ns Sy 100000000 Po 10^8 Pc Pq u64
1773 .It Sy zfs_lua_max_memlimit Ns = Ns Sy 104857600 Po 100 MiB Pc Pq u64
1777 .It Sy zfs_max_dataset_nesting Ns = Ns Sy 50 Pq int
1782 .It Sy zfs_max_log_walking Ns = Ns Sy 5 Pq u64
1786 .It Sy zfs_max_logsm_summary_length Ns = Ns Sy 10 Pq u64
1789 .It Sy zfs_max_recordsize Ns = Ns Sy 16777216 Po 16 MiB Pc Pq uint
1794 Additionally, very large blocks can have an impact on I/O latency,
1795 and also potentially on the memory allocator.
1796 Therefore, we formerly forbade creating blocks larger than 1M.
1806 .It Sy zfs_allow_redacted_dataset_mount Ns = Ns Sy 0 Ns | Ns 1 Pq int
1810 .It Sy zfs_min_metaslabs_to_flush Ns = Ns Sy 1 Pq u64
1813 .It Sy zfs_metaslab_fragmentation_threshold Ns = Ns Sy 77 Ns % Pq uint
1819 .It Sy zfs_mg_fragmentation_threshold Ns = Ns Sy 95 Ns % Pq uint
1827 .It Sy zfs_mg_noalloc_threshold Ns = Ns Sy 0 Ns % Pq uint
1843 Setting the threshold to a non-zero percentage will stop allocations
1850 .It Sy zfs_ddt_data_is_special Ns = Ns Sy 1 Ns | Ns 0 Pq int
1853 .It Sy zfs_user_indirect_is_special Ns = Ns Sy 1 Ns | Ns 0 Pq int
1857 .It Sy zfs_multihost_history Ns = Ns Sy 0 Pq uint
1860 .Pa /proc/spl/kstat/zfs/ Ns Ao Ar pool Ac Ns Pa /multihost .
1862 .It Sy zfs_multihost_interval Ns = Ns Sy 1000 Ns ms Po 1 s Pc Pq u64
1865 pool property is on.
1870 .Sy zfs_multihost_interval No / Sy leaf-vdevs .
1878 .It Sy zfs_multihost_import_intervals Ns = Ns Sy 20 Pq uint
1879 Used to control the duration of the activity test on import.
1888 or the same product computed on the host which last had the pool imported,
1900 .It Sy zfs_multihost_fail_intervals Ns = Ns Sy 10 Pq uint
1907 The failures will still be reported to the ZED which depending on
1919 .It Sy zfs_no_scrub_io Ns = Ns Sy 0 Ns | Ns 1 Pq int
1924 .It Sy zfs_no_scrub_prefetch Ns = Ns Sy 0 Ns | Ns 1 Pq int
1927 .It Sy zfs_nocacheflush Ns = Ns Sy 0 Ns | Ns 1 Pq int
1928 Disable cache flush operations on disks when writing.
1929 Setting this will cause pool corruption on power loss
1930 if a volatile out-of-order write cache is enabled.
1932 .It Sy zfs_nopwrite_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
1933 Allow no-operation writes.
1934 The occurrence of nopwrites will further depend on other pool properties
1937 .It Sy zfs_dmu_offset_next_sync Ns = Ns Sy 1 Ns | Ns 0 Pq int
1944 .It Sy zfs_pd_bytes_max Ns = Ns Sy 52428800 Ns B Po 50 MiB Pc Pq int
1949 .It Sy zfs_traverse_indirect_prefetch_limit Ns = Ns Sy 32 Pq uint
1950 The number of blocks pointed by indirect (non-L0) block which should be
1955 .It Sy zfs_per_txg_dirty_frees_percent Ns = Ns Sy 30 Ns % Pq u64
1960 .It Sy zfs_prefetch_disable Ns = Ns Sy 0 Ns | Ns 1 Pq int
1968 .It Sy zfs_qat_checksum_disable Ns = Ns Sy 0 Ns | Ns 1 Pq int
1973 .It Sy zfs_qat_compress_disable Ns = Ns Sy 0 Ns | Ns 1 Pq int
1978 .It Sy zfs_qat_encrypt_disable Ns = Ns Sy 0 Ns | Ns 1 Pq int
1979 Disable QAT hardware acceleration for AES-GCM encryption.
1983 .It Sy zfs_vnops_read_chunk_size Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq u64
1986 .It Sy zfs_read_history Ns = Ns Sy 0 Pq uint
1988 .Pa /proc/spl/kstat/zfs/ Ns Ao Ar pool Ac Ns Pa /reads .
1990 .It Sy zfs_read_history_hits Ns = Ns Sy 0 Ns | Ns 1 Pq int
1993 .It Sy zfs_rebuild_max_segment Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq u64
1995 top-level vdev.
1997 .It Sy zfs_rebuild_scrub_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
2003 .It Sy zfs_rebuild_vdev_limit Ns = Ns Sy 67108864 Ns B Po 64 MiB Pc Pq u64
2007 .It Sy zfs_reconstruct_indirect_combinations_max Ns = Ns Sy 4096 Pq int
2017 .It Sy zfs_recover Ns = Ns Sy 0 Ns | Ns 1 Pq int
2022 .It Sy zfs_removal_ignore_errors Ns = Ns Sy 0 Ns | Ns 1 Pq int
2031 .It Sy zfs_removal_suspend_progress Ns = Ns Sy 0 Ns | Ns 1 Pq uint
2035 .It Sy zfs_remove_max_segment Ns = Ns Sy 16777216 Ns B Po 16 MiB Pc Pq uint
2036 The largest contiguous segment that we will attempt to allocate when removing
2042 .It Sy zfs_resilver_disable_defer Ns = Ns Sy 0 Ns | Ns 1 Pq int
2048 .It Sy zfs_resilver_defer_percent Ns = Ns Sy 10 Ns % Pq uint
2055 .It Sy zfs_resilver_min_time_ms Ns = Ns Sy 3000 Ns ms Po 3 s Pc Pq uint
2058 working on a resilver between TXG flushes.
2060 .It Sy zfs_scan_ignore_errors Ns = Ns Sy 0 Ns | Ns 1 Pq int
2066 .It Sy zfs_scrub_after_expand Ns = Ns Sy 1 Ns | Ns 0 Pq int
2072 .It Sy zfs_scrub_min_time_ms Ns = Ns Sy 1000 Ns ms Po 1 s Pc Pq uint
2075 working on a scrub between TXG flushes.
2077 .It Sy zfs_scrub_error_blocks_per_txg Ns = Ns Sy 4096 Pq uint
2080 .It Sy zfs_scan_checkpoint_intval Ns = Ns Sy 7200 Ns s Po 2 hour Pc Pq uint
2085 .It Sy zfs_scan_fill_weight Ns = Ns Sy 3 Pq uint
2087 A higher number indicates that we care more about how filled in a segment is,
2088 while a lower number indicates we care more about the size of the extent without
2091 Changing the value afterwards will have no effect on scrub or resilver
2094 .It Sy zfs_scan_issue_strategy Ns = Ns Sy 0 Pq uint
2096 .Bl -tag -compact -offset 4n -width "a"
2103 The largest mostly-contiguous chunk of found data will be verified first.
2104 By deferring scrubbing of small segments, we may later find adjacent data
2111 .It Sy zfs_scan_legacy Ns = Ns Sy 0 Ns | Ns 1 Pq int
2118 .It Sy zfs_scan_max_ext_gap Ns = Ns Sy 2097152 Ns B Po 2 MiB Pc Pq int
2124 .It Sy zfs_scan_mem_lim_fact Ns = Ns Sy 20 Ns ^-1 Pq uint
2127 When the hard limit is reached we stop scanning metadata and start issuing
2129 This is done until we get below the soft limit.
2131 .It Sy zfs_scan_mem_lim_soft_fact Ns = Ns Sy 20 Ns ^-1 Pq uint
2134 When we cross this limit from below no action is taken.
2135 When we cross this limit from above it is because we are issuing verification
2137 In this case (unless the metadata scan is done) we stop issuing verification I/O
2138 and start scanning metadata again until we get to the hard limit.
2140 .It Sy zfs_scan_report_txgs Ns = Ns Sy 0 Ns | Ns 1 Pq uint
2147 .It Sy zfs_scan_strict_mem_lim Ns = Ns Sy 0 Ns | Ns 1 Pq int
2148 Enforce tight memory limits on pool scans when a sequential scan is in progress.
2151 .It Sy zfs_scan_suspend_progress Ns = Ns Sy 0 Ns | Ns 1 Pq int
2155 .It Sy zfs_scan_vdev_limit Ns = Ns Sy 16777216 Ns B Po 16 MiB Pc Pq int
2159 .It Sy zfs_send_corrupt_data Ns = Ns Sy 0 Ns | Ns 1 Pq int
2162 .It Sy zfs_send_unmodified_spill_blocks Ns = Ns Sy 1 Ns | Ns 0 Pq int
2166 Including unmodified copies of the spill blocks creates a backwards-compatible
2169 .It Sy zfs_send_no_prefetch_queue_ff Ns = Ns Sy 20 Ns ^\-1 Pq uint
2175 .It Sy zfs_send_no_prefetch_queue_length Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq uint
2177 .Nm zfs Cm send Ns 's
2180 .It Sy zfs_send_queue_ff Ns = Ns Sy 20 Ns ^\-1 Pq uint
2186 .It Sy zfs_send_queue_length Ns = Ns Sy 16777216 Ns B Po 16 MiB Pc Pq uint
2191 .It Sy zfs_recv_queue_ff Ns = Ns Sy 20 Ns ^\-1 Pq uint
2197 .It Sy zfs_recv_queue_length Ns = Ns Sy 16777216 Ns B Po 16 MiB Pc Pq uint
2203 .It Sy zfs_recv_write_batch_size Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq uint
2212 .It Sy zfs_recv_best_effort_corrective Ns = Ns Sy 0 Pq int
2213 When this variable is set to non-zero a corrective receive:
2214 .Bl -enum -compact -offset 4n -width "1."
2220 terminated instead it moves on to the next record.
2223 .It Sy zfs_override_estimate_recordsize Ns = Ns Sy 0 Ns | Ns 1 Pq uint
2232 .It Sy zfs_sync_pass_deferred_free Ns = Ns Sy 2 Pq uint
2236 .It Sy zfs_spa_discard_memory_limit Ns = Ns Sy 16777216 Ns B Po 16 MiB Pc Pq int
2237 Maximum memory used for prefetching a checkpoint's space map on each
2240 .It Sy zfs_special_class_metadata_reserve_pct Ns = Ns Sy 25 Ns % Pq uint
2241 Only allow small data blocks to be allocated on the special and dedup vdev
2242 types when the available free space percentage on these vdevs exceeds this
2247 .It Sy zfs_sync_pass_dont_compress Ns = Ns Sy 8 Pq uint
2249 With the default setting, in practice, we don't have this many sync passes,
2255 the average number of sync passes; because when we turn compression off,
2256 many blocks' size will change, and thus we have to re-allocate
2269 .It Sy zfs_sync_pass_rewrite Ns = Ns Sy 2 Pq uint
2272 .It Sy zfs_trim_extent_bytes_max Ns = Ns Sy 134217728 Ns B Po 128 MiB Pc Pq uint
2277 .It Sy zfs_trim_extent_bytes_min Ns = Ns Sy 32768 Ns B Po 32 KiB Pc Pq uint
2284 .It Sy zfs_trim_metaslab_skip Ns = Ns Sy 0 Ns | Ns 1 Pq uint
2286 This option is useful for pools constructed from large thinly-provisioned
2294 .It Sy zfs_trim_queue_limit Ns = Ns Sy 10 Pq uint
2299 .It Sy zfs_trim_txg_batch Ns = Ns Sy 32 Pq uint
2302 This setting represents a trade-off between issuing larger,
2314 .It Sy zfs_txg_history Ns = Ns Sy 100 Pq uint
2316 .Pa /proc/spl/kstat/zfs/ Ns Ao Ar pool Ac Ns Pa /TXGs .
2318 .It Sy zfs_txg_timeout Ns = Ns Sy 5 Ns s Pq uint
2322 .It Sy zfs_vdev_aggregation_limit Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq uint
2325 .It Sy zfs_vdev_aggregation_limit_non_rotating Ns = Ns Sy 131072 Ns B Po 128 KiB Pc Pq uint
2326 Max vdev I/O aggregation size for non-rotating media.
2328 .It Sy zfs_vdev_mirror_rotating_inc Ns = Ns Sy 0 Pq int
2331 immediately follows its predecessor on rotational vdevs
2332 for the purpose of making decisions based on load.
2334 .It Sy zfs_vdev_mirror_rotating_seek_inc Ns = Ns Sy 5 Pq int
2342 .It Sy zfs_vdev_mirror_rotating_seek_offset Ns = Ns Sy 1048576 Ns B Po 1 MiB Pc Pq int
2347 .It Sy zfs_vdev_mirror_non_rotating_inc Ns = Ns Sy 0 Pq int
2349 the purpose of selecting the least busy mirror member on non-rotational vdevs
2352 .It Sy zfs_vdev_mirror_non_rotating_seek_inc Ns = Ns Sy 1 Pq int
2361 .It Sy zfs_vdev_read_gap_limit Ns = Ns Sy 32768 Ns B Po 32 KiB Pc Pq uint
2362 Aggregate read I/O operations if the on-disk gap between them is within this
2365 .It Sy zfs_vdev_write_gap_limit Ns = Ns Sy 4096 Ns B Po 4 KiB Pc Pq uint
2366 Aggregate write I/O operations if the on-disk gap between them is within this
2369 .It Sy zfs_vdev_raidz_impl Ns = Ns Sy fastest Pq string
2372 Variants that don't depend on CPU-specific features
2373 may be selected on module load, as they are supported on all systems.
2376 and supported on the running system.
2385 fastest selected by built-in benchmark
2388 sse2 SSE2 instruction set 64-bit x86
2389 ssse3 SSSE3 instruction set 64-bit x86
2390 avx2 AVX2 instruction set 64-bit x86
2391 avx512f AVX512F instruction set 64-bit x86
2392 avx512bw AVX512F & AVX512BW instruction sets 64-bit x86
2393 aarch64_neon NEON Aarch64/64-bit ARMv8
2394 aarch64_neonx2 NEON with more unrolling Aarch64/64-bit ARMv8
2398 .It Sy zfs_zevent_len_max Ns = Ns Sy 512 Pq uint
2401 .Xr zpool-events 8 .
2403 .It Sy zfs_zevent_retain_max Ns = Ns Sy 2000 Pq int
2409 .It Sy zfs_zevent_retain_expire_secs Ns = Ns Sy 900 Ns s Po 15 min Pc Pq int
2412 .It Sy zfs_zil_clean_taskq_maxalloc Ns = Ns Sy 1048576 Pq int
2417 .It Sy zfs_zil_clean_taskq_minalloc Ns = Ns Sy 1024 Pq int
2418 The number of taskq entries that are pre-populated when the taskq is first
2421 .It Sy zfs_zil_clean_taskq_nthr_pct Ns = Ns Sy 100 Ns % Pq int
2428 .It Sy zil_maxblocksize Ns = Ns Sy 131072 Ns B Po 128 KiB Pc Pq uint
2434 .It Sy zil_maxcopied Ns = Ns Sy 7680 Ns B Po 7.5 KiB Pc Pq uint
2439 .It Sy zil_nocacheflush Ns = Ns Sy 0 Ns | Ns 1 Pq int
2442 Setting this will cause ZIL corruption on power loss
2443 if a volatile out-of-order write cache is enabled.
2445 .It Sy zil_replay_disable Ns = Ns Sy 0 Ns | Ns 1 Pq int
2449 .It Sy zil_slog_bulk Ns = Ns Sy 67108864 Ns B Po 64 MiB Pc Pq u64
2454 .It Sy zfs_zil_saxattr Ns = Ns Sy 1 Ns | Ns 0 Pq int
2456 .Sy xattr Ns = Ns Sy sa
2459 feature is enabled on the pool.
2464 .It Sy zfs_embedded_slog_min_ms Ns = Ns Sy 64 Pq uint
2465 Usually, one metaslab from each normal-class vdev is dedicated for use by
2470 This ensures that we don't set aside an unreasonable amount of space for the
2473 .It Sy zstd_earlyabort_pass Ns = Ns Sy 1 Pq uint
2475 using LZ4 and zstd-1 passes is enabled.
2477 .It Sy zstd_abort_size Ns = Ns Sy 131072 Pq uint
2481 .It Sy zio_deadman_log_all Ns = Ns Sy 0 Ns | Ns 1 Pq int
2482 If non-zero, the zio deadman will produce debugging messages
2490 .It Sy zio_slow_io_ms Ns = Ns Sy 30000 Ns ms Po 30 s Pc Pq int
2497 .It Sy zio_dva_throttle_enabled Ns = Ns Sy 1 Ns | Ns 0 Pq int
2499 This allows for dynamic allocation distribution based on device performance.
2501 .It Sy zfs_xattr_compat Ns = Ns 0 Ns | Ns 1 Pq int
2505 .Pq the default on Linux ,
2507 compatible with previous versions of ZFS on Linux.
2510 .Pq the default on Fx ,
2512 previous versions of ZFS on illumos and
2515 Either naming scheme can be read on this and future versions of ZFS, regardless
2516 of this tunable, but legacy ZFS on illumos or
2519 legacy versions of ZFS on Linux are unable to read user namespace xattrs written
2525 .It Sy zio_requeue_io_start_cut_in_line Ns = Ns Sy 0 Ns | Ns 1 Pq int
2528 .It Sy zio_taskq_batch_pct Ns = Ns Sy 80 Ns % Pq uint
2541 .It Sy zio_taskq_batch_tpq Ns = Ns Sy 0 Pq uint
2549 generate a system-dependent value close to 6 threads per taskq.
2552 .It Sy zio_taskq_write_tpq Ns = Ns Sy 16 Pq uint
2554 Higher values improve CPU utilization on high throughput,
2555 while lower reduce taskq locks contention on high IOPS.
2558 .It Sy zio_taskq_read Ns = Ns Sy fixed,1,8 null scale null Pq charp
2564 .It Sy zio_taskq_write Ns = Ns Sy sync null scale null Pq charp
2570 .It Sy zvol_inhibit_dev Ns = Ns Sy 0 Ns | Ns 1 Pq uint
2572 This may slightly improve startup time on
2575 .It Sy zvol_major Ns = Ns Sy 230 Pq uint
2578 .It Sy zvol_max_discard_blocks Ns = Ns Sy 16384 Pq long
2579 Discard (TRIM) operations done on zvols will be done in batches of this
2584 .It Sy zvol_prefetch_bytes Ns = Ns Sy 131072 Ns B Po 128 KiB Pc Pq uint
2592 .It Sy zvol_request_sync Ns = Ns Sy 0 Ns | Ns 1 Pq uint
2601 is ignored when running on a kernel that supports block multiqueue
2602 .Pq Li blk-mq .
2604 .It Sy zvol_num_taskqs Ns = Ns Sy 0 Pq uint
2609 This only applies on Linux.
2611 .It Sy zvol_threads Ns = Ns Sy 0 Pq uint
2619 .It Sy zvol_blk_mq_threads Ns = Ns Sy 0 Pq uint
2622 .Li blk-mq
2630 .It Sy zvol_use_blk_mq Ns = Ns Sy 0 Ns | Ns 1 Pq uint
2634 .Li blk-mq
2639 This setting can give better or worse zvol performance depending on
2642 .Li blk-mq
2645 .It Sy zvol_blk_mq_blocks_per_thread Ns = Ns Sy 8 Pq uint
2649 .Sy volblocksize Ns -sized blocks per zvol thread.
2657 .Li blk-mq
2660 .It Sy zvol_blk_mq_queue_depth Ns = Ns Sy 0 Pq uint
2662 .Li blk-mq
2665 .Li blk-mq
2673 .Dv BLKDEV_MAX_RQ Ns / Ns Dv BLKDEV_DEFAULT_RQ
2676 .It Sy zvol_volmode Ns = Ns Sy 1 Pq uint
2678 .Sy volmode Ns = Ns Sy default :
2679 .Bl -tag -compact -offset 4n -width "a"
2688 .It Sy zvol_enforce_quotas Ns = Ns Sy 0 Ns | Ns 1 Pq uint
2703 Note that the sum of the per-queue minima must not exceed the aggregate maximum.
2704 If the sum of the per-queue maxima exceeds the aggregate maximum,
2708 regardless of whether all per-queue minima have been met.
2714 effect on throughput or can actually cause it to decrease.
2729 .Sy max_active Ns s
2732 .Sy max_active Ns s
2733 may lead to higher overall throughput, depending on underlying storage.
2736 .Sy max_active Ns s
2762 follows a piece-wise linear function defined by a few adjustable points:
2763 .Bd -literal
2764 | o---------| <-- \fBzfs_vdev_async_write_max_active\fP
2771 |-------o | | <-- \fBzfs_vdev_async_write_min_active\fP
2775 | `-- \fBzfs_vdev_async_write_active_max_dirty_percent\fP
2776 `--------- \fBzfs_vdev_async_write_active_min_dirty_percent\fP
2786 Ideally, the amount of dirty data on a busy pool will stay in the sloped
2794 In this case, we must further throttle incoming writes,
2798 We delay transactions when we've determined that the backend storage
2801 If there is already a transaction waiting, we delay relative to when
2806 If we are the only waiter, wait relative to when the transaction started,
2812 .D1 min_time = min( Ns Sy zfs_delay_scale No \(mu Po Sy dirty No \- Sy min Pc / Po Sy max No \- Sy …
2815 The percentage of dirty data at which we start to delay is defined by
2819 so that we only start to delay after writing at full speed
2825 .Bd -literal
2827 10ms +-------------------------------------------------------------*+
2846 | \fBzfs_delay_scale\fP ----------> ******** |
2847 0 +-------------------------------------*********----------------+
2848 0% <- \fBzfs_dirty_data_max\fP -> 100%
2851 Note, that since the delay is added to the outstanding time remaining on the
2863 represented on a logarithmic scale:
2864 .Bd -literal
2866 100ms +-------------------------------------------------------------++
2875 + \fBzfs_delay_scale\fP ----------> ***** +
2886 +--------------------------------------------------------------+
2887 0% <- \fBzfs_dirty_data_max\fP -> 100%
2894 for the I/O scheduler to reach optimal throughput on the back-end storage,