/* SPDX-License-Identifier: GPL-2.0 */ #ifndef _LINUX_MODULE_PARAMS_H #define _LINUX_MODULE_PARAMS_H /* (C) Copyright 2001, 2002 Rusty Russell IBM Corporation */ #include <linux/init.h> #include <linux/stringify.h> #include <linux/kernel.h> /* You can override this manually, but generally this should match the module name. */ #ifdef MODULE #define MODULE_PARAM_PREFIX … #define __MODULE_INFO_PREFIX … #else #define MODULE_PARAM_PREFIX … /* We cannot use MODULE_PARAM_PREFIX because some modules override it. */ #define __MODULE_INFO_PREFIX … #endif /* Chosen so that structs with an unsigned long line up. */ #define MAX_PARAM_PREFIX_LEN … #define __MODULE_INFO(tag, name, info) … #define __MODULE_PARM_TYPE(name, _type) … /* One for each parameter, describing how to use it. Some files do multiple of these per line, so can't just use MODULE_INFO. */ #define MODULE_PARM_DESC(_parm, desc) … struct kernel_param; /* * Flags available for kernel_param_ops * * NOARG - the parameter allows for no argument (foo instead of foo=1) */ enum { … }; struct kernel_param_ops { … }; /* * Flags available for kernel_param * * UNSAFE - the parameter is dangerous and setting it will taint the kernel * HWPARAM - Hardware param not permitted in lockdown mode */ enum { … }; struct kernel_param { … }; extern const struct kernel_param __start___param[], __stop___param[]; /* Special one for strings we want to copy into */ struct kparam_string { … }; /* Special one for arrays */ struct kparam_array { … }; /** * module_param - typesafe helper for a module/cmdline parameter * @name: the variable to alter, and exposed parameter name. * @type: the type of the parameter * @perm: visibility in sysfs. * * @name becomes the module parameter, or (prefixed by KBUILD_MODNAME and a * ".") the kernel commandline parameter. Note that - is changed to _, so * the user can use "foo-bar=1" even for variable "foo_bar". * * @perm is 0 if the variable is not to appear in sysfs, or 0444 * for world-readable, 0644 for root-writable, etc. Note that if it * is writable, you may need to use kernel_param_lock() around * accesses (esp. charp, which can be kfreed when it changes). * * The @type is simply pasted to refer to a param_ops_##type and a * param_check_##type: for convenience many standard types are provided but * you can create your own by defining those variables. * * Standard types are: * byte, hexint, short, ushort, int, uint, long, ulong * charp: a character pointer * bool: a bool, values 0/1, y/n, Y/N. * invbool: the above, only sense-reversed (N = true). */ #define module_param(name, type, perm) … /** * module_param_unsafe - same as module_param but taints kernel * @name: the variable to alter, and exposed parameter name. * @type: the type of the parameter * @perm: visibility in sysfs. */ #define module_param_unsafe(name, type, perm) … /** * module_param_named - typesafe helper for a renamed module/cmdline parameter * @name: a valid C identifier which is the parameter name. * @value: the actual lvalue to alter. * @type: the type of the parameter * @perm: visibility in sysfs. * * Usually it's a good idea to have variable names and user-exposed names the * same, but that's harder if the variable must be non-static or is inside a * structure. This allows exposure under a different name. */ #define module_param_named(name, value, type, perm) … /** * module_param_named_unsafe - same as module_param_named but taints kernel * @name: a valid C identifier which is the parameter name. * @value: the actual lvalue to alter. * @type: the type of the parameter * @perm: visibility in sysfs. */ #define module_param_named_unsafe(name, value, type, perm) … /** * module_param_cb - general callback for a module/cmdline parameter * @name: a valid C identifier which is the parameter name. * @ops: the set & get operations for this parameter. * @arg: args for @ops * @perm: visibility in sysfs. * * The ops can have NULL set or get functions. */ #define module_param_cb(name, ops, arg, perm) … #define module_param_cb_unsafe(name, ops, arg, perm) … #define __level_param_cb(name, ops, arg, perm, level) … /** * core_param_cb - general callback for a module/cmdline parameter * to be evaluated before core initcall level * @name: a valid C identifier which is the parameter name. * @ops: the set & get operations for this parameter. * @arg: args for @ops * @perm: visibility in sysfs. * * The ops can have NULL set or get functions. */ #define core_param_cb(name, ops, arg, perm) … /** * postcore_param_cb - general callback for a module/cmdline parameter * to be evaluated before postcore initcall level * @name: a valid C identifier which is the parameter name. * @ops: the set & get operations for this parameter. * @arg: args for @ops * @perm: visibility in sysfs. * * The ops can have NULL set or get functions. */ #define postcore_param_cb(name, ops, arg, perm) … /** * arch_param_cb - general callback for a module/cmdline parameter * to be evaluated before arch initcall level * @name: a valid C identifier which is the parameter name. * @ops: the set & get operations for this parameter. * @arg: args for @ops * @perm: visibility in sysfs. * * The ops can have NULL set or get functions. */ #define arch_param_cb(name, ops, arg, perm) … /** * subsys_param_cb - general callback for a module/cmdline parameter * to be evaluated before subsys initcall level * @name: a valid C identifier which is the parameter name. * @ops: the set & get operations for this parameter. * @arg: args for @ops * @perm: visibility in sysfs. * * The ops can have NULL set or get functions. */ #define subsys_param_cb(name, ops, arg, perm) … /** * fs_param_cb - general callback for a module/cmdline parameter * to be evaluated before fs initcall level * @name: a valid C identifier which is the parameter name. * @ops: the set & get operations for this parameter. * @arg: args for @ops * @perm: visibility in sysfs. * * The ops can have NULL set or get functions. */ #define fs_param_cb(name, ops, arg, perm) … /** * device_param_cb - general callback for a module/cmdline parameter * to be evaluated before device initcall level * @name: a valid C identifier which is the parameter name. * @ops: the set & get operations for this parameter. * @arg: args for @ops * @perm: visibility in sysfs. * * The ops can have NULL set or get functions. */ #define device_param_cb(name, ops, arg, perm) … /** * late_param_cb - general callback for a module/cmdline parameter * to be evaluated before late initcall level * @name: a valid C identifier which is the parameter name. * @ops: the set & get operations for this parameter. * @arg: args for @ops * @perm: visibility in sysfs. * * The ops can have NULL set or get functions. */ #define late_param_cb(name, ops, arg, perm) … /* On alpha, ia64 and ppc64 relocations to global data cannot go into read-only sections (which is part of respective UNIX ABI on these platforms). So 'const' makes no sense and even causes compile failures with some compilers. */ #if defined(CONFIG_ALPHA) || defined(CONFIG_PPC64) #define __moduleparam_const #else #define __moduleparam_const … #endif /* This is the fundamental function for registering boot/module parameters. */ #define __module_param_call(prefix, name, ops, arg, perm, level, flags) … /* * Useful for describing a set/get pair used only once (i.e. for this * parameter). For repeated set/get pairs (i.e. the same struct * kernel_param_ops), use module_param_cb() instead. */ #define module_param_call(name, _set, _get, arg, perm) … #ifdef CONFIG_SYSFS extern void kernel_param_lock(struct module *mod); extern void kernel_param_unlock(struct module *mod); #else static inline void kernel_param_lock(struct module *mod) { } static inline void kernel_param_unlock(struct module *mod) { } #endif #ifndef MODULE /** * core_param - define a historical core kernel parameter. * @name: the name of the cmdline and sysfs parameter (often the same as var) * @var: the variable * @type: the type of the parameter * @perm: visibility in sysfs * * core_param is just like module_param(), but cannot be modular and * doesn't add a prefix (such as "printk."). This is for compatibility * with __setup(), and it makes sense as truly core parameters aren't * tied to the particular file they're in. */ #define core_param(name, var, type, perm) … /** * core_param_unsafe - same as core_param but taints kernel * @name: the name of the cmdline and sysfs parameter (often the same as var) * @var: the variable * @type: the type of the parameter * @perm: visibility in sysfs */ #define core_param_unsafe(name, var, type, perm) … #endif /* !MODULE */ /** * module_param_string - a char array parameter * @name: the name of the parameter * @string: the string variable * @len: the maximum length of the string, incl. terminator * @perm: visibility in sysfs. * * This actually copies the string when it's set (unlike type charp). * @len is usually just sizeof(string). */ #define module_param_string(name, string, len, perm) … /** * parameq - checks if two parameter names match * @name1: parameter name 1 * @name2: parameter name 2 * * Returns true if the two parameter names are equal. * Dashes (-) are considered equal to underscores (_). */ extern bool parameq(const char *name1, const char *name2); /** * parameqn - checks if two parameter names match * @name1: parameter name 1 * @name2: parameter name 2 * @n: the length to compare * * Similar to parameq(), except it compares @n characters. */ extern bool parameqn(const char *name1, const char *name2, size_t n); parse_unknown_fn; /* Called on module insert or kernel boot */ extern char *parse_args(const char *name, char *args, const struct kernel_param *params, unsigned num, s16 level_min, s16 level_max, void *arg, parse_unknown_fn unknown); /* Called by module remove. */ #ifdef CONFIG_SYSFS extern void destroy_params(const struct kernel_param *params, unsigned num); #else static inline void destroy_params(const struct kernel_param *params, unsigned num) { } #endif /* !CONFIG_SYSFS */ /* All the helper functions */ /* The macros to do compile-time type checking stolen from Jakub Jelinek, who IIRC came up with this idea for the 2.4 module init code. */ #define __param_check(name, p, type) … extern const struct kernel_param_ops param_ops_byte; extern int param_set_byte(const char *val, const struct kernel_param *kp); extern int param_get_byte(char *buffer, const struct kernel_param *kp); #define param_check_byte(name, p) … extern const struct kernel_param_ops param_ops_short; extern int param_set_short(const char *val, const struct kernel_param *kp); extern int param_get_short(char *buffer, const struct kernel_param *kp); #define param_check_short(name, p) … extern const struct kernel_param_ops param_ops_ushort; extern int param_set_ushort(const char *val, const struct kernel_param *kp); extern int param_get_ushort(char *buffer, const struct kernel_param *kp); #define param_check_ushort(name, p) … extern const struct kernel_param_ops param_ops_int; extern int param_set_int(const char *val, const struct kernel_param *kp); extern int param_get_int(char *buffer, const struct kernel_param *kp); #define param_check_int(name, p) … extern const struct kernel_param_ops param_ops_uint; extern int param_set_uint(const char *val, const struct kernel_param *kp); extern int param_get_uint(char *buffer, const struct kernel_param *kp); int param_set_uint_minmax(const char *val, const struct kernel_param *kp, unsigned int min, unsigned int max); #define param_check_uint(name, p) … extern const struct kernel_param_ops param_ops_long; extern int param_set_long(const char *val, const struct kernel_param *kp); extern int param_get_long(char *buffer, const struct kernel_param *kp); #define param_check_long(name, p) … extern const struct kernel_param_ops param_ops_ulong; extern int param_set_ulong(const char *val, const struct kernel_param *kp); extern int param_get_ulong(char *buffer, const struct kernel_param *kp); #define param_check_ulong(name, p) … extern const struct kernel_param_ops param_ops_ullong; extern int param_set_ullong(const char *val, const struct kernel_param *kp); extern int param_get_ullong(char *buffer, const struct kernel_param *kp); #define param_check_ullong(name, p) … extern const struct kernel_param_ops param_ops_hexint; extern int param_set_hexint(const char *val, const struct kernel_param *kp); extern int param_get_hexint(char *buffer, const struct kernel_param *kp); #define param_check_hexint(name, p) … extern const struct kernel_param_ops param_ops_charp; extern int param_set_charp(const char *val, const struct kernel_param *kp); extern int param_get_charp(char *buffer, const struct kernel_param *kp); extern void param_free_charp(void *arg); #define param_check_charp(name, p) … /* We used to allow int as well as bool. We're taking that away! */ extern const struct kernel_param_ops param_ops_bool; extern int param_set_bool(const char *val, const struct kernel_param *kp); extern int param_get_bool(char *buffer, const struct kernel_param *kp); #define param_check_bool(name, p) … extern const struct kernel_param_ops param_ops_bool_enable_only; extern int param_set_bool_enable_only(const char *val, const struct kernel_param *kp); /* getter is the same as for the regular bool */ #define param_check_bool_enable_only … extern const struct kernel_param_ops param_ops_invbool; extern int param_set_invbool(const char *val, const struct kernel_param *kp); extern int param_get_invbool(char *buffer, const struct kernel_param *kp); #define param_check_invbool(name, p) … /* An int, which can only be set like a bool (though it shows as an int). */ extern const struct kernel_param_ops param_ops_bint; extern int param_set_bint(const char *val, const struct kernel_param *kp); #define param_get_bint … #define param_check_bint … /** * module_param_array - a parameter which is an array of some type * @name: the name of the array variable * @type: the type, as per module_param() * @nump: optional pointer filled in with the number written * @perm: visibility in sysfs * * Input and output are as comma-separated values. Commas inside values * don't work properly (eg. an array of charp). * * ARRAY_SIZE(@name) is used to determine the number of elements in the * array, so the definition must be visible. */ #define module_param_array(name, type, nump, perm) … /** * module_param_array_named - renamed parameter which is an array of some type * @name: a valid C identifier which is the parameter name * @array: the name of the array variable * @type: the type, as per module_param() * @nump: optional pointer filled in with the number written * @perm: visibility in sysfs * * This exposes a different name than the actual variable name. See * module_param_named() for why this might be necessary. */ #define module_param_array_named(name, array, type, nump, perm) … enum hwparam_type { … }; /** * module_param_hw_named - A parameter representing a hw parameters * @name: a valid C identifier which is the parameter name. * @value: the actual lvalue to alter. * @type: the type of the parameter * @hwtype: what the value represents (enum hwparam_type) * @perm: visibility in sysfs. * * Usually it's a good idea to have variable names and user-exposed names the * same, but that's harder if the variable must be non-static or is inside a * structure. This allows exposure under a different name. */ #define module_param_hw_named(name, value, type, hwtype, perm) … #define module_param_hw(name, type, hwtype, perm) … /** * module_param_hw_array - A parameter representing an array of hw parameters * @name: the name of the array variable * @type: the type, as per module_param() * @hwtype: what the value represents (enum hwparam_type) * @nump: optional pointer filled in with the number written * @perm: visibility in sysfs * * Input and output are as comma-separated values. Commas inside values * don't work properly (eg. an array of charp). * * ARRAY_SIZE(@name) is used to determine the number of elements in the * array, so the definition must be visible. */ #define module_param_hw_array(name, type, hwtype, nump, perm) … extern const struct kernel_param_ops param_array_ops; extern const struct kernel_param_ops param_ops_string; extern int param_set_copystring(const char *val, const struct kernel_param *); extern int param_get_string(char *buffer, const struct kernel_param *kp); /* for exporting parameters in /sys/module/.../parameters */ struct module; #if defined(CONFIG_SYSFS) && defined(CONFIG_MODULES) extern int module_param_sysfs_setup(struct module *mod, const struct kernel_param *kparam, unsigned int num_params); extern void module_param_sysfs_remove(struct module *mod); #else static inline int module_param_sysfs_setup(struct module *mod, const struct kernel_param *kparam, unsigned int num_params) { return 0; } static inline void module_param_sysfs_remove(struct module *mod) { } #endif #endif /* _LINUX_MODULE_PARAMS_H */
Codebase Browser
linux