include/linux/moduleparam.h

   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
  13 #define MODULE_PARAM_PREFIX KBUILD_MODNAME "."
  14 #endif
  15
  16 /* Chosen so that structs with an unsigned long line up. */
  17 #define MAX_PARAM_PREFIX_LEN (64 - sizeof(unsigned long))
  18
  19 #ifdef MODULE
  20 #define __MODULE_INFO(tag, name, info)                                    \
  21 static const char __UNIQUE_ID(name)[]                                     \
  22   __used __attribute__((section(".modinfo"), unused, aligned(1)))         \
  23   = __stringify(tag) "=" info
  24 #else  /* !MODULE */
  25 /* This struct is here for syntactic coherency, it is not used */
  26 #define __MODULE_INFO(tag, name, info)                                    \
  27   struct __UNIQUE_ID(name) {}
  28 #endif
  29 #define __MODULE_PARM_TYPE(name, _type)                                   \
  30   __MODULE_INFO(parmtype, name##type, #name ":" _type)
  31
  32 /* One for each parameter, describing how to use it.  Some files do
  33    multiple of these per line, so can't just use MODULE_INFO. */
  34 #define MODULE_PARM_DESC(_parm, desc) \
  35         __MODULE_INFO(parm, _parm, #_parm ":" desc)
  36
  37 struct kernel_param;
  38
  39 /*
  40  * Flags available for kernel_param_ops
  41  *
  42  * NOARG - the parameter allows for no argument (foo instead of foo=1)
  43  */
  44 enum {
  45         KERNEL_PARAM_OPS_FL_NOARG = (1 << 0)
  46 };
  47
  48 struct kernel_param_ops {
  49         /* How the ops should behave */
  50         unsigned int flags;
  51         /* Returns 0, or -errno.  arg is in kp->arg. */
  52         int (*set)(const char *val, const struct kernel_param *kp);
  53         /* Returns length written or -errno.  Buffer is 4k (ie. be short!) */
  54         int (*get)(char *buffer, const struct kernel_param *kp);
  55         /* Optional function to free kp->arg when module unloaded. */
  56         void (*free)(void *arg);
  57 };
  58
  59 /*
  60  * Flags available for kernel_param
  61  *
  62  * UNSAFE - the parameter is dangerous and setting it will taint the kernel
  63  * HWPARAM - Hardware param not permitted in lockdown mode
  64  */
  65 enum {
  66         KERNEL_PARAM_FL_UNSAFE  = (1 << 0),
  67         KERNEL_PARAM_FL_HWPARAM = (1 << 1),
  68 };
  69
  70 struct kernel_param {
  71         const char *name;
  72         struct module *mod;
  73         const struct kernel_param_ops *ops;
  74         const u16 perm;
  75         s8 level;
  76         u8 flags;
  77         union {
  78                 void *arg;
  79                 const struct kparam_string *str;
  80                 const struct kparam_array *arr;
  81         };
  82 };
  83
  84 extern const struct kernel_param __start___param[], __stop___param[];
  85
  86 /* Special one for strings we want to copy into */
  87 struct kparam_string {
  88         unsigned int maxlen;
  89         char *string;
  90 };
  91
  92 /* Special one for arrays */
  93 struct kparam_array
  94 {
  95         unsigned int max;
  96         unsigned int elemsize;
  97         unsigned int *num;
  98         const struct kernel_param_ops *ops;
  99         void *elem;
 100 };
 101
 102 /**
 103  * module_param - typesafe helper for a module/cmdline parameter
 104  * @value: the variable to alter, and exposed parameter name.
 105  * @type: the type of the parameter
 106  * @perm: visibility in sysfs.
 107  *
 108  * @value becomes the module parameter, or (prefixed by KBUILD_MODNAME and a
 109  * ".") the kernel commandline parameter.  Note that - is changed to _, so
 110  * the user can use "foo-bar=1" even for variable "foo_bar".
 111  *
 112  * @perm is 0 if the the variable is not to appear in sysfs, or 0444
 113  * for world-readable, 0644 for root-writable, etc.  Note that if it
 114  * is writable, you may need to use kernel_param_lock() around
 115  * accesses (esp. charp, which can be kfreed when it changes).
 116  *
 117  * The @type is simply pasted to refer to a param_ops_##type and a
 118  * param_check_##type: for convenience many standard types are provided but
 119  * you can create your own by defining those variables.
 120  *
 121  * Standard types are:
 122  *      byte, short, ushort, int, uint, long, ulong
 123  *      charp: a character pointer
 124  *      bool: a bool, values 0/1, y/n, Y/N.
 125  *      invbool: the above, only sense-reversed (N = true).
 126  */
 127 #define module_param(name, type, perm)                          \
 128         module_param_named(name, name, type, perm)
 129
 130 /**
 131  * module_param_unsafe - same as module_param but taints kernel
 132  */
 133 #define module_param_unsafe(name, type, perm)                   \
 134         module_param_named_unsafe(name, name, type, perm)
 135
 136 /**
 137  * module_param_named - typesafe helper for a renamed module/cmdline parameter
 138  * @name: a valid C identifier which is the parameter name.
 139  * @value: the actual lvalue to alter.
 140  * @type: the type of the parameter
 141  * @perm: visibility in sysfs.
 142  *
 143  * Usually it's a good idea to have variable names and user-exposed names the
 144  * same, but that's harder if the variable must be non-static or is inside a
 145  * structure.  This allows exposure under a different name.
 146  */
 147 #define module_param_named(name, value, type, perm)                        \
 148         param_check_##type(name, &(value));                                \
 149         module_param_cb(name, &param_ops_##type, &value, perm);            \
 150         __MODULE_PARM_TYPE(name, #type)
 151
 152 /**
 153  * module_param_named_unsafe - same as module_param_named but taints kernel
 154  */
 155 #define module_param_named_unsafe(name, value, type, perm)              \
 156         param_check_##type(name, &(value));                             \
 157         module_param_cb_unsafe(name, &param_ops_##type, &value, perm);  \
 158         __MODULE_PARM_TYPE(name, #type)
 159
 160 /**
 161  * module_param_cb - general callback for a module/cmdline parameter
 162  * @name: a valid C identifier which is the parameter name.
 163  * @ops: the set & get operations for this parameter.
 164  * @perm: visibility in sysfs.
 165  *
 166  * The ops can have NULL set or get functions.
 167  */
 168 #define module_param_cb(name, ops, arg, perm)                                 \
 169         __module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1, 0)
 170
 171 #define module_param_cb_unsafe(name, ops, arg, perm)                          \
 172         __module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1,    \
 173                             KERNEL_PARAM_FL_UNSAFE)
 174
 175 /**
 176  * <level>_param_cb - general callback for a module/cmdline parameter
 177  *                    to be evaluated before certain initcall level
 178  * @name: a valid C identifier which is the parameter name.
 179  * @ops: the set & get operations for this parameter.
 180  * @perm: visibility in sysfs.
 181  *
 182  * The ops can have NULL set or get functions.
 183  */
 184 #define __level_param_cb(name, ops, arg, perm, level)                   \
 185         __module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, level, 0)
 186
 187 #define core_param_cb(name, ops, arg, perm)             \
 188         __level_param_cb(name, ops, arg, perm, 1)
 189
 190 #define postcore_param_cb(name, ops, arg, perm)         \
 191         __level_param_cb(name, ops, arg, perm, 2)
 192
 193 #define arch_param_cb(name, ops, arg, perm)             \
 194         __level_param_cb(name, ops, arg, perm, 3)
 195
 196 #define subsys_param_cb(name, ops, arg, perm)           \
 197         __level_param_cb(name, ops, arg, perm, 4)
 198
 199 #define fs_param_cb(name, ops, arg, perm)               \
 200         __level_param_cb(name, ops, arg, perm, 5)
 201
 202 #define device_param_cb(name, ops, arg, perm)           \
 203         __level_param_cb(name, ops, arg, perm, 6)
 204
 205 #define late_param_cb(name, ops, arg, perm)             \
 206         __level_param_cb(name, ops, arg, perm, 7)
 207
 208 /* On alpha, ia64 and ppc64 relocations to global data cannot go into
 209    read-only sections (which is part of respective UNIX ABI on these
 210    platforms). So 'const' makes no sense and even causes compile failures
 211    with some compilers. */
 212 #if defined(CONFIG_ALPHA) || defined(CONFIG_IA64) || defined(CONFIG_PPC64)
 213 #define __moduleparam_const
 214 #else
 215 #define __moduleparam_const const
 216 #endif
 217
 218 /* This is the fundamental function for registering boot/module
 219    parameters. */
 220 #define __module_param_call(prefix, name, ops, arg, perm, level, flags) \
 221         /* Default value instead of permissions? */                     \
 222         static const char __param_str_##name[] = prefix #name;          \
 223         static struct kernel_param __moduleparam_const __param_##name   \
 224         __used                                                          \
 225     __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \
 226         = { __param_str_##name, THIS_MODULE, ops,                       \
 227             VERIFY_OCTAL_PERMISSIONS(perm), level, flags, { arg } }
 228
 229 /* Obsolete - use module_param_cb() */
 230 #define module_param_call(name, set, get, arg, perm)                    \
 231         static const struct kernel_param_ops __param_ops_##name =               \
 232                 { .flags = 0, (void *)set, (void *)get };               \
 233         __module_param_call(MODULE_PARAM_PREFIX,                        \
 234                             name, &__param_ops_##name, arg,             \
 235                             (perm) + sizeof(__check_old_set_param(set))*0, -1, 0)
 236
 237 /* We don't get oldget: it's often a new-style param_get_uint, etc. */
 238 static inline int
 239 __check_old_set_param(int (*oldset)(const char *, struct kernel_param *))
 240 {
 241         return 0;
 242 }
 243
 244 #ifdef CONFIG_SYSFS
 245 extern void kernel_param_lock(struct module *mod);
 246 extern void kernel_param_unlock(struct module *mod);
 247 #else
 248 static inline void kernel_param_lock(struct module *mod)
 249 {
 250 }
 251 static inline void kernel_param_unlock(struct module *mod)
 252 {
 253 }
 254 #endif
 255
 256 #ifndef MODULE
 257 /**
 258  * core_param - define a historical core kernel parameter.
 259  * @name: the name of the cmdline and sysfs parameter (often the same as var)
 260  * @var: the variable
 261  * @type: the type of the parameter
 262  * @perm: visibility in sysfs
 263  *
 264  * core_param is just like module_param(), but cannot be modular and
 265  * doesn't add a prefix (such as "printk.").  This is for compatibility
 266  * with __setup(), and it makes sense as truly core parameters aren't
 267  * tied to the particular file they're in.
 268  */
 269 #define core_param(name, var, type, perm)                               \
 270         param_check_##type(name, &(var));                               \
 271         __module_param_call("", name, &param_ops_##type, &var, perm, -1, 0)
 272
 273 /**
 274  * core_param_unsafe - same as core_param but taints kernel
 275  */
 276 #define core_param_unsafe(name, var, type, perm)                \
 277         param_check_##type(name, &(var));                               \
 278         __module_param_call("", name, &param_ops_##type, &var, perm,    \
 279                             -1, KERNEL_PARAM_FL_UNSAFE)
 280
 281 #endif /* !MODULE */
 282
 283 /**
 284  * module_param_string - a char array parameter
 285  * @name: the name of the parameter
 286  * @string: the string variable
 287  * @len: the maximum length of the string, incl. terminator
 288  * @perm: visibility in sysfs.
 289  *
 290  * This actually copies the string when it's set (unlike type charp).
 291  * @len is usually just sizeof(string).
 292  */
 293 #define module_param_string(name, string, len, perm)                    \
 294         static const struct kparam_string __param_string_##name         \
 295                 = { len, string };                                      \
 296         __module_param_call(MODULE_PARAM_PREFIX, name,                  \
 297                             &param_ops_string,                          \
 298                             .str = &__param_string_##name, perm, -1, 0);\
 299         __MODULE_PARM_TYPE(name, "string")
 300
 301 /**
 302  * parameq - checks if two parameter names match
 303  * @name1: parameter name 1
 304  * @name2: parameter name 2
 305  *
 306  * Returns true if the two parameter names are equal.
 307  * Dashes (-) are considered equal to underscores (_).
 308  */
 309 extern bool parameq(const char *name1, const char *name2);
 310
 311 /**
 312  * parameqn - checks if two parameter names match
 313  * @name1: parameter name 1
 314  * @name2: parameter name 2
 315  * @n: the length to compare
 316  *
 317  * Similar to parameq(), except it compares @n characters.
 318  */
 319 extern bool parameqn(const char *name1, const char *name2, size_t n);
 320
 321 /* Called on module insert or kernel boot */
 322 extern char *parse_args(const char *name,
 323                       char *args,
 324                       const struct kernel_param *params,
 325                       unsigned num,
 326                       s16 level_min,
 327                       s16 level_max,
 328                       void *arg,
 329                       int (*unknown)(char *param, char *val,
 330                                      const char *doing, void *arg));
 331
 332 /* Called by module remove. */
 333 #ifdef CONFIG_SYSFS
 334 extern void destroy_params(const struct kernel_param *params, unsigned num);
 335 #else
 336 static inline void destroy_params(const struct kernel_param *params,
 337                                   unsigned num)
 338 {
 339 }
 340 #endif /* !CONFIG_SYSFS */
 341
 342 /* All the helper functions */
 343 /* The macros to do compile-time type checking stolen from Jakub
 344    Jelinek, who IIRC came up with this idea for the 2.4 module init code. */
 345 #define __param_check(name, p, type) \
 346         static inline type __always_unused *__check_##name(void) { return(p); }
 347
 348 extern const struct kernel_param_ops param_ops_byte;
 349 extern int param_set_byte(const char *val, const struct kernel_param *kp);
 350 extern int param_get_byte(char *buffer, const struct kernel_param *kp);
 351 #define param_check_byte(name, p) __param_check(name, p, unsigned char)
 352
 353 extern const struct kernel_param_ops param_ops_short;
 354 extern int param_set_short(const char *val, const struct kernel_param *kp);
 355 extern int param_get_short(char *buffer, const struct kernel_param *kp);
 356 #define param_check_short(name, p) __param_check(name, p, short)
 357
 358 extern const struct kernel_param_ops param_ops_ushort;
 359 extern int param_set_ushort(const char *val, const struct kernel_param *kp);
 360 extern int param_get_ushort(char *buffer, const struct kernel_param *kp);
 361 #define param_check_ushort(name, p) __param_check(name, p, unsigned short)
 362
 363 extern const struct kernel_param_ops param_ops_int;
 364 extern int param_set_int(const char *val, const struct kernel_param *kp);
 365 extern int param_get_int(char *buffer, const struct kernel_param *kp);
 366 #define param_check_int(name, p) __param_check(name, p, int)
 367
 368 extern const struct kernel_param_ops param_ops_uint;
 369 extern int param_set_uint(const char *val, const struct kernel_param *kp);
 370 extern int param_get_uint(char *buffer, const struct kernel_param *kp);
 371 #define param_check_uint(name, p) __param_check(name, p, unsigned int)
 372
 373 extern const struct kernel_param_ops param_ops_long;
 374 extern int param_set_long(const char *val, const struct kernel_param *kp);
 375 extern int param_get_long(char *buffer, const struct kernel_param *kp);
 376 #define param_check_long(name, p) __param_check(name, p, long)
 377
 378 extern const struct kernel_param_ops param_ops_ulong;
 379 extern int param_set_ulong(const char *val, const struct kernel_param *kp);
 380 extern int param_get_ulong(char *buffer, const struct kernel_param *kp);
 381 #define param_check_ulong(name, p) __param_check(name, p, unsigned long)
 382
 383 extern const struct kernel_param_ops param_ops_ullong;
 384 extern int param_set_ullong(const char *val, const struct kernel_param *kp);
 385 extern int param_get_ullong(char *buffer, const struct kernel_param *kp);
 386 #define param_check_ullong(name, p) __param_check(name, p, unsigned long long)
 387
 388 extern const struct kernel_param_ops param_ops_charp;
 389 extern int param_set_charp(const char *val, const struct kernel_param *kp);
 390 extern int param_get_charp(char *buffer, const struct kernel_param *kp);
 391 extern void param_free_charp(void *arg);
 392 #define param_check_charp(name, p) __param_check(name, p, char *)
 393
 394 /* We used to allow int as well as bool.  We're taking that away! */
 395 extern const struct kernel_param_ops param_ops_bool;
 396 extern int param_set_bool(const char *val, const struct kernel_param *kp);
 397 extern int param_get_bool(char *buffer, const struct kernel_param *kp);
 398 #define param_check_bool(name, p) __param_check(name, p, bool)
 399
 400 extern const struct kernel_param_ops param_ops_bool_enable_only;
 401 extern int param_set_bool_enable_only(const char *val,
 402                                       const struct kernel_param *kp);
 403 /* getter is the same as for the regular bool */
 404 #define param_check_bool_enable_only param_check_bool
 405
 406 extern const struct kernel_param_ops param_ops_invbool;
 407 extern int param_set_invbool(const char *val, const struct kernel_param *kp);
 408 extern int param_get_invbool(char *buffer, const struct kernel_param *kp);
 409 #define param_check_invbool(name, p) __param_check(name, p, bool)
 410
 411 /* An int, which can only be set like a bool (though it shows as an int). */
 412 extern const struct kernel_param_ops param_ops_bint;
 413 extern int param_set_bint(const char *val, const struct kernel_param *kp);
 414 #define param_get_bint param_get_int
 415 #define param_check_bint param_check_int
 416
 417 /**
 418  * module_param_array - a parameter which is an array of some type
 419  * @name: the name of the array variable
 420  * @type: the type, as per module_param()
 421  * @nump: optional pointer filled in with the number written
 422  * @perm: visibility in sysfs
 423  *
 424  * Input and output are as comma-separated values.  Commas inside values
 425  * don't work properly (eg. an array of charp).
 426  *
 427  * ARRAY_SIZE(@name) is used to determine the number of elements in the
 428  * array, so the definition must be visible.
 429  */
 430 #define module_param_array(name, type, nump, perm)              \
 431         module_param_array_named(name, name, type, nump, perm)
 432
 433 /**
 434  * module_param_array_named - renamed parameter which is an array of some type
 435  * @name: a valid C identifier which is the parameter name
 436  * @array: the name of the array variable
 437  * @type: the type, as per module_param()
 438  * @nump: optional pointer filled in with the number written
 439  * @perm: visibility in sysfs
 440  *
 441  * This exposes a different name than the actual variable name.  See
 442  * module_param_named() for why this might be necessary.
 443  */
 444 #define module_param_array_named(name, array, type, nump, perm)         \
 445         param_check_##type(name, &(array)[0]);                          \
 446         static const struct kparam_array __param_arr_##name             \
 447         = { .max = ARRAY_SIZE(array), .num = nump,                      \
 448             .ops = &param_ops_##type,                                   \
 449             .elemsize = sizeof(array[0]), .elem = array };              \
 450         __module_param_call(MODULE_PARAM_PREFIX, name,                  \
 451                             &param_array_ops,                           \
 452                             .arr = &__param_arr_##name,                 \
 453                             perm, -1, 0);                               \
 454         __MODULE_PARM_TYPE(name, "array of " #type)
 455
 456 enum hwparam_type {
 457         hwparam_ioport,         /* Module parameter configures an I/O port */
 458         hwparam_iomem,          /* Module parameter configures an I/O mem address */
 459         hwparam_ioport_or_iomem, /* Module parameter could be either, depending on other option */
 460         hwparam_irq,            /* Module parameter configures an IRQ */
 461         hwparam_dma,            /* Module parameter configures a DMA channel */
 462         hwparam_dma_addr,       /* Module parameter configures a DMA buffer address */
 463         hwparam_other,          /* Module parameter configures some other value */
 464 };
 465
 466 /**
 467  * module_param_hw_named - A parameter representing a hw parameters
 468  * @name: a valid C identifier which is the parameter name.
 469  * @value: the actual lvalue to alter.
 470  * @type: the type of the parameter
 471  * @hwtype: what the value represents (enum hwparam_type)
 472  * @perm: visibility in sysfs.
 473  *
 474  * Usually it's a good idea to have variable names and user-exposed names the
 475  * same, but that's harder if the variable must be non-static or is inside a
 476  * structure.  This allows exposure under a different name.
 477  */
 478 #define module_param_hw_named(name, value, type, hwtype, perm)          \
 479         param_check_##type(name, &(value));                             \
 480         __module_param_call(MODULE_PARAM_PREFIX, name,                  \
 481                             &param_ops_##type, &value,                  \
 482                             perm, -1,                                   \
 483                             KERNEL_PARAM_FL_HWPARAM | (hwparam_##hwtype & 0));  \
 484         __MODULE_PARM_TYPE(name, #type)
 485
 486 #define module_param_hw(name, type, hwtype, perm)               \
 487         module_param_hw_named(name, name, type, hwtype, perm)
 488
 489 /**
 490  * module_param_hw_array - A parameter representing an array of hw parameters
 491  * @name: the name of the array variable
 492  * @type: the type, as per module_param()
 493  * @hwtype: what the value represents (enum hwparam_type)
 494  * @nump: optional pointer filled in with the number written
 495  * @perm: visibility in sysfs
 496  *
 497  * Input and output are as comma-separated values.  Commas inside values
 498  * don't work properly (eg. an array of charp).
 499  *
 500  * ARRAY_SIZE(@name) is used to determine the number of elements in the
 501  * array, so the definition must be visible.
 502  */
 503 #define module_param_hw_array(name, type, hwtype, nump, perm)           \
 504         param_check_##type(name, &(name)[0]);                           \
 505         static const struct kparam_array __param_arr_##name             \
 506         = { .max = ARRAY_SIZE(name), .num = nump,                       \
 507             .ops = &param_ops_##type,                                   \
 508             .elemsize = sizeof(name[0]), .elem = name };                \
 509         __module_param_call(MODULE_PARAM_PREFIX, name,                  \
 510                             &param_array_ops,                           \
 511                             .arr = &__param_arr_##name,                 \
 512                             perm, -1,                                   \
 513                             KERNEL_PARAM_FL_HWPARAM | (hwparam_##hwtype & 0));  \
 514         __MODULE_PARM_TYPE(name, "array of " #type)
 515
 516
 517 extern const struct kernel_param_ops param_array_ops;
 518
 519 extern const struct kernel_param_ops param_ops_string;
 520 extern int param_set_copystring(const char *val, const struct kernel_param *);
 521 extern int param_get_string(char *buffer, const struct kernel_param *kp);
 522
 523 /* for exporting parameters in /sys/module/.../parameters */
 524
 525 struct module;
 526
 527 #if defined(CONFIG_SYSFS) && defined(CONFIG_MODULES)
 528 extern int module_param_sysfs_setup(struct module *mod,
 529                                     const struct kernel_param *kparam,
 530                                     unsigned int num_params);
 531
 532 extern void module_param_sysfs_remove(struct module *mod);
 533 #else
 534 static inline int module_param_sysfs_setup(struct module *mod,
 535                              const struct kernel_param *kparam,
 536                              unsigned int num_params)
 537 {
 538         return 0;
 539 }
 540
 541 static inline void module_param_sysfs_remove(struct module *mod)
 542 { }
 543 #endif
 544
 545 #endif /* _LINUX_MODULE_PARAMS_H */