aboutsummaryrefslogtreecommitdiffstats
path: root/include/linux/moduleparam.h
diff options
context:
space:
mode:
Diffstat (limited to 'include/linux/moduleparam.h')
-rw-r--r--include/linux/moduleparam.h298
1 files changed, 227 insertions, 71 deletions
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index 82a9124f7d75..07b41951e3fa 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -16,35 +16,40 @@
16/* Chosen so that structs with an unsigned long line up. */ 16/* Chosen so that structs with an unsigned long line up. */
17#define MAX_PARAM_PREFIX_LEN (64 - sizeof(unsigned long)) 17#define MAX_PARAM_PREFIX_LEN (64 - sizeof(unsigned long))
18 18
19#ifdef MODULE
20#define ___module_cat(a,b) __mod_ ## a ## b 19#define ___module_cat(a,b) __mod_ ## a ## b
21#define __module_cat(a,b) ___module_cat(a,b) 20#define __module_cat(a,b) ___module_cat(a,b)
21#ifdef MODULE
22#define __MODULE_INFO(tag, name, info) \ 22#define __MODULE_INFO(tag, name, info) \
23static const char __module_cat(name,__LINE__)[] \ 23static const char __module_cat(name,__LINE__)[] \
24 __used \ 24 __used __attribute__((section(".modinfo"), unused, aligned(1))) \
25 __attribute__((section(".modinfo"),unused)) = __stringify(tag) "=" info 25 = __stringify(tag) "=" info
26#else /* !MODULE */ 26#else /* !MODULE */
27#define __MODULE_INFO(tag, name, info) 27/* This struct is here for syntactic coherency, it is not used */
28#define __MODULE_INFO(tag, name, info) \
29 struct __module_cat(name,__LINE__) {}
28#endif 30#endif
29#define __MODULE_PARM_TYPE(name, _type) \ 31#define __MODULE_PARM_TYPE(name, _type) \
30 __MODULE_INFO(parmtype, name##type, #name ":" _type) 32 __MODULE_INFO(parmtype, name##type, #name ":" _type)
31 33
32struct kernel_param; 34struct kernel_param;
33 35
34/* Returns 0, or -errno. arg is in kp->arg. */ 36struct kernel_param_ops {
35typedef int (*param_set_fn)(const char *val, struct kernel_param *kp); 37 /* Returns 0, or -errno. arg is in kp->arg. */
36/* Returns length written or -errno. Buffer is 4k (ie. be short!) */ 38 int (*set)(const char *val, const struct kernel_param *kp);
37typedef int (*param_get_fn)(char *buffer, struct kernel_param *kp); 39 /* Returns length written or -errno. Buffer is 4k (ie. be short!) */
40 int (*get)(char *buffer, const struct kernel_param *kp);
41 /* Optional function to free kp->arg when module unloaded. */
42 void (*free)(void *arg);
43};
38 44
39/* Flag bits for kernel_param.flags */ 45/* Flag bits for kernel_param.flags */
40#define KPARAM_ISBOOL 2 46#define KPARAM_ISBOOL 2
41 47
42struct kernel_param { 48struct kernel_param {
43 const char *name; 49 const char *name;
50 const struct kernel_param_ops *ops;
44 u16 perm; 51 u16 perm;
45 u16 flags; 52 u16 flags;
46 param_set_fn set;
47 param_get_fn get;
48 union { 53 union {
49 void *arg; 54 void *arg;
50 const struct kparam_string *str; 55 const struct kparam_string *str;
@@ -63,12 +68,67 @@ struct kparam_array
63{ 68{
64 unsigned int max; 69 unsigned int max;
65 unsigned int *num; 70 unsigned int *num;
66 param_set_fn set; 71 const struct kernel_param_ops *ops;
67 param_get_fn get;
68 unsigned int elemsize; 72 unsigned int elemsize;
69 void *elem; 73 void *elem;
70}; 74};
71 75
76/**
77 * module_param - typesafe helper for a module/cmdline parameter
78 * @value: the variable to alter, and exposed parameter name.
79 * @type: the type of the parameter
80 * @perm: visibility in sysfs.
81 *
82 * @value becomes the module parameter, or (prefixed by KBUILD_MODNAME and a
83 * ".") the kernel commandline parameter. Note that - is changed to _, so
84 * the user can use "foo-bar=1" even for variable "foo_bar".
85 *
86 * @perm is 0 if the the variable is not to appear in sysfs, or 0444
87 * for world-readable, 0644 for root-writable, etc. Note that if it
88 * is writable, you may need to use kparam_block_sysfs_write() around
89 * accesses (esp. charp, which can be kfreed when it changes).
90 *
91 * The @type is simply pasted to refer to a param_ops_##type and a
92 * param_check_##type: for convenience many standard types are provided but
93 * you can create your own by defining those variables.
94 *
95 * Standard types are:
96 * byte, short, ushort, int, uint, long, ulong
97 * charp: a character pointer
98 * bool: a bool, values 0/1, y/n, Y/N.
99 * invbool: the above, only sense-reversed (N = true).
100 */
101#define module_param(name, type, perm) \
102 module_param_named(name, name, type, perm)
103
104/**
105 * module_param_named - typesafe helper for a renamed module/cmdline parameter
106 * @name: a valid C identifier which is the parameter name.
107 * @value: the actual lvalue to alter.
108 * @type: the type of the parameter
109 * @perm: visibility in sysfs.
110 *
111 * Usually it's a good idea to have variable names and user-exposed names the
112 * same, but that's harder if the variable must be non-static or is inside a
113 * structure. This allows exposure under a different name.
114 */
115#define module_param_named(name, value, type, perm) \
116 param_check_##type(name, &(value)); \
117 module_param_cb(name, &param_ops_##type, &value, perm); \
118 __MODULE_PARM_TYPE(name, #type)
119
120/**
121 * module_param_cb - general callback for a module/cmdline parameter
122 * @name: a valid C identifier which is the parameter name.
123 * @ops: the set & get operations for this parameter.
124 * @perm: visibility in sysfs.
125 *
126 * The ops can have NULL set or get functions.
127 */
128#define module_param_cb(name, ops, arg, perm) \
129 __module_param_call(MODULE_PARAM_PREFIX, \
130 name, ops, arg, __same_type((arg), bool *), perm)
131
72/* On alpha, ia64 and ppc64 relocations to global data cannot go into 132/* On alpha, ia64 and ppc64 relocations to global data cannot go into
73 read-only sections (which is part of respective UNIX ABI on these 133 read-only sections (which is part of respective UNIX ABI on these
74 platforms). So 'const' makes no sense and even causes compile failures 134 platforms). So 'const' makes no sense and even causes compile failures
@@ -80,10 +140,8 @@ struct kparam_array
80#endif 140#endif
81 141
82/* This is the fundamental function for registering boot/module 142/* This is the fundamental function for registering boot/module
83 parameters. perm sets the visibility in sysfs: 000 means it's 143 parameters. */
84 not there, read bits mean it's readable, write bits mean it's 144#define __module_param_call(prefix, name, ops, arg, isbool, perm) \
85 writable. */
86#define __module_param_call(prefix, name, set, get, arg, isbool, perm) \
87 /* Default value instead of permissions? */ \ 145 /* Default value instead of permissions? */ \
88 static int __param_perm_check_##name __attribute__((unused)) = \ 146 static int __param_perm_check_##name __attribute__((unused)) = \
89 BUILD_BUG_ON_ZERO((perm) < 0 || (perm) > 0777 || ((perm) & 2)) \ 147 BUILD_BUG_ON_ZERO((perm) < 0 || (perm) > 0777 || ((perm) & 2)) \
@@ -92,31 +150,87 @@ struct kparam_array
92 static struct kernel_param __moduleparam_const __param_##name \ 150 static struct kernel_param __moduleparam_const __param_##name \
93 __used \ 151 __used \
94 __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \ 152 __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \
95 = { __param_str_##name, perm, isbool ? KPARAM_ISBOOL : 0, \ 153 = { __param_str_##name, ops, perm, isbool ? KPARAM_ISBOOL : 0, \
96 set, get, { arg } } 154 { arg } }
155
156/* Obsolete - use module_param_cb() */
157#define module_param_call(name, set, get, arg, perm) \
158 static struct kernel_param_ops __param_ops_##name = \
159 { (void *)set, (void *)get }; \
160 __module_param_call(MODULE_PARAM_PREFIX, \
161 name, &__param_ops_##name, arg, \
162 __same_type(arg, bool *), \
163 (perm) + sizeof(__check_old_set_param(set))*0)
164
165/* We don't get oldget: it's often a new-style param_get_uint, etc. */
166static inline int
167__check_old_set_param(int (*oldset)(const char *, struct kernel_param *))
168{
169 return 0;
170}
97 171
98#define module_param_call(name, set, get, arg, perm) \ 172/**
99 __module_param_call(MODULE_PARAM_PREFIX, \ 173 * kparam_block_sysfs_write - make sure a parameter isn't written via sysfs.
100 name, set, get, arg, \ 174 * @name: the name of the parameter
101 __same_type(*(arg), bool), perm) 175 *
176 * There's no point blocking write on a paramter that isn't writable via sysfs!
177 */
178#define kparam_block_sysfs_write(name) \
179 do { \
180 BUG_ON(!(__param_##name.perm & 0222)); \
181 __kernel_param_lock(); \
182 } while (0)
102 183
103/* Helper functions: type is byte, short, ushort, int, uint, long, 184/**
104 ulong, charp, bool or invbool, or XXX if you define param_get_XXX, 185 * kparam_unblock_sysfs_write - allows sysfs to write to a parameter again.
105 param_set_XXX and param_check_XXX. */ 186 * @name: the name of the parameter
106#define module_param_named(name, value, type, perm) \ 187 */
107 param_check_##type(name, &(value)); \ 188#define kparam_unblock_sysfs_write(name) \
108 module_param_call(name, param_set_##type, param_get_##type, &value, perm); \ 189 do { \
109 __MODULE_PARM_TYPE(name, #type) 190 BUG_ON(!(__param_##name.perm & 0222)); \
191 __kernel_param_unlock(); \
192 } while (0)
110 193
111#define module_param(name, type, perm) \ 194/**
112 module_param_named(name, name, type, perm) 195 * kparam_block_sysfs_read - make sure a parameter isn't read via sysfs.
196 * @name: the name of the parameter
197 *
198 * This also blocks sysfs writes.
199 */
200#define kparam_block_sysfs_read(name) \
201 do { \
202 BUG_ON(!(__param_##name.perm & 0444)); \
203 __kernel_param_lock(); \
204 } while (0)
205
206/**
207 * kparam_unblock_sysfs_read - allows sysfs to read a parameter again.
208 * @name: the name of the parameter
209 */
210#define kparam_unblock_sysfs_read(name) \
211 do { \
212 BUG_ON(!(__param_##name.perm & 0444)); \
213 __kernel_param_unlock(); \
214 } while (0)
215
216#ifdef CONFIG_SYSFS
217extern void __kernel_param_lock(void);
218extern void __kernel_param_unlock(void);
219#else
220static inline void __kernel_param_lock(void)
221{
222}
223static inline void __kernel_param_unlock(void)
224{
225}
226#endif
113 227
114#ifndef MODULE 228#ifndef MODULE
115/** 229/**
116 * core_param - define a historical core kernel parameter. 230 * core_param - define a historical core kernel parameter.
117 * @name: the name of the cmdline and sysfs parameter (often the same as var) 231 * @name: the name of the cmdline and sysfs parameter (often the same as var)
118 * @var: the variable 232 * @var: the variable
119 * @type: the type (for param_set_##type and param_get_##type) 233 * @type: the type of the parameter
120 * @perm: visibility in sysfs 234 * @perm: visibility in sysfs
121 * 235 *
122 * core_param is just like module_param(), but cannot be modular and 236 * core_param is just like module_param(), but cannot be modular and
@@ -126,23 +240,32 @@ struct kparam_array
126 */ 240 */
127#define core_param(name, var, type, perm) \ 241#define core_param(name, var, type, perm) \
128 param_check_##type(name, &(var)); \ 242 param_check_##type(name, &(var)); \
129 __module_param_call("", name, param_set_##type, param_get_##type, \ 243 __module_param_call("", name, &param_ops_##type, \
130 &var, __same_type(var, bool), perm) 244 &var, __same_type(var, bool), perm)
131#endif /* !MODULE */ 245#endif /* !MODULE */
132 246
133/* Actually copy string: maxlen param is usually sizeof(string). */ 247/**
248 * module_param_string - a char array parameter
249 * @name: the name of the parameter
250 * @string: the string variable
251 * @len: the maximum length of the string, incl. terminator
252 * @perm: visibility in sysfs.
253 *
254 * This actually copies the string when it's set (unlike type charp).
255 * @len is usually just sizeof(string).
256 */
134#define module_param_string(name, string, len, perm) \ 257#define module_param_string(name, string, len, perm) \
135 static const struct kparam_string __param_string_##name \ 258 static const struct kparam_string __param_string_##name \
136 = { len, string }; \ 259 = { len, string }; \
137 __module_param_call(MODULE_PARAM_PREFIX, name, \ 260 __module_param_call(MODULE_PARAM_PREFIX, name, \
138 param_set_copystring, param_get_string, \ 261 &param_ops_string, \
139 .str = &__param_string_##name, 0, perm); \ 262 .str = &__param_string_##name, 0, perm); \
140 __MODULE_PARM_TYPE(name, "string") 263 __MODULE_PARM_TYPE(name, "string")
141 264
142/* Called on module insert or kernel boot */ 265/* Called on module insert or kernel boot */
143extern int parse_args(const char *name, 266extern int parse_args(const char *name,
144 char *args, 267 char *args,
145 struct kernel_param *params, 268 const struct kernel_param *params,
146 unsigned num, 269 unsigned num,
147 int (*unknown)(char *param, char *val)); 270 int (*unknown)(char *param, char *val));
148 271
@@ -162,72 +285,105 @@ static inline void destroy_params(const struct kernel_param *params,
162#define __param_check(name, p, type) \ 285#define __param_check(name, p, type) \
163 static inline type *__check_##name(void) { return(p); } 286 static inline type *__check_##name(void) { return(p); }
164 287
165extern int param_set_byte(const char *val, struct kernel_param *kp); 288extern struct kernel_param_ops param_ops_byte;
166extern int param_get_byte(char *buffer, struct kernel_param *kp); 289extern int param_set_byte(const char *val, const struct kernel_param *kp);
290extern int param_get_byte(char *buffer, const struct kernel_param *kp);
167#define param_check_byte(name, p) __param_check(name, p, unsigned char) 291#define param_check_byte(name, p) __param_check(name, p, unsigned char)
168 292
169extern int param_set_short(const char *val, struct kernel_param *kp); 293extern struct kernel_param_ops param_ops_short;
170extern int param_get_short(char *buffer, struct kernel_param *kp); 294extern int param_set_short(const char *val, const struct kernel_param *kp);
295extern int param_get_short(char *buffer, const struct kernel_param *kp);
171#define param_check_short(name, p) __param_check(name, p, short) 296#define param_check_short(name, p) __param_check(name, p, short)
172 297
173extern int param_set_ushort(const char *val, struct kernel_param *kp); 298extern struct kernel_param_ops param_ops_ushort;
174extern int param_get_ushort(char *buffer, struct kernel_param *kp); 299extern int param_set_ushort(const char *val, const struct kernel_param *kp);
300extern int param_get_ushort(char *buffer, const struct kernel_param *kp);
175#define param_check_ushort(name, p) __param_check(name, p, unsigned short) 301#define param_check_ushort(name, p) __param_check(name, p, unsigned short)
176 302
177extern int param_set_int(const char *val, struct kernel_param *kp); 303extern struct kernel_param_ops param_ops_int;
178extern int param_get_int(char *buffer, struct kernel_param *kp); 304extern int param_set_int(const char *val, const struct kernel_param *kp);
305extern int param_get_int(char *buffer, const struct kernel_param *kp);
179#define param_check_int(name, p) __param_check(name, p, int) 306#define param_check_int(name, p) __param_check(name, p, int)
180 307
181extern int param_set_uint(const char *val, struct kernel_param *kp); 308extern struct kernel_param_ops param_ops_uint;
182extern int param_get_uint(char *buffer, struct kernel_param *kp); 309extern int param_set_uint(const char *val, const struct kernel_param *kp);
310extern int param_get_uint(char *buffer, const struct kernel_param *kp);
183#define param_check_uint(name, p) __param_check(name, p, unsigned int) 311#define param_check_uint(name, p) __param_check(name, p, unsigned int)
184 312
185extern int param_set_long(const char *val, struct kernel_param *kp); 313extern struct kernel_param_ops param_ops_long;
186extern int param_get_long(char *buffer, struct kernel_param *kp); 314extern int param_set_long(const char *val, const struct kernel_param *kp);
315extern int param_get_long(char *buffer, const struct kernel_param *kp);
187#define param_check_long(name, p) __param_check(name, p, long) 316#define param_check_long(name, p) __param_check(name, p, long)
188 317
189extern int param_set_ulong(const char *val, struct kernel_param *kp); 318extern struct kernel_param_ops param_ops_ulong;
190extern int param_get_ulong(char *buffer, struct kernel_param *kp); 319extern int param_set_ulong(const char *val, const struct kernel_param *kp);
320extern int param_get_ulong(char *buffer, const struct kernel_param *kp);
191#define param_check_ulong(name, p) __param_check(name, p, unsigned long) 321#define param_check_ulong(name, p) __param_check(name, p, unsigned long)
192 322
193extern int param_set_charp(const char *val, struct kernel_param *kp); 323extern struct kernel_param_ops param_ops_charp;
194extern int param_get_charp(char *buffer, struct kernel_param *kp); 324extern int param_set_charp(const char *val, const struct kernel_param *kp);
325extern int param_get_charp(char *buffer, const struct kernel_param *kp);
195#define param_check_charp(name, p) __param_check(name, p, char *) 326#define param_check_charp(name, p) __param_check(name, p, char *)
196 327
197/* For historical reasons "bool" parameters can be (unsigned) "int". */ 328/* For historical reasons "bool" parameters can be (unsigned) "int". */
198extern int param_set_bool(const char *val, struct kernel_param *kp); 329extern struct kernel_param_ops param_ops_bool;
199extern int param_get_bool(char *buffer, struct kernel_param *kp); 330extern int param_set_bool(const char *val, const struct kernel_param *kp);
331extern int param_get_bool(char *buffer, const struct kernel_param *kp);
200#define param_check_bool(name, p) \ 332#define param_check_bool(name, p) \
201 static inline void __check_##name(void) \ 333 static inline void __check_##name(void) \
202 { \ 334 { \
203 BUILD_BUG_ON(!__same_type(*(p), bool) && \ 335 BUILD_BUG_ON(!__same_type((p), bool *) && \
204 !__same_type(*(p), unsigned int) && \ 336 !__same_type((p), unsigned int *) && \
205 !__same_type(*(p), int)); \ 337 !__same_type((p), int *)); \
206 } 338 }
207 339
208extern int param_set_invbool(const char *val, struct kernel_param *kp); 340extern struct kernel_param_ops param_ops_invbool;
209extern int param_get_invbool(char *buffer, struct kernel_param *kp); 341extern int param_set_invbool(const char *val, const struct kernel_param *kp);
342extern int param_get_invbool(char *buffer, const struct kernel_param *kp);
210#define param_check_invbool(name, p) __param_check(name, p, bool) 343#define param_check_invbool(name, p) __param_check(name, p, bool)
211 344
212/* Comma-separated array: *nump is set to number they actually specified. */ 345/**
346 * module_param_array - a parameter which is an array of some type
347 * @name: the name of the array variable
348 * @type: the type, as per module_param()
349 * @nump: optional pointer filled in with the number written
350 * @perm: visibility in sysfs
351 *
352 * Input and output are as comma-separated values. Commas inside values
353 * don't work properly (eg. an array of charp).
354 *
355 * ARRAY_SIZE(@name) is used to determine the number of elements in the
356 * array, so the definition must be visible.
357 */
358#define module_param_array(name, type, nump, perm) \
359 module_param_array_named(name, name, type, nump, perm)
360
361/**
362 * module_param_array_named - renamed parameter which is an array of some type
363 * @name: a valid C identifier which is the parameter name
364 * @array: the name of the array variable
365 * @type: the type, as per module_param()
366 * @nump: optional pointer filled in with the number written
367 * @perm: visibility in sysfs
368 *
369 * This exposes a different name than the actual variable name. See
370 * module_param_named() for why this might be necessary.
371 */
213#define module_param_array_named(name, array, type, nump, perm) \ 372#define module_param_array_named(name, array, type, nump, perm) \
214 static const struct kparam_array __param_arr_##name \ 373 static const struct kparam_array __param_arr_##name \
215 = { ARRAY_SIZE(array), nump, param_set_##type, param_get_##type,\ 374 = { ARRAY_SIZE(array), nump, &param_ops_##type, \
216 sizeof(array[0]), array }; \ 375 sizeof(array[0]), array }; \
217 __module_param_call(MODULE_PARAM_PREFIX, name, \ 376 __module_param_call(MODULE_PARAM_PREFIX, name, \
218 param_array_set, param_array_get, \ 377 &param_array_ops, \
219 .arr = &__param_arr_##name, \ 378 .arr = &__param_arr_##name, \
220 __same_type(array[0], bool), perm); \ 379 __same_type(array[0], bool), perm); \
221 __MODULE_PARM_TYPE(name, "array of " #type) 380 __MODULE_PARM_TYPE(name, "array of " #type)
222 381
223#define module_param_array(name, type, nump, perm) \ 382extern struct kernel_param_ops param_array_ops;
224 module_param_array_named(name, name, type, nump, perm)
225
226extern int param_array_set(const char *val, struct kernel_param *kp);
227extern int param_array_get(char *buffer, struct kernel_param *kp);
228 383
229extern int param_set_copystring(const char *val, struct kernel_param *kp); 384extern struct kernel_param_ops param_ops_string;
230extern int param_get_string(char *buffer, struct kernel_param *kp); 385extern int param_set_copystring(const char *val, const struct kernel_param *);
386extern int param_get_string(char *buffer, const struct kernel_param *kp);
231 387
232/* for exporting parameters in /sys/parameters */ 388/* for exporting parameters in /sys/parameters */
233 389
@@ -235,13 +391,13 @@ struct module;
235 391
236#if defined(CONFIG_SYSFS) && defined(CONFIG_MODULES) 392#if defined(CONFIG_SYSFS) && defined(CONFIG_MODULES)
237extern int module_param_sysfs_setup(struct module *mod, 393extern int module_param_sysfs_setup(struct module *mod,
238 struct kernel_param *kparam, 394 const struct kernel_param *kparam,
239 unsigned int num_params); 395 unsigned int num_params);
240 396
241extern void module_param_sysfs_remove(struct module *mod); 397extern void module_param_sysfs_remove(struct module *mod);
242#else 398#else
243static inline int module_param_sysfs_setup(struct module *mod, 399static inline int module_param_sysfs_setup(struct module *mod,
244 struct kernel_param *kparam, 400 const struct kernel_param *kparam,
245 unsigned int num_params) 401 unsigned int num_params)
246{ 402{
247 return 0; 403 return 0;
generated by cgit v1.2.2 (git 2.25.0) at 2026-03-16 03:16:34 -0400