c/mirror_zfs
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_zfs.git synced 2024-12-25 18:59:33 +03:00
Code Issues Packages Projects Releases Wiki Activity

Make module tunables cross platform

Browse Source 
Adds ZFS_MODULE_PARAM to abstract module parameter
setting to operating systems other than Linux.

Reviewed-by: Jorgen Lundman <lundman@lundman.net>
Reviewed-by: Igor Kozhukhov <igor@dilos.org>
Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Signed-off-by: Matt Macy <mmacy@FreeBSD.org>
Signed-off-by: Ryan Moeller <ryan@ixsystems.com>
Closes #9230
This commit is contained in:
Matthew Macy 2019-09-05 14:49:49 -07:00 committed by Brian Behlendorf
parent 65a91b166e
commit 03fdcb9adc
43 changed files with 544 additions and 660 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
include/os/linux/kernel/linux/mod_compat.h
View File

@ -36,4 +36,77 @@ typedef const struct kernel_param zfs_kernel_param_t;
typedef struct kernel_param zfs_kernel_param_t; typedef struct kernel_param zfs_kernel_param_t;
#endif #endif
#define ZMOD_RW 0644
#define ZMOD_RD 0444
/* BEGIN CSTYLED */
#define INT int
#define UINT uint
#define ULONG ulong
#define LONG long
#define STRING charp
/* END CSTYLED */
enum scope_prefix_types {
zfs,
zfs_arc,
zfs_condense,
zfs_dbuf,
zfs_dbuf_cache,
zfs_l2arc,
zfs_livelist,
zfs_livelist_condense,
zfs_lua,
zfs_metaslab,
zfs_mg,
zfs_multihost,
zfs_prefetch,
zfs_reconstruct,
zfs_recv,
zfs_send,
zfs_spa,
zfs_trim,
zfs_vdev,
zfs_vdev_cache,
zfs_vdev_mirror,
zfs_zio,
zfs_zil,
};
/*
* Declare a module parameter / sysctl node
*
* scope_prefix the part of the the sysctl / sysfs tree the node resides under
* (currently a no-op on Linux)
* name_prefix the part of the variable name that will be excluded from the
* exported names on platforms with a hierarchical namespace
* name the part of the variable that will be exposed on platforms with a
* hierarchical namespace, or as name_prefix ## name on Linux
* type the variable type
* perm the permissions (read/write or read only)
* desc a brief description of the option
*
* Examples:
* ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_inc, UINT,
* ZMOD_RW, "Rotating media load increment for non-seeking I/O's");
* on FreeBSD:
* vfs.zfs.vdev.mirror.rotating_inc
* on Linux:
* zfs_vdev_mirror_rotating_inc
*
* *ZFS_MODULE_PARAM(zfs, , dmu_prefetch_max, UINT, ZMOD_RW,
* "Limit one prefetch call to this size");
* on FreeBSD:
* vfs.zfs.dmu_prefetch_max
* on Linux:
* dmu_prefetch_max
*/
/* BEGIN CSTYLED */
#define ZFS_MODULE_PARAM(scope_prefix, name_prefix, name, type, perm, desc) \
CTASSERT_GLOBAL((sizeof (scope_prefix) == sizeof (enum scope_prefix_types))); \
module_param(name_prefix ## name, type, perm); \
MODULE_PARM_DESC(name_prefix ## name, desc)
/* END CSTYLED */
#endif /* _MOD_COMPAT_H */ #endif /* _MOD_COMPAT_H */

11
include/sys/zfs_context.h
View File

@ -65,6 +65,7 @@
#include <sys/procfs_list.h> #include <sys/procfs_list.h>
#include <linux/dcache_compat.h> #include <linux/dcache_compat.h>
#include <linux/utsname_compat.h> #include <linux/utsname_compat.h>
#include <linux/mod_compat.h>
#else /* _KERNEL */ #else /* _KERNEL */
@ -200,6 +201,16 @@ extern int aok;
ZFS_PROBE4(#a, (unsigned long)c, (unsigned long)e, (unsigned long)g, \ ZFS_PROBE4(#a, (unsigned long)c, (unsigned long)e, (unsigned long)g, \
(unsigned long)i) (unsigned long)i)
/*
* Tunables.
*/
#define ZFS_MODULE_PARAM(scope_prefix, name_prefix, name, type, perm, desc)
/*
* Exported symbols
*/
#define EXPORT_SYMBOL(x)
/* /*
* Threads. * Threads.
*/ */

6
module/zcommon/zfs_namecheck.c
View File

@ -417,7 +417,6 @@ pool_namecheck(const char *pool, namecheck_err_t *why, char *what)
return (0); return (0);
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(entity_namecheck); EXPORT_SYMBOL(entity_namecheck);
EXPORT_SYMBOL(pool_namecheck); EXPORT_SYMBOL(pool_namecheck);
EXPORT_SYMBOL(dataset_namecheck); EXPORT_SYMBOL(dataset_namecheck);
@ -426,6 +425,5 @@ EXPORT_SYMBOL(dataset_nestcheck);
EXPORT_SYMBOL(get_dataset_depth); EXPORT_SYMBOL(get_dataset_depth);
EXPORT_SYMBOL(zfs_max_dataset_nesting); EXPORT_SYMBOL(zfs_max_dataset_nesting);
module_param(zfs_max_dataset_nesting, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, max_dataset_nesting, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_max_dataset_nesting, "Maximum depth of nested datasets"); "Limit to the amount of nesting a path can have. Defaults to 50.");
#endif

140
module/zfs/arc.c
View File

@ -893,7 +893,8 @@ static arc_state_t *arc_l2c_only;
#define arc_tempreserve ARCSTAT(arcstat_tempreserve) #define arc_tempreserve ARCSTAT(arcstat_tempreserve)
#define arc_loaned_bytes ARCSTAT(arcstat_loaned_bytes) #define arc_loaned_bytes ARCSTAT(arcstat_loaned_bytes)
#define arc_meta_limit ARCSTAT(arcstat_meta_limit) /* max size for metadata */ #define arc_meta_limit ARCSTAT(arcstat_meta_limit) /* max size for metadata */
#define arc_dnode_limit ARCSTAT(arcstat_dnode_limit) /* max size for dnodes */ /* max size for dnodes */
#define arc_dnode_size_limit ARCSTAT(arcstat_dnode_limit)
#define arc_meta_min ARCSTAT(arcstat_meta_min) /* min size for metadata */ #define arc_meta_min ARCSTAT(arcstat_meta_min) /* min size for metadata */
#define arc_meta_max ARCSTAT(arcstat_meta_max) /* max size of metadata */ #define arc_meta_max ARCSTAT(arcstat_meta_max) /* max size of metadata */
#define arc_need_free ARCSTAT(arcstat_need_free) /* bytes to be freed */ #define arc_need_free ARCSTAT(arcstat_need_free) /* bytes to be freed */
@ -4214,9 +4215,9 @@ arc_evict_state(arc_state_t *state, uint64_t spa, int64_t bytes,
* shrinker. * shrinker.
*/ */
if (type == ARC_BUFC_DATA && aggsum_compare(&astat_dnode_size, if (type == ARC_BUFC_DATA && aggsum_compare(&astat_dnode_size,
arc_dnode_limit) > 0) { arc_dnode_size_limit) > 0) {
arc_prune_async((aggsum_upper_bound(&astat_dnode_size) - arc_prune_async((aggsum_upper_bound(&astat_dnode_size) -
arc_dnode_limit) / sizeof (dnode_t) / arc_dnode_size_limit) / sizeof (dnode_t) /
zfs_arc_dnode_reduce_percent); zfs_arc_dnode_reduce_percent);
} }
@ -7573,8 +7574,8 @@ arc_tuning_update(void)
arc_p = (arc_c >> 1); arc_p = (arc_c >> 1);
if (arc_meta_limit > arc_c_max) if (arc_meta_limit > arc_c_max)
arc_meta_limit = arc_c_max; arc_meta_limit = arc_c_max;
if (arc_dnode_limit > arc_meta_limit) if (arc_dnode_size_limit > arc_meta_limit)
arc_dnode_limit = arc_meta_limit; arc_dnode_size_limit = arc_meta_limit;
} }
/* Valid range: 32M - <arc_c_max> */ /* Valid range: 32M - <arc_c_max> */
@ -7592,8 +7593,8 @@ arc_tuning_update(void)
arc_meta_min = zfs_arc_meta_min; arc_meta_min = zfs_arc_meta_min;
if (arc_meta_limit < arc_meta_min) if (arc_meta_limit < arc_meta_min)
arc_meta_limit = arc_meta_min; arc_meta_limit = arc_meta_min;
if (arc_dnode_limit < arc_meta_min) if (arc_dnode_size_limit < arc_meta_min)
arc_dnode_limit = arc_meta_min; arc_dnode_size_limit = arc_meta_min;
} }
/* Valid range: <arc_meta_min> - <arc_c_max> */ /* Valid range: <arc_meta_min> - <arc_c_max> */
@ -7607,10 +7608,10 @@ arc_tuning_update(void)
/* Valid range: <arc_meta_min> - <arc_meta_limit> */ /* Valid range: <arc_meta_min> - <arc_meta_limit> */
limit = zfs_arc_dnode_limit ? zfs_arc_dnode_limit : limit = zfs_arc_dnode_limit ? zfs_arc_dnode_limit :
MIN(zfs_arc_dnode_limit_percent, 100) * arc_meta_limit / 100; MIN(zfs_arc_dnode_limit_percent, 100) * arc_meta_limit / 100;
if ((limit != arc_dnode_limit) && if ((limit != arc_dnode_size_limit) &&
(limit >= arc_meta_min) && (limit >= arc_meta_min) &&
(limit <= arc_meta_limit)) (limit <= arc_meta_limit))
arc_dnode_limit = limit; arc_dnode_size_limit = limit;
/* Valid range: 1 - N */ /* Valid range: 1 - N */
if (zfs_arc_grow_retry) if (zfs_arc_grow_retry)
@ -7840,7 +7841,7 @@ arc_init(void)
percent = MIN(zfs_arc_meta_limit_percent, 100); percent = MIN(zfs_arc_meta_limit_percent, 100);
arc_meta_limit = MAX(arc_meta_min, (percent * arc_c_max) / 100); arc_meta_limit = MAX(arc_meta_min, (percent * arc_c_max) / 100);
percent = MIN(zfs_arc_dnode_limit_percent, 100); percent = MIN(zfs_arc_dnode_limit_percent, 100);
arc_dnode_limit = (percent * arc_meta_limit) / 100; arc_dnode_size_limit = (percent * arc_meta_limit) / 100;
/* Apply user specified tunings */ /* Apply user specified tunings */
arc_tuning_update(); arc_tuning_update();
@ -9376,7 +9377,6 @@ l2arc_stop(void)
mutex_exit(&l2arc_feed_thr_lock); mutex_exit(&l2arc_feed_thr_lock);
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(arc_buf_size); EXPORT_SYMBOL(arc_buf_size);
EXPORT_SYMBOL(arc_write); EXPORT_SYMBOL(arc_write);
EXPORT_SYMBOL(arc_read); EXPORT_SYMBOL(arc_read);
@ -9386,104 +9386,96 @@ EXPORT_SYMBOL(arc_add_prune_callback);
EXPORT_SYMBOL(arc_remove_prune_callback); EXPORT_SYMBOL(arc_remove_prune_callback);
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(zfs_arc_min, ulong, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, min, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_min, "Min arc size"); "Min arc size");
module_param(zfs_arc_max, ulong, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, max, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_max, "Max arc size"); "Max arc size");
module_param(zfs_arc_meta_limit, ulong, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_limit, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_meta_limit, "Meta limit for arc size"); "Metadata limit for arc size");
module_param(zfs_arc_meta_limit_percent, ulong, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_limit_percent, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_meta_limit_percent,
"Percent of arc size for arc meta limit"); "Percent of arc size for arc meta limit");
module_param(zfs_arc_meta_min, ulong, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_min, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_meta_min, "Min arc metadata"); "Min arc metadata");
module_param(zfs_arc_meta_prune, int, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_prune, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_meta_prune, "Meta objects to scan for prune"); "Meta objects to scan for prune");
module_param(zfs_arc_meta_adjust_restarts, int, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_adjust_restarts, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_meta_adjust_restarts,
"Limit number of restarts in arc_adjust_meta"); "Limit number of restarts in arc_adjust_meta");
module_param(zfs_arc_meta_strategy, int, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_strategy, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_meta_strategy, "Meta reclaim strategy"); "Meta reclaim strategy");
module_param(zfs_arc_grow_retry, int, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, grow_retry, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_grow_retry, "Seconds before growing arc size"); "Seconds before growing arc size");
module_param(zfs_arc_p_dampener_disable, int, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, p_dampener_disable, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_p_dampener_disable, "disable arc_p adapt dampener"); "Disable arc_p adapt dampener");
module_param(zfs_arc_shrink_shift, int, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, shrink_shift, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_shrink_shift, "log2(fraction of arc to reclaim)"); "log2(fraction of arc to reclaim)");
module_param(zfs_arc_pc_percent, uint, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, pc_percent, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_pc_percent,
"Percent of pagecache to reclaim arc to"); "Percent of pagecache to reclaim arc to");
module_param(zfs_arc_p_min_shift, int, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, p_min_shift, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_p_min_shift, "arc_c shift to calc min/max arc_p"); "arc_c shift to calc min/max arc_p");
module_param(zfs_arc_average_blocksize, int, 0444); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, average_blocksize, INT, ZMOD_RD,
MODULE_PARM_DESC(zfs_arc_average_blocksize, "Target average block size"); "Target average block size");
module_param(zfs_compressed_arc_enabled, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, compressed_arc_enabled, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_compressed_arc_enabled, "Disable compressed arc buffers"); "Disable compressed arc buffers");
module_param(zfs_arc_min_prefetch_ms, int, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, min_prefetch_ms, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_min_prefetch_ms, "Min life of prefetch block in ms"); "Min life of prefetch block in ms");
module_param(zfs_arc_min_prescient_prefetch_ms, int, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, min_prescient_prefetch_ms, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_min_prescient_prefetch_ms,
"Min life of prescient prefetched block in ms"); "Min life of prescient prefetched block in ms");
module_param(l2arc_write_max, ulong, 0644); ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, write_max, ULONG, ZMOD_RW,
MODULE_PARM_DESC(l2arc_write_max, "Max write bytes per interval"); "Max write bytes per interval");
module_param(l2arc_write_boost, ulong, 0644); ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, write_boost, ULONG, ZMOD_RW,
MODULE_PARM_DESC(l2arc_write_boost, "Extra write bytes during device warmup"); "Extra write bytes during device warmup");
module_param(l2arc_headroom, ulong, 0644); ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, headroom, ULONG, ZMOD_RW,
MODULE_PARM_DESC(l2arc_headroom, "Number of max device writes to precache"); "Number of max device writes to precache");
module_param(l2arc_headroom_boost, ulong, 0644); ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, headroom_boost, ULONG, ZMOD_RW,
MODULE_PARM_DESC(l2arc_headroom_boost, "Compressed l2arc_headroom multiplier"); "Compressed l2arc_headroom multiplier");
module_param(l2arc_feed_secs, ulong, 0644); ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, feed_secs, ULONG, ZMOD_RW,
MODULE_PARM_DESC(l2arc_feed_secs, "Seconds between L2ARC writing"); "Seconds between L2ARC writing");
module_param(l2arc_feed_min_ms, ulong, 0644); ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, feed_min_ms, ULONG, ZMOD_RW,
MODULE_PARM_DESC(l2arc_feed_min_ms, "Min feed interval in milliseconds"); "Min feed interval in milliseconds");
module_param(l2arc_noprefetch, int, 0644); ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, noprefetch, INT, ZMOD_RW,
MODULE_PARM_DESC(l2arc_noprefetch, "Skip caching prefetched buffers"); "Skip caching prefetched buffers");
module_param(l2arc_feed_again, int, 0644); ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, feed_again, INT, ZMOD_RW,
MODULE_PARM_DESC(l2arc_feed_again, "Turbo L2ARC warmup"); "Turbo L2ARC warmup");
module_param(l2arc_norw, int, 0644); ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, norw, INT, ZMOD_RW,
MODULE_PARM_DESC(l2arc_norw, "No reads during writes"); "No reads during writes");
module_param(zfs_arc_lotsfree_percent, int, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, lotsfree_percent, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_lotsfree_percent,
"System free memory I/O throttle in bytes"); "System free memory I/O throttle in bytes");
module_param(zfs_arc_sys_free, ulong, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, sys_free, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_sys_free, "System free memory target size in bytes"); "System free memory target size in bytes");
module_param(zfs_arc_dnode_limit, ulong, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, dnode_limit, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_dnode_limit, "Minimum bytes of dnodes in arc"); "Minimum bytes of dnodes in arc");
module_param(zfs_arc_dnode_limit_percent, ulong, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, dnode_limit_percent, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_dnode_limit_percent,
"Percent of ARC meta buffers for dnodes"); "Percent of ARC meta buffers for dnodes");
module_param(zfs_arc_dnode_reduce_percent, ulong, 0644); ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, dnode_reduce_percent, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_arc_dnode_reduce_percent,
"Percentage of excess dnodes to try to unpin"); "Percentage of excess dnodes to try to unpin");
/* END CSTYLED */ /* END CSTYLED */
#endif

24
module/zfs/dbuf.c
View File

@ -4757,7 +4757,6 @@ dbuf_write(dbuf_dirty_record_t *dr, arc_buf_t *data, dmu_tx_t *tx)
} }
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(dbuf_find); EXPORT_SYMBOL(dbuf_find);
EXPORT_SYMBOL(dbuf_is_metadata); EXPORT_SYMBOL(dbuf_is_metadata);
EXPORT_SYMBOL(dbuf_destroy); EXPORT_SYMBOL(dbuf_destroy);
@ -4795,31 +4794,24 @@ EXPORT_SYMBOL(dmu_buf_get_user);
EXPORT_SYMBOL(dmu_buf_get_blkptr); EXPORT_SYMBOL(dmu_buf_get_blkptr);
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(dbuf_cache_max_bytes, ulong, 0644); ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, max_bytes, ULONG, ZMOD_RW,
MODULE_PARM_DESC(dbuf_cache_max_bytes,
"Maximum size in bytes of the dbuf cache."); "Maximum size in bytes of the dbuf cache.");
module_param(dbuf_cache_hiwater_pct, uint, 0644); ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, hiwater_pct, UINT, ZMOD_RW,
MODULE_PARM_DESC(dbuf_cache_hiwater_pct,
"Percentage over dbuf_cache_max_bytes when dbufs must be evicted " "Percentage over dbuf_cache_max_bytes when dbufs must be evicted "
"directly."); "directly.");
module_param(dbuf_cache_lowater_pct, uint, 0644); ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, lowater_pct, UINT, ZMOD_RW,
MODULE_PARM_DESC(dbuf_cache_lowater_pct,
"Percentage below dbuf_cache_max_bytes when the evict thread stops " "Percentage below dbuf_cache_max_bytes when the evict thread stops "
"evicting dbufs."); "evicting dbufs.");
module_param(dbuf_metadata_cache_max_bytes, ulong, 0644); ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, metadata_cache_max_bytes, ULONG, ZMOD_RW,
MODULE_PARM_DESC(dbuf_metadata_cache_max_bytes,
"Maximum size in bytes of the dbuf metadata cache."); "Maximum size in bytes of the dbuf metadata cache.");
module_param(dbuf_cache_shift, int, 0644); ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, cache_shift, INT, ZMOD_RW,
MODULE_PARM_DESC(dbuf_cache_shift,
"Set the size of the dbuf cache to a log2 fraction of arc size."); "Set the size of the dbuf cache to a log2 fraction of arc size.");
module_param(dbuf_metadata_cache_shift, int, 0644); ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, metadata_cache_shift, INT, ZMOD_RW,
MODULE_PARM_DESC(dbuf_cache_shift, "Set the size of the dbuf metadata cache to a log2 fraction of arc "
"Set the size of the dbuf metadata cache to a log2 fraction of " "size.");
"arc size.");
/* END CSTYLED */ /* END CSTYLED */
#endif

8
module/zfs/dbuf_stats.c
View File

@ -225,7 +225,7 @@ dbuf_stats_destroy(void)
dbuf_stats_hash_table_destroy(); dbuf_stats_hash_table_destroy();
} }
#if defined(_KERNEL) /* BEGIN CSTYLED */
module_param(zfs_dbuf_state_index, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, dbuf_state_index, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_dbuf_state_index, "Calculate arc header index"); "Calculate arc header index");
#endif /* END CSTYLED */

8
module/zfs/ddt.c
View File

@ -1187,7 +1187,7 @@ ddt_walk(spa_t *spa, ddt_bookmark_t *ddb, ddt_entry_t *dde)
return (SET_ERROR(ENOENT)); return (SET_ERROR(ENOENT));
} }
#if defined(_KERNEL) /* BEGIN CSTYLED */
module_param(zfs_dedup_prefetch, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, dedup_prefetch, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_dedup_prefetch, "Enable prefetching dedup-ed blks"); "Enable prefetching dedup-ed blks");
#endif /* END CSTYLED */

19
module/zfs/dmu.c
View File

@ -2474,7 +2474,6 @@ dmu_fini(void)
abd_fini(); abd_fini();
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(dmu_bonus_hold); EXPORT_SYMBOL(dmu_bonus_hold);
EXPORT_SYMBOL(dmu_bonus_hold_by_dnode); EXPORT_SYMBOL(dmu_bonus_hold_by_dnode);
EXPORT_SYMBOL(dmu_buf_hold_array_by_bonus); EXPORT_SYMBOL(dmu_buf_hold_array_by_bonus);
@ -2508,21 +2507,15 @@ EXPORT_SYMBOL(dmu_buf_hold);
EXPORT_SYMBOL(dmu_ot); EXPORT_SYMBOL(dmu_ot);
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(zfs_nopwrite_enabled, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, nopwrite_enabled, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_nopwrite_enabled, "Enable NOP writes"); "Enable NOP writes");
module_param(zfs_per_txg_dirty_frees_percent, ulong, 0644); ZFS_MODULE_PARAM(zfs, zfs_, per_txg_dirty_frees_percent, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_per_txg_dirty_frees_percent, "Percentage of dirtied blocks from frees in one TXG");
"percentage of dirtied blocks from frees in one TXG");
module_param(zfs_dmu_offset_next_sync, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, dmu_offset_next_sync, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_dmu_offset_next_sync,
"Enable forcing txg sync to find holes"); "Enable forcing txg sync to find holes");
module_param(dmu_prefetch_max, int, 0644); ZFS_MODULE_PARAM(zfs, , dmu_prefetch_max, INT, ZMOD_RW,
MODULE_PARM_DESC(dmu_prefetch_max,
"Limit one prefetch call to this size"); "Limit one prefetch call to this size");
/* END CSTYLED */ /* END CSTYLED */
#endif

5
module/zfs/dmu_object.c
View File

@ -504,7 +504,6 @@ dmu_object_free_zapified(objset_t *mos, uint64_t object, dmu_tx_t *tx)
VERIFY0(dmu_object_free(mos, object, tx)); VERIFY0(dmu_object_free(mos, object, tx));
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(dmu_object_alloc); EXPORT_SYMBOL(dmu_object_alloc);
EXPORT_SYMBOL(dmu_object_alloc_ibs); EXPORT_SYMBOL(dmu_object_alloc_ibs);
EXPORT_SYMBOL(dmu_object_alloc_dnsize); EXPORT_SYMBOL(dmu_object_alloc_dnsize);
@ -520,8 +519,6 @@ EXPORT_SYMBOL(dmu_object_zapify);
EXPORT_SYMBOL(dmu_object_free_zapified); EXPORT_SYMBOL(dmu_object_free_zapified);
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(dmu_object_alloc_chunk_shift, int, 0644); ZFS_MODULE_PARAM(zfs, , dmu_object_alloc_chunk_shift, INT, ZMOD_RW,
MODULE_PARM_DESC(dmu_object_alloc_chunk_shift,
"CPU-specific allocator grabs 2^N objects at once"); "CPU-specific allocator grabs 2^N objects at once");
/* END CSTYLED */ /* END CSTYLED */
#endif

12
module/zfs/dmu_recv.c
View File

@ -3201,10 +3201,10 @@ dmu_objset_is_receiving(objset_t *os)
os->os_dsl_dataset->ds_owner == dmu_recv_tag); os->os_dsl_dataset->ds_owner == dmu_recv_tag);
} }
#if defined(_KERNEL) /* BEGIN CSTYLED */
module_param(zfs_recv_queue_length, int, 0644); ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, queue_length, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_recv_queue_length, "Maximum receive queue length"); "Maximum receive queue length");
module_param(zfs_recv_queue_ff, int, 0644); ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, queue_ff, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_recv_queue_ff, "Receive queue fill fraction"); "Receive queue fill fraction");
#endif /* END CSTYLED */

28
module/zfs/dmu_send.c
View File

@ -2925,29 +2925,25 @@ dmu_send_estimate_fast(dsl_dataset_t *ds, dsl_dataset_t *fromds,
return (err); return (err);
} }
#if defined(_KERNEL) /* BEGIN CSTYLED */
module_param(zfs_send_corrupt_data, int, 0644); ZFS_MODULE_PARAM(zfs_send, zfs_send_, corrupt_data, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_send_corrupt_data, "Allow sending corrupt data"); "Allow sending corrupt data");
module_param(zfs_send_queue_length, int, 0644); ZFS_MODULE_PARAM(zfs_send, zfs_send_, queue_length, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_send_queue_length, "Maximum send queue length"); "Maximum send queue length");
module_param(zfs_send_unmodified_spill_blocks, int, 0644); ZFS_MODULE_PARAM(zfs_send, zfs_send_, unmodified_spill_blocks, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_send_unmodified_spill_blocks,
"Send unmodified spill blocks"); "Send unmodified spill blocks");
module_param(zfs_send_no_prefetch_queue_length, int, 0644); ZFS_MODULE_PARAM(zfs_send, zfs_send_, no_prefetch_queue_length, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_send_no_prefetch_queue_length,
"Maximum send queue length for non-prefetch queues"); "Maximum send queue length for non-prefetch queues");
module_param(zfs_send_queue_ff, int, 0644); ZFS_MODULE_PARAM(zfs_send, zfs_send_, queue_ff, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_send_queue_ff, "Send queue fill fraction"); "Send queue fill fraction");
module_param(zfs_send_no_prefetch_queue_ff, int, 0644); ZFS_MODULE_PARAM(zfs_send, zfs_send_, no_prefetch_queue_ff, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_send_no_prefetch_queue_ff,
"Send queue fill fraction for non-prefetch queues"); "Send queue fill fraction for non-prefetch queues");
module_param(zfs_override_estimate_recordsize, int, 0644); ZFS_MODULE_PARAM(zfs_send, zfs_, override_estimate_recordsize, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_override_estimate_recordsize,
"Override block size estimate with fixed size"); "Override block size estimate with fixed size");
#endif /* END CSTYLED */

19
module/zfs/dmu_traverse.c
View File

@ -768,18 +768,19 @@ traverse_pool(spa_t *spa, uint64_t txg_start, int flags,
return (err); return (err);
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(traverse_dataset); EXPORT_SYMBOL(traverse_dataset);
EXPORT_SYMBOL(traverse_pool); EXPORT_SYMBOL(traverse_pool);
module_param(zfs_pd_bytes_max, int, 0644); /* BEGIN CSTYLED */
MODULE_PARM_DESC(zfs_pd_bytes_max, "Max number of bytes to prefetch"); ZFS_MODULE_PARAM(zfs, zfs_, pd_bytes_max, INT, ZMOD_RW,
"Max number of bytes to prefetch");
#if defined(_KERNEL)
module_param_named(ignore_hole_birth, send_holes_without_birth_time, int, 0644); module_param_named(ignore_hole_birth, send_holes_without_birth_time, int, 0644);
MODULE_PARM_DESC(ignore_hole_birth, "Alias for send_holes_without_birth_time"); MODULE_PARM_DESC(ignore_hole_birth,
"Alias for send_holes_without_birth_time");
module_param_named(send_holes_without_birth_time,
send_holes_without_birth_time, int, 0644);
MODULE_PARM_DESC(send_holes_without_birth_time,
"Ignore hole_birth txg for zfs send");
#endif #endif
ZFS_MODULE_PARAM(zfs, , send_holes_without_birth_time, INT, ZMOD_RW,
"Ignore hole_birth txg for zfs send");
/* END CSTYLED */

21
module/zfs/dmu_zfetch.c
View File

@ -366,22 +366,19 @@ dmu_zfetch(zfetch_t *zf, uint64_t blkid, uint64_t nblks, boolean_t fetch_data,
ZFETCHSTAT_BUMP(zfetchstat_hits); ZFETCHSTAT_BUMP(zfetchstat_hits);
} }
#if defined(_KERNEL)
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(zfs_prefetch_disable, int, 0644); ZFS_MODULE_PARAM(zfs_prefetch, zfs_prefetch_, disable, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_prefetch_disable, "Disable all ZFS prefetching"); "Disable all ZFS prefetching");
module_param(zfetch_max_streams, uint, 0644); ZFS_MODULE_PARAM(zfs_prefetch, zfetch_, max_streams, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfetch_max_streams, "Max number of streams per zfetch"); "Max number of streams per zfetch");
module_param(zfetch_min_sec_reap, uint, 0644); ZFS_MODULE_PARAM(zfs_prefetch, zfetch_, min_sec_reap, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfetch_min_sec_reap, "Min time before stream reclaim"); "Min time before stream reclaim");
module_param(zfetch_max_distance, uint, 0644); ZFS_MODULE_PARAM(zfs_prefetch, zfetch_, max_distance, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfetch_max_distance,
"Max bytes to prefetch per stream (default 8MB)"); "Max bytes to prefetch per stream (default 8MB)");
module_param(zfetch_array_rd_sz, ulong, 0644); ZFS_MODULE_PARAM(zfs_prefetch, zfetch_, array_rd_sz, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfetch_array_rd_sz, "Number of bytes in a array_read"); "Number of bytes in a array_read");
/* END CSTYLED */ /* END CSTYLED */
#endif

16
module/zfs/dsl_dataset.c
View File

@ -4872,20 +4872,19 @@ dsl_dataset_activate_redaction(dsl_dataset_t *ds, uint64_t *redact_snaps,
ds->ds_feature[SPA_FEATURE_REDACTED_DATASETS] = ftuaa; ds->ds_feature[SPA_FEATURE_REDACTED_DATASETS] = ftuaa;
} }
/* BEGIN CSTYLED */
#if defined(_KERNEL)
#if defined(_LP64) #if defined(_LP64)
module_param(zfs_max_recordsize, int, 0644); #define RECORDSIZE_PERM ZMOD_RW
MODULE_PARM_DESC(zfs_max_recordsize, "Max allowed record size");
#else #else
/* Limited to 1M on 32-bit platforms due to lack of virtual address space */ /* Limited to 1M on 32-bit platforms due to lack of virtual address space */
module_param(zfs_max_recordsize, int, 0444); #define RECORDSIZE_PERM ZMOD_RD
MODULE_PARM_DESC(zfs_max_recordsize, "Max allowed record size");
#endif #endif
ZFS_MODULE_PARAM(zfs, zfs_, max_recordsize, INT, RECORDSIZE_PERM,
"Max allowed record size");
module_param(zfs_allow_redacted_dataset_mount, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, allow_redacted_dataset_mount, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_allow_redacted_dataset_mount,
"Allow mounting of redacted datasets"); "Allow mounting of redacted datasets");
/* END CSTYLED */
EXPORT_SYMBOL(dsl_dataset_hold); EXPORT_SYMBOL(dsl_dataset_hold);
EXPORT_SYMBOL(dsl_dataset_hold_flags); EXPORT_SYMBOL(dsl_dataset_hold_flags);
@ -4923,4 +4922,3 @@ EXPORT_SYMBOL(dsl_dsobj_to_dsname);
EXPORT_SYMBOL(dsl_dataset_check_quota); EXPORT_SYMBOL(dsl_dataset_check_quota);
EXPORT_SYMBOL(dsl_dataset_clone_swap_check_impl); EXPORT_SYMBOL(dsl_dataset_clone_swap_check_impl);
EXPORT_SYMBOL(dsl_dataset_clone_swap_sync_impl); EXPORT_SYMBOL(dsl_dataset_clone_swap_sync_impl);
#endif

11
module/zfs/dsl_deadlist.c
View File

@ -996,13 +996,10 @@ dsl_process_sub_livelist(bpobj_t *bpobj, bplist_t *to_free, zthr_t *t,
return (err); return (err);
} }
#if defined(_KERNEL) /* BEGIN CSTYLED */
/* CSTYLED */ ZFS_MODULE_PARAM(zfs_livelist, zfs_livelist_, max_entries, ULONG, ZMOD_RW,
module_param(zfs_livelist_max_entries, ulong, 0644);
MODULE_PARM_DESC(zfs_livelist_max_entries,
"Size to start the next sub-livelist in a livelist"); "Size to start the next sub-livelist in a livelist");
module_param(zfs_livelist_min_percent_shared, int, 0644); ZFS_MODULE_PARAM(zfs_livelist, zfs_livelist_, min_percent_shared, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_livelist_min_percent_shared,
"Threshold at which livelist is disabled"); "Threshold at which livelist is disabled");
#endif /* END CSTYLED */

50
module/zfs/dsl_pool.c
View File

@ -1342,53 +1342,43 @@ dsl_pool_config_held_writer(dsl_pool_t *dp)
return (RRW_WRITE_HELD(&dp->dp_config_rwlock)); return (RRW_WRITE_HELD(&dp->dp_config_rwlock));
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(dsl_pool_config_enter); EXPORT_SYMBOL(dsl_pool_config_enter);
EXPORT_SYMBOL(dsl_pool_config_exit); EXPORT_SYMBOL(dsl_pool_config_exit);
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
/* zfs_dirty_data_max_percent only applied at module load in arc_init(). */ /* zfs_dirty_data_max_percent only applied at module load in arc_init(). */
module_param(zfs_dirty_data_max_percent, int, 0444); ZFS_MODULE_PARAM(zfs, zfs_, dirty_data_max_percent, INT, ZMOD_RD,
MODULE_PARM_DESC(zfs_dirty_data_max_percent, "percent of ram can be dirty"); "Max percent of RAM allowed to be dirty");
/* zfs_dirty_data_max_max_percent only applied at module load in arc_init(). */ /* zfs_dirty_data_max_max_percent only applied at module load in arc_init(). */
module_param(zfs_dirty_data_max_max_percent, int, 0444); ZFS_MODULE_PARAM(zfs, zfs_, dirty_data_max_max_percent, INT, ZMOD_RD,
MODULE_PARM_DESC(zfs_dirty_data_max_max_percent,
"zfs_dirty_data_max upper bound as % of RAM"); "zfs_dirty_data_max upper bound as % of RAM");
module_param(zfs_delay_min_dirty_percent, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, delay_min_dirty_percent, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_delay_min_dirty_percent, "transaction delay threshold"); "Transaction delay threshold");
module_param(zfs_dirty_data_max, ulong, 0644); ZFS_MODULE_PARAM(zfs, zfs_, dirty_data_max, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_dirty_data_max, "determines the dirty space limit"); "Determines the dirty space limit");
/* zfs_dirty_data_max_max only applied at module load in arc_init(). */ /* zfs_dirty_data_max_max only applied at module load in arc_init(). */
module_param(zfs_dirty_data_max_max, ulong, 0444); ZFS_MODULE_PARAM(zfs, zfs_, dirty_data_max_max, ULONG, ZMOD_RD,
MODULE_PARM_DESC(zfs_dirty_data_max_max,
"zfs_dirty_data_max upper bound in bytes"); "zfs_dirty_data_max upper bound in bytes");
module_param(zfs_dirty_data_sync_percent, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, dirty_data_sync_percent, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_dirty_data_sync_percent, "Dirty data txg sync threshold as a percentage of zfs_dirty_data_max");
"dirty data txg sync threshold as a percentage of zfs_dirty_data_max");
module_param(zfs_delay_scale, ulong, 0644); ZFS_MODULE_PARAM(zfs, zfs_, delay_scale, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_delay_scale, "how quickly delay approaches infinity"); "How quickly delay approaches infinity");
module_param(zfs_sync_taskq_batch_pct, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, sync_taskq_batch_pct, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_sync_taskq_batch_pct, "Max percent of CPUs that are used to sync dirty data");
"max percent of CPUs that are used to sync dirty data");
module_param(zfs_zil_clean_taskq_nthr_pct, int, 0644); ZFS_MODULE_PARAM(zfs_zil, zfs_zil_, clean_taskq_nthr_pct, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_zil_clean_taskq_nthr_pct, "Max percent of CPUs that are used per dp_sync_taskq");
"max percent of CPUs that are used per dp_sync_taskq");
module_param(zfs_zil_clean_taskq_minalloc, int, 0644); ZFS_MODULE_PARAM(zfs_zil, zfs_zil_, clean_taskq_minalloc, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_zil_clean_taskq_minalloc, "Number of taskq entries that are pre-populated");
"number of taskq entries that are pre-populated");
module_param(zfs_zil_clean_taskq_maxalloc, int, 0644);
MODULE_PARM_DESC(zfs_zil_clean_taskq_maxalloc,
"max number of taskq entries that are cached");
ZFS_MODULE_PARAM(zfs_zil, zfs_zil_, clean_taskq_maxalloc, INT, ZMOD_RW,
"Max number of taskq entries that are cached");
/* END CSTYLED */ /* END CSTYLED */
#endif

76
module/zfs/dsl_scan.c
View File

@ -4205,74 +4205,62 @@ dsl_scan_freed(spa_t *spa, const blkptr_t *bp)
dsl_scan_freed_dva(spa, bp, i); dsl_scan_freed_dva(spa, bp, i);
} }
#if defined(_KERNEL) /* BEGIN CSTYLED */
/* CSTYLED */ ZFS_MODULE_PARAM(zfs, zfs_, scan_vdev_limit, ULONG, ZMOD_RW,
module_param(zfs_scan_vdev_limit, ulong, 0644);
MODULE_PARM_DESC(zfs_scan_vdev_limit,
"Max bytes in flight per leaf vdev for scrubs and resilvers"); "Max bytes in flight per leaf vdev for scrubs and resilvers");
module_param(zfs_scrub_min_time_ms, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, scrub_min_time_ms, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_scrub_min_time_ms, "Min millisecs to scrub per txg"); "Min millisecs to scrub per txg");
module_param(zfs_obsolete_min_time_ms, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, obsolete_min_time_ms, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_obsolete_min_time_ms, "Min millisecs to obsolete per txg"); "Min millisecs to obsolete per txg");
module_param(zfs_free_min_time_ms, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, free_min_time_ms, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_free_min_time_ms, "Min millisecs to free per txg"); "Min millisecs to free per txg");
module_param(zfs_resilver_min_time_ms, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, resilver_min_time_ms, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_resilver_min_time_ms, "Min millisecs to resilver per txg"); "Min millisecs to resilver per txg");
module_param(zfs_scan_suspend_progress, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, scan_suspend_progress, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_scan_suspend_progress,
"Set to prevent scans from progressing"); "Set to prevent scans from progressing");
module_param(zfs_no_scrub_io, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, no_scrub_io, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_no_scrub_io, "Set to disable scrub I/O"); "Set to disable scrub I/O");
module_param(zfs_no_scrub_prefetch, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, no_scrub_prefetch, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_no_scrub_prefetch, "Set to disable scrub prefetching"); "Set to disable scrub prefetching");
/* CSTYLED */ ZFS_MODULE_PARAM(zfs, zfs_, async_block_max_blocks, ULONG, ZMOD_RW,
module_param(zfs_async_block_max_blocks, ulong, 0644);
MODULE_PARM_DESC(zfs_async_block_max_blocks,
"Max number of blocks freed in one txg"); "Max number of blocks freed in one txg");
module_param(zfs_free_bpobj_enabled, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, free_bpobj_enabled, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_free_bpobj_enabled, "Enable processing of the free_bpobj"); "Enable processing of the free_bpobj");
module_param(zfs_scan_mem_lim_fact, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, scan_mem_lim_fact, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_scan_mem_lim_fact, "Fraction of RAM for scan hard limit"); "Fraction of RAM for scan hard limit");
module_param(zfs_scan_issue_strategy, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, scan_issue_strategy, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_scan_issue_strategy, "IO issuing strategy during scrubbing. "
"IO issuing strategy during scrubbing. 0 = default, 1 = LBA, 2 = size"); "0 = default, 1 = LBA, 2 = size");
module_param(zfs_scan_legacy, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, scan_legacy, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_scan_legacy, "Scrub using legacy non-sequential method"); "Scrub using legacy non-sequential method");
module_param(zfs_scan_checkpoint_intval, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, scan_checkpoint_intval, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_scan_checkpoint_intval,
"Scan progress on-disk checkpointing interval"); "Scan progress on-disk checkpointing interval");
/* CSTYLED */ ZFS_MODULE_PARAM(zfs, zfs_, scan_max_ext_gap, ULONG, ZMOD_RW,
module_param(zfs_scan_max_ext_gap, ulong, 0644);
MODULE_PARM_DESC(zfs_scan_max_ext_gap,
"Max gap in bytes between sequential scrub / resilver I/Os"); "Max gap in bytes between sequential scrub / resilver I/Os");
module_param(zfs_scan_mem_lim_soft_fact, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, scan_mem_lim_soft_fact, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_scan_mem_lim_soft_fact,
"Fraction of hard limit used as soft limit"); "Fraction of hard limit used as soft limit");
module_param(zfs_scan_strict_mem_lim, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, scan_strict_mem_lim, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_scan_strict_mem_lim,
"Tunable to attempt to reduce lock contention"); "Tunable to attempt to reduce lock contention");
module_param(zfs_scan_fill_weight, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, scan_fill_weight, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_scan_fill_weight,
"Tunable to adjust bias towards more filled segments during scans"); "Tunable to adjust bias towards more filled segments during scans");
module_param(zfs_resilver_disable_defer, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, resilver_disable_defer, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_resilver_disable_defer,
"Process all resilvers immediately"); "Process all resilvers immediately");
#endif /* END CSTYLED */

129
module/zfs/metaslab.c
View File

@ -5868,83 +5868,64 @@ metaslab_unflushed_txg(metaslab_t *ms)
return (ms->ms_unflushed_txg); return (ms->ms_unflushed_txg);
} }
#if defined(_KERNEL) ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, aliquot, ULONG, ZMOD_RW,
"Allocation granularity (a.k.a. stripe size)");
ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, debug_load, INT, ZMOD_RW,
"Load all metaslabs when pool is first opened");
ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, debug_unload, INT, ZMOD_RW,
"Prevent metaslabs from being unloaded");
ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, preload_enabled, INT, ZMOD_RW,
"Preload potential metaslabs during reassessment");
ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, unload_delay, INT, ZMOD_RW,
"Delay in txgs after metaslab was last used before unloading");
ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, unload_delay_ms, INT, ZMOD_RW,
"Delay in milliseconds after metaslab was last used before unloading");
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(metaslab_aliquot, ulong, 0644); ZFS_MODULE_PARAM(zfs_mg, zfs_mg_, noalloc_threshold, INT, ZMOD_RW,
MODULE_PARM_DESC(metaslab_aliquot, "Percentage of metaslab group size that should be free to make it "
"allocation granularity (a.k.a. stripe size)"); "eligible for allocation");
module_param(metaslab_debug_load, int, 0644); ZFS_MODULE_PARAM(zfs_mg, zfs_mg_, fragmentation_threshold, INT, ZMOD_RW,
MODULE_PARM_DESC(metaslab_debug_load, "Percentage of metaslab group size that should be considered eligible "
"load all metaslabs when pool is first opened"); "for allocations unless all metaslab groups within the metaslab class "
"have also crossed this threshold");
module_param(metaslab_debug_unload, int, 0644); ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, fragmentation_threshold, INT,
MODULE_PARM_DESC(metaslab_debug_unload, ZMOD_RW, "Fragmentation for metaslab to allow allocation");
"prevent metaslabs from being unloaded");
module_param(metaslab_preload_enabled, int, 0644); ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, fragmentation_factor_enabled, INT, ZMOD_RW,
MODULE_PARM_DESC(metaslab_preload_enabled, "Use the fragmentation metric to prefer less fragmented metaslabs");
"preload potential metaslabs during reassessment");
module_param(metaslab_unload_delay, int, 0644);
MODULE_PARM_DESC(metaslab_unload_delay,
"delay in txgs after metaslab was last used before unloading");
module_param(metaslab_unload_delay_ms, int, 0644);
MODULE_PARM_DESC(metaslab_unload_delay_ms,
"delay in milliseconds after metaslab was last used before unloading");
module_param(zfs_mg_noalloc_threshold, int, 0644);
MODULE_PARM_DESC(zfs_mg_noalloc_threshold,
"percentage of free space for metaslab group to allow allocation");
module_param(zfs_mg_fragmentation_threshold, int, 0644);
MODULE_PARM_DESC(zfs_mg_fragmentation_threshold,
"fragmentation for metaslab group to allow allocation");
module_param(zfs_metaslab_fragmentation_threshold, int, 0644);
MODULE_PARM_DESC(zfs_metaslab_fragmentation_threshold,
"fragmentation for metaslab to allow allocation");
module_param(metaslab_fragmentation_factor_enabled, int, 0644);
MODULE_PARM_DESC(metaslab_fragmentation_factor_enabled,
"use the fragmentation metric to prefer less fragmented metaslabs");
module_param(metaslab_lba_weighting_enabled, int, 0644);
MODULE_PARM_DESC(metaslab_lba_weighting_enabled,
"prefer metaslabs with lower LBAs");
module_param(metaslab_bias_enabled, int, 0644);
MODULE_PARM_DESC(metaslab_bias_enabled,
"enable metaslab group biasing");
module_param(zfs_metaslab_segment_weight_enabled, int, 0644);
MODULE_PARM_DESC(zfs_metaslab_segment_weight_enabled,
"enable segment-based metaslab selection");
module_param(zfs_metaslab_switch_threshold, int, 0644);
MODULE_PARM_DESC(zfs_metaslab_switch_threshold,
"segment-based metaslab selection maximum buckets before switching");
module_param(metaslab_force_ganging, ulong, 0644);
MODULE_PARM_DESC(metaslab_force_ganging,
"blocks larger than this size are forced to be gang blocks");
module_param(metaslab_df_max_search, int, 0644);
MODULE_PARM_DESC(metaslab_df_max_search,
"max distance (bytes) to search forward before using size tree");
module_param(metaslab_df_use_largest_segment, int, 0644);
MODULE_PARM_DESC(metaslab_df_use_largest_segment,
"when looking in size tree, use largest segment instead of exact fit");
module_param(zfs_metaslab_max_size_cache_sec, ulong, 0644);
MODULE_PARM_DESC(zfs_metaslab_max_size_cache_sec,
"how long to trust the cached max chunk size of a metaslab");
module_param(zfs_metaslab_mem_limit, int, 0644);
MODULE_PARM_DESC(zfs_metaslab_mem_limit,
"percentage of memory that can be used to store metaslab range trees");
/* END CSTYLED */ /* END CSTYLED */
#endif ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, lba_weighting_enabled, INT, ZMOD_RW,
"Prefer metaslabs with lower LBAs");
ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, bias_enabled, INT, ZMOD_RW,
"Enable metaslab group biasing");
ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, segment_weight_enabled, INT,
ZMOD_RW, "Enable segment-based metaslab selection");
ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, switch_threshold, INT, ZMOD_RW,
"Segment-based metaslab selection maximum buckets before switching");
ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, force_ganging, ULONG, ZMOD_RW,
"Blocks larger than this size are forced to be gang blocks");
ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, df_max_search, INT, ZMOD_RW,
"Max distance (bytes) to search forward before using size tree");
ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, df_use_largest_segment, INT, ZMOD_RW,
"When looking in size tree, use largest segment instead of exact fit");
ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, max_size_cache_sec, ULONG,
ZMOD_RW, "How long to trust the cached max chunk size of a metaslab");
ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, mem_limit, INT, ZMOD_RW,
"Percentage of memory that can be used to store metaslab range trees");

16
module/zfs/mmp.c
View File

@ -717,7 +717,6 @@ mmp_signal_all_threads(void)
} }
#if defined(_KERNEL) #if defined(_KERNEL)
#include <linux/mod_compat.h>
static int static int
param_set_multihost_interval(const char *val, zfs_kernel_param_t *kp) param_set_multihost_interval(const char *val, zfs_kernel_param_t *kp)
@ -734,18 +733,19 @@ param_set_multihost_interval(const char *val, zfs_kernel_param_t *kp)
return (ret); return (ret);
} }
/* BEGIN CSTYLED */ #endif
module_param(zfs_multihost_fail_intervals, uint, 0644);
MODULE_PARM_DESC(zfs_multihost_fail_intervals,
"Max allowed period without a successful mmp write");
/* BEGIN CSTYLED */
#if defined(_KERNEL)
module_param_call(zfs_multihost_interval, param_set_multihost_interval, module_param_call(zfs_multihost_interval, param_set_multihost_interval,
param_get_ulong, &zfs_multihost_interval, 0644); param_get_ulong, &zfs_multihost_interval, 0644);
MODULE_PARM_DESC(zfs_multihost_interval, MODULE_PARM_DESC(zfs_multihost_interval,
"Milliseconds between mmp writes to each leaf"); "Milliseconds between mmp writes to each leaf");
#endif
module_param(zfs_multihost_import_intervals, uint, 0644); ZFS_MODULE_PARAM(zfs_multihost, zfs_multihost_, fail_intervals, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfs_multihost_import_intervals, "Max allowed period without a successful mmp write");
ZFS_MODULE_PARAM(zfs_multihost, zfs_multihost_, import_intervals, UINT, ZMOD_RW,
"Number of zfs_multihost_interval periods to wait for activity"); "Number of zfs_multihost_interval periods to wait for activity");
/* END CSTYLED */ /* END CSTYLED */
#endif

8
module/zfs/multilist.c
View File

@ -425,13 +425,7 @@ multilist_link_active(multilist_node_t *link)
return (list_link_active(link)); return (list_link_active(link));
} }
#if defined(_KERNEL)
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
ZFS_MODULE_PARAM(zfs, zfs_, multilist_num_sublists, INT, ZMOD_RW,
module_param(zfs_multilist_num_sublists, int, 0644);
MODULE_PARM_DESC(zfs_multilist_num_sublists,
"Number of sublists used in each multilist"); "Number of sublists used in each multilist");
/* END CSTYLED */ /* END CSTYLED */
#endif

1
module/zfs/qat_compress.c
View File

@ -24,7 +24,6 @@
#include <linux/vmalloc.h> #include <linux/vmalloc.h>
#include <linux/pagemap.h> #include <linux/pagemap.h>
#include <linux/completion.h> #include <linux/completion.h>
#include <linux/mod_compat.h>
#include <sys/zfs_context.h> #include <sys/zfs_context.h>
#include <sys/byteorder.h> #include <sys/byteorder.h>
#include <sys/zio.h> #include <sys/zio.h>

1
module/zfs/qat_crypt.c
View File

@ -31,7 +31,6 @@
#include <linux/vmalloc.h> #include <linux/vmalloc.h>
#include <linux/pagemap.h> #include <linux/pagemap.h>
#include <linux/completion.h> #include <linux/completion.h>
#include <linux/mod_compat.h>
#include <sys/zfs_context.h> #include <sys/zfs_context.h>
#include <sys/zio_crypt.h> #include <sys/zio_crypt.h>
#include "lac/cpa_cy_im.h" #include "lac/cpa_cy_im.h"

51
module/zfs/spa.c
View File

@ -9260,7 +9260,6 @@ spa_event_notify(spa_t *spa, vdev_t *vd, nvlist_t *hist_nvl, const char *name)
spa_event_post(spa_event_create(spa, vd, hist_nvl, name)); spa_event_post(spa_event_create(spa, vd, hist_nvl, name));
} }
#if defined(_KERNEL)
/* state manipulation functions */ /* state manipulation functions */
EXPORT_SYMBOL(spa_open); EXPORT_SYMBOL(spa_open);
EXPORT_SYMBOL(spa_open_rewind); EXPORT_SYMBOL(spa_open_rewind);
@ -9315,57 +9314,41 @@ EXPORT_SYMBOL(spa_prop_clear_bootfs);
/* asynchronous event notification */ /* asynchronous event notification */
EXPORT_SYMBOL(spa_event_notify); EXPORT_SYMBOL(spa_event_notify);
#endif
#if defined(_KERNEL)
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(spa_load_verify_shift, int, 0644); ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_shift, INT, ZMOD_RW,
MODULE_PARM_DESC(spa_load_verify_shift, "log2(fraction of arc that can " "log2(fraction of arc that can be used by inflight I/Os when "
"be used by inflight I/Os when verifying pool during import"); "verifying pool during import");
/* END CSTYLED */
module_param(spa_load_verify_metadata, int, 0644); ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_metadata, INT, ZMOD_RW,
MODULE_PARM_DESC(spa_load_verify_metadata,
"Set to traverse metadata on pool import"); "Set to traverse metadata on pool import");
module_param(spa_load_verify_data, int, 0644); ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_data, INT, ZMOD_RW,
MODULE_PARM_DESC(spa_load_verify_data,
"Set to traverse data on pool import"); "Set to traverse data on pool import");
module_param(spa_load_print_vdev_tree, int, 0644); ZFS_MODULE_PARAM(zfs_spa, spa_, load_print_vdev_tree, INT, ZMOD_RW,
MODULE_PARM_DESC(spa_load_print_vdev_tree,
"Print vdev tree to zfs_dbgmsg during pool import"); "Print vdev tree to zfs_dbgmsg during pool import");
/* CSTYLED */ ZFS_MODULE_PARAM(zfs_zio, zio_, taskq_batch_pct, UINT, ZMOD_RD,
module_param(zio_taskq_batch_pct, uint, 0444);
MODULE_PARM_DESC(zio_taskq_batch_pct,
"Percentage of CPUs to run an IO worker thread"); "Percentage of CPUs to run an IO worker thread");
/* BEGIN CSTYLED */ ZFS_MODULE_PARAM(zfs, zfs_, max_missing_tvds, ULONG, ZMOD_RW,
module_param(zfs_max_missing_tvds, ulong, 0644); "Allow importing pool with up to this number of missing top-level "
MODULE_PARM_DESC(zfs_max_missing_tvds, "vdevs (in read-only mode)");
"Allow importing pool with up to this number of missing top-level vdevs"
" (in read-only mode)");
/* END CSTYLED */
module_param(zfs_livelist_condense_zthr_pause, int, 0644); ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, zthr_pause, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_livelist_condense_zthr_pause,
"Set the livelist condense zthr to pause"); "Set the livelist condense zthr to pause");
module_param(zfs_livelist_condense_sync_pause, int, 0644);
MODULE_PARM_DESC(zfs_livelist_condense_sync_pause, ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, sync_pause, INT, ZMOD_RW,
"Set the livelist condense synctask to pause"); "Set the livelist condense synctask to pause");
module_param(zfs_livelist_condense_sync_cancel, int, 0644); ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, sync_cancel, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_livelist_condense_sync_cancel,
"Whether livelist condensing was canceled in the synctask"); "Whether livelist condensing was canceled in the synctask");
module_param(zfs_livelist_condense_zthr_cancel, int, 0644);
MODULE_PARM_DESC(zfs_livelist_condense_zthr_cancel, ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, zthr_cancel, INT, ZMOD_RW,
"Whether livelist condensing was canceled in the zthr function"); "Whether livelist condensing was canceled in the zthr function");
/* BEGIN CSTYLED */ ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, new_alloc, INT, ZMOD_RW,
module_param(zfs_livelist_condense_new_alloc, int, 0644);
MODULE_PARM_DESC(zfs_livelist_condense_new_alloc,
"Whether extra ALLOC blkptrs were added to a livelist entry while it " "Whether extra ALLOC blkptrs were added to a livelist entry while it "
"was being condensed"); "was being condensed");
/* END CSTYLED */ /* END CSTYLED */
#endif

9
module/zfs/spa_checkpoint.c
View File

@ -624,15 +624,12 @@ spa_checkpoint_discard(const char *pool)
ZFS_SPACE_CHECK_DISCARD_CHECKPOINT)); ZFS_SPACE_CHECK_DISCARD_CHECKPOINT));
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(spa_checkpoint_get_stats); EXPORT_SYMBOL(spa_checkpoint_get_stats);
EXPORT_SYMBOL(spa_checkpoint_discard_thread); EXPORT_SYMBOL(spa_checkpoint_discard_thread);
EXPORT_SYMBOL(spa_checkpoint_discard_thread_check); EXPORT_SYMBOL(spa_checkpoint_discard_thread_check);
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(zfs_spa_discard_memory_limit, ulong, 0644); ZFS_MODULE_PARAM(zfs_spa, zfs_spa_, discard_memory_limit, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_spa_discard_memory_limit, "Limit for memory used in prefetching the checkpoint space map done "
"Maximum memory for prefetching checkpoint space " "on each vdev while discarding the checkpoint");
"map per top-level vdev while discarding checkpoint");
/* END CSTYLED */ /* END CSTYLED */
#endif

16
module/zfs/spa_config.c
View File

@ -611,17 +611,19 @@ spa_config_update(spa_t *spa, int what)
spa_config_update(spa, SPA_CONFIG_UPDATE_VDEVS); spa_config_update(spa, SPA_CONFIG_UPDATE_VDEVS);
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(spa_config_load); EXPORT_SYMBOL(spa_config_load);
EXPORT_SYMBOL(spa_all_configs); EXPORT_SYMBOL(spa_all_configs);
EXPORT_SYMBOL(spa_config_set); EXPORT_SYMBOL(spa_config_set);
EXPORT_SYMBOL(spa_config_generate); EXPORT_SYMBOL(spa_config_generate);
EXPORT_SYMBOL(spa_config_update); EXPORT_SYMBOL(spa_config_update);
module_param(spa_config_path, charp, 0444); /* BEGIN CSTYLED */
MODULE_PARM_DESC(spa_config_path, "SPA config file (/etc/zfs/zpool.cache)"); #ifdef __linux__
/* string sysctls require a char array on FreeBSD */
module_param(zfs_autoimport_disable, int, 0644); ZFS_MODULE_PARAM(zfs_spa, spa_, config_path, STRING, ZMOD_RD,
MODULE_PARM_DESC(zfs_autoimport_disable, "Disable pool import at module load"); "SPA config file (/etc/zfs/zpool.cache)");
#endif #endif
ZFS_MODULE_PARAM(zfs, zfs_, autoimport_disable, INT, ZMOD_RW,
"Disable pool import at module load");
/* END CSTYLED */

73
module/zfs/spa_log_spacemap.c
View File

@ -1282,54 +1282,41 @@ spa_ld_log_spacemaps(spa_t *spa)
return (error); return (error);
} }
#if defined(_KERNEL)
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(zfs_keep_log_spacemaps_at_export, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, unflushed_max_mem_amt, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_keep_log_spacemaps_at_export,
"Prevent the log spacemaps from being flushed and destroyed "
"during pool export/destroy");
module_param(zfs_max_logsm_summary_length, ulong, 0644);
MODULE_PARM_DESC(zfs_max_logsm_summary_length,
"Maximum number of rows allowed in the summary of "
"the spacemap log");
module_param(zfs_max_log_walking, ulong, 0644);
MODULE_PARM_DESC(zfs_max_log_walking,
"The number of past TXGs that the flushing algorithm of the log "
"spacemap feature uses to estimate incoming log blocks");
module_param(zfs_min_metaslabs_to_flush, ulong, 0644);
MODULE_PARM_DESC(zfs_min_metaslabs_to_flush,
"Minimum number of metaslabs to flush per dirty TXG");
module_param(zfs_unflushed_log_block_pct, ulong, 0644);
MODULE_PARM_DESC(zfs_unflushed_log_block_pct,
"Tunable used to determine the number of blocks that can be "
"used for the spacemap log, expressed as a percentage of the "
" total number of metaslabs in the pool (e.g. 400 means the "
" number of log blocks is capped at 4 times the number of "
"metaslabs)");
module_param(zfs_unflushed_log_block_max, ulong, 0644);
MODULE_PARM_DESC(zfs_unflushed_log_block_max,
"Hard limit (upper-bound) in the size of the space map log "
"in terms of blocks.");
module_param(zfs_unflushed_log_block_min, ulong, 0644);
MODULE_PARM_DESC(zfs_unflushed_log_block_min,
"Lower-bound limit for the maximum amount of blocks in "
"log spacemap.");
module_param(zfs_unflushed_max_mem_amt, ulong, 0644);
MODULE_PARM_DESC(zfs_unflushed_max_mem_amt,
"Specific hard-limit in memory that ZFS allows to be used for " "Specific hard-limit in memory that ZFS allows to be used for "
"unflushed changes"); "unflushed changes");
module_param(zfs_unflushed_max_mem_ppm, ulong, 0644); ZFS_MODULE_PARAM(zfs, zfs_, unflushed_max_mem_ppm, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_unflushed_max_mem_ppm,
"Percentage of the overall system memory that ZFS allows to be " "Percentage of the overall system memory that ZFS allows to be "
"used for unflushed changes (value is calculated over 1000000 for " "used for unflushed changes (value is calculated over 1000000 for "
"finer granularity"); "finer granularity");
ZFS_MODULE_PARAM(zfs, zfs_, unflushed_log_block_max, ULONG, ZMOD_RW,
"Hard limit (upper-bound) in the size of the space map log "
"in terms of blocks.");
ZFS_MODULE_PARAM(zfs, zfs_, unflushed_log_block_min, ULONG, ZMOD_RW,
"Lower-bound limit for the maximum amount of blocks allowed in "
"log spacemap (see zfs_unflushed_log_block_max)");
ZFS_MODULE_PARAM(zfs, zfs_, unflushed_log_block_pct, ULONG, ZMOD_RW,
"Tunable used to determine the number of blocks that can be used for "
"the spacemap log, expressed as a percentage of the total number of "
"metaslabs in the pool (e.g. 400 means the number of log blocks is "
"capped at 4 times the number of metaslabs)");
ZFS_MODULE_PARAM(zfs, zfs_, max_log_walking, ULONG, ZMOD_RW,
"The number of past TXGs that the flushing algorithm of the log "
"spacemap feature uses to estimate incoming log blocks");
ZFS_MODULE_PARAM(zfs, zfs_, max_logsm_summary_length, ULONG, ZMOD_RW,
"Maximum number of rows allowed in the summary of the spacemap log");
ZFS_MODULE_PARAM(zfs, zfs_, min_metaslabs_to_flush, ULONG, ZMOD_RW,
"Minimum number of metaslabs to flush per dirty TXG");
ZFS_MODULE_PARAM(zfs, zfs_, keep_log_spacemaps_at_export, INT, ZMOD_RW,
"Prevent the log spacemaps from being flushed and destroyed "
"during pool export/destroy");
/* END CSTYLED */ /* END CSTYLED */
#endif

63
module/zfs/spa_misc.c
View File

@ -2710,8 +2710,6 @@ spa_suspend_async_destroy(spa_t *spa)
#if defined(_KERNEL) #if defined(_KERNEL)
#include <linux/mod_compat.h>
static int static int
param_set_deadman_failmode(const char *val, zfs_kernel_param_t *kp) param_set_deadman_failmode(const char *val, zfs_kernel_param_t *kp)
{ {
@ -2800,6 +2798,8 @@ param_set_slop_shift(const char *buf, zfs_kernel_param_t *kp)
return (0); return (0);
} }
#endif
/* Namespace manipulation */ /* Namespace manipulation */
EXPORT_SYMBOL(spa_lookup); EXPORT_SYMBOL(spa_lookup);
EXPORT_SYMBOL(spa_add); EXPORT_SYMBOL(spa_add);
@ -2888,17 +2888,31 @@ EXPORT_SYMBOL(spa_suspend_async_destroy);
EXPORT_SYMBOL(spa_has_checkpoint); EXPORT_SYMBOL(spa_has_checkpoint);
EXPORT_SYMBOL(spa_top_vdevs_spacemap_addressable); EXPORT_SYMBOL(spa_top_vdevs_spacemap_addressable);
/* BEGIN CSTYLED */ ZFS_MODULE_PARAM(zfs, zfs_, flags, UINT, ZMOD_RW,
module_param(zfs_flags, uint, 0644); "Set additional debugging flags");
MODULE_PARM_DESC(zfs_flags, "Set additional debugging flags");
module_param(zfs_recover, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, recover, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_recover, "Set to attempt to recover from fatal errors"); "Set to attempt to recover from fatal errors");
module_param(zfs_free_leak_on_eio, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, free_leak_on_eio, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_free_leak_on_eio,
"Set to ignore IO errors during free and permanently leak the space"); "Set to ignore IO errors during free and permanently leak the space");
ZFS_MODULE_PARAM(zfs, zfs_, deadman_checktime_ms, ULONG, ZMOD_RW,
"Dead I/O check interval in milliseconds");
ZFS_MODULE_PARAM(zfs, zfs_, deadman_enabled, INT, ZMOD_RW,
"Enable deadman timer");
ZFS_MODULE_PARAM(zfs_spa, spa_, asize_inflation, INT, ZMOD_RW,
"SPA size estimate multiplication factor");
ZFS_MODULE_PARAM(zfs, zfs_, ddt_data_is_special, INT, ZMOD_RW,
"Place DDT data into the special class");
ZFS_MODULE_PARAM(zfs, zfs_, user_indirect_is_special, INT, ZMOD_RW,
"Place user data indirect blocks into the special class");
#ifdef _KERNEL
module_param_call(zfs_deadman_synctime_ms, param_set_deadman_synctime, module_param_call(zfs_deadman_synctime_ms, param_set_deadman_synctime,
param_get_ulong, &zfs_deadman_synctime_ms, 0644); param_get_ulong, &zfs_deadman_synctime_ms, 0644);
MODULE_PARM_DESC(zfs_deadman_synctime_ms, MODULE_PARM_DESC(zfs_deadman_synctime_ms,
@ -2909,36 +2923,17 @@ module_param_call(zfs_deadman_ziotime_ms, param_set_deadman_ziotime,
MODULE_PARM_DESC(zfs_deadman_ziotime_ms, MODULE_PARM_DESC(zfs_deadman_ziotime_ms,
"IO expiration time in milliseconds"); "IO expiration time in milliseconds");
module_param(zfs_deadman_checktime_ms, ulong, 0644);
MODULE_PARM_DESC(zfs_deadman_checktime_ms,
"Dead I/O check interval in milliseconds");
module_param(zfs_deadman_enabled, int, 0644);
MODULE_PARM_DESC(zfs_deadman_enabled, "Enable deadman timer");
module_param_call(zfs_deadman_failmode, param_set_deadman_failmode,
param_get_charp, &zfs_deadman_failmode, 0644);
MODULE_PARM_DESC(zfs_deadman_failmode, "Failmode for deadman timer");
module_param(spa_asize_inflation, int, 0644);
MODULE_PARM_DESC(spa_asize_inflation,
"SPA size estimate multiplication factor");
module_param_call(spa_slop_shift, param_set_slop_shift, param_get_int, module_param_call(spa_slop_shift, param_set_slop_shift, param_get_int,
&spa_slop_shift, 0644); &spa_slop_shift, 0644);
MODULE_PARM_DESC(spa_slop_shift, "Reserved free space in pool"); MODULE_PARM_DESC(spa_slop_shift, "Reserved free space in pool");
module_param(zfs_ddt_data_is_special, int, 0644); module_param_call(zfs_deadman_failmode, param_set_deadman_failmode,
MODULE_PARM_DESC(zfs_ddt_data_is_special, param_get_charp, &zfs_deadman_failmode, 0644);
"Place DDT data into the special class"); MODULE_PARM_DESC(zfs_deadman_failmode, "Failmode for deadman timer");
#endif
module_param(zfs_user_indirect_is_special, int, 0644); /* BEGIN CSTYLED */
MODULE_PARM_DESC(zfs_user_indirect_is_special, ZFS_MODULE_PARAM(zfs, zfs_, special_class_metadata_reserve_pct, INT, ZMOD_RW,
"Place user data indirect blocks into the special class");
module_param(zfs_special_class_metadata_reserve_pct, int, 0644);
MODULE_PARM_DESC(zfs_special_class_metadata_reserve_pct,
"Small file blocks in special vdevs depends on this much " "Small file blocks in special vdevs depends on this much "
"free space available"); "free space available");
/* END CSTYLED */ /* END CSTYLED */
#endif

8
module/zfs/txg.c
View File

@ -1038,7 +1038,6 @@ txg_list_next(txg_list_t *tl, void *p, uint64_t txg)
return (tn == NULL ? NULL : (char *)tn - tl->tl_offset); return (tn == NULL ? NULL : (char *)tn - tl->tl_offset);
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(txg_init); EXPORT_SYMBOL(txg_init);
EXPORT_SYMBOL(txg_fini); EXPORT_SYMBOL(txg_fini);
EXPORT_SYMBOL(txg_sync_start); EXPORT_SYMBOL(txg_sync_start);
@ -1054,6 +1053,7 @@ EXPORT_SYMBOL(txg_wait_callbacks);
EXPORT_SYMBOL(txg_stalled); EXPORT_SYMBOL(txg_stalled);
EXPORT_SYMBOL(txg_sync_waiting); EXPORT_SYMBOL(txg_sync_waiting);
module_param(zfs_txg_timeout, int, 0644); /* BEGIN CSTYLED */
MODULE_PARM_DESC(zfs_txg_timeout, "Max seconds worth of delta per txg"); ZFS_MODULE_PARAM(zfs, zfs_, txg_timeout, INT, ZMOD_RW,
#endif "Max seconds worth of delta per txg");
/* END CSTYLED */

34
module/zfs/vdev.c
View File

@ -4764,7 +4764,6 @@ vdev_xlate(vdev_t *vd, const range_seg_t *logical_rs, range_seg_t *physical_rs)
physical_rs->rs_end = intermediate.rs_end; physical_rs->rs_end = intermediate.rs_end;
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(vdev_fault); EXPORT_SYMBOL(vdev_fault);
EXPORT_SYMBOL(vdev_degrade); EXPORT_SYMBOL(vdev_degrade);
EXPORT_SYMBOL(vdev_online); EXPORT_SYMBOL(vdev_online);
@ -4772,40 +4771,31 @@ EXPORT_SYMBOL(vdev_offline);
EXPORT_SYMBOL(vdev_clear); EXPORT_SYMBOL(vdev_clear);
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(zfs_vdev_default_ms_count, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, default_ms_count, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_default_ms_count,
"Target number of metaslabs per top-level vdev"); "Target number of metaslabs per top-level vdev");
module_param(zfs_vdev_default_ms_shift, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, default_ms_shift, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_default_ms_shift,
"Default limit for metaslab size"); "Default limit for metaslab size");
module_param(zfs_vdev_min_ms_count, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, min_ms_count, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_min_ms_count,
"Minimum number of metaslabs per top-level vdev"); "Minimum number of metaslabs per top-level vdev");
module_param(zfs_vdev_ms_count_limit, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, ms_count_limit, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_ms_count_limit,
"Practical upper limit of total metaslabs per top-level vdev"); "Practical upper limit of total metaslabs per top-level vdev");
module_param(zfs_slow_io_events_per_second, uint, 0644); ZFS_MODULE_PARAM(zfs, zfs_, slow_io_events_per_second, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfs_slow_io_events_per_second,
"Rate limit slow IO (delay) events to this many per second"); "Rate limit slow IO (delay) events to this many per second");
module_param(zfs_checksum_events_per_second, uint, 0644); ZFS_MODULE_PARAM(zfs, zfs_, checksum_events_per_second, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfs_checksum_events_per_second, "Rate limit checksum events " "Rate limit checksum events to this many checksum errors per second "
"to this many checksum errors per second (do not set below zed" "(do not set below zed threshold).");
"threshold).");
module_param(zfs_scan_ignore_errors, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, scan_ignore_errors, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_scan_ignore_errors,
"Ignore errors during resilver/scrub"); "Ignore errors during resilver/scrub");
module_param(vdev_validate_skip, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, vdev_, validate_skip, INT, ZMOD_RW,
MODULE_PARM_DESC(vdev_validate_skip,
"Bypass vdev_validate()"); "Bypass vdev_validate()");
module_param(zfs_nocacheflush, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, nocacheflush, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_nocacheflush, "Disable cache flushes"); "Disable cache flushes");
/* END CSTYLED */ /* END CSTYLED */
#endif

16
module/zfs/vdev_cache.c
View File

@ -425,13 +425,13 @@ vdev_cache_stat_fini(void)
} }
} }
#if defined(_KERNEL) /* BEGIN CSTYLED */
module_param(zfs_vdev_cache_max, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, cache_max, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_cache_max, "Inflate reads small than max"); "Inflate reads small than max");
module_param(zfs_vdev_cache_size, int, 0444); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, cache_size, INT, ZMOD_RD,
MODULE_PARM_DESC(zfs_vdev_cache_size, "Total size of the per-disk cache"); "Total size of the per-disk cache");
module_param(zfs_vdev_cache_bshift, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, cache_bshift, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_cache_bshift, "Shift size to inflate reads too"); "Shift size to inflate reads too");
#endif /* END CSTYLED */

1
module/zfs/vdev_disk.c
View File

@ -34,7 +34,6 @@
#include <sys/abd.h> #include <sys/abd.h>
#include <sys/fs/zfs.h> #include <sys/fs/zfs.h>
#include <sys/zio.h> #include <sys/zio.h>
#include <linux/mod_compat.h>
#include <linux/msdos_fs.h> #include <linux/msdos_fs.h>
#include <linux/vfs_compat.h> #include <linux/vfs_compat.h>

27
module/zfs/vdev_indirect.c
View File

@ -1858,7 +1858,6 @@ vdev_ops_t vdev_indirect_ops = {
.vdev_op_leaf = B_FALSE /* leaf vdev */ .vdev_op_leaf = B_FALSE /* leaf vdev */
}; };
#if defined(_KERNEL)
EXPORT_SYMBOL(rs_alloc); EXPORT_SYMBOL(rs_alloc);
EXPORT_SYMBOL(spa_condense_fini); EXPORT_SYMBOL(spa_condense_fini);
EXPORT_SYMBOL(spa_start_indirect_condensing_thread); EXPORT_SYMBOL(spa_start_indirect_condensing_thread);
@ -1871,25 +1870,21 @@ EXPORT_SYMBOL(vdev_indirect_sync_obsolete);
EXPORT_SYMBOL(vdev_obsolete_counts_are_precise); EXPORT_SYMBOL(vdev_obsolete_counts_are_precise);
EXPORT_SYMBOL(vdev_obsolete_sm_object); EXPORT_SYMBOL(vdev_obsolete_sm_object);
module_param(zfs_condense_indirect_vdevs_enable, int, 0644); /* BEGIN CSTYLED */
MODULE_PARM_DESC(zfs_condense_indirect_vdevs_enable, ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, indirect_vdevs_enable, INT, ZMOD_RW,
"Whether to attempt condensing indirect vdev mappings"); "Whether to attempt condensing indirect vdev mappings");
/* CSTYLED */ ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, min_mapping_bytes, ULONG, ZMOD_RW,
module_param(zfs_condense_min_mapping_bytes, ulong, 0644); "Don't bother condensing if the mapping uses less than this amount of "
MODULE_PARM_DESC(zfs_condense_min_mapping_bytes, "memory");
"Minimum size of vdev mapping to condense");
/* CSTYLED */ ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, max_obsolete_bytes, ULONG, ZMOD_RW,
module_param(zfs_condense_max_obsolete_bytes, ulong, 0644);
MODULE_PARM_DESC(zfs_condense_max_obsolete_bytes,
"Minimum size obsolete spacemap to attempt condensing"); "Minimum size obsolete spacemap to attempt condensing");
module_param(zfs_condense_indirect_commit_entry_delay_ms, int, 0644); ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, indirect_commit_entry_delay_ms, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_condense_indirect_commit_entry_delay_ms, "Used by tests to ensure certain actions happen in the middle of a "
"Delay while condensing vdev mapping"); "condense. A maximum value of 1 should be sufficient.");
module_param(zfs_reconstruct_indirect_combinations_max, int, 0644); ZFS_MODULE_PARAM(zfs_reconstruct, zfs_reconstruct_, indirect_combinations_max, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_reconstruct_indirect_combinations_max,
"Maximum number of combinations when reconstructing split segments"); "Maximum number of combinations when reconstructing split segments");
#endif /* END CSTYLED */

8
module/zfs/vdev_initialize.c
View File

@ -723,15 +723,13 @@ vdev_initialize_restart(vdev_t *vd)
} }
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(vdev_initialize); EXPORT_SYMBOL(vdev_initialize);
EXPORT_SYMBOL(vdev_initialize_stop); EXPORT_SYMBOL(vdev_initialize_stop);
EXPORT_SYMBOL(vdev_initialize_stop_all); EXPORT_SYMBOL(vdev_initialize_stop_all);
EXPORT_SYMBOL(vdev_initialize_stop_wait); EXPORT_SYMBOL(vdev_initialize_stop_wait);
EXPORT_SYMBOL(vdev_initialize_restart); EXPORT_SYMBOL(vdev_initialize_restart);
/* CSTYLED */ /* BEGIN CSTYLED */
module_param(zfs_initialize_value, ulong, 0644); ZFS_MODULE_PARAM(zfs, zfs_, initialize_value, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_initialize_value,
"Value written during zpool initialize"); "Value written during zpool initialize");
#endif /* END CSTYLED */

22
module/zfs/vdev_mirror.c
View File

@ -833,28 +833,20 @@ vdev_ops_t vdev_spare_ops = {
.vdev_op_leaf = B_FALSE /* not a leaf vdev */ .vdev_op_leaf = B_FALSE /* not a leaf vdev */
}; };
#if defined(_KERNEL)
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(zfs_vdev_mirror_rotating_inc, int, 0644); ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_inc, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_mirror_rotating_inc,
"Rotating media load increment for non-seeking I/O's"); "Rotating media load increment for non-seeking I/O's");
module_param(zfs_vdev_mirror_rotating_seek_inc, int, 0644); ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_seek_inc, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_mirror_rotating_seek_inc,
"Rotating media load increment for seeking I/O's"); "Rotating media load increment for seeking I/O's");
module_param(zfs_vdev_mirror_rotating_seek_offset, int, 0644); ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_seek_offset, INT, ZMOD_RW,
"Offset in bytes from the last I/O which triggers "
"a reduced rotating media seek increment");
MODULE_PARM_DESC(zfs_vdev_mirror_rotating_seek_offset, ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, non_rotating_inc, INT, ZMOD_RW,
"Offset in bytes from the last I/O which "
"triggers a reduced rotating media seek increment");
module_param(zfs_vdev_mirror_non_rotating_inc, int, 0644);
MODULE_PARM_DESC(zfs_vdev_mirror_non_rotating_inc,
"Non-rotating media load increment for non-seeking I/O's"); "Non-rotating media load increment for non-seeking I/O's");
module_param(zfs_vdev_mirror_non_rotating_seek_inc, int, 0644); ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, non_rotating_seek_inc, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_mirror_non_rotating_seek_inc,
"Non-rotating media load increment for seeking I/O's"); "Non-rotating media load increment for seeking I/O's");
/* END CSTYLED */ /* END CSTYLED */
#endif

84
module/zfs/vdev_queue.c
View File

@ -952,99 +952,79 @@ vdev_queue_last_offset(vdev_t *vd)
return (vd->vdev_queue.vq_last_offset); return (vd->vdev_queue.vq_last_offset);
} }
#if defined(_KERNEL) /* BEGIN CSTYLED */
module_param(zfs_vdev_aggregation_limit, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, aggregation_limit, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_aggregation_limit, "Max vdev I/O aggregation size"); "Max vdev I/O aggregation size");
module_param(zfs_vdev_aggregation_limit_non_rotating, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, aggregation_limit_non_rotating, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_aggregation_limit_non_rotating,
"Max vdev I/O aggregation size for non-rotating media"); "Max vdev I/O aggregation size for non-rotating media");
module_param(zfs_vdev_aggregate_trim, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, aggregate_trim, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_aggregate_trim, "Allow TRIM I/O to be aggregated"); "Allow TRIM I/O to be aggregated");
module_param(zfs_vdev_read_gap_limit, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, read_gap_limit, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_read_gap_limit, "Aggregate read I/O over gap"); "Aggregate read I/O over gap");
module_param(zfs_vdev_write_gap_limit, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, write_gap_limit, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_write_gap_limit, "Aggregate write I/O over gap"); "Aggregate write I/O over gap");
module_param(zfs_vdev_max_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, max_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_max_active, "Maximum number of active I/Os per vdev"); "Maximum number of active I/Os per vdev");
module_param(zfs_vdev_async_write_active_max_dirty_percent, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_write_active_max_dirty_percent, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_async_write_active_max_dirty_percent,
"Async write concurrency max threshold"); "Async write concurrency max threshold");
module_param(zfs_vdev_async_write_active_min_dirty_percent, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_write_active_min_dirty_percent, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_async_write_active_min_dirty_percent,
"Async write concurrency min threshold"); "Async write concurrency min threshold");
module_param(zfs_vdev_async_read_max_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_read_max_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_async_read_max_active,
"Max active async read I/Os per vdev"); "Max active async read I/Os per vdev");
module_param(zfs_vdev_async_read_min_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_read_min_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_async_read_min_active,
"Min active async read I/Os per vdev"); "Min active async read I/Os per vdev");
module_param(zfs_vdev_async_write_max_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_write_max_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_async_write_max_active,
"Max active async write I/Os per vdev"); "Max active async write I/Os per vdev");
module_param(zfs_vdev_async_write_min_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_write_min_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_async_write_min_active,
"Min active async write I/Os per vdev"); "Min active async write I/Os per vdev");
module_param(zfs_vdev_initializing_max_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, initializing_max_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_initializing_max_active,
"Max active initializing I/Os per vdev"); "Max active initializing I/Os per vdev");
module_param(zfs_vdev_initializing_min_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, initializing_min_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_initializing_min_active,
"Min active initializing I/Os per vdev"); "Min active initializing I/Os per vdev");
module_param(zfs_vdev_removal_max_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, removal_max_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_removal_max_active,
"Max active removal I/Os per vdev"); "Max active removal I/Os per vdev");
module_param(zfs_vdev_removal_min_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, removal_min_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_removal_min_active,
"Min active removal I/Os per vdev"); "Min active removal I/Os per vdev");
module_param(zfs_vdev_scrub_max_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, scrub_max_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_scrub_max_active,
"Max active scrub I/Os per vdev"); "Max active scrub I/Os per vdev");
module_param(zfs_vdev_scrub_min_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, scrub_min_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_scrub_min_active,
"Min active scrub I/Os per vdev"); "Min active scrub I/Os per vdev");
module_param(zfs_vdev_sync_read_max_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, sync_read_max_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_sync_read_max_active,
"Max active sync read I/Os per vdev"); "Max active sync read I/Os per vdev");
module_param(zfs_vdev_sync_read_min_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, sync_read_min_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_sync_read_min_active,
"Min active sync read I/Os per vdev"); "Min active sync read I/Os per vdev");
module_param(zfs_vdev_sync_write_max_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, sync_write_max_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_sync_write_max_active,
"Max active sync write I/Os per vdev"); "Max active sync write I/Os per vdev");
module_param(zfs_vdev_sync_write_min_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, sync_write_min_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_sync_write_min_active,
"Min active sync write I/Os per vdev"); "Min active sync write I/Os per vdev");
module_param(zfs_vdev_trim_max_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, trim_max_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_trim_max_active,
"Max active trim/discard I/Os per vdev"); "Max active trim/discard I/Os per vdev");
module_param(zfs_vdev_trim_min_active, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, trim_min_active, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_trim_min_active,
"Min active trim/discard I/Os per vdev"); "Min active trim/discard I/Os per vdev");
module_param(zfs_vdev_queue_depth_pct, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, queue_depth_pct, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_vdev_queue_depth_pct,
"Queue depth percentage for each top-level vdev"); "Queue depth percentage for each top-level vdev");
#endif /* END CSTYLED */

1
module/zfs/vdev_raidz_math.c
View File

@ -640,7 +640,6 @@ vdev_raidz_impl_set(const char *val)
} }
#if defined(_KERNEL) #if defined(_KERNEL)
#include <linux/mod_compat.h>
static int static int
zfs_vdev_raidz_impl_set(const char *val, zfs_kernel_param_t *kp) zfs_vdev_raidz_impl_set(const char *val, zfs_kernel_param_t *kp)

16
module/zfs/vdev_removal.c
View File

@ -2289,22 +2289,17 @@ spa_removal_get_stats(spa_t *spa, pool_removal_stat_t *prs)
return (0); return (0);
} }
#if defined(_KERNEL) /* BEGIN CSTYLED */
module_param(zfs_removal_ignore_errors, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_, removal_ignore_errors, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_removal_ignore_errors,
"Ignore hard IO errors when removing device"); "Ignore hard IO errors when removing device");
module_param(zfs_remove_max_segment, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, zfs_, remove_max_segment, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_remove_max_segment,
"Largest contiguous segment to allocate when removing device"); "Largest contiguous segment to allocate when removing device");
module_param(vdev_removal_max_span, int, 0644); ZFS_MODULE_PARAM(zfs_vdev, vdev_, removal_max_span, INT, ZMOD_RW,
MODULE_PARM_DESC(vdev_removal_max_span,
"Largest span of free chunks a remap segment can span"); "Largest span of free chunks a remap segment can span");
/* BEGIN CSTYLED */ ZFS_MODULE_PARAM(zfs_vdev, zfs_, removal_suspend_progress, INT, ZMOD_RW,
module_param(zfs_removal_suspend_progress, int, 0644);
MODULE_PARM_DESC(zfs_removal_suspend_progress,
"Pause device removal after this many bytes are copied " "Pause device removal after this many bytes are copied "
"(debug use only - causes removal to hang)"); "(debug use only - causes removal to hang)");
/* END CSTYLED */ /* END CSTYLED */
@ -2318,4 +2313,3 @@ EXPORT_SYMBOL(spa_vdev_remove);
EXPORT_SYMBOL(spa_vdev_remove_cancel); EXPORT_SYMBOL(spa_vdev_remove_cancel);
EXPORT_SYMBOL(spa_vdev_remove_suspend); EXPORT_SYMBOL(spa_vdev_remove_suspend);
EXPORT_SYMBOL(svr_sync); EXPORT_SYMBOL(svr_sync);
#endif

17
module/zfs/vdev_trim.c
View File

@ -1425,7 +1425,6 @@ vdev_autotrim_restart(spa_t *spa)
vdev_autotrim(spa); vdev_autotrim(spa);
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(vdev_trim); EXPORT_SYMBOL(vdev_trim);
EXPORT_SYMBOL(vdev_trim_stop); EXPORT_SYMBOL(vdev_trim_stop);
EXPORT_SYMBOL(vdev_trim_stop_all); EXPORT_SYMBOL(vdev_trim_stop_all);
@ -1437,24 +1436,18 @@ EXPORT_SYMBOL(vdev_autotrim_stop_wait);
EXPORT_SYMBOL(vdev_autotrim_restart); EXPORT_SYMBOL(vdev_autotrim_restart);
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(zfs_trim_extent_bytes_max, uint, 0644); ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, extent_bytes_max, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfs_trim_extent_bytes_max,
"Max size of TRIM commands, larger will be split"); "Max size of TRIM commands, larger will be split");
module_param(zfs_trim_extent_bytes_min, uint, 0644); ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, extent_bytes_min, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfs_trim_extent_bytes_min,
"Min size of TRIM commands, smaller will be skipped"); "Min size of TRIM commands, smaller will be skipped");
module_param(zfs_trim_metaslab_skip, uint, 0644); ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, metaslab_skip, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfs_trim_metaslab_skip,
"Skip metaslabs which have never been initialized"); "Skip metaslabs which have never been initialized");
module_param(zfs_trim_txg_batch, uint, 0644); ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, txg_batch, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfs_trim_txg_batch,
"Min number of txgs to aggregate frees before issuing TRIM"); "Min number of txgs to aggregate frees before issuing TRIM");
module_param(zfs_trim_queue_limit, uint, 0644); ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, queue_limit, UINT, ZMOD_RW,
MODULE_PARM_DESC(zfs_trim_queue_limit,
"Max queued TRIMs outstanding per leaf vdev"); "Max queued TRIMs outstanding per leaf vdev");
/* END CSTYLED */ /* END CSTYLED */
#endif

6
module/zfs/zap.c
View File

@ -1379,11 +1379,7 @@ fzap_get_stats(zap_t *zap, zap_stats_t *zs)
} }
} }
#if defined(_KERNEL)
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(zap_iterate_prefetch, int, 0644); ZFS_MODULE_PARAM(zfs, , zap_iterate_prefetch, INT, ZMOD_RW,
MODULE_PARM_DESC(zap_iterate_prefetch,
"When iterating ZAP object, prefetch it"); "When iterating ZAP object, prefetch it");
/* END CSTYLED */ /* END CSTYLED */
#endif

8
module/zfs/zcp.c
View File

@ -1434,14 +1434,10 @@ zcp_parse_args(lua_State *state, const char *fname, const zcp_arg_t *pargs,
} }
} }
#if defined(_KERNEL)
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(zfs_lua_max_instrlimit, ulong, 0644); ZFS_MODULE_PARAM(zfs_lua, zfs_lua_, max_instrlimit, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_lua_max_instrlimit,
"Max instruction limit that can be specified for a channel program"); "Max instruction limit that can be specified for a channel program");
module_param(zfs_lua_max_memlimit, ulong, 0644); ZFS_MODULE_PARAM(zfs_lua, zfs_lua_, max_memlimit, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_lua_max_memlimit,
"Max memory limit that can be specified for a channel program"); "Max memory limit that can be specified for a channel program");
/* END CSTYLED */ /* END CSTYLED */
#endif

8
module/zfs/zfs_log.c
View File

@ -743,7 +743,7 @@ zfs_log_acl(zilog_t *zilog, dmu_tx_t *tx, znode_t *zp,
zil_itx_assign(zilog, itx, tx); zil_itx_assign(zilog, itx, tx);
} }
#if defined(_KERNEL) /* BEGIN CSTYLED */
module_param(zfs_immediate_write_sz, long, 0644); ZFS_MODULE_PARAM(zfs, zfs_, immediate_write_sz, LONG, ZMOD_RW,
MODULE_PARM_DESC(zfs_immediate_write_sz, "Largest data block to write to zil"); "Largest data block to write to zil");
#endif /* END CSTYLED */

22
module/zfs/zil.c
View File

@ -3643,7 +3643,6 @@ zil_reset(const char *osname, void *arg)
return (0); return (0);
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(zil_alloc); EXPORT_SYMBOL(zil_alloc);
EXPORT_SYMBOL(zil_free); EXPORT_SYMBOL(zil_free);
EXPORT_SYMBOL(zil_open); EXPORT_SYMBOL(zil_open);
@ -3668,19 +3667,18 @@ EXPORT_SYMBOL(zil_set_sync);
EXPORT_SYMBOL(zil_set_logbias); EXPORT_SYMBOL(zil_set_logbias);
/* BEGIN CSTYLED */ /* BEGIN CSTYLED */
module_param(zfs_commit_timeout_pct, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, commit_timeout_pct, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_commit_timeout_pct, "ZIL block open timeout percentage"); "ZIL block open timeout percentage");
module_param(zil_replay_disable, int, 0644); ZFS_MODULE_PARAM(zfs_zil, zil_, replay_disable, INT, ZMOD_RW,
MODULE_PARM_DESC(zil_replay_disable, "Disable intent logging replay"); "Disable intent logging replay");
module_param(zil_nocacheflush, int, 0644); ZFS_MODULE_PARAM(zfs_zil, zil_, nocacheflush, INT, ZMOD_RW,
MODULE_PARM_DESC(zil_nocacheflush, "Disable ZIL cache flushes"); "Disable ZIL cache flushes");
module_param(zil_slog_bulk, ulong, 0644); ZFS_MODULE_PARAM(zfs_zil, zil_, slog_bulk, ULONG, ZMOD_RW,
MODULE_PARM_DESC(zil_slog_bulk, "Limit in bytes slog sync writes per commit"); "Limit in bytes slog sync writes per commit");
module_param(zil_maxblocksize, int, 0644); ZFS_MODULE_PARAM(zfs_zil, zil_, maxblocksize, INT, ZMOD_RW,
MODULE_PARM_DESC(zil_maxblocksize, "Limit in bytes of ZIL log block size"); "Limit in bytes of ZIL log block size");
/* END CSTYLED */ /* END CSTYLED */
#endif

26
module/zfs/zio.c
View File

@ -4842,37 +4842,31 @@ zbookmark_subtree_completed(const dnode_phys_t *dnp,
last_block) <= 0); last_block) <= 0);
} }
#if defined(_KERNEL)
EXPORT_SYMBOL(zio_type_name); EXPORT_SYMBOL(zio_type_name);
EXPORT_SYMBOL(zio_buf_alloc); EXPORT_SYMBOL(zio_buf_alloc);
EXPORT_SYMBOL(zio_data_buf_alloc); EXPORT_SYMBOL(zio_data_buf_alloc);
EXPORT_SYMBOL(zio_buf_free); EXPORT_SYMBOL(zio_buf_free);
EXPORT_SYMBOL(zio_data_buf_free); EXPORT_SYMBOL(zio_data_buf_free);
module_param(zio_slow_io_ms, int, 0644); /* BEGIN CSTYLED */
MODULE_PARM_DESC(zio_slow_io_ms, ZFS_MODULE_PARAM(zfs_zio, zio_, slow_io_ms, INT, ZMOD_RW,
"Max I/O completion time (milliseconds) before marking it as slow"); "Max I/O completion time (milliseconds) before marking it as slow");
module_param(zio_requeue_io_start_cut_in_line, int, 0644); ZFS_MODULE_PARAM(zfs_zio, zio_, requeue_io_start_cut_in_line, INT, ZMOD_RW,
MODULE_PARM_DESC(zio_requeue_io_start_cut_in_line, "Prioritize requeued I/O"); "Prioritize requeued I/O");
module_param(zfs_sync_pass_deferred_free, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_deferred_free, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_sync_pass_deferred_free,
"Defer frees starting in this pass"); "Defer frees starting in this pass");
module_param(zfs_sync_pass_dont_compress, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_dont_compress, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_sync_pass_dont_compress,
"Don't compress starting in this pass"); "Don't compress starting in this pass");
module_param(zfs_sync_pass_rewrite, int, 0644); ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_rewrite, INT, ZMOD_RW,
MODULE_PARM_DESC(zfs_sync_pass_rewrite,
"Rewrite new bps starting in this pass"); "Rewrite new bps starting in this pass");
module_param(zio_dva_throttle_enabled, int, 0644); ZFS_MODULE_PARAM(zfs_zio, zio_, dva_throttle_enabled, INT, ZMOD_RW,
MODULE_PARM_DESC(zio_dva_throttle_enabled,
"Throttle block allocations in the ZIO pipeline"); "Throttle block allocations in the ZIO pipeline");
module_param(zio_deadman_log_all, int, 0644); ZFS_MODULE_PARAM(zfs_zio, zio_, deadman_log_all, INT, ZMOD_RW,
MODULE_PARM_DESC(zio_deadman_log_all,
"Log all slow ZIOs, not just those with vdevs"); "Log all slow ZIOs, not just those with vdevs");
#endif /* END CSTYLED */