diff options
43 files changed, 529 insertions, 645 deletions
diff --git a/include/os/linux/kernel/linux/mod_compat.h b/include/os/linux/kernel/linux/mod_compat.h index 32aea4471..1f19f4b40 100644 --- a/include/os/linux/kernel/linux/mod_compat.h +++ b/include/os/linux/kernel/linux/mod_compat.h @@ -36,4 +36,77 @@ typedef const struct kernel_param zfs_kernel_param_t; typedef struct kernel_param zfs_kernel_param_t; #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 */ diff --git a/include/sys/zfs_context.h b/include/sys/zfs_context.h index 60a248486..a55009f35 100644 --- a/include/sys/zfs_context.h +++ b/include/sys/zfs_context.h @@ -65,6 +65,7 @@ #include <sys/procfs_list.h> #include <linux/dcache_compat.h> #include <linux/utsname_compat.h> +#include <linux/mod_compat.h> #else /* _KERNEL */ @@ -201,6 +202,16 @@ extern int aok; (unsigned long)i) /* + * Tunables. + */ +#define ZFS_MODULE_PARAM(scope_prefix, name_prefix, name, type, perm, desc) + +/* + * Exported symbols + */ +#define EXPORT_SYMBOL(x) + +/* * Threads. */ typedef pthread_t kthread_t; diff --git a/module/zcommon/zfs_namecheck.c b/module/zcommon/zfs_namecheck.c index 1649fd545..b9f704f5f 100644 --- a/module/zcommon/zfs_namecheck.c +++ b/module/zcommon/zfs_namecheck.c @@ -417,7 +417,6 @@ pool_namecheck(const char *pool, namecheck_err_t *why, char *what) return (0); } -#if defined(_KERNEL) EXPORT_SYMBOL(entity_namecheck); EXPORT_SYMBOL(pool_namecheck); EXPORT_SYMBOL(dataset_namecheck); @@ -426,6 +425,5 @@ EXPORT_SYMBOL(dataset_nestcheck); EXPORT_SYMBOL(get_dataset_depth); EXPORT_SYMBOL(zfs_max_dataset_nesting); -module_param(zfs_max_dataset_nesting, int, 0644); -MODULE_PARM_DESC(zfs_max_dataset_nesting, "Maximum depth of nested datasets"); -#endif +ZFS_MODULE_PARAM(zfs, zfs_, max_dataset_nesting, INT, ZMOD_RW, + "Limit to the amount of nesting a path can have. Defaults to 50."); diff --git a/module/zfs/arc.c b/module/zfs/arc.c index 1235074ef..187158955 100644 --- a/module/zfs/arc.c +++ b/module/zfs/arc.c @@ -893,7 +893,8 @@ static arc_state_t *arc_l2c_only; #define arc_tempreserve ARCSTAT(arcstat_tempreserve) #define arc_loaned_bytes ARCSTAT(arcstat_loaned_bytes) #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_max ARCSTAT(arcstat_meta_max) /* max size of metadata */ #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. */ 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_dnode_limit) / sizeof (dnode_t) / + arc_dnode_size_limit) / sizeof (dnode_t) / zfs_arc_dnode_reduce_percent); } @@ -7573,8 +7574,8 @@ arc_tuning_update(void) arc_p = (arc_c >> 1); if (arc_meta_limit > arc_c_max) arc_meta_limit = arc_c_max; - if (arc_dnode_limit > arc_meta_limit) - arc_dnode_limit = arc_meta_limit; + if (arc_dnode_size_limit > arc_meta_limit) + arc_dnode_size_limit = arc_meta_limit; } /* Valid range: 32M - <arc_c_max> */ @@ -7592,8 +7593,8 @@ arc_tuning_update(void) arc_meta_min = zfs_arc_meta_min; if (arc_meta_limit < arc_meta_min) arc_meta_limit = arc_meta_min; - if (arc_dnode_limit < arc_meta_min) - arc_dnode_limit = arc_meta_min; + if (arc_dnode_size_limit < arc_meta_min) + arc_dnode_size_limit = arc_meta_min; } /* Valid range: <arc_meta_min> - <arc_c_max> */ @@ -7607,10 +7608,10 @@ arc_tuning_update(void) /* Valid range: <arc_meta_min> - <arc_meta_limit> */ limit = zfs_arc_dnode_limit ? zfs_arc_dnode_limit : 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_limit)) - arc_dnode_limit = limit; + arc_dnode_size_limit = limit; /* Valid range: 1 - N */ if (zfs_arc_grow_retry) @@ -7840,7 +7841,7 @@ arc_init(void) percent = MIN(zfs_arc_meta_limit_percent, 100); arc_meta_limit = MAX(arc_meta_min, (percent * arc_c_max) / 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 */ arc_tuning_update(); @@ -9376,7 +9377,6 @@ l2arc_stop(void) mutex_exit(&l2arc_feed_thr_lock); } -#if defined(_KERNEL) EXPORT_SYMBOL(arc_buf_size); EXPORT_SYMBOL(arc_write); EXPORT_SYMBOL(arc_read); @@ -9386,104 +9386,96 @@ EXPORT_SYMBOL(arc_add_prune_callback); EXPORT_SYMBOL(arc_remove_prune_callback); /* BEGIN CSTYLED */ -module_param(zfs_arc_min, ulong, 0644); -MODULE_PARM_DESC(zfs_arc_min, "Min arc size"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, min, ULONG, ZMOD_RW, + "Min arc size"); -module_param(zfs_arc_max, ulong, 0644); -MODULE_PARM_DESC(zfs_arc_max, "Max arc size"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, max, ULONG, ZMOD_RW, + "Max arc size"); -module_param(zfs_arc_meta_limit, ulong, 0644); -MODULE_PARM_DESC(zfs_arc_meta_limit, "Meta limit for arc size"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_limit, ULONG, ZMOD_RW, + "Metadata limit for arc size"); -module_param(zfs_arc_meta_limit_percent, ulong, 0644); -MODULE_PARM_DESC(zfs_arc_meta_limit_percent, +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_limit_percent, ULONG, ZMOD_RW, "Percent of arc size for arc meta limit"); -module_param(zfs_arc_meta_min, ulong, 0644); -MODULE_PARM_DESC(zfs_arc_meta_min, "Min arc metadata"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_min, ULONG, ZMOD_RW, + "Min arc metadata"); -module_param(zfs_arc_meta_prune, int, 0644); -MODULE_PARM_DESC(zfs_arc_meta_prune, "Meta objects to scan for prune"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_prune, INT, ZMOD_RW, + "Meta objects to scan for prune"); -module_param(zfs_arc_meta_adjust_restarts, int, 0644); -MODULE_PARM_DESC(zfs_arc_meta_adjust_restarts, +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_adjust_restarts, INT, ZMOD_RW, "Limit number of restarts in arc_adjust_meta"); -module_param(zfs_arc_meta_strategy, int, 0644); -MODULE_PARM_DESC(zfs_arc_meta_strategy, "Meta reclaim strategy"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_strategy, INT, ZMOD_RW, + "Meta reclaim strategy"); -module_param(zfs_arc_grow_retry, int, 0644); -MODULE_PARM_DESC(zfs_arc_grow_retry, "Seconds before growing arc size"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, grow_retry, INT, ZMOD_RW, + "Seconds before growing arc size"); -module_param(zfs_arc_p_dampener_disable, int, 0644); -MODULE_PARM_DESC(zfs_arc_p_dampener_disable, "disable arc_p adapt dampener"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, p_dampener_disable, INT, ZMOD_RW, + "Disable arc_p adapt dampener"); -module_param(zfs_arc_shrink_shift, int, 0644); -MODULE_PARM_DESC(zfs_arc_shrink_shift, "log2(fraction of arc to reclaim)"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, shrink_shift, INT, ZMOD_RW, + "log2(fraction of arc to reclaim)"); -module_param(zfs_arc_pc_percent, uint, 0644); -MODULE_PARM_DESC(zfs_arc_pc_percent, +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, pc_percent, UINT, ZMOD_RW, "Percent of pagecache to reclaim arc to"); -module_param(zfs_arc_p_min_shift, int, 0644); -MODULE_PARM_DESC(zfs_arc_p_min_shift, "arc_c shift to calc min/max arc_p"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, p_min_shift, INT, ZMOD_RW, + "arc_c shift to calc min/max arc_p"); -module_param(zfs_arc_average_blocksize, int, 0444); -MODULE_PARM_DESC(zfs_arc_average_blocksize, "Target average block size"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, average_blocksize, INT, ZMOD_RD, + "Target average block size"); -module_param(zfs_compressed_arc_enabled, int, 0644); -MODULE_PARM_DESC(zfs_compressed_arc_enabled, "Disable compressed arc buffers"); +ZFS_MODULE_PARAM(zfs, zfs_, compressed_arc_enabled, INT, ZMOD_RW, + "Disable compressed arc buffers"); -module_param(zfs_arc_min_prefetch_ms, int, 0644); -MODULE_PARM_DESC(zfs_arc_min_prefetch_ms, "Min life of prefetch block in ms"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, min_prefetch_ms, INT, ZMOD_RW, + "Min life of prefetch block in ms"); -module_param(zfs_arc_min_prescient_prefetch_ms, int, 0644); -MODULE_PARM_DESC(zfs_arc_min_prescient_prefetch_ms, +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, min_prescient_prefetch_ms, INT, ZMOD_RW, "Min life of prescient prefetched block in ms"); -module_param(l2arc_write_max, ulong, 0644); -MODULE_PARM_DESC(l2arc_write_max, "Max write bytes per interval"); +ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, write_max, ULONG, ZMOD_RW, + "Max write bytes per interval"); -module_param(l2arc_write_boost, ulong, 0644); -MODULE_PARM_DESC(l2arc_write_boost, "Extra write bytes during device warmup"); +ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, write_boost, ULONG, ZMOD_RW, + "Extra write bytes during device warmup"); -module_param(l2arc_headroom, ulong, 0644); -MODULE_PARM_DESC(l2arc_headroom, "Number of max device writes to precache"); +ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, headroom, ULONG, ZMOD_RW, + "Number of max device writes to precache"); -module_param(l2arc_headroom_boost, ulong, 0644); -MODULE_PARM_DESC(l2arc_headroom_boost, "Compressed l2arc_headroom multiplier"); +ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, headroom_boost, ULONG, ZMOD_RW, + "Compressed l2arc_headroom multiplier"); -module_param(l2arc_feed_secs, ulong, 0644); -MODULE_PARM_DESC(l2arc_feed_secs, "Seconds between L2ARC writing"); +ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, feed_secs, ULONG, ZMOD_RW, + "Seconds between L2ARC writing"); -module_param(l2arc_feed_min_ms, ulong, 0644); -MODULE_PARM_DESC(l2arc_feed_min_ms, "Min feed interval in milliseconds"); +ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, feed_min_ms, ULONG, ZMOD_RW, + "Min feed interval in milliseconds"); -module_param(l2arc_noprefetch, int, 0644); -MODULE_PARM_DESC(l2arc_noprefetch, "Skip caching prefetched buffers"); +ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, noprefetch, INT, ZMOD_RW, + "Skip caching prefetched buffers"); -module_param(l2arc_feed_again, int, 0644); -MODULE_PARM_DESC(l2arc_feed_again, "Turbo L2ARC warmup"); +ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, feed_again, INT, ZMOD_RW, + "Turbo L2ARC warmup"); -module_param(l2arc_norw, int, 0644); -MODULE_PARM_DESC(l2arc_norw, "No reads during writes"); +ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, norw, INT, ZMOD_RW, + "No reads during writes"); -module_param(zfs_arc_lotsfree_percent, int, 0644); -MODULE_PARM_DESC(zfs_arc_lotsfree_percent, +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, lotsfree_percent, INT, ZMOD_RW, "System free memory I/O throttle in bytes"); -module_param(zfs_arc_sys_free, ulong, 0644); -MODULE_PARM_DESC(zfs_arc_sys_free, "System free memory target size in bytes"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, sys_free, ULONG, ZMOD_RW, + "System free memory target size in bytes"); -module_param(zfs_arc_dnode_limit, ulong, 0644); -MODULE_PARM_DESC(zfs_arc_dnode_limit, "Minimum bytes of dnodes in arc"); +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, dnode_limit, ULONG, ZMOD_RW, + "Minimum bytes of dnodes in arc"); -module_param(zfs_arc_dnode_limit_percent, ulong, 0644); -MODULE_PARM_DESC(zfs_arc_dnode_limit_percent, +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, dnode_limit_percent, ULONG, ZMOD_RW, "Percent of ARC meta buffers for dnodes"); -module_param(zfs_arc_dnode_reduce_percent, ulong, 0644); -MODULE_PARM_DESC(zfs_arc_dnode_reduce_percent, +ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, dnode_reduce_percent, ULONG, ZMOD_RW, "Percentage of excess dnodes to try to unpin"); /* END CSTYLED */ -#endif diff --git a/module/zfs/dbuf.c b/module/zfs/dbuf.c index c3127ee0e..dd33ae97c 100644 --- a/module/zfs/dbuf.c +++ b/module/zfs/dbuf.c @@ -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_is_metadata); EXPORT_SYMBOL(dbuf_destroy); @@ -4795,31 +4794,24 @@ EXPORT_SYMBOL(dmu_buf_get_user); EXPORT_SYMBOL(dmu_buf_get_blkptr); /* BEGIN CSTYLED */ -module_param(dbuf_cache_max_bytes, ulong, 0644); -MODULE_PARM_DESC(dbuf_cache_max_bytes, +ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, max_bytes, ULONG, ZMOD_RW, "Maximum size in bytes of the dbuf cache."); -module_param(dbuf_cache_hiwater_pct, uint, 0644); -MODULE_PARM_DESC(dbuf_cache_hiwater_pct, +ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, hiwater_pct, UINT, ZMOD_RW, "Percentage over dbuf_cache_max_bytes when dbufs must be evicted " "directly."); -module_param(dbuf_cache_lowater_pct, uint, 0644); -MODULE_PARM_DESC(dbuf_cache_lowater_pct, +ZFS_MODULE_PARAM(zfs_dbuf_cache, dbuf_cache_, lowater_pct, UINT, ZMOD_RW, "Percentage below dbuf_cache_max_bytes when the evict thread stops " "evicting dbufs."); -module_param(dbuf_metadata_cache_max_bytes, ulong, 0644); -MODULE_PARM_DESC(dbuf_metadata_cache_max_bytes, +ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, metadata_cache_max_bytes, ULONG, ZMOD_RW, "Maximum size in bytes of the dbuf metadata cache."); -module_param(dbuf_cache_shift, int, 0644); -MODULE_PARM_DESC(dbuf_cache_shift, +ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, cache_shift, INT, ZMOD_RW, "Set the size of the dbuf cache to a log2 fraction of arc size."); -module_param(dbuf_metadata_cache_shift, int, 0644); -MODULE_PARM_DESC(dbuf_cache_shift, - "Set the size of the dbuf metadata cache to a log2 fraction of " - "arc size."); +ZFS_MODULE_PARAM(zfs_dbuf, dbuf_, metadata_cache_shift, INT, ZMOD_RW, + "Set the size of the dbuf metadata cache to a log2 fraction of arc " + "size."); /* END CSTYLED */ -#endif diff --git a/module/zfs/dbuf_stats.c b/module/zfs/dbuf_stats.c index afe7c34cf..b652d2a24 100644 --- a/module/zfs/dbuf_stats.c +++ b/module/zfs/dbuf_stats.c @@ -225,7 +225,7 @@ dbuf_stats_destroy(void) dbuf_stats_hash_table_destroy(); } -#if defined(_KERNEL) -module_param(zfs_dbuf_state_index, int, 0644); -MODULE_PARM_DESC(zfs_dbuf_state_index, "Calculate arc header index"); -#endif +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs, zfs_, dbuf_state_index, INT, ZMOD_RW, + "Calculate arc header index"); +/* END CSTYLED */ diff --git a/module/zfs/ddt.c b/module/zfs/ddt.c index 05424d875..a0f90496a 100644 --- a/module/zfs/ddt.c +++ b/module/zfs/ddt.c @@ -1187,7 +1187,7 @@ ddt_walk(spa_t *spa, ddt_bookmark_t *ddb, ddt_entry_t *dde) return (SET_ERROR(ENOENT)); } -#if defined(_KERNEL) -module_param(zfs_dedup_prefetch, int, 0644); -MODULE_PARM_DESC(zfs_dedup_prefetch, "Enable prefetching dedup-ed blks"); -#endif +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs, zfs_, dedup_prefetch, INT, ZMOD_RW, + "Enable prefetching dedup-ed blks"); +/* END CSTYLED */ diff --git a/module/zfs/dmu.c b/module/zfs/dmu.c index c7ddbcba7..861858e3a 100644 --- a/module/zfs/dmu.c +++ b/module/zfs/dmu.c @@ -2474,7 +2474,6 @@ dmu_fini(void) abd_fini(); } -#if defined(_KERNEL) EXPORT_SYMBOL(dmu_bonus_hold); EXPORT_SYMBOL(dmu_bonus_hold_by_dnode); EXPORT_SYMBOL(dmu_buf_hold_array_by_bonus); @@ -2508,21 +2507,15 @@ EXPORT_SYMBOL(dmu_buf_hold); EXPORT_SYMBOL(dmu_ot); /* BEGIN CSTYLED */ -module_param(zfs_nopwrite_enabled, int, 0644); -MODULE_PARM_DESC(zfs_nopwrite_enabled, "Enable NOP writes"); +ZFS_MODULE_PARAM(zfs, zfs_, nopwrite_enabled, INT, ZMOD_RW, + "Enable NOP writes"); -module_param(zfs_per_txg_dirty_frees_percent, ulong, 0644); -MODULE_PARM_DESC(zfs_per_txg_dirty_frees_percent, - "percentage of dirtied blocks from frees in one TXG"); +ZFS_MODULE_PARAM(zfs, zfs_, per_txg_dirty_frees_percent, ULONG, ZMOD_RW, + "Percentage of dirtied blocks from frees in one TXG"); -module_param(zfs_dmu_offset_next_sync, int, 0644); -MODULE_PARM_DESC(zfs_dmu_offset_next_sync, +ZFS_MODULE_PARAM(zfs, zfs_, dmu_offset_next_sync, INT, ZMOD_RW, "Enable forcing txg sync to find holes"); -module_param(dmu_prefetch_max, int, 0644); -MODULE_PARM_DESC(dmu_prefetch_max, +ZFS_MODULE_PARAM(zfs, , dmu_prefetch_max, INT, ZMOD_RW, "Limit one prefetch call to this size"); - /* END CSTYLED */ - -#endif diff --git a/module/zfs/dmu_object.c b/module/zfs/dmu_object.c index ec78ebbdc..be4eba91c 100644 --- a/module/zfs/dmu_object.c +++ b/module/zfs/dmu_object.c @@ -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)); } -#if defined(_KERNEL) EXPORT_SYMBOL(dmu_object_alloc); EXPORT_SYMBOL(dmu_object_alloc_ibs); EXPORT_SYMBOL(dmu_object_alloc_dnsize); @@ -520,8 +519,6 @@ EXPORT_SYMBOL(dmu_object_zapify); EXPORT_SYMBOL(dmu_object_free_zapified); /* BEGIN CSTYLED */ -module_param(dmu_object_alloc_chunk_shift, int, 0644); -MODULE_PARM_DESC(dmu_object_alloc_chunk_shift, +ZFS_MODULE_PARAM(zfs, , dmu_object_alloc_chunk_shift, INT, ZMOD_RW, "CPU-specific allocator grabs 2^N objects at once"); /* END CSTYLED */ -#endif diff --git a/module/zfs/dmu_recv.c b/module/zfs/dmu_recv.c index 49b8c0acf..ac27c98be 100644 --- a/module/zfs/dmu_recv.c +++ b/module/zfs/dmu_recv.c @@ -3201,10 +3201,10 @@ dmu_objset_is_receiving(objset_t *os) os->os_dsl_dataset->ds_owner == dmu_recv_tag); } -#if defined(_KERNEL) -module_param(zfs_recv_queue_length, int, 0644); -MODULE_PARM_DESC(zfs_recv_queue_length, "Maximum receive queue length"); +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, queue_length, INT, ZMOD_RW, + "Maximum receive queue length"); -module_param(zfs_recv_queue_ff, int, 0644); -MODULE_PARM_DESC(zfs_recv_queue_ff, "Receive queue fill fraction"); -#endif +ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, queue_ff, INT, ZMOD_RW, + "Receive queue fill fraction"); +/* END CSTYLED */ diff --git a/module/zfs/dmu_send.c b/module/zfs/dmu_send.c index 39f6883ff..42116a1c3 100644 --- a/module/zfs/dmu_send.c +++ b/module/zfs/dmu_send.c @@ -2925,29 +2925,25 @@ dmu_send_estimate_fast(dsl_dataset_t *ds, dsl_dataset_t *fromds, return (err); } -#if defined(_KERNEL) -module_param(zfs_send_corrupt_data, int, 0644); -MODULE_PARM_DESC(zfs_send_corrupt_data, "Allow sending corrupt data"); +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs_send, zfs_send_, corrupt_data, INT, ZMOD_RW, + "Allow sending corrupt data"); -module_param(zfs_send_queue_length, int, 0644); -MODULE_PARM_DESC(zfs_send_queue_length, "Maximum send queue length"); +ZFS_MODULE_PARAM(zfs_send, zfs_send_, queue_length, INT, ZMOD_RW, + "Maximum send queue length"); -module_param(zfs_send_unmodified_spill_blocks, int, 0644); -MODULE_PARM_DESC(zfs_send_unmodified_spill_blocks, +ZFS_MODULE_PARAM(zfs_send, zfs_send_, unmodified_spill_blocks, INT, ZMOD_RW, "Send unmodified spill blocks"); -module_param(zfs_send_no_prefetch_queue_length, int, 0644); -MODULE_PARM_DESC(zfs_send_no_prefetch_queue_length, +ZFS_MODULE_PARAM(zfs_send, zfs_send_, no_prefetch_queue_length, INT, ZMOD_RW, "Maximum send queue length for non-prefetch queues"); -module_param(zfs_send_queue_ff, int, 0644); -MODULE_PARM_DESC(zfs_send_queue_ff, "Send queue fill fraction"); +ZFS_MODULE_PARAM(zfs_send, zfs_send_, queue_ff, INT, ZMOD_RW, + "Send queue fill fraction"); -module_param(zfs_send_no_prefetch_queue_ff, int, 0644); -MODULE_PARM_DESC(zfs_send_no_prefetch_queue_ff, +ZFS_MODULE_PARAM(zfs_send, zfs_send_, no_prefetch_queue_ff, INT, ZMOD_RW, "Send queue fill fraction for non-prefetch queues"); -module_param(zfs_override_estimate_recordsize, int, 0644); -MODULE_PARM_DESC(zfs_override_estimate_recordsize, +ZFS_MODULE_PARAM(zfs_send, zfs_, override_estimate_recordsize, INT, ZMOD_RW, "Override block size estimate with fixed size"); -#endif +/* END CSTYLED */ diff --git a/module/zfs/dmu_traverse.c b/module/zfs/dmu_traverse.c index 2a74d569a..83830fe39 100644 --- a/module/zfs/dmu_traverse.c +++ b/module/zfs/dmu_traverse.c @@ -768,18 +768,19 @@ traverse_pool(spa_t *spa, uint64_t txg_start, int flags, return (err); } -#if defined(_KERNEL) EXPORT_SYMBOL(traverse_dataset); EXPORT_SYMBOL(traverse_pool); -module_param(zfs_pd_bytes_max, int, 0644); -MODULE_PARM_DESC(zfs_pd_bytes_max, "Max number of bytes to prefetch"); +/* BEGIN CSTYLED */ +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_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"); +#endif -module_param_named(send_holes_without_birth_time, - send_holes_without_birth_time, int, 0644); -MODULE_PARM_DESC(send_holes_without_birth_time, +ZFS_MODULE_PARAM(zfs, , send_holes_without_birth_time, INT, ZMOD_RW, "Ignore hole_birth txg for zfs send"); -#endif +/* END CSTYLED */ diff --git a/module/zfs/dmu_zfetch.c b/module/zfs/dmu_zfetch.c index b99106ae7..5935b5f99 100644 --- a/module/zfs/dmu_zfetch.c +++ b/module/zfs/dmu_zfetch.c @@ -366,22 +366,19 @@ dmu_zfetch(zfetch_t *zf, uint64_t blkid, uint64_t nblks, boolean_t fetch_data, ZFETCHSTAT_BUMP(zfetchstat_hits); } -#if defined(_KERNEL) /* BEGIN CSTYLED */ -module_param(zfs_prefetch_disable, int, 0644); -MODULE_PARM_DESC(zfs_prefetch_disable, "Disable all ZFS prefetching"); +ZFS_MODULE_PARAM(zfs_prefetch, zfs_prefetch_, disable, INT, ZMOD_RW, + "Disable all ZFS prefetching"); -module_param(zfetch_max_streams, uint, 0644); -MODULE_PARM_DESC(zfetch_max_streams, "Max number of streams per zfetch"); +ZFS_MODULE_PARAM(zfs_prefetch, zfetch_, max_streams, UINT, ZMOD_RW, + "Max number of streams per zfetch"); -module_param(zfetch_min_sec_reap, uint, 0644); -MODULE_PARM_DESC(zfetch_min_sec_reap, "Min time before stream reclaim"); +ZFS_MODULE_PARAM(zfs_prefetch, zfetch_, min_sec_reap, UINT, ZMOD_RW, + "Min time before stream reclaim"); -module_param(zfetch_max_distance, uint, 0644); -MODULE_PARM_DESC(zfetch_max_distance, +ZFS_MODULE_PARAM(zfs_prefetch, zfetch_, max_distance, UINT, ZMOD_RW, "Max bytes to prefetch per stream (default 8MB)"); -module_param(zfetch_array_rd_sz, ulong, 0644); -MODULE_PARM_DESC(zfetch_array_rd_sz, "Number of bytes in a array_read"); +ZFS_MODULE_PARAM(zfs_prefetch, zfetch_, array_rd_sz, ULONG, ZMOD_RW, + "Number of bytes in a array_read"); /* END CSTYLED */ -#endif diff --git a/module/zfs/dsl_dataset.c b/module/zfs/dsl_dataset.c index 8c5e6cb5c..ba24e499b 100644 --- a/module/zfs/dsl_dataset.c +++ b/module/zfs/dsl_dataset.c @@ -4872,20 +4872,19 @@ dsl_dataset_activate_redaction(dsl_dataset_t *ds, uint64_t *redact_snaps, ds->ds_feature[SPA_FEATURE_REDACTED_DATASETS] = ftuaa; } - -#if defined(_KERNEL) +/* BEGIN CSTYLED */ #if defined(_LP64) -module_param(zfs_max_recordsize, int, 0644); -MODULE_PARM_DESC(zfs_max_recordsize, "Max allowed record size"); +#define RECORDSIZE_PERM ZMOD_RW #else /* Limited to 1M on 32-bit platforms due to lack of virtual address space */ -module_param(zfs_max_recordsize, int, 0444); -MODULE_PARM_DESC(zfs_max_recordsize, "Max allowed record size"); +#define RECORDSIZE_PERM ZMOD_RD #endif +ZFS_MODULE_PARAM(zfs, zfs_, max_recordsize, INT, RECORDSIZE_PERM, + "Max allowed record size"); -module_param(zfs_allow_redacted_dataset_mount, int, 0644); -MODULE_PARM_DESC(zfs_allow_redacted_dataset_mount, +ZFS_MODULE_PARAM(zfs, zfs_, allow_redacted_dataset_mount, INT, ZMOD_RW, "Allow mounting of redacted datasets"); +/* END CSTYLED */ EXPORT_SYMBOL(dsl_dataset_hold); 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_clone_swap_check_impl); EXPORT_SYMBOL(dsl_dataset_clone_swap_sync_impl); -#endif diff --git a/module/zfs/dsl_deadlist.c b/module/zfs/dsl_deadlist.c index 15a59315c..2e4d18ade 100644 --- a/module/zfs/dsl_deadlist.c +++ b/module/zfs/dsl_deadlist.c @@ -996,13 +996,10 @@ dsl_process_sub_livelist(bpobj_t *bpobj, bplist_t *to_free, zthr_t *t, return (err); } -#if defined(_KERNEL) -/* CSTYLED */ -module_param(zfs_livelist_max_entries, ulong, 0644); -MODULE_PARM_DESC(zfs_livelist_max_entries, +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs_livelist, zfs_livelist_, max_entries, ULONG, ZMOD_RW, "Size to start the next sub-livelist in a livelist"); -module_param(zfs_livelist_min_percent_shared, int, 0644); -MODULE_PARM_DESC(zfs_livelist_min_percent_shared, +ZFS_MODULE_PARAM(zfs_livelist, zfs_livelist_, min_percent_shared, INT, ZMOD_RW, "Threshold at which livelist is disabled"); -#endif +/* END CSTYLED */ diff --git a/module/zfs/dsl_pool.c b/module/zfs/dsl_pool.c index 1f1fd6462..09045bb47 100644 --- a/module/zfs/dsl_pool.c +++ b/module/zfs/dsl_pool.c @@ -1342,53 +1342,43 @@ dsl_pool_config_held_writer(dsl_pool_t *dp) return (RRW_WRITE_HELD(&dp->dp_config_rwlock)); } -#if defined(_KERNEL) EXPORT_SYMBOL(dsl_pool_config_enter); EXPORT_SYMBOL(dsl_pool_config_exit); /* BEGIN CSTYLED */ /* zfs_dirty_data_max_percent only applied at module load in arc_init(). */ -module_param(zfs_dirty_data_max_percent, int, 0444); -MODULE_PARM_DESC(zfs_dirty_data_max_percent, "percent of ram can be dirty"); +ZFS_MODULE_PARAM(zfs, zfs_, dirty_data_max_percent, INT, ZMOD_RD, + "Max percent of RAM allowed to be dirty"); /* zfs_dirty_data_max_max_percent only applied at module load in arc_init(). */ -module_param(zfs_dirty_data_max_max_percent, int, 0444); -MODULE_PARM_DESC(zfs_dirty_data_max_max_percent, +ZFS_MODULE_PARAM(zfs, zfs_, dirty_data_max_max_percent, INT, ZMOD_RD, "zfs_dirty_data_max upper bound as % of RAM"); -module_param(zfs_delay_min_dirty_percent, int, 0644); -MODULE_PARM_DESC(zfs_delay_min_dirty_percent, "transaction delay threshold"); +ZFS_MODULE_PARAM(zfs, zfs_, delay_min_dirty_percent, INT, ZMOD_RW, + "Transaction delay threshold"); -module_param(zfs_dirty_data_max, ulong, 0644); -MODULE_PARM_DESC(zfs_dirty_data_max, "determines the dirty space limit"); +ZFS_MODULE_PARAM(zfs, zfs_, dirty_data_max, ULONG, ZMOD_RW, + "Determines the dirty space limit"); /* zfs_dirty_data_max_max only applied at module load in arc_init(). */ -module_param(zfs_dirty_data_max_max, ulong, 0444); -MODULE_PARM_DESC(zfs_dirty_data_max_max, +ZFS_MODULE_PARAM(zfs, zfs_, dirty_data_max_max, ULONG, ZMOD_RD, "zfs_dirty_data_max upper bound in bytes"); -module_param(zfs_dirty_data_sync_percent, int, 0644); -MODULE_PARM_DESC(zfs_dirty_data_sync_percent, - "dirty data txg sync threshold as a percentage of zfs_dirty_data_max"); +ZFS_MODULE_PARAM(zfs, zfs_, dirty_data_sync_percent, INT, ZMOD_RW, + "Dirty data txg sync threshold as a percentage of zfs_dirty_data_max"); -module_param(zfs_delay_scale, ulong, 0644); -MODULE_PARM_DESC(zfs_delay_scale, "how quickly delay approaches infinity"); +ZFS_MODULE_PARAM(zfs, zfs_, delay_scale, ULONG, ZMOD_RW, + "How quickly delay approaches infinity"); -module_param(zfs_sync_taskq_batch_pct, int, 0644); -MODULE_PARM_DESC(zfs_sync_taskq_batch_pct, - "max percent of CPUs that are used to sync dirty data"); +ZFS_MODULE_PARAM(zfs, zfs_, sync_taskq_batch_pct, INT, ZMOD_RW, + "Max percent of CPUs that are used to sync dirty data"); -module_param(zfs_zil_clean_taskq_nthr_pct, int, 0644); -MODULE_PARM_DESC(zfs_zil_clean_taskq_nthr_pct, - "max percent of CPUs that are used per dp_sync_taskq"); +ZFS_MODULE_PARAM(zfs_zil, zfs_zil_, clean_taskq_nthr_pct, INT, ZMOD_RW, + "Max percent of CPUs that are used per dp_sync_taskq"); -module_param(zfs_zil_clean_taskq_minalloc, int, 0644); -MODULE_PARM_DESC(zfs_zil_clean_taskq_minalloc, - "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_minalloc, INT, ZMOD_RW, + "Number of taskq entries that are pre-populated"); +ZFS_MODULE_PARAM(zfs_zil, zfs_zil_, clean_taskq_maxalloc, INT, ZMOD_RW, + "Max number of taskq entries that are cached"); /* END CSTYLED */ -#endif diff --git a/module/zfs/dsl_scan.c b/module/zfs/dsl_scan.c index 1becd4d55..160bc8ff3 100644 --- a/module/zfs/dsl_scan.c +++ b/module/zfs/dsl_scan.c @@ -4205,74 +4205,62 @@ dsl_scan_freed(spa_t *spa, const blkptr_t *bp) dsl_scan_freed_dva(spa, bp, i); } -#if defined(_KERNEL) -/* CSTYLED */ -module_param(zfs_scan_vdev_limit, ulong, 0644); -MODULE_PARM_DESC(zfs_scan_vdev_limit, +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs, zfs_, scan_vdev_limit, ULONG, ZMOD_RW, "Max bytes in flight per leaf vdev for scrubs and resilvers"); -module_param(zfs_scrub_min_time_ms, int, 0644); -MODULE_PARM_DESC(zfs_scrub_min_time_ms, "Min millisecs to scrub per txg"); +ZFS_MODULE_PARAM(zfs, zfs_, scrub_min_time_ms, INT, ZMOD_RW, + "Min millisecs to scrub per txg"); -module_param(zfs_obsolete_min_time_ms, int, 0644); -MODULE_PARM_DESC(zfs_obsolete_min_time_ms, "Min millisecs to obsolete per txg"); +ZFS_MODULE_PARAM(zfs, zfs_, obsolete_min_time_ms, INT, ZMOD_RW, + "Min millisecs to obsolete per txg"); -module_param(zfs_free_min_time_ms, int, 0644); -MODULE_PARM_DESC(zfs_free_min_time_ms, "Min millisecs to free per txg"); +ZFS_MODULE_PARAM(zfs, zfs_, free_min_time_ms, INT, ZMOD_RW, + "Min millisecs to free per txg"); -module_param(zfs_resilver_min_time_ms, int, 0644); -MODULE_PARM_DESC(zfs_resilver_min_time_ms, "Min millisecs to resilver per txg"); +ZFS_MODULE_PARAM(zfs, zfs_, resilver_min_time_ms, INT, ZMOD_RW, + "Min millisecs to resilver per txg"); -module_param(zfs_scan_suspend_progress, int, 0644); -MODULE_PARM_DESC(zfs_scan_suspend_progress, +ZFS_MODULE_PARAM(zfs, zfs_, scan_suspend_progress, INT, ZMOD_RW, "Set to prevent scans from progressing"); -module_param(zfs_no_scrub_io, int, 0644); -MODULE_PARM_DESC(zfs_no_scrub_io, "Set to disable scrub I/O"); +ZFS_MODULE_PARAM(zfs, zfs_, no_scrub_io, INT, ZMOD_RW, + "Set to disable scrub I/O"); -module_param(zfs_no_scrub_prefetch, int, 0644); -MODULE_PARM_DESC(zfs_no_scrub_prefetch, "Set to disable scrub prefetching"); +ZFS_MODULE_PARAM(zfs, zfs_, no_scrub_prefetch, INT, ZMOD_RW, + "Set to disable scrub prefetching"); -/* CSTYLED */ -module_param(zfs_async_block_max_blocks, ulong, 0644); -MODULE_PARM_DESC(zfs_async_block_max_blocks, +ZFS_MODULE_PARAM(zfs, zfs_, async_block_max_blocks, ULONG, ZMOD_RW, "Max number of blocks freed in one txg"); -module_param(zfs_free_bpobj_enabled, int, 0644); -MODULE_PARM_DESC(zfs_free_bpobj_enabled, "Enable processing of the free_bpobj"); +ZFS_MODULE_PARAM(zfs, zfs_, free_bpobj_enabled, INT, ZMOD_RW, + "Enable processing of the free_bpobj"); -module_param(zfs_scan_mem_lim_fact, int, 0644); -MODULE_PARM_DESC(zfs_scan_mem_lim_fact, "Fraction of RAM for scan hard limit"); +ZFS_MODULE_PARAM(zfs, zfs_, scan_mem_lim_fact, INT, ZMOD_RW, + "Fraction of RAM for scan hard limit"); -module_param(zfs_scan_issue_strategy, int, 0644); -MODULE_PARM_DESC(zfs_scan_issue_strategy, - "IO issuing strategy during scrubbing. 0 = default, 1 = LBA, 2 = size"); +ZFS_MODULE_PARAM(zfs, zfs_, scan_issue_strategy, INT, ZMOD_RW, + "IO issuing strategy during scrubbing. " + "0 = default, 1 = LBA, 2 = size"); -module_param(zfs_scan_legacy, int, 0644); -MODULE_PARM_DESC(zfs_scan_legacy, "Scrub using legacy non-sequential method"); +ZFS_MODULE_PARAM(zfs, zfs_, scan_legacy, INT, ZMOD_RW, + "Scrub using legacy non-sequential method"); -module_param(zfs_scan_checkpoint_intval, int, 0644); -MODULE_PARM_DESC(zfs_scan_checkpoint_intval, +ZFS_MODULE_PARAM(zfs, zfs_, scan_checkpoint_intval, INT, ZMOD_RW, "Scan progress on-disk checkpointing interval"); -/* CSTYLED */ -module_param(zfs_scan_max_ext_gap, ulong, 0644); -MODULE_PARM_DESC(zfs_scan_max_ext_gap, +ZFS_MODULE_PARAM(zfs, zfs_, scan_max_ext_gap, ULONG, ZMOD_RW, "Max gap in bytes between sequential scrub / resilver I/Os"); -module_param(zfs_scan_mem_lim_soft_fact, int, 0644); -MODULE_PARM_DESC(zfs_scan_mem_lim_soft_fact, +ZFS_MODULE_PARAM(zfs, zfs_, scan_mem_lim_soft_fact, INT, ZMOD_RW, "Fraction of hard limit used as soft limit"); -module_param(zfs_scan_strict_mem_lim, int, 0644); -MODULE_PARM_DESC(zfs_scan_strict_mem_lim, +ZFS_MODULE_PARAM(zfs, zfs_, scan_strict_mem_lim, INT, ZMOD_RW, "Tunable to attempt to reduce lock contention"); -module_param(zfs_scan_fill_weight, int, 0644); -MODULE_PARM_DESC(zfs_scan_fill_weight, +ZFS_MODULE_PARAM(zfs, zfs_, scan_fill_weight, INT, ZMOD_RW, "Tunable to adjust bias towards more filled segments during scans"); -module_param(zfs_resilver_disable_defer, int, 0644); -MODULE_PARM_DESC(zfs_resilver_disable_defer, +ZFS_MODULE_PARAM(zfs, zfs_, resilver_disable_defer, INT, ZMOD_RW, "Process all resilvers immediately"); -#endif +/* END CSTYLED */ diff --git a/module/zfs/metaslab.c b/module/zfs/metaslab.c index bbc7d8a69..d4dacbc2f 100644 --- a/module/zfs/metaslab.c +++ b/module/zfs/metaslab.c @@ -5868,83 +5868,64 @@ metaslab_unflushed_txg(metaslab_t *ms) return (ms->ms_unflushed_txg); } -#if defined(_KERNEL) -/* BEGIN CSTYLED */ -module_param(metaslab_aliquot, ulong, 0644); -MODULE_PARM_DESC(metaslab_aliquot, - "allocation granularity (a.k.a. stripe size)"); - -module_param(metaslab_debug_load, int, 0644); -MODULE_PARM_DESC(metaslab_debug_load, - "load all metaslabs when pool is first opened"); +ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, aliquot, ULONG, ZMOD_RW, + "Allocation granularity (a.k.a. stripe size)"); -module_param(metaslab_debug_unload, int, 0644); -MODULE_PARM_DESC(metaslab_debug_unload, - "prevent metaslabs from being unloaded"); +ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, debug_load, INT, ZMOD_RW, + "Load all metaslabs when pool is first opened"); -module_param(metaslab_preload_enabled, int, 0644); -MODULE_PARM_DESC(metaslab_preload_enabled, - "preload potential metaslabs during reassessment"); +ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, debug_unload, INT, ZMOD_RW, + "Prevent metaslabs from being unloaded"); -module_param(metaslab_unload_delay, int, 0644); -MODULE_PARM_DESC(metaslab_unload_delay, - "delay in txgs after metaslab was last used before unloading"); +ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, preload_enabled, INT, ZMOD_RW, + "Preload potential metaslabs during reassessment"); -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"); +ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, unload_delay, INT, ZMOD_RW, + "Delay in txgs 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"); +ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, unload_delay_ms, INT, ZMOD_RW, + "Delay in milliseconds after metaslab was last used before unloading"); -module_param(zfs_mg_fragmentation_threshold, int, 0644); -MODULE_PARM_DESC(zfs_mg_fragmentation_threshold, - "fragmentation for metaslab group to allow allocation"); +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs_mg, zfs_mg_, noalloc_threshold, INT, ZMOD_RW, + "Percentage of metaslab group size that should be free to make it " + "eligible for allocation"); -module_param(zfs_metaslab_fragmentation_threshold, int, 0644); -MODULE_PARM_DESC(zfs_metaslab_fragmentation_threshold, - "fragmentation for metaslab to allow allocation"); +ZFS_MODULE_PARAM(zfs_mg, zfs_mg_, fragmentation_threshold, INT, ZMOD_RW, + "Percentage of metaslab group size that should be considered eligible " + "for allocations unless all metaslab groups within the metaslab class " + "have also crossed this threshold"); -module_param(metaslab_fragmentation_factor_enabled, int, 0644); -MODULE_PARM_DESC(metaslab_fragmentation_factor_enabled, - "use the fragmentation metric to prefer less fragmented metaslabs"); +ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, fragmentation_threshold, INT, + ZMOD_RW, "Fragmentation for metaslab to allow allocation"); -module_param(metaslab_lba_weighting_enabled, int, 0644); -MODULE_PARM_DESC(metaslab_lba_weighting_enabled, - "prefer metaslabs with lower LBAs"); +ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, fragmentation_factor_enabled, INT, ZMOD_RW, + "Use the fragmentation metric to prefer less fragmented metaslabs"); +/* END CSTYLED */ -module_param(metaslab_bias_enabled, int, 0644); -MODULE_PARM_DESC(metaslab_bias_enabled, - "enable metaslab group biasing"); +ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, lba_weighting_enabled, INT, ZMOD_RW, + "Prefer metaslabs with lower LBAs"); -module_param(zfs_metaslab_segment_weight_enabled, int, 0644); -MODULE_PARM_DESC(zfs_metaslab_segment_weight_enabled, - "enable segment-based metaslab selection"); +ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, bias_enabled, INT, ZMOD_RW, + "Enable metaslab group biasing"); -module_param(zfs_metaslab_switch_threshold, int, 0644); -MODULE_PARM_DESC(zfs_metaslab_switch_threshold, - "segment-based metaslab selection maximum buckets before switching"); +ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, segment_weight_enabled, INT, + ZMOD_RW, "Enable segment-based metaslab selection"); -module_param(metaslab_force_ganging, ulong, 0644); -MODULE_PARM_DESC(metaslab_force_ganging, - "blocks larger than this size are forced to be gang blocks"); +ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, switch_threshold, INT, ZMOD_RW, + "Segment-based metaslab selection maximum buckets before switching"); -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"); +ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, force_ganging, ULONG, ZMOD_RW, + "Blocks larger than this size are forced to be gang blocks"); -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"); +ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, df_max_search, INT, ZMOD_RW, + "Max distance (bytes) to search forward before using size tree"); -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"); +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"); -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 */ +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"); -#endif +ZFS_MODULE_PARAM(zfs_metaslab, zfs_metaslab_, mem_limit, INT, ZMOD_RW, + "Percentage of memory that can be used to store metaslab range trees"); diff --git a/module/zfs/mmp.c b/module/zfs/mmp.c index 810d20fdd..ae8d6b1a0 100644 --- a/module/zfs/mmp.c +++ b/module/zfs/mmp.c @@ -717,7 +717,6 @@ mmp_signal_all_threads(void) } #if defined(_KERNEL) -#include <linux/mod_compat.h> static int 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); } -/* BEGIN CSTYLED */ -module_param(zfs_multihost_fail_intervals, uint, 0644); -MODULE_PARM_DESC(zfs_multihost_fail_intervals, - "Max allowed period without a successful mmp write"); +#endif +/* BEGIN CSTYLED */ +#if defined(_KERNEL) module_param_call(zfs_multihost_interval, param_set_multihost_interval, param_get_ulong, &zfs_multihost_interval, 0644); MODULE_PARM_DESC(zfs_multihost_interval, "Milliseconds between mmp writes to each leaf"); +#endif + +ZFS_MODULE_PARAM(zfs_multihost, zfs_multihost_, fail_intervals, UINT, ZMOD_RW, + "Max allowed period without a successful mmp write"); -module_param(zfs_multihost_import_intervals, uint, 0644); -MODULE_PARM_DESC(zfs_multihost_import_intervals, +ZFS_MODULE_PARAM(zfs_multihost, zfs_multihost_, import_intervals, UINT, ZMOD_RW, "Number of zfs_multihost_interval periods to wait for activity"); /* END CSTYLED */ -#endif diff --git a/module/zfs/multilist.c b/module/zfs/multilist.c index b74ee0f06..6f935917c 100644 --- a/module/zfs/multilist.c +++ b/module/zfs/multilist.c @@ -425,13 +425,7 @@ multilist_link_active(multilist_node_t *link) return (list_link_active(link)); } -#if defined(_KERNEL) - /* BEGIN CSTYLED */ - -module_param(zfs_multilist_num_sublists, int, 0644); -MODULE_PARM_DESC(zfs_multilist_num_sublists, +ZFS_MODULE_PARAM(zfs, zfs_, multilist_num_sublists, INT, ZMOD_RW, "Number of sublists used in each multilist"); - /* END CSTYLED */ -#endif diff --git a/module/zfs/qat_compress.c b/module/zfs/qat_compress.c index b3c8c1621..4136b6555 100644 --- a/module/zfs/qat_compress.c +++ b/module/zfs/qat_compress.c @@ -24,7 +24,6 @@ #include <linux/vmalloc.h> #include <linux/pagemap.h> #include <linux/completion.h> -#include <linux/mod_compat.h> #include <sys/zfs_context.h> #include <sys/byteorder.h> #include <sys/zio.h> diff --git a/module/zfs/qat_crypt.c b/module/zfs/qat_crypt.c index 2170366df..02e19d21d 100644 --- a/module/zfs/qat_crypt.c +++ b/module/zfs/qat_crypt.c @@ -31,7 +31,6 @@ #include <linux/vmalloc.h> #include <linux/pagemap.h> #include <linux/completion.h> -#include <linux/mod_compat.h> #include <sys/zfs_context.h> #include <sys/zio_crypt.h> #include "lac/cpa_cy_im.h" diff --git a/module/zfs/spa.c b/module/zfs/spa.c index d885c20c9..0e2cd31b1 100644 --- a/module/zfs/spa.c +++ b/module/zfs/spa.c @@ -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)); } -#if defined(_KERNEL) /* state manipulation functions */ EXPORT_SYMBOL(spa_open); EXPORT_SYMBOL(spa_open_rewind); @@ -9315,57 +9314,41 @@ EXPORT_SYMBOL(spa_prop_clear_bootfs); /* asynchronous event notification */ EXPORT_SYMBOL(spa_event_notify); -#endif -#if defined(_KERNEL) /* BEGIN CSTYLED */ -module_param(spa_load_verify_shift, int, 0644); -MODULE_PARM_DESC(spa_load_verify_shift, "log2(fraction of arc that can " - "be used by inflight I/Os when verifying pool during import"); -/* END CSTYLED */ +ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_shift, INT, ZMOD_RW, + "log2(fraction of arc that can be used by inflight I/Os when " + "verifying pool during import"); -module_param(spa_load_verify_metadata, int, 0644); -MODULE_PARM_DESC(spa_load_verify_metadata, +ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_metadata, INT, ZMOD_RW, "Set to traverse metadata on pool import"); -module_param(spa_load_verify_data, int, 0644); -MODULE_PARM_DESC(spa_load_verify_data, +ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_data, INT, ZMOD_RW, "Set to traverse data on pool import"); -module_param(spa_load_print_vdev_tree, int, 0644); -MODULE_PARM_DESC(spa_load_print_vdev_tree, +ZFS_MODULE_PARAM(zfs_spa, spa_, load_print_vdev_tree, INT, ZMOD_RW, "Print vdev tree to zfs_dbgmsg during pool import"); -/* CSTYLED */ -module_param(zio_taskq_batch_pct, uint, 0444); -MODULE_PARM_DESC(zio_taskq_batch_pct, +ZFS_MODULE_PARAM(zfs_zio, zio_, taskq_batch_pct, UINT, ZMOD_RD, "Percentage of CPUs to run an IO worker thread"); -/* BEGIN CSTYLED */ -module_param(zfs_max_missing_tvds, ulong, 0644); -MODULE_PARM_DESC(zfs_max_missing_tvds, - "Allow importing pool with up to this number of missing top-level vdevs" - " (in read-only mode)"); -/* END CSTYLED */ +ZFS_MODULE_PARAM(zfs, zfs_, max_missing_tvds, ULONG, ZMOD_RW, + "Allow importing pool with up to this number of missing top-level " + "vdevs (in read-only mode)"); -module_param(zfs_livelist_condense_zthr_pause, int, 0644); -MODULE_PARM_DESC(zfs_livelist_condense_zthr_pause, +ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, zthr_pause, INT, ZMOD_RW, "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"); -module_param(zfs_livelist_condense_sync_cancel, int, 0644); -MODULE_PARM_DESC(zfs_livelist_condense_sync_cancel, +ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, sync_cancel, INT, ZMOD_RW, "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"); -/* BEGIN CSTYLED */ -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" - " was being condensed"); +ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, new_alloc, INT, ZMOD_RW, + "Whether extra ALLOC blkptrs were added to a livelist entry while it " + "was being condensed"); /* END CSTYLED */ -#endif diff --git a/module/zfs/spa_checkpoint.c b/module/zfs/spa_checkpoint.c index 44711acef..b167a8321 100644 --- a/module/zfs/spa_checkpoint.c +++ b/module/zfs/spa_checkpoint.c @@ -624,15 +624,12 @@ spa_checkpoint_discard(const char *pool) ZFS_SPACE_CHECK_DISCARD_CHECKPOINT)); } -#if defined(_KERNEL) EXPORT_SYMBOL(spa_checkpoint_get_stats); EXPORT_SYMBOL(spa_checkpoint_discard_thread); EXPORT_SYMBOL(spa_checkpoint_discard_thread_check); /* BEGIN CSTYLED */ -module_param(zfs_spa_discard_memory_limit, ulong, 0644); -MODULE_PARM_DESC(zfs_spa_discard_memory_limit, - "Maximum memory for prefetching checkpoint space " - "map per top-level vdev while discarding checkpoint"); +ZFS_MODULE_PARAM(zfs_spa, zfs_spa_, discard_memory_limit, ULONG, ZMOD_RW, + "Limit for memory used in prefetching the checkpoint space map done " + "on each vdev while discarding the checkpoint"); /* END CSTYLED */ -#endif diff --git a/module/zfs/spa_config.c b/module/zfs/spa_config.c index 6c0894338..43da79dc3 100644 --- a/module/zfs/spa_config.c +++ b/module/zfs/spa_config.c @@ -611,17 +611,19 @@ spa_config_update(spa_t *spa, int what) spa_config_update(spa, SPA_CONFIG_UPDATE_VDEVS); } -#if defined(_KERNEL) EXPORT_SYMBOL(spa_config_load); EXPORT_SYMBOL(spa_all_configs); EXPORT_SYMBOL(spa_config_set); EXPORT_SYMBOL(spa_config_generate); EXPORT_SYMBOL(spa_config_update); -module_param(spa_config_path, charp, 0444); -MODULE_PARM_DESC(spa_config_path, "SPA config file (/etc/zfs/zpool.cache)"); - -module_param(zfs_autoimport_disable, int, 0644); -MODULE_PARM_DESC(zfs_autoimport_disable, "Disable pool import at module load"); - +/* BEGIN CSTYLED */ +#ifdef __linux__ +/* string sysctls require a char array on FreeBSD */ +ZFS_MODULE_PARAM(zfs_spa, spa_, config_path, STRING, ZMOD_RD, + "SPA config file (/etc/zfs/zpool.cache)"); #endif + +ZFS_MODULE_PARAM(zfs, zfs_, autoimport_disable, INT, ZMOD_RW, + "Disable pool import at module load"); +/* END CSTYLED */ diff --git a/module/zfs/spa_log_spacemap.c b/module/zfs/spa_log_spacemap.c index 8a8593a27..5c55d32ec 100644 --- a/module/zfs/spa_log_spacemap.c +++ b/module/zfs/spa_log_spacemap.c @@ -1282,54 +1282,41 @@ spa_ld_log_spacemaps(spa_t *spa) return (error); } -#if defined(_KERNEL) /* BEGIN CSTYLED */ -module_param(zfs_keep_log_spacemaps_at_export, int, 0644); -MODULE_PARM_DESC(zfs_keep_log_spacemaps_at_export, - "Prevent the log spacemaps from being flushed and destroyed " - "during pool export/destroy"); +ZFS_MODULE_PARAM(zfs, zfs_, unflushed_max_mem_amt, ULONG, ZMOD_RW, + "Specific hard-limit in memory that ZFS allows to be used for " + "unflushed changes"); -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"); +ZFS_MODULE_PARAM(zfs, zfs_, unflushed_max_mem_ppm, ULONG, ZMOD_RW, + "Percentage of the overall system memory that ZFS allows to be " + "used for unflushed changes (value is calculated over 1000000 for " + "finer granularity"); -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"); +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."); -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"); +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)"); -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)"); +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)"); -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."); +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"); -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."); +ZFS_MODULE_PARAM(zfs, zfs_, max_logsm_summary_length, ULONG, ZMOD_RW, + "Maximum number of rows allowed in the summary of the spacemap log"); -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 " - "unflushed changes"); +ZFS_MODULE_PARAM(zfs, zfs_, min_metaslabs_to_flush, ULONG, ZMOD_RW, + "Minimum number of metaslabs to flush per dirty TXG"); -module_param(zfs_unflushed_max_mem_ppm, ulong, 0644); -MODULE_PARM_DESC(zfs_unflushed_max_mem_ppm, - "Percentage of the overall system memory that ZFS allows to be " - "used for unflushed changes (value is calculated over 1000000 for " - "finer granularity"); +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 */ -#endif diff --git a/module/zfs/spa_misc.c b/module/zfs/spa_misc.c index d998fe225..b0c1ae1e6 100644 --- a/module/zfs/spa_misc.c +++ b/module/zfs/spa_misc.c @@ -2710,8 +2710,6 @@ spa_suspend_async_destroy(spa_t *spa) #if defined(_KERNEL) -#include <linux/mod_compat.h> - static int 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); } +#endif + /* Namespace manipulation */ EXPORT_SYMBOL(spa_lookup); EXPORT_SYMBOL(spa_add); @@ -2888,17 +2888,31 @@ EXPORT_SYMBOL(spa_suspend_async_destroy); EXPORT_SYMBOL(spa_has_checkpoint); EXPORT_SYMBOL(spa_top_vdevs_spacemap_addressable); -/* BEGIN CSTYLED */ -module_param(zfs_flags, uint, 0644); -MODULE_PARM_DESC(zfs_flags, "Set additional debugging flags"); +ZFS_MODULE_PARAM(zfs, zfs_, flags, UINT, ZMOD_RW, + "Set additional debugging flags"); -module_param(zfs_recover, int, 0644); -MODULE_PARM_DESC(zfs_recover, "Set to attempt to recover from fatal errors"); +ZFS_MODULE_PARAM(zfs, zfs_, recover, INT, ZMOD_RW, + "Set to attempt to recover from fatal errors"); -module_param(zfs_free_leak_on_eio, int, 0644); -MODULE_PARM_DESC(zfs_free_leak_on_eio, +ZFS_MODULE_PARAM(zfs, zfs_, free_leak_on_eio, INT, ZMOD_RW, "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, param_get_ulong, &zfs_deadman_synctime_ms, 0644); 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, "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, - &spa_slop_shift, 0644); + &spa_slop_shift, 0644); MODULE_PARM_DESC(spa_slop_shift, "Reserved free space in pool"); -module_param(zfs_ddt_data_is_special, int, 0644); -MODULE_PARM_DESC(zfs_ddt_data_is_special, - "Place DDT data into the special class"); - -module_param(zfs_user_indirect_is_special, int, 0644); -MODULE_PARM_DESC(zfs_user_indirect_is_special, - "Place user data indirect blocks into the special class"); +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"); +#endif -module_param(zfs_special_class_metadata_reserve_pct, int, 0644); -MODULE_PARM_DESC(zfs_special_class_metadata_reserve_pct, +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs, zfs_, special_class_metadata_reserve_pct, INT, ZMOD_RW, "Small file blocks in special vdevs depends on this much " "free space available"); /* END CSTYLED */ -#endif diff --git a/module/zfs/txg.c b/module/zfs/txg.c index dc085f78d..2a5f4f689 100644 --- a/module/zfs/txg.c +++ b/module/zfs/txg.c @@ -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); } -#if defined(_KERNEL) EXPORT_SYMBOL(txg_init); EXPORT_SYMBOL(txg_fini); EXPORT_SYMBOL(txg_sync_start); @@ -1054,6 +1053,7 @@ EXPORT_SYMBOL(txg_wait_callbacks); EXPORT_SYMBOL(txg_stalled); EXPORT_SYMBOL(txg_sync_waiting); -module_param(zfs_txg_timeout, int, 0644); -MODULE_PARM_DESC(zfs_txg_timeout, "Max seconds worth of delta per txg"); -#endif +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs, zfs_, txg_timeout, INT, ZMOD_RW, + "Max seconds worth of delta per txg"); +/* END CSTYLED */ diff --git a/module/zfs/vdev.c b/module/zfs/vdev.c index f083732b2..eff1d34f7 100644 --- a/module/zfs/vdev.c +++ b/module/zfs/vdev.c @@ -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; } -#if defined(_KERNEL) EXPORT_SYMBOL(vdev_fault); EXPORT_SYMBOL(vdev_degrade); EXPORT_SYMBOL(vdev_online); @@ -4772,40 +4771,31 @@ EXPORT_SYMBOL(vdev_offline); EXPORT_SYMBOL(vdev_clear); /* BEGIN CSTYLED */ -module_param(zfs_vdev_default_ms_count, int, 0644); -MODULE_PARM_DESC(zfs_vdev_default_ms_count, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, default_ms_count, INT, ZMOD_RW, "Target number of metaslabs per top-level vdev"); -module_param(zfs_vdev_default_ms_shift, int, 0644); -MODULE_PARM_DESC(zfs_vdev_default_ms_shift, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, default_ms_shift, INT, ZMOD_RW, "Default limit for metaslab size"); -module_param(zfs_vdev_min_ms_count, int, 0644); -MODULE_PARM_DESC(zfs_vdev_min_ms_count, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, min_ms_count, INT, ZMOD_RW, "Minimum number of metaslabs per top-level vdev"); -module_param(zfs_vdev_ms_count_limit, int, 0644); -MODULE_PARM_DESC(zfs_vdev_ms_count_limit, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, ms_count_limit, INT, ZMOD_RW, "Practical upper limit of total metaslabs per top-level vdev"); -module_param(zfs_slow_io_events_per_second, uint, 0644); -MODULE_PARM_DESC(zfs_slow_io_events_per_second, +ZFS_MODULE_PARAM(zfs, zfs_, slow_io_events_per_second, UINT, ZMOD_RW, "Rate limit slow IO (delay) events to this many per second"); -module_param(zfs_checksum_events_per_second, uint, 0644); -MODULE_PARM_DESC(zfs_checksum_events_per_second, "Rate limit checksum events " - "to this many checksum errors per second (do not set below zed" - "threshold)."); +ZFS_MODULE_PARAM(zfs, zfs_, checksum_events_per_second, UINT, ZMOD_RW, + "Rate limit checksum events to this many checksum errors per second " + "(do not set below zed threshold)."); -module_param(zfs_scan_ignore_errors, int, 0644); -MODULE_PARM_DESC(zfs_scan_ignore_errors, +ZFS_MODULE_PARAM(zfs, zfs_, scan_ignore_errors, INT, ZMOD_RW, "Ignore errors during resilver/scrub"); -module_param(vdev_validate_skip, int, 0644); -MODULE_PARM_DESC(vdev_validate_skip, +ZFS_MODULE_PARAM(zfs_vdev, vdev_, validate_skip, INT, ZMOD_RW, "Bypass vdev_validate()"); -module_param(zfs_nocacheflush, int, 0644); -MODULE_PARM_DESC(zfs_nocacheflush, "Disable cache flushes"); +ZFS_MODULE_PARAM(zfs, zfs_, nocacheflush, INT, ZMOD_RW, + "Disable cache flushes"); /* END CSTYLED */ -#endif diff --git a/module/zfs/vdev_cache.c b/module/zfs/vdev_cache.c index b63b9f979..35a5b480b 100644 --- a/module/zfs/vdev_cache.c +++ b/module/zfs/vdev_cache.c @@ -425,13 +425,13 @@ vdev_cache_stat_fini(void) } } -#if defined(_KERNEL) -module_param(zfs_vdev_cache_max, int, 0644); -MODULE_PARM_DESC(zfs_vdev_cache_max, "Inflate reads small than max"); +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, cache_max, INT, ZMOD_RW, + "Inflate reads small than max"); -module_param(zfs_vdev_cache_size, int, 0444); -MODULE_PARM_DESC(zfs_vdev_cache_size, "Total size of the per-disk cache"); +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, cache_size, INT, ZMOD_RD, + "Total size of the per-disk cache"); -module_param(zfs_vdev_cache_bshift, int, 0644); -MODULE_PARM_DESC(zfs_vdev_cache_bshift, "Shift size to inflate reads too"); -#endif +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, cache_bshift, INT, ZMOD_RW, + "Shift size to inflate reads too"); +/* END CSTYLED */ diff --git a/module/zfs/vdev_disk.c b/module/zfs/vdev_disk.c index 1686ddfce..21f9ae454 100644 --- a/module/zfs/vdev_disk.c +++ b/module/zfs/vdev_disk.c @@ -34,7 +34,6 @@ #include <sys/abd.h> #include <sys/fs/zfs.h> #include <sys/zio.h> -#include <linux/mod_compat.h> #include <linux/msdos_fs.h> #include <linux/vfs_compat.h> diff --git a/module/zfs/vdev_indirect.c b/module/zfs/vdev_indirect.c index 5827d3fac..4869402c2 100644 --- a/module/zfs/vdev_indirect.c +++ b/module/zfs/vdev_indirect.c @@ -1858,7 +1858,6 @@ vdev_ops_t vdev_indirect_ops = { .vdev_op_leaf = B_FALSE /* leaf vdev */ }; -#if defined(_KERNEL) EXPORT_SYMBOL(rs_alloc); EXPORT_SYMBOL(spa_condense_fini); 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_sm_object); -module_param(zfs_condense_indirect_vdevs_enable, int, 0644); -MODULE_PARM_DESC(zfs_condense_indirect_vdevs_enable, +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, indirect_vdevs_enable, INT, ZMOD_RW, "Whether to attempt condensing indirect vdev mappings"); -/* CSTYLED */ -module_param(zfs_condense_min_mapping_bytes, ulong, 0644); -MODULE_PARM_DESC(zfs_condense_min_mapping_bytes, - "Minimum size of vdev mapping to condense"); +ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, min_mapping_bytes, ULONG, ZMOD_RW, + "Don't bother condensing if the mapping uses less than this amount of " + "memory"); -/* CSTYLED */ -module_param(zfs_condense_max_obsolete_bytes, ulong, 0644); -MODULE_PARM_DESC(zfs_condense_max_obsolete_bytes, +ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, max_obsolete_bytes, ULONG, ZMOD_RW, "Minimum size obsolete spacemap to attempt condensing"); -module_param(zfs_condense_indirect_commit_entry_delay_ms, int, 0644); -MODULE_PARM_DESC(zfs_condense_indirect_commit_entry_delay_ms, - "Delay while condensing vdev mapping"); +ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, indirect_commit_entry_delay_ms, INT, ZMOD_RW, + "Used by tests to ensure certain actions happen in the middle of a " + "condense. A maximum value of 1 should be sufficient."); -module_param(zfs_reconstruct_indirect_combinations_max, int, 0644); -MODULE_PARM_DESC(zfs_reconstruct_indirect_combinations_max, +ZFS_MODULE_PARAM(zfs_reconstruct, zfs_reconstruct_, indirect_combinations_max, INT, ZMOD_RW, "Maximum number of combinations when reconstructing split segments"); -#endif +/* END CSTYLED */ diff --git a/module/zfs/vdev_initialize.c b/module/zfs/vdev_initialize.c index 4963ba38d..ca83cabed 100644 --- a/module/zfs/vdev_initialize.c +++ b/module/zfs/vdev_initialize.c @@ -723,15 +723,13 @@ vdev_initialize_restart(vdev_t *vd) } } -#if defined(_KERNEL) EXPORT_SYMBOL(vdev_initialize); EXPORT_SYMBOL(vdev_initialize_stop); EXPORT_SYMBOL(vdev_initialize_stop_all); EXPORT_SYMBOL(vdev_initialize_stop_wait); EXPORT_SYMBOL(vdev_initialize_restart); -/* CSTYLED */ -module_param(zfs_initialize_value, ulong, 0644); -MODULE_PARM_DESC(zfs_initialize_value, +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs, zfs_, initialize_value, ULONG, ZMOD_RW, "Value written during zpool initialize"); -#endif +/* END CSTYLED */ diff --git a/module/zfs/vdev_mirror.c b/module/zfs/vdev_mirror.c index 2f75fca82..552b83e00 100644 --- a/module/zfs/vdev_mirror.c +++ b/module/zfs/vdev_mirror.c @@ -833,28 +833,20 @@ vdev_ops_t vdev_spare_ops = { .vdev_op_leaf = B_FALSE /* not a leaf vdev */ }; -#if defined(_KERNEL) /* BEGIN CSTYLED */ -module_param(zfs_vdev_mirror_rotating_inc, int, 0644); -MODULE_PARM_DESC(zfs_vdev_mirror_rotating_inc, +ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_inc, INT, ZMOD_RW, "Rotating media load increment for non-seeking I/O's"); -module_param(zfs_vdev_mirror_rotating_seek_inc, int, 0644); -MODULE_PARM_DESC(zfs_vdev_mirror_rotating_seek_inc, +ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_seek_inc, INT, ZMOD_RW, "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, - "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, +ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, non_rotating_inc, INT, ZMOD_RW, "Non-rotating media load increment for non-seeking I/O's"); -module_param(zfs_vdev_mirror_non_rotating_seek_inc, int, 0644); -MODULE_PARM_DESC(zfs_vdev_mirror_non_rotating_seek_inc, +ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, non_rotating_seek_inc, INT, ZMOD_RW, "Non-rotating media load increment for seeking I/O's"); /* END CSTYLED */ -#endif diff --git a/module/zfs/vdev_queue.c b/module/zfs/vdev_queue.c index d3d9a6baa..5e4db3df6 100644 --- a/module/zfs/vdev_queue.c +++ b/module/zfs/vdev_queue.c @@ -952,99 +952,79 @@ vdev_queue_last_offset(vdev_t *vd) return (vd->vdev_queue.vq_last_offset); } -#if defined(_KERNEL) -module_param(zfs_vdev_aggregation_limit, int, 0644); -MODULE_PARM_DESC(zfs_vdev_aggregation_limit, "Max vdev I/O aggregation size"); +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, aggregation_limit, INT, ZMOD_RW, + "Max vdev I/O aggregation size"); -module_param(zfs_vdev_aggregation_limit_non_rotating, int, 0644); -MODULE_PARM_DESC(zfs_vdev_aggregation_limit_non_rotating, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, aggregation_limit_non_rotating, INT, ZMOD_RW, "Max vdev I/O aggregation size for non-rotating media"); -module_param(zfs_vdev_aggregate_trim, int, 0644); -MODULE_PARM_DESC(zfs_vdev_aggregate_trim, "Allow TRIM I/O to be aggregated"); +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, aggregate_trim, INT, ZMOD_RW, + "Allow TRIM I/O to be aggregated"); -module_param(zfs_vdev_read_gap_limit, int, 0644); -MODULE_PARM_DESC(zfs_vdev_read_gap_limit, "Aggregate read I/O over gap"); +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, read_gap_limit, INT, ZMOD_RW, + "Aggregate read I/O over gap"); -module_param(zfs_vdev_write_gap_limit, int, 0644); -MODULE_PARM_DESC(zfs_vdev_write_gap_limit, "Aggregate write I/O over gap"); +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, write_gap_limit, INT, ZMOD_RW, + "Aggregate write I/O over gap"); -module_param(zfs_vdev_max_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_max_active, "Maximum number of active I/Os per vdev"); +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, max_active, INT, ZMOD_RW, + "Maximum number of active I/Os per vdev"); -module_param(zfs_vdev_async_write_active_max_dirty_percent, int, 0644); -MODULE_PARM_DESC(zfs_vdev_async_write_active_max_dirty_percent, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_write_active_max_dirty_percent, INT, ZMOD_RW, "Async write concurrency max threshold"); -module_param(zfs_vdev_async_write_active_min_dirty_percent, int, 0644); -MODULE_PARM_DESC(zfs_vdev_async_write_active_min_dirty_percent, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_write_active_min_dirty_percent, INT, ZMOD_RW, "Async write concurrency min threshold"); -module_param(zfs_vdev_async_read_max_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_async_read_max_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_read_max_active, INT, ZMOD_RW, "Max active async read I/Os per vdev"); -module_param(zfs_vdev_async_read_min_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_async_read_min_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_read_min_active, INT, ZMOD_RW, "Min active async read I/Os per vdev"); -module_param(zfs_vdev_async_write_max_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_async_write_max_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_write_max_active, INT, ZMOD_RW, "Max active async write I/Os per vdev"); -module_param(zfs_vdev_async_write_min_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_async_write_min_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, async_write_min_active, INT, ZMOD_RW, "Min active async write I/Os per vdev"); -module_param(zfs_vdev_initializing_max_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_initializing_max_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, initializing_max_active, INT, ZMOD_RW, "Max active initializing I/Os per vdev"); -module_param(zfs_vdev_initializing_min_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_initializing_min_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, initializing_min_active, INT, ZMOD_RW, "Min active initializing I/Os per vdev"); -module_param(zfs_vdev_removal_max_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_removal_max_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, removal_max_active, INT, ZMOD_RW, "Max active removal I/Os per vdev"); -module_param(zfs_vdev_removal_min_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_removal_min_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, removal_min_active, INT, ZMOD_RW, "Min active removal I/Os per vdev"); -module_param(zfs_vdev_scrub_max_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_scrub_max_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, scrub_max_active, INT, ZMOD_RW, "Max active scrub I/Os per vdev"); -module_param(zfs_vdev_scrub_min_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_scrub_min_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, scrub_min_active, INT, ZMOD_RW, "Min active scrub I/Os per vdev"); -module_param(zfs_vdev_sync_read_max_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_sync_read_max_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, sync_read_max_active, INT, ZMOD_RW, "Max active sync read I/Os per vdev"); -module_param(zfs_vdev_sync_read_min_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_sync_read_min_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, sync_read_min_active, INT, ZMOD_RW, "Min active sync read I/Os per vdev"); -module_param(zfs_vdev_sync_write_max_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_sync_write_max_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, sync_write_max_active, INT, ZMOD_RW, "Max active sync write I/Os per vdev"); -module_param(zfs_vdev_sync_write_min_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_sync_write_min_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, sync_write_min_active, INT, ZMOD_RW, "Min active sync write I/Os per vdev"); -module_param(zfs_vdev_trim_max_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_trim_max_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, trim_max_active, INT, ZMOD_RW, "Max active trim/discard I/Os per vdev"); -module_param(zfs_vdev_trim_min_active, int, 0644); -MODULE_PARM_DESC(zfs_vdev_trim_min_active, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, trim_min_active, INT, ZMOD_RW, "Min active trim/discard I/Os per vdev"); -module_param(zfs_vdev_queue_depth_pct, int, 0644); -MODULE_PARM_DESC(zfs_vdev_queue_depth_pct, +ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, queue_depth_pct, INT, ZMOD_RW, "Queue depth percentage for each top-level vdev"); -#endif +/* END CSTYLED */ diff --git a/module/zfs/vdev_raidz_math.c b/module/zfs/vdev_raidz_math.c index 86d4aabdc..4e5fcbdaf 100644 --- a/module/zfs/vdev_raidz_math.c +++ b/module/zfs/vdev_raidz_math.c @@ -640,7 +640,6 @@ vdev_raidz_impl_set(const char *val) } #if defined(_KERNEL) -#include <linux/mod_compat.h> static int zfs_vdev_raidz_impl_set(const char *val, zfs_kernel_param_t *kp) diff --git a/module/zfs/vdev_removal.c b/module/zfs/vdev_removal.c index 3d6df0c41..3ba06e4ac 100644 --- a/module/zfs/vdev_removal.c +++ b/module/zfs/vdev_removal.c @@ -2289,22 +2289,17 @@ spa_removal_get_stats(spa_t *spa, pool_removal_stat_t *prs) return (0); } -#if defined(_KERNEL) -module_param(zfs_removal_ignore_errors, int, 0644); -MODULE_PARM_DESC(zfs_removal_ignore_errors, +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs_vdev, zfs_, removal_ignore_errors, INT, ZMOD_RW, "Ignore hard IO errors when removing device"); -module_param(zfs_remove_max_segment, int, 0644); -MODULE_PARM_DESC(zfs_remove_max_segment, +ZFS_MODULE_PARAM(zfs_vdev, zfs_, remove_max_segment, INT, ZMOD_RW, "Largest contiguous segment to allocate when removing device"); -module_param(vdev_removal_max_span, int, 0644); -MODULE_PARM_DESC(vdev_removal_max_span, +ZFS_MODULE_PARAM(zfs_vdev, vdev_, removal_max_span, INT, ZMOD_RW, "Largest span of free chunks a remap segment can span"); -/* BEGIN CSTYLED */ -module_param(zfs_removal_suspend_progress, int, 0644); -MODULE_PARM_DESC(zfs_removal_suspend_progress, +ZFS_MODULE_PARAM(zfs_vdev, zfs_, removal_suspend_progress, INT, ZMOD_RW, "Pause device removal after this many bytes are copied " "(debug use only - causes removal to hang)"); /* END CSTYLED */ @@ -2318,4 +2313,3 @@ EXPORT_SYMBOL(spa_vdev_remove); EXPORT_SYMBOL(spa_vdev_remove_cancel); EXPORT_SYMBOL(spa_vdev_remove_suspend); EXPORT_SYMBOL(svr_sync); -#endif diff --git a/module/zfs/vdev_trim.c b/module/zfs/vdev_trim.c index 70b122a0a..771e7a159 100644 --- a/module/zfs/vdev_trim.c +++ b/module/zfs/vdev_trim.c @@ -1425,7 +1425,6 @@ vdev_autotrim_restart(spa_t *spa) vdev_autotrim(spa); } -#if defined(_KERNEL) EXPORT_SYMBOL(vdev_trim); EXPORT_SYMBOL(vdev_trim_stop); EXPORT_SYMBOL(vdev_trim_stop_all); @@ -1437,24 +1436,18 @@ EXPORT_SYMBOL(vdev_autotrim_stop_wait); EXPORT_SYMBOL(vdev_autotrim_restart); /* BEGIN CSTYLED */ -module_param(zfs_trim_extent_bytes_max, uint, 0644); -MODULE_PARM_DESC(zfs_trim_extent_bytes_max, +ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, extent_bytes_max, UINT, ZMOD_RW, "Max size of TRIM commands, larger will be split"); -module_param(zfs_trim_extent_bytes_min, uint, 0644); -MODULE_PARM_DESC(zfs_trim_extent_bytes_min, +ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, extent_bytes_min, UINT, ZMOD_RW, "Min size of TRIM commands, smaller will be skipped"); -module_param(zfs_trim_metaslab_skip, uint, 0644); -MODULE_PARM_DESC(zfs_trim_metaslab_skip, +ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, metaslab_skip, UINT, ZMOD_RW, "Skip metaslabs which have never been initialized"); -module_param(zfs_trim_txg_batch, uint, 0644); -MODULE_PARM_DESC(zfs_trim_txg_batch, +ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, txg_batch, UINT, ZMOD_RW, "Min number of txgs to aggregate frees before issuing TRIM"); -module_param(zfs_trim_queue_limit, uint, 0644); -MODULE_PARM_DESC(zfs_trim_queue_limit, +ZFS_MODULE_PARAM(zfs_trim, zfs_trim_, queue_limit, UINT, ZMOD_RW, "Max queued TRIMs outstanding per leaf vdev"); /* END CSTYLED */ -#endif diff --git a/module/zfs/zap.c b/module/zfs/zap.c index 30f62ac43..01c06aa3f 100644 --- a/module/zfs/zap.c +++ b/module/zfs/zap.c @@ -1379,11 +1379,7 @@ fzap_get_stats(zap_t *zap, zap_stats_t *zs) } } -#if defined(_KERNEL) /* BEGIN CSTYLED */ -module_param(zap_iterate_prefetch, int, 0644); -MODULE_PARM_DESC(zap_iterate_prefetch, +ZFS_MODULE_PARAM(zfs, , zap_iterate_prefetch, INT, ZMOD_RW, "When iterating ZAP object, prefetch it"); - /* END CSTYLED */ -#endif diff --git a/module/zfs/zcp.c b/module/zfs/zcp.c index 44e4d230a..870ba0366 100644 --- a/module/zfs/zcp.c +++ b/module/zfs/zcp.c @@ -1434,14 +1434,10 @@ zcp_parse_args(lua_State *state, const char *fname, const zcp_arg_t *pargs, } } -#if defined(_KERNEL) /* BEGIN CSTYLED */ -module_param(zfs_lua_max_instrlimit, ulong, 0644); -MODULE_PARM_DESC(zfs_lua_max_instrlimit, +ZFS_MODULE_PARAM(zfs_lua, zfs_lua_, max_instrlimit, ULONG, ZMOD_RW, "Max instruction limit that can be specified for a channel program"); -module_param(zfs_lua_max_memlimit, ulong, 0644); -MODULE_PARM_DESC(zfs_lua_max_memlimit, +ZFS_MODULE_PARAM(zfs_lua, zfs_lua_, max_memlimit, ULONG, ZMOD_RW, "Max memory limit that can be specified for a channel program"); /* END CSTYLED */ -#endif diff --git a/module/zfs/zfs_log.c b/module/zfs/zfs_log.c index 41b663b65..ae4cbdec1 100644 --- a/module/zfs/zfs_log.c +++ b/module/zfs/zfs_log.c @@ -743,7 +743,7 @@ zfs_log_acl(zilog_t *zilog, dmu_tx_t *tx, znode_t *zp, zil_itx_assign(zilog, itx, tx); } -#if defined(_KERNEL) -module_param(zfs_immediate_write_sz, long, 0644); -MODULE_PARM_DESC(zfs_immediate_write_sz, "Largest data block to write to zil"); -#endif +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs, zfs_, immediate_write_sz, LONG, ZMOD_RW, + "Largest data block to write to zil"); +/* END CSTYLED */ diff --git a/module/zfs/zil.c b/module/zfs/zil.c index 8411e333b..9df5820e5 100644 --- a/module/zfs/zil.c +++ b/module/zfs/zil.c @@ -3643,7 +3643,6 @@ zil_reset(const char *osname, void *arg) return (0); } -#if defined(_KERNEL) EXPORT_SYMBOL(zil_alloc); EXPORT_SYMBOL(zil_free); EXPORT_SYMBOL(zil_open); @@ -3668,19 +3667,18 @@ EXPORT_SYMBOL(zil_set_sync); EXPORT_SYMBOL(zil_set_logbias); /* BEGIN CSTYLED */ -module_param(zfs_commit_timeout_pct, int, 0644); -MODULE_PARM_DESC(zfs_commit_timeout_pct, "ZIL block open timeout percentage"); +ZFS_MODULE_PARAM(zfs, zfs_, commit_timeout_pct, INT, ZMOD_RW, + "ZIL block open timeout percentage"); -module_param(zil_replay_disable, int, 0644); -MODULE_PARM_DESC(zil_replay_disable, "Disable intent logging replay"); +ZFS_MODULE_PARAM(zfs_zil, zil_, replay_disable, INT, ZMOD_RW, + "Disable intent logging replay"); -module_param(zil_nocacheflush, int, 0644); -MODULE_PARM_DESC(zil_nocacheflush, "Disable ZIL cache flushes"); +ZFS_MODULE_PARAM(zfs_zil, zil_, nocacheflush, INT, ZMOD_RW, + "Disable ZIL cache flushes"); -module_param(zil_slog_bulk, ulong, 0644); -MODULE_PARM_DESC(zil_slog_bulk, "Limit in bytes slog sync writes per commit"); +ZFS_MODULE_PARAM(zfs_zil, zil_, slog_bulk, ULONG, ZMOD_RW, + "Limit in bytes slog sync writes per commit"); -module_param(zil_maxblocksize, int, 0644); -MODULE_PARM_DESC(zil_maxblocksize, "Limit in bytes of ZIL log block size"); +ZFS_MODULE_PARAM(zfs_zil, zil_, maxblocksize, INT, ZMOD_RW, + "Limit in bytes of ZIL log block size"); /* END CSTYLED */ -#endif diff --git a/module/zfs/zio.c b/module/zfs/zio.c index 7b4ab341f..f966023aa 100644 --- a/module/zfs/zio.c +++ b/module/zfs/zio.c @@ -4842,37 +4842,31 @@ zbookmark_subtree_completed(const dnode_phys_t *dnp, last_block) <= 0); } -#if defined(_KERNEL) EXPORT_SYMBOL(zio_type_name); EXPORT_SYMBOL(zio_buf_alloc); EXPORT_SYMBOL(zio_data_buf_alloc); EXPORT_SYMBOL(zio_buf_free); EXPORT_SYMBOL(zio_data_buf_free); -module_param(zio_slow_io_ms, int, 0644); -MODULE_PARM_DESC(zio_slow_io_ms, +/* BEGIN CSTYLED */ +ZFS_MODULE_PARAM(zfs_zio, zio_, slow_io_ms, INT, ZMOD_RW, "Max I/O completion time (milliseconds) before marking it as slow"); -module_param(zio_requeue_io_start_cut_in_line, int, 0644); -MODULE_PARM_DESC(zio_requeue_io_start_cut_in_line, "Prioritize requeued I/O"); +ZFS_MODULE_PARAM(zfs_zio, zio_, requeue_io_start_cut_in_line, INT, ZMOD_RW, + "Prioritize requeued I/O"); -module_param(zfs_sync_pass_deferred_free, int, 0644); -MODULE_PARM_DESC(zfs_sync_pass_deferred_free, +ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_deferred_free, INT, ZMOD_RW, "Defer frees starting in this pass"); -module_param(zfs_sync_pass_dont_compress, int, 0644); -MODULE_PARM_DESC(zfs_sync_pass_dont_compress, +ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_dont_compress, INT, ZMOD_RW, "Don't compress starting in this pass"); -module_param(zfs_sync_pass_rewrite, int, 0644); -MODULE_PARM_DESC(zfs_sync_pass_rewrite, +ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_rewrite, INT, ZMOD_RW, "Rewrite new bps starting in this pass"); -module_param(zio_dva_throttle_enabled, int, 0644); -MODULE_PARM_DESC(zio_dva_throttle_enabled, +ZFS_MODULE_PARAM(zfs_zio, zio_, dva_throttle_enabled, INT, ZMOD_RW, "Throttle block allocations in the ZIO pipeline"); -module_param(zio_deadman_log_all, int, 0644); -MODULE_PARM_DESC(zio_deadman_log_all, +ZFS_MODULE_PARAM(zfs_zio, zio_, deadman_log_all, INT, ZMOD_RW, "Log all slow ZIOs, not just those with vdevs"); -#endif +/* END CSTYLED */ |