Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef _LINUX_MODULE_PARAMS_H |
| 2 | #define _LINUX_MODULE_PARAMS_H |
| 3 | /* (C) Copyright 2001, 2002 Rusty Russell IBM Corporation */ |
| 4 | #include <linux/init.h> |
| 5 | #include <linux/stringify.h> |
| 6 | #include <linux/kernel.h> |
| 7 | |
| 8 | /* You can override this manually, but generally this should match the |
| 9 | module name. */ |
| 10 | #ifdef MODULE |
| 11 | #define MODULE_PARAM_PREFIX /* empty */ |
| 12 | #else |
Sam Ravnborg | 367cb70 | 2006-01-06 21:17:50 +0100 | [diff] [blame] | 13 | #define MODULE_PARAM_PREFIX KBUILD_MODNAME "." |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | #endif |
| 15 | |
Rusty Russell | 730b69d | 2008-10-22 10:00:22 -0500 | [diff] [blame] | 16 | /* Chosen so that structs with an unsigned long line up. */ |
| 17 | #define MAX_PARAM_PREFIX_LEN (64 - sizeof(unsigned long)) |
| 18 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #define ___module_cat(a,b) __mod_ ## a ## b |
| 20 | #define __module_cat(a,b) ___module_cat(a,b) |
Linus Walleij | b75be42 | 2011-01-05 13:27:04 +0100 | [diff] [blame] | 21 | #ifdef MODULE |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | #define __MODULE_INFO(tag, name, info) \ |
| 23 | static const char __module_cat(name,__LINE__)[] \ |
Jan Beulich | b647277 | 2010-10-26 14:22:26 -0700 | [diff] [blame] | 24 | __used __attribute__((section(".modinfo"), unused, aligned(1))) \ |
| 25 | = __stringify(tag) "=" info |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | #else /* !MODULE */ |
Linus Walleij | b75be42 | 2011-01-05 13:27:04 +0100 | [diff] [blame] | 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__) {} |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | #endif |
| 31 | #define __MODULE_PARM_TYPE(name, _type) \ |
| 32 | __MODULE_INFO(parmtype, name##type, #name ":" _type) |
| 33 | |
Paul Gortmaker | 639938e | 2011-08-30 11:24:44 -0400 | [diff] [blame^] | 34 | /* One for each parameter, describing how to use it. Some files do |
| 35 | multiple of these per line, so can't just use MODULE_INFO. */ |
| 36 | #define MODULE_PARM_DESC(_parm, desc) \ |
| 37 | __MODULE_INFO(parm, _parm, #_parm ":" desc) |
| 38 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | struct kernel_param; |
| 40 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 41 | struct kernel_param_ops { |
| 42 | /* Returns 0, or -errno. arg is in kp->arg. */ |
| 43 | int (*set)(const char *val, const struct kernel_param *kp); |
| 44 | /* Returns length written or -errno. Buffer is 4k (ie. be short!) */ |
| 45 | int (*get)(char *buffer, const struct kernel_param *kp); |
Rusty Russell | e6df34a | 2010-08-11 23:04:17 -0600 | [diff] [blame] | 46 | /* Optional function to free kp->arg when module unloaded. */ |
| 47 | void (*free)(void *arg); |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 48 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | |
Rusty Russell | 45fcc70 | 2009-06-12 21:46:56 -0600 | [diff] [blame] | 50 | /* Flag bits for kernel_param.flags */ |
Rusty Russell | fddd520 | 2009-06-12 21:46:57 -0600 | [diff] [blame] | 51 | #define KPARAM_ISBOOL 2 |
Rusty Russell | 45fcc70 | 2009-06-12 21:46:56 -0600 | [diff] [blame] | 52 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | struct kernel_param { |
| 54 | const char *name; |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 55 | const struct kernel_param_ops *ops; |
Rusty Russell | 45fcc70 | 2009-06-12 21:46:56 -0600 | [diff] [blame] | 56 | u16 perm; |
| 57 | u16 flags; |
Jan Beulich | 22e48ea | 2007-10-16 23:29:34 -0700 | [diff] [blame] | 58 | union { |
| 59 | void *arg; |
| 60 | const struct kparam_string *str; |
| 61 | const struct kparam_array *arr; |
| 62 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | }; |
| 64 | |
| 65 | /* Special one for strings we want to copy into */ |
| 66 | struct kparam_string { |
| 67 | unsigned int maxlen; |
| 68 | char *string; |
| 69 | }; |
| 70 | |
| 71 | /* Special one for arrays */ |
| 72 | struct kparam_array |
| 73 | { |
| 74 | unsigned int max; |
Richard Kennedy | c5be0b2 | 2011-05-19 16:55:25 -0600 | [diff] [blame] | 75 | unsigned int elemsize; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | unsigned int *num; |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 77 | const struct kernel_param_ops *ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | void *elem; |
| 79 | }; |
| 80 | |
Rusty Russell | 546970b | 2010-08-11 23:04:20 -0600 | [diff] [blame] | 81 | /** |
| 82 | * module_param - typesafe helper for a module/cmdline parameter |
| 83 | * @value: the variable to alter, and exposed parameter name. |
| 84 | * @type: the type of the parameter |
| 85 | * @perm: visibility in sysfs. |
| 86 | * |
| 87 | * @value becomes the module parameter, or (prefixed by KBUILD_MODNAME and a |
| 88 | * ".") the kernel commandline parameter. Note that - is changed to _, so |
| 89 | * the user can use "foo-bar=1" even for variable "foo_bar". |
| 90 | * |
| 91 | * @perm is 0 if the the variable is not to appear in sysfs, or 0444 |
| 92 | * for world-readable, 0644 for root-writable, etc. Note that if it |
| 93 | * is writable, you may need to use kparam_block_sysfs_write() around |
| 94 | * accesses (esp. charp, which can be kfreed when it changes). |
| 95 | * |
| 96 | * The @type is simply pasted to refer to a param_ops_##type and a |
| 97 | * param_check_##type: for convenience many standard types are provided but |
| 98 | * you can create your own by defining those variables. |
| 99 | * |
| 100 | * Standard types are: |
| 101 | * byte, short, ushort, int, uint, long, ulong |
| 102 | * charp: a character pointer |
| 103 | * bool: a bool, values 0/1, y/n, Y/N. |
| 104 | * invbool: the above, only sense-reversed (N = true). |
| 105 | */ |
| 106 | #define module_param(name, type, perm) \ |
| 107 | module_param_named(name, name, type, perm) |
| 108 | |
| 109 | /** |
| 110 | * module_param_named - typesafe helper for a renamed module/cmdline parameter |
| 111 | * @name: a valid C identifier which is the parameter name. |
| 112 | * @value: the actual lvalue to alter. |
| 113 | * @type: the type of the parameter |
| 114 | * @perm: visibility in sysfs. |
| 115 | * |
| 116 | * Usually it's a good idea to have variable names and user-exposed names the |
| 117 | * same, but that's harder if the variable must be non-static or is inside a |
| 118 | * structure. This allows exposure under a different name. |
| 119 | */ |
| 120 | #define module_param_named(name, value, type, perm) \ |
| 121 | param_check_##type(name, &(value)); \ |
| 122 | module_param_cb(name, ¶m_ops_##type, &value, perm); \ |
| 123 | __MODULE_PARM_TYPE(name, #type) |
| 124 | |
| 125 | /** |
| 126 | * module_param_cb - general callback for a module/cmdline parameter |
| 127 | * @name: a valid C identifier which is the parameter name. |
| 128 | * @ops: the set & get operations for this parameter. |
| 129 | * @perm: visibility in sysfs. |
| 130 | * |
| 131 | * The ops can have NULL set or get functions. |
| 132 | */ |
| 133 | #define module_param_cb(name, ops, arg, perm) \ |
| 134 | __module_param_call(MODULE_PARAM_PREFIX, \ |
Rusty Russell | a6de51b | 2010-08-11 23:04:40 -0600 | [diff] [blame] | 135 | name, ops, arg, __same_type((arg), bool *), perm) |
Rusty Russell | 546970b | 2010-08-11 23:04:20 -0600 | [diff] [blame] | 136 | |
Ivan Kokshaysky | 91d35dd | 2008-02-13 15:03:26 -0800 | [diff] [blame] | 137 | /* On alpha, ia64 and ppc64 relocations to global data cannot go into |
| 138 | read-only sections (which is part of respective UNIX ABI on these |
| 139 | platforms). So 'const' makes no sense and even causes compile failures |
| 140 | with some compilers. */ |
| 141 | #if defined(CONFIG_ALPHA) || defined(CONFIG_IA64) || defined(CONFIG_PPC64) |
| 142 | #define __moduleparam_const |
| 143 | #else |
| 144 | #define __moduleparam_const const |
| 145 | #endif |
| 146 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | /* This is the fundamental function for registering boot/module |
Rusty Russell | 546970b | 2010-08-11 23:04:20 -0600 | [diff] [blame] | 148 | parameters. */ |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 149 | #define __module_param_call(prefix, name, ops, arg, isbool, perm) \ |
Alexey Dobriyan | 9774a1f | 2006-12-06 20:36:56 -0800 | [diff] [blame] | 150 | /* Default value instead of permissions? */ \ |
| 151 | static int __param_perm_check_##name __attribute__((unused)) = \ |
Rusty Russell | 730b69d | 2008-10-22 10:00:22 -0500 | [diff] [blame] | 152 | BUILD_BUG_ON_ZERO((perm) < 0 || (perm) > 0777 || ((perm) & 2)) \ |
| 153 | + BUILD_BUG_ON_ZERO(sizeof(""prefix) > MAX_PARAM_PREFIX_LEN); \ |
Jan Beulich | 22e48ea | 2007-10-16 23:29:34 -0700 | [diff] [blame] | 154 | static const char __param_str_##name[] = prefix #name; \ |
Ivan Kokshaysky | 91d35dd | 2008-02-13 15:03:26 -0800 | [diff] [blame] | 155 | static struct kernel_param __moduleparam_const __param_##name \ |
Adrian Bunk | 3ff6eec | 2008-01-24 22:16:20 +0100 | [diff] [blame] | 156 | __used \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \ |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 158 | = { __param_str_##name, ops, perm, isbool ? KPARAM_ISBOOL : 0, \ |
| 159 | { arg } } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 161 | /* Obsolete - use module_param_cb() */ |
| 162 | #define module_param_call(name, set, get, arg, perm) \ |
| 163 | static struct kernel_param_ops __param_ops_##name = \ |
| 164 | { (void *)set, (void *)get }; \ |
| 165 | __module_param_call(MODULE_PARAM_PREFIX, \ |
| 166 | name, &__param_ops_##name, arg, \ |
Rusty Russell | a6de51b | 2010-08-11 23:04:40 -0600 | [diff] [blame] | 167 | __same_type(arg, bool *), \ |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 168 | (perm) + sizeof(__check_old_set_param(set))*0) |
| 169 | |
| 170 | /* We don't get oldget: it's often a new-style param_get_uint, etc. */ |
| 171 | static inline int |
| 172 | __check_old_set_param(int (*oldset)(const char *, struct kernel_param *)) |
| 173 | { |
| 174 | return 0; |
| 175 | } |
| 176 | |
Rusty Russell | 907b29e | 2010-08-11 23:04:19 -0600 | [diff] [blame] | 177 | /** |
| 178 | * kparam_block_sysfs_write - make sure a parameter isn't written via sysfs. |
| 179 | * @name: the name of the parameter |
| 180 | * |
| 181 | * There's no point blocking write on a paramter that isn't writable via sysfs! |
| 182 | */ |
| 183 | #define kparam_block_sysfs_write(name) \ |
| 184 | do { \ |
| 185 | BUG_ON(!(__param_##name.perm & 0222)); \ |
| 186 | __kernel_param_lock(); \ |
| 187 | } while (0) |
| 188 | |
| 189 | /** |
| 190 | * kparam_unblock_sysfs_write - allows sysfs to write to a parameter again. |
| 191 | * @name: the name of the parameter |
| 192 | */ |
| 193 | #define kparam_unblock_sysfs_write(name) \ |
| 194 | do { \ |
| 195 | BUG_ON(!(__param_##name.perm & 0222)); \ |
| 196 | __kernel_param_unlock(); \ |
| 197 | } while (0) |
| 198 | |
| 199 | /** |
| 200 | * kparam_block_sysfs_read - make sure a parameter isn't read via sysfs. |
| 201 | * @name: the name of the parameter |
| 202 | * |
| 203 | * This also blocks sysfs writes. |
| 204 | */ |
| 205 | #define kparam_block_sysfs_read(name) \ |
| 206 | do { \ |
| 207 | BUG_ON(!(__param_##name.perm & 0444)); \ |
| 208 | __kernel_param_lock(); \ |
| 209 | } while (0) |
| 210 | |
| 211 | /** |
| 212 | * kparam_unblock_sysfs_read - allows sysfs to read a parameter again. |
| 213 | * @name: the name of the parameter |
| 214 | */ |
| 215 | #define kparam_unblock_sysfs_read(name) \ |
| 216 | do { \ |
| 217 | BUG_ON(!(__param_##name.perm & 0444)); \ |
| 218 | __kernel_param_unlock(); \ |
| 219 | } while (0) |
| 220 | |
| 221 | #ifdef CONFIG_SYSFS |
| 222 | extern void __kernel_param_lock(void); |
| 223 | extern void __kernel_param_unlock(void); |
| 224 | #else |
| 225 | static inline void __kernel_param_lock(void) |
| 226 | { |
| 227 | } |
| 228 | static inline void __kernel_param_unlock(void) |
| 229 | { |
| 230 | } |
| 231 | #endif |
| 232 | |
Rusty Russell | 67e67ce | 2008-10-22 10:00:23 -0500 | [diff] [blame] | 233 | #ifndef MODULE |
| 234 | /** |
| 235 | * core_param - define a historical core kernel parameter. |
| 236 | * @name: the name of the cmdline and sysfs parameter (often the same as var) |
| 237 | * @var: the variable |
Rusty Russell | 546970b | 2010-08-11 23:04:20 -0600 | [diff] [blame] | 238 | * @type: the type of the parameter |
Rusty Russell | 67e67ce | 2008-10-22 10:00:23 -0500 | [diff] [blame] | 239 | * @perm: visibility in sysfs |
| 240 | * |
| 241 | * core_param is just like module_param(), but cannot be modular and |
| 242 | * doesn't add a prefix (such as "printk."). This is for compatibility |
| 243 | * with __setup(), and it makes sense as truly core parameters aren't |
| 244 | * tied to the particular file they're in. |
| 245 | */ |
| 246 | #define core_param(name, var, type, perm) \ |
| 247 | param_check_##type(name, &(var)); \ |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 248 | __module_param_call("", name, ¶m_ops_##type, \ |
Rusty Russell | fddd520 | 2009-06-12 21:46:57 -0600 | [diff] [blame] | 249 | &var, __same_type(var, bool), perm) |
Rusty Russell | 67e67ce | 2008-10-22 10:00:23 -0500 | [diff] [blame] | 250 | #endif /* !MODULE */ |
| 251 | |
Rusty Russell | 546970b | 2010-08-11 23:04:20 -0600 | [diff] [blame] | 252 | /** |
| 253 | * module_param_string - a char array parameter |
| 254 | * @name: the name of the parameter |
| 255 | * @string: the string variable |
| 256 | * @len: the maximum length of the string, incl. terminator |
| 257 | * @perm: visibility in sysfs. |
| 258 | * |
| 259 | * This actually copies the string when it's set (unlike type charp). |
| 260 | * @len is usually just sizeof(string). |
| 261 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | #define module_param_string(name, string, len, perm) \ |
Jan Beulich | 22e48ea | 2007-10-16 23:29:34 -0700 | [diff] [blame] | 263 | static const struct kparam_string __param_string_##name \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | = { len, string }; \ |
Rusty Russell | fddd520 | 2009-06-12 21:46:57 -0600 | [diff] [blame] | 265 | __module_param_call(MODULE_PARAM_PREFIX, name, \ |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 266 | ¶m_ops_string, \ |
Rusty Russell | fddd520 | 2009-06-12 21:46:57 -0600 | [diff] [blame] | 267 | .str = &__param_string_##name, 0, perm); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | __MODULE_PARM_TYPE(name, "string") |
| 269 | |
Michal Schmidt | b1e4d20 | 2011-10-10 00:03:37 +0200 | [diff] [blame] | 270 | /** |
| 271 | * parameq - checks if two parameter names match |
| 272 | * @name1: parameter name 1 |
| 273 | * @name2: parameter name 2 |
| 274 | * |
| 275 | * Returns true if the two parameter names are equal. |
| 276 | * Dashes (-) are considered equal to underscores (_). |
| 277 | */ |
| 278 | extern bool parameq(const char *name1, const char *name2); |
| 279 | |
| 280 | /** |
| 281 | * parameqn - checks if two parameter names match |
| 282 | * @name1: parameter name 1 |
| 283 | * @name2: parameter name 2 |
| 284 | * @n: the length to compare |
| 285 | * |
| 286 | * Similar to parameq(), except it compares @n characters. |
| 287 | */ |
| 288 | extern bool parameqn(const char *name1, const char *name2, size_t n); |
| 289 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 290 | /* Called on module insert or kernel boot */ |
| 291 | extern int parse_args(const char *name, |
| 292 | char *args, |
Rusty Russell | 914dcaa | 2010-08-11 23:04:18 -0600 | [diff] [blame] | 293 | const struct kernel_param *params, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | unsigned num, |
| 295 | int (*unknown)(char *param, char *val)); |
| 296 | |
Rusty Russell | e180a6b | 2009-03-31 13:05:29 -0600 | [diff] [blame] | 297 | /* Called by module remove. */ |
| 298 | #ifdef CONFIG_SYSFS |
| 299 | extern void destroy_params(const struct kernel_param *params, unsigned num); |
| 300 | #else |
| 301 | static inline void destroy_params(const struct kernel_param *params, |
| 302 | unsigned num) |
| 303 | { |
| 304 | } |
| 305 | #endif /* !CONFIG_SYSFS */ |
| 306 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 307 | /* All the helper functions */ |
| 308 | /* The macros to do compile-time type checking stolen from Jakub |
| 309 | Jelinek, who IIRC came up with this idea for the 2.4 module init code. */ |
| 310 | #define __param_check(name, p, type) \ |
| 311 | static inline type *__check_##name(void) { return(p); } |
| 312 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 313 | extern struct kernel_param_ops param_ops_byte; |
| 314 | extern int param_set_byte(const char *val, const struct kernel_param *kp); |
| 315 | extern int param_get_byte(char *buffer, const struct kernel_param *kp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 316 | #define param_check_byte(name, p) __param_check(name, p, unsigned char) |
| 317 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 318 | extern struct kernel_param_ops param_ops_short; |
| 319 | extern int param_set_short(const char *val, const struct kernel_param *kp); |
| 320 | extern int param_get_short(char *buffer, const struct kernel_param *kp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | #define param_check_short(name, p) __param_check(name, p, short) |
| 322 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 323 | extern struct kernel_param_ops param_ops_ushort; |
| 324 | extern int param_set_ushort(const char *val, const struct kernel_param *kp); |
| 325 | extern int param_get_ushort(char *buffer, const struct kernel_param *kp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | #define param_check_ushort(name, p) __param_check(name, p, unsigned short) |
| 327 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 328 | extern struct kernel_param_ops param_ops_int; |
| 329 | extern int param_set_int(const char *val, const struct kernel_param *kp); |
| 330 | extern int param_get_int(char *buffer, const struct kernel_param *kp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | #define param_check_int(name, p) __param_check(name, p, int) |
| 332 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 333 | extern struct kernel_param_ops param_ops_uint; |
| 334 | extern int param_set_uint(const char *val, const struct kernel_param *kp); |
| 335 | extern int param_get_uint(char *buffer, const struct kernel_param *kp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 336 | #define param_check_uint(name, p) __param_check(name, p, unsigned int) |
| 337 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 338 | extern struct kernel_param_ops param_ops_long; |
| 339 | extern int param_set_long(const char *val, const struct kernel_param *kp); |
| 340 | extern int param_get_long(char *buffer, const struct kernel_param *kp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 341 | #define param_check_long(name, p) __param_check(name, p, long) |
| 342 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 343 | extern struct kernel_param_ops param_ops_ulong; |
| 344 | extern int param_set_ulong(const char *val, const struct kernel_param *kp); |
| 345 | extern int param_get_ulong(char *buffer, const struct kernel_param *kp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 346 | #define param_check_ulong(name, p) __param_check(name, p, unsigned long) |
| 347 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 348 | extern struct kernel_param_ops param_ops_charp; |
| 349 | extern int param_set_charp(const char *val, const struct kernel_param *kp); |
| 350 | extern int param_get_charp(char *buffer, const struct kernel_param *kp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | #define param_check_charp(name, p) __param_check(name, p, char *) |
| 352 | |
Rusty Russell | fddd520 | 2009-06-12 21:46:57 -0600 | [diff] [blame] | 353 | /* For historical reasons "bool" parameters can be (unsigned) "int". */ |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 354 | extern struct kernel_param_ops param_ops_bool; |
| 355 | extern int param_set_bool(const char *val, const struct kernel_param *kp); |
| 356 | extern int param_get_bool(char *buffer, const struct kernel_param *kp); |
Rusty Russell | fddd520 | 2009-06-12 21:46:57 -0600 | [diff] [blame] | 357 | #define param_check_bool(name, p) \ |
| 358 | static inline void __check_##name(void) \ |
| 359 | { \ |
Rusty Russell | a6de51b | 2010-08-11 23:04:40 -0600 | [diff] [blame] | 360 | BUILD_BUG_ON(!__same_type((p), bool *) && \ |
| 361 | !__same_type((p), unsigned int *) && \ |
| 362 | !__same_type((p), int *)); \ |
Rusty Russell | fddd520 | 2009-06-12 21:46:57 -0600 | [diff] [blame] | 363 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 364 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 365 | extern struct kernel_param_ops param_ops_invbool; |
| 366 | extern int param_set_invbool(const char *val, const struct kernel_param *kp); |
| 367 | extern int param_get_invbool(char *buffer, const struct kernel_param *kp); |
Rusty Russell | 9a71af2 | 2009-06-12 21:46:53 -0600 | [diff] [blame] | 368 | #define param_check_invbool(name, p) __param_check(name, p, bool) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 369 | |
Rusty Russell | 546970b | 2010-08-11 23:04:20 -0600 | [diff] [blame] | 370 | /** |
| 371 | * module_param_array - a parameter which is an array of some type |
| 372 | * @name: the name of the array variable |
| 373 | * @type: the type, as per module_param() |
| 374 | * @nump: optional pointer filled in with the number written |
| 375 | * @perm: visibility in sysfs |
| 376 | * |
| 377 | * Input and output are as comma-separated values. Commas inside values |
| 378 | * don't work properly (eg. an array of charp). |
| 379 | * |
| 380 | * ARRAY_SIZE(@name) is used to determine the number of elements in the |
| 381 | * array, so the definition must be visible. |
| 382 | */ |
| 383 | #define module_param_array(name, type, nump, perm) \ |
| 384 | module_param_array_named(name, name, type, nump, perm) |
| 385 | |
| 386 | /** |
| 387 | * module_param_array_named - renamed parameter which is an array of some type |
| 388 | * @name: a valid C identifier which is the parameter name |
| 389 | * @array: the name of the array variable |
| 390 | * @type: the type, as per module_param() |
| 391 | * @nump: optional pointer filled in with the number written |
| 392 | * @perm: visibility in sysfs |
| 393 | * |
| 394 | * This exposes a different name than the actual variable name. See |
| 395 | * module_param_named() for why this might be necessary. |
| 396 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | #define module_param_array_named(name, array, type, nump, perm) \ |
Jan Beulich | 22e48ea | 2007-10-16 23:29:34 -0700 | [diff] [blame] | 398 | static const struct kparam_array __param_arr_##name \ |
Richard Kennedy | c5be0b2 | 2011-05-19 16:55:25 -0600 | [diff] [blame] | 399 | = { .max = ARRAY_SIZE(array), .num = nump, \ |
| 400 | .ops = ¶m_ops_##type, \ |
| 401 | .elemsize = sizeof(array[0]), .elem = array }; \ |
Rusty Russell | fddd520 | 2009-06-12 21:46:57 -0600 | [diff] [blame] | 402 | __module_param_call(MODULE_PARAM_PREFIX, name, \ |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 403 | ¶m_array_ops, \ |
Rusty Russell | fddd520 | 2009-06-12 21:46:57 -0600 | [diff] [blame] | 404 | .arr = &__param_arr_##name, \ |
| 405 | __same_type(array[0], bool), perm); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | __MODULE_PARM_TYPE(name, "array of " #type) |
| 407 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 408 | extern struct kernel_param_ops param_array_ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 409 | |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 410 | extern struct kernel_param_ops param_ops_string; |
| 411 | extern int param_set_copystring(const char *val, const struct kernel_param *); |
| 412 | extern int param_get_string(char *buffer, const struct kernel_param *kp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 413 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 414 | /* for exporting parameters in /sys/parameters */ |
| 415 | |
| 416 | struct module; |
| 417 | |
Randy Dunlap | ef665c1 | 2007-02-13 15:19:06 -0800 | [diff] [blame] | 418 | #if defined(CONFIG_SYSFS) && defined(CONFIG_MODULES) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 419 | extern int module_param_sysfs_setup(struct module *mod, |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 420 | const struct kernel_param *kparam, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 421 | unsigned int num_params); |
| 422 | |
| 423 | extern void module_param_sysfs_remove(struct module *mod); |
Randy Dunlap | ef665c1 | 2007-02-13 15:19:06 -0800 | [diff] [blame] | 424 | #else |
| 425 | static inline int module_param_sysfs_setup(struct module *mod, |
Rusty Russell | 9bbb9e5 | 2010-08-11 23:04:12 -0600 | [diff] [blame] | 426 | const struct kernel_param *kparam, |
Randy Dunlap | ef665c1 | 2007-02-13 15:19:06 -0800 | [diff] [blame] | 427 | unsigned int num_params) |
| 428 | { |
| 429 | return 0; |
| 430 | } |
| 431 | |
| 432 | static inline void module_param_sysfs_remove(struct module *mod) |
| 433 | { } |
| 434 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 435 | |
| 436 | #endif /* _LINUX_MODULE_PARAMS_H */ |