include/linux/moduleparam.h

10    module name. */
23 #define __MODULE_INFO(tag, name, info)					  \  argument
24 static const char __UNIQUE_ID(name)[]					  \
28 #define __MODULE_PARM_TYPE(name, _type)					  \  argument
29   __MODULE_INFO(parmtype, name##type, #name ":" _type)
70 	const char *name;  member
103  * @name: the variable to alter, and exposed parameter name.
107  * @name becomes the module parameter, or (prefixed by KBUILD_MODNAME and a
126 #define module_param(name, type, perm)				\  argument
127 	module_param_named(name, name, type, perm)
131  * @name: the variable to alter, and exposed parameter name.
135 #define module_param_unsafe(name, type, perm)			\  argument
136 	module_param_named_unsafe(name, name, type, perm)
140  * @name: a valid C identifier which is the parameter name.
147  * structure.  This allows exposure under a different name.
149 #define module_param_named(name, value, type, perm)			   \  argument
150 	param_check_##type(name, &(value));				   \
151 	module_param_cb(name, &param_ops_##type, &value, perm);		   \
152 	__MODULE_PARM_TYPE(name, #type)
156  * @name: a valid C identifier which is the parameter name.
161 #define module_param_named_unsafe(name, value, type, perm)		\  argument
162 	param_check_##type(name, &(value));				\
163 	module_param_cb_unsafe(name, &param_ops_##type, &value, perm);	\
164 	__MODULE_PARM_TYPE(name, #type)
168  * @name: a valid C identifier which is the parameter name.
175 #define module_param_cb(name, ops, arg, perm)				      \  argument
176 	__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1, 0)
178 #define module_param_cb_unsafe(name, ops, arg, perm)			      \  argument
179 	__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1,    \
182 #define __level_param_cb(name, ops, arg, perm, level)			\  argument
183 	__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, level, 0)
187  * @name: a valid C identifier which is the parameter name.
194 #define core_param_cb(name, ops, arg, perm)		\  argument
195 	__level_param_cb(name, ops, arg, perm, 1)
200  * @name: a valid C identifier which is the parameter name.
207 #define postcore_param_cb(name, ops, arg, perm)		\  argument
208 	__level_param_cb(name, ops, arg, perm, 2)
213  * @name: a valid C identifier which is the parameter name.
220 #define arch_param_cb(name, ops, arg, perm)		\  argument
221 	__level_param_cb(name, ops, arg, perm, 3)
226  * @name: a valid C identifier which is the parameter name.
233 #define subsys_param_cb(name, ops, arg, perm)		\  argument
234 	__level_param_cb(name, ops, arg, perm, 4)
239  * @name: a valid C identifier which is the parameter name.
246 #define fs_param_cb(name, ops, arg, perm)		\  argument
247 	__level_param_cb(name, ops, arg, perm, 5)
252  * @name: a valid C identifier which is the parameter name.
259 #define device_param_cb(name, ops, arg, perm)		\  argument
260 	__level_param_cb(name, ops, arg, perm, 6)
265  * @name: a valid C identifier which is the parameter name.
272 #define late_param_cb(name, ops, arg, perm)		\  argument
273 	__level_param_cb(name, ops, arg, perm, 7)
287 #define __module_param_call(prefix, name, ops, arg, perm, level, flags)	\  argument
289 	static const char __param_str_##name[] = prefix #name;		\
290 	static struct kernel_param __moduleparam_const __param_##name	\
293 	= { __param_str_##name, THIS_MODULE, ops,			\
297 #define module_param_call(name, _set, _get, arg, perm)			\  argument
298 	static const struct kernel_param_ops __param_ops_##name =	\
301 			    name, &__param_ops_##name, arg, perm, -1, 0)
318  * @name: the name of the cmdline and sysfs parameter (often the same as var)
328 #define core_param(name, var, type, perm)				\  argument
329 	param_check_##type(name, &(var));				\
330 	__module_param_call("", name, &param_ops_##type, &var, perm, -1, 0)
334  * @name: the name of the cmdline and sysfs parameter (often the same as var)
339 #define core_param_unsafe(name, var, type, perm)		\  argument
340 	param_check_##type(name, &(var));				\
341 	__module_param_call("", name, &param_ops_##type, &var, perm,	\
348  * @name: the name of the parameter
356 #define module_param_string(name, string, len, perm)			\  argument
357 	static const struct kparam_string __param_string_##name		\
359 	__module_param_call(MODULE_PARAM_PREFIX, name,			\
361 			    .str = &__param_string_##name, perm, -1, 0);\
362 	__MODULE_PARM_TYPE(name, "string")
366  * @name1: parameter name 1
367  * @name2: parameter name 2
376  * @name1: parameter name 1
377  * @name2: parameter name 2
385 extern char *parse_args(const char *name,
408 #define __param_check(name, p, type) \  argument
409 	static inline type __always_unused *__check_##name(void) { return(p); }
414 #define param_check_byte(name, p) __param_check(name, p, unsigned char)  argument
419 #define param_check_short(name, p) __param_check(name, p, short)  argument
424 #define param_check_ushort(name, p) __param_check(name, p, unsigned short)  argument
429 #define param_check_int(name, p) __param_check(name, p, int)  argument
434 #define param_check_uint(name, p) __param_check(name, p, unsigned int)  argument
439 #define param_check_long(name, p) __param_check(name, p, long)  argument
444 #define param_check_ulong(name, p) __param_check(name, p, unsigned long)  argument
449 #define param_check_ullong(name, p) __param_check(name, p, unsigned long long)  argument
454 #define param_check_hexint(name, p) param_check_uint(name, p)  argument
460 #define param_check_charp(name, p) __param_check(name, p, char *)  argument
466 #define param_check_bool(name, p) __param_check(name, p, bool)  argument
477 #define param_check_invbool(name, p) __param_check(name, p, bool)  argument
487  * @name: the name of the array variable
495  * ARRAY_SIZE(@name) is used to determine the number of elements in the
498 #define module_param_array(name, type, nump, perm)		\  argument
499 	module_param_array_named(name, name, type, nump, perm)
503  * @name: a valid C identifier which is the parameter name
504  * @array: the name of the array variable
509  * This exposes a different name than the actual variable name.  See
512 #define module_param_array_named(name, array, type, nump, perm)		\  argument
513 	param_check_##type(name, &(array)[0]);				\
514 	static const struct kparam_array __param_arr_##name		\
518 	__module_param_call(MODULE_PARAM_PREFIX, name,			\
520 			    .arr = &__param_arr_##name,			\
522 	__MODULE_PARM_TYPE(name, "array of " #type)
536  * @name: a valid C identifier which is the parameter name.
544  * structure.  This allows exposure under a different name.
546 #define module_param_hw_named(name, value, type, hwtype, perm)		\  argument
547 	param_check_##type(name, &(value));				\
548 	__module_param_call(MODULE_PARAM_PREFIX, name,			\
552 	__MODULE_PARM_TYPE(name, #type)
554 #define module_param_hw(name, type, hwtype, perm)		\  argument
555 	module_param_hw_named(name, name, type, hwtype, perm)
559  * @name: the name of the array variable
568  * ARRAY_SIZE(@name) is used to determine the number of elements in the
571 #define module_param_hw_array(name, type, hwtype, nump, perm)		\  argument
572 	param_check_##type(name, &(name)[0]);				\
573 	static const struct kparam_array __param_arr_##name		\
574 	= { .max = ARRAY_SIZE(name), .num = nump,			\
576 	    .elemsize = sizeof(name[0]), .elem = name };		\
577 	__module_param_call(MODULE_PARAM_PREFIX, name,			\
579 			    .arr = &__param_arr_##name,			\
582 	__MODULE_PARM_TYPE(name, "array of " #type)