2005-04-16 22:20:36 +00:00
|
|
|
#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 /* empty */
|
|
|
|
|
#else
|
2006-01-06 20:17:50 +00:00
|
|
|
#define MODULE_PARAM_PREFIX KBUILD_MODNAME "."
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
2008-10-22 15:00:22 +00:00
|
|
|
/* Chosen so that structs with an unsigned long line up. */
|
|
|
|
|
#define MAX_PARAM_PREFIX_LEN (64 - sizeof(unsigned long))
|
|
|
|
|
|
2011-01-05 12:27:04 +00:00
|
|
|
#ifdef MODULE
|
2005-04-16 22:20:36 +00:00
|
|
|
#define __MODULE_INFO(tag, name, info) \
|
2012-11-22 02:00:25 +00:00
|
|
|
static const char __UNIQUE_ID(name)[] \
|
2010-10-26 21:22:26 +00:00
|
|
|
__used __attribute__((section(".modinfo"), unused, aligned(1))) \
|
|
|
|
|
= __stringify(tag) "=" info
|
2005-04-16 22:20:36 +00:00
|
|
|
#else /* !MODULE */
|
2011-01-05 12:27:04 +00:00
|
|
|
/* This struct is here for syntactic coherency, it is not used */
|
|
|
|
|
#define __MODULE_INFO(tag, name, info) \
|
2012-11-22 02:00:25 +00:00
|
|
|
struct __UNIQUE_ID(name) {}
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
#define __MODULE_PARM_TYPE(name, _type) \
|
|
|
|
|
__MODULE_INFO(parmtype, name##type, #name ":" _type)
|
|
|
|
|
|
2011-08-30 15:24:44 +00:00
|
|
|
/* 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) \
|
|
|
|
|
__MODULE_INFO(parm, _parm, #_parm ":" desc)
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct kernel_param;
|
|
|
|
|
|
2013-08-20 06:03:19 +00:00
|
|
|
/*
|
|
|
|
|
* Flags available for kernel_param_ops
|
|
|
|
|
*
|
|
|
|
|
* NOARG - the parameter allows for no argument (foo instead of foo=1)
|
|
|
|
|
*/
|
|
|
|
|
enum {
|
2014-08-26 20:51:23 +00:00
|
|
|
KERNEL_PARAM_OPS_FL_NOARG = (1 << 0)
|
2013-08-20 06:03:19 +00:00
|
|
|
};
|
|
|
|
|
|
2010-08-12 05:04:12 +00:00
|
|
|
struct kernel_param_ops {
|
2013-08-20 06:03:19 +00:00
|
|
|
/* How the ops should behave */
|
|
|
|
|
unsigned int flags;
|
2010-08-12 05:04:12 +00:00
|
|
|
/* Returns 0, or -errno. arg is in kp->arg. */
|
|
|
|
|
int (*set)(const char *val, const struct kernel_param *kp);
|
|
|
|
|
/* Returns length written or -errno. Buffer is 4k (ie. be short!) */
|
|
|
|
|
int (*get)(char *buffer, const struct kernel_param *kp);
|
2010-08-12 05:04:17 +00:00
|
|
|
/* Optional function to free kp->arg when module unloaded. */
|
|
|
|
|
void (*free)(void *arg);
|
2010-08-12 05:04:12 +00:00
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-08-26 20:52:23 +00:00
|
|
|
/*
|
|
|
|
|
* Flags available for kernel_param
|
|
|
|
|
*
|
|
|
|
|
* UNSAFE - the parameter is dangerous and setting it will taint the kernel
|
|
|
|
|
*/
|
|
|
|
|
enum {
|
|
|
|
|
KERNEL_PARAM_FL_UNSAFE = (1 << 0)
|
|
|
|
|
};
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct kernel_param {
|
|
|
|
|
const char *name;
|
module: add per-module param_lock
Add a "param_lock" mutex to each module, and update params.c to use
the correct built-in or module mutex while locking kernel params.
Remove the kparam_block_sysfs_r/w() macros, replace them with direct
calls to kernel_param_[un]lock(module).
The kernel param code currently uses a single mutex to protect
modification of any and all kernel params. While this generally works,
there is one specific problem with it; a module callback function
cannot safely load another module, i.e. with request_module() or even
with indirect calls such as crypto_has_alg(). If the module to be
loaded has any of its params configured (e.g. with a /etc/modprobe.d/*
config file), then the attempt will result in a deadlock between the
first module param callback waiting for modprobe, and modprobe trying to
lock the single kernel param mutex to set the new module's param.
This fixes that by using per-module mutexes, so that each individual module
is protected against concurrent changes in its own kernel params, but is
not blocked by changes to other module params. All built-in modules
continue to use the built-in mutex, since they will always be loaded at
runtime and references (e.g. request_module(), crypto_has_alg()) to them
will never cause load-time param changing.
This also simplifies the interface used by modules to block sysfs access
to their params; while there are currently functions to block and unblock
sysfs param access which are split up by read and write and expect a single
kernel param to be passed, their actual operation is identical and applies
to all params, not just the one passed to them; they simply lock and unlock
the global param mutex. They are replaced with direct calls to
kernel_param_[un]lock(THIS_MODULE), which locks THIS_MODULE's param_lock, or
if the module is built-in, it locks the built-in mutex.
Suggested-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Dan Streetman <ddstreet@ieee.org>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2015-06-16 20:48:52 +00:00
|
|
|
struct module *mod;
|
2010-08-12 05:04:12 +00:00
|
|
|
const struct kernel_param_ops *ops;
|
2015-06-16 20:47:52 +00:00
|
|
|
const u16 perm;
|
2014-08-26 20:52:23 +00:00
|
|
|
s8 level;
|
|
|
|
|
u8 flags;
|
2007-10-17 06:29:34 +00:00
|
|
|
union {
|
|
|
|
|
void *arg;
|
|
|
|
|
const struct kparam_string *str;
|
|
|
|
|
const struct kparam_array *arr;
|
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
2014-10-13 22:55:44 +00:00
|
|
|
extern const struct kernel_param __start___param[], __stop___param[];
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Special one for strings we want to copy into */
|
|
|
|
|
struct kparam_string {
|
|
|
|
|
unsigned int maxlen;
|
|
|
|
|
char *string;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Special one for arrays */
|
|
|
|
|
struct kparam_array
|
|
|
|
|
{
|
|
|
|
|
unsigned int max;
|
2011-05-19 22:55:25 +00:00
|
|
|
unsigned int elemsize;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int *num;
|
2010-08-12 05:04:12 +00:00
|
|
|
const struct kernel_param_ops *ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
void *elem;
|
|
|
|
|
};
|
|
|
|
|
|
2010-08-12 05:04:20 +00:00
|
|
|
/**
|
|
|
|
|
* module_param - typesafe helper for a module/cmdline parameter
|
|
|
|
|
* @value: the variable to alter, and exposed parameter name.
|
|
|
|
|
* @type: the type of the parameter
|
|
|
|
|
* @perm: visibility in sysfs.
|
|
|
|
|
*
|
|
|
|
|
* @value 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 the variable is not to appear in sysfs, or 0444
|
|
|
|
|
* for world-readable, 0644 for root-writable, etc. Note that if it
|
module: add per-module param_lock
Add a "param_lock" mutex to each module, and update params.c to use
the correct built-in or module mutex while locking kernel params.
Remove the kparam_block_sysfs_r/w() macros, replace them with direct
calls to kernel_param_[un]lock(module).
The kernel param code currently uses a single mutex to protect
modification of any and all kernel params. While this generally works,
there is one specific problem with it; a module callback function
cannot safely load another module, i.e. with request_module() or even
with indirect calls such as crypto_has_alg(). If the module to be
loaded has any of its params configured (e.g. with a /etc/modprobe.d/*
config file), then the attempt will result in a deadlock between the
first module param callback waiting for modprobe, and modprobe trying to
lock the single kernel param mutex to set the new module's param.
This fixes that by using per-module mutexes, so that each individual module
is protected against concurrent changes in its own kernel params, but is
not blocked by changes to other module params. All built-in modules
continue to use the built-in mutex, since they will always be loaded at
runtime and references (e.g. request_module(), crypto_has_alg()) to them
will never cause load-time param changing.
This also simplifies the interface used by modules to block sysfs access
to their params; while there are currently functions to block and unblock
sysfs param access which are split up by read and write and expect a single
kernel param to be passed, their actual operation is identical and applies
to all params, not just the one passed to them; they simply lock and unlock
the global param mutex. They are replaced with direct calls to
kernel_param_[un]lock(THIS_MODULE), which locks THIS_MODULE's param_lock, or
if the module is built-in, it locks the built-in mutex.
Suggested-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Dan Streetman <ddstreet@ieee.org>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2015-06-16 20:48:52 +00:00
|
|
|
* is writable, you may need to use kernel_param_lock() around
|
2010-08-12 05:04:20 +00:00
|
|
|
* 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, 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_named(name, name, type, perm)
|
|
|
|
|
|
2014-08-26 20:53:23 +00:00
|
|
|
/**
|
|
|
|
|
* module_param_unsafe - same as module_param but taints kernel
|
|
|
|
|
*/
|
|
|
|
|
#define module_param_unsafe(name, type, perm) \
|
|
|
|
|
module_param_named_unsafe(name, name, type, perm)
|
|
|
|
|
|
2010-08-12 05:04:20 +00:00
|
|
|
/**
|
|
|
|
|
* 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) \
|
|
|
|
|
param_check_##type(name, &(value)); \
|
|
|
|
|
module_param_cb(name, ¶m_ops_##type, &value, perm); \
|
|
|
|
|
__MODULE_PARM_TYPE(name, #type)
|
|
|
|
|
|
2014-08-26 20:53:23 +00:00
|
|
|
/**
|
|
|
|
|
* module_param_named_unsafe - same as module_param_named but taints kernel
|
|
|
|
|
*/
|
|
|
|
|
#define module_param_named_unsafe(name, value, type, perm) \
|
|
|
|
|
param_check_##type(name, &(value)); \
|
|
|
|
|
module_param_cb_unsafe(name, ¶m_ops_##type, &value, perm); \
|
|
|
|
|
__MODULE_PARM_TYPE(name, #type)
|
|
|
|
|
|
2010-08-12 05:04:20 +00:00
|
|
|
/**
|
|
|
|
|
* 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.
|
|
|
|
|
* @perm: visibility in sysfs.
|
|
|
|
|
*
|
|
|
|
|
* The ops can have NULL set or get functions.
|
|
|
|
|
*/
|
|
|
|
|
#define module_param_cb(name, ops, arg, perm) \
|
2014-08-26 20:52:23 +00:00
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1, 0)
|
2012-03-26 02:20:51 +00:00
|
|
|
|
2014-08-26 20:53:23 +00:00
|
|
|
#define module_param_cb_unsafe(name, ops, arg, perm) \
|
|
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1, \
|
|
|
|
|
KERNEL_PARAM_FL_UNSAFE)
|
|
|
|
|
|
2012-03-26 02:20:51 +00:00
|
|
|
/**
|
|
|
|
|
* <level>_param_cb - general callback for a module/cmdline parameter
|
|
|
|
|
* to be evaluated before certain initcall level
|
|
|
|
|
* @name: a valid C identifier which is the parameter name.
|
|
|
|
|
* @ops: the set & get operations for this parameter.
|
|
|
|
|
* @perm: visibility in sysfs.
|
|
|
|
|
*
|
|
|
|
|
* The ops can have NULL set or get functions.
|
|
|
|
|
*/
|
|
|
|
|
#define __level_param_cb(name, ops, arg, perm, level) \
|
2014-08-26 20:52:23 +00:00
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, level, 0)
|
2012-03-26 02:20:51 +00:00
|
|
|
|
|
|
|
|
#define core_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 1)
|
|
|
|
|
|
|
|
|
|
#define postcore_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 2)
|
|
|
|
|
|
|
|
|
|
#define arch_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 3)
|
|
|
|
|
|
|
|
|
|
#define subsys_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 4)
|
|
|
|
|
|
|
|
|
|
#define fs_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 5)
|
|
|
|
|
|
|
|
|
|
#define device_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 6)
|
|
|
|
|
|
|
|
|
|
#define late_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 7)
|
2010-08-12 05:04:20 +00:00
|
|
|
|
2008-02-13 23:03:26 +00:00
|
|
|
/* 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_IA64) || defined(CONFIG_PPC64)
|
|
|
|
|
#define __moduleparam_const
|
|
|
|
|
#else
|
|
|
|
|
#define __moduleparam_const const
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* This is the fundamental function for registering boot/module
|
2010-08-12 05:04:20 +00:00
|
|
|
parameters. */
|
2014-08-26 20:52:23 +00:00
|
|
|
#define __module_param_call(prefix, name, ops, arg, perm, level, flags) \
|
[PATCH] Compile-time check re world-writeable module params
One of the mistakes a module_param() user can make is to supply default
value of module parameter as the last argument. module_param() accepts
permissions instead. If default value is, say, 3 (-------wx), parameter
becomes world-writeable.
So far, the only remedy was to apply grep(1) and read drivers submitted
to -mm. BTDT.
With this patch applied, compiler will finally do some job.
*) bounds checking on permissions
*) world-writeable bit checking on permissions
*) compile breakage if checks trigger
First version of this check (only "& 2" part) directly caught 4 out of 7
places during my last grep.
Subject: Neverending module_param() bugs
[X] drivers/acpi/sbs.c:101:module_param(capacity_mode, int, CAPACITY_UNIT);
[X] drivers/acpi/sbs.c:102:module_param(update_mode, int, UPDATE_MODE);
[ ] drivers/acpi/sbs.c:103:module_param(update_info_mode, int, UPDATE_INFO_MODE);
[ ] drivers/acpi/sbs.c:104:module_param(update_time, int, UPDATE_TIME);
[ ] drivers/acpi/sbs.c:105:module_param(update_time2, int, UPDATE_TIME2);
[X] drivers/char/watchdog/sbc8360.c:203:module_param(timeout, int, 27);
[X] drivers/media/video/tuner-simple.c:13:module_param(offset, int, 0666);
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 04:36:56 +00:00
|
|
|
/* Default value instead of permissions? */ \
|
module: add per-module param_lock
Add a "param_lock" mutex to each module, and update params.c to use
the correct built-in or module mutex while locking kernel params.
Remove the kparam_block_sysfs_r/w() macros, replace them with direct
calls to kernel_param_[un]lock(module).
The kernel param code currently uses a single mutex to protect
modification of any and all kernel params. While this generally works,
there is one specific problem with it; a module callback function
cannot safely load another module, i.e. with request_module() or even
with indirect calls such as crypto_has_alg(). If the module to be
loaded has any of its params configured (e.g. with a /etc/modprobe.d/*
config file), then the attempt will result in a deadlock between the
first module param callback waiting for modprobe, and modprobe trying to
lock the single kernel param mutex to set the new module's param.
This fixes that by using per-module mutexes, so that each individual module
is protected against concurrent changes in its own kernel params, but is
not blocked by changes to other module params. All built-in modules
continue to use the built-in mutex, since they will always be loaded at
runtime and references (e.g. request_module(), crypto_has_alg()) to them
will never cause load-time param changing.
This also simplifies the interface used by modules to block sysfs access
to their params; while there are currently functions to block and unblock
sysfs param access which are split up by read and write and expect a single
kernel param to be passed, their actual operation is identical and applies
to all params, not just the one passed to them; they simply lock and unlock
the global param mutex. They are replaced with direct calls to
kernel_param_[un]lock(THIS_MODULE), which locks THIS_MODULE's param_lock, or
if the module is built-in, it locks the built-in mutex.
Suggested-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Dan Streetman <ddstreet@ieee.org>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2015-06-16 20:48:52 +00:00
|
|
|
static const char __param_str_##name[] = prefix #name; \
|
2008-02-13 23:03:26 +00:00
|
|
|
static struct kernel_param __moduleparam_const __param_##name \
|
2008-01-24 21:16:20 +00:00
|
|
|
__used \
|
2005-04-16 22:20:36 +00:00
|
|
|
__attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \
|
module: add per-module param_lock
Add a "param_lock" mutex to each module, and update params.c to use
the correct built-in or module mutex while locking kernel params.
Remove the kparam_block_sysfs_r/w() macros, replace them with direct
calls to kernel_param_[un]lock(module).
The kernel param code currently uses a single mutex to protect
modification of any and all kernel params. While this generally works,
there is one specific problem with it; a module callback function
cannot safely load another module, i.e. with request_module() or even
with indirect calls such as crypto_has_alg(). If the module to be
loaded has any of its params configured (e.g. with a /etc/modprobe.d/*
config file), then the attempt will result in a deadlock between the
first module param callback waiting for modprobe, and modprobe trying to
lock the single kernel param mutex to set the new module's param.
This fixes that by using per-module mutexes, so that each individual module
is protected against concurrent changes in its own kernel params, but is
not blocked by changes to other module params. All built-in modules
continue to use the built-in mutex, since they will always be loaded at
runtime and references (e.g. request_module(), crypto_has_alg()) to them
will never cause load-time param changing.
This also simplifies the interface used by modules to block sysfs access
to their params; while there are currently functions to block and unblock
sysfs param access which are split up by read and write and expect a single
kernel param to be passed, their actual operation is identical and applies
to all params, not just the one passed to them; they simply lock and unlock
the global param mutex. They are replaced with direct calls to
kernel_param_[un]lock(THIS_MODULE), which locks THIS_MODULE's param_lock, or
if the module is built-in, it locks the built-in mutex.
Suggested-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Dan Streetman <ddstreet@ieee.org>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2015-06-16 20:48:52 +00:00
|
|
|
= { __param_str_##name, THIS_MODULE, ops, \
|
|
|
|
|
VERIFY_OCTAL_PERMISSIONS(perm), level, flags, { arg } }
|
2010-08-12 05:04:12 +00:00
|
|
|
|
|
|
|
|
/* Obsolete - use module_param_cb() */
|
|
|
|
|
#define module_param_call(name, set, get, arg, perm) \
|
2015-05-27 01:39:38 +00:00
|
|
|
static const struct kernel_param_ops __param_ops_##name = \
|
2014-09-11 00:17:23 +00:00
|
|
|
{ .flags = 0, (void *)set, (void *)get }; \
|
2010-08-12 05:04:12 +00:00
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, \
|
|
|
|
|
name, &__param_ops_##name, arg, \
|
2014-08-26 20:52:23 +00:00
|
|
|
(perm) + sizeof(__check_old_set_param(set))*0, -1, 0)
|
2010-08-12 05:04:12 +00:00
|
|
|
|
|
|
|
|
/* We don't get oldget: it's often a new-style param_get_uint, etc. */
|
|
|
|
|
static inline int
|
|
|
|
|
__check_old_set_param(int (*oldset)(const char *, struct kernel_param *))
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-08-12 05:04:19 +00:00
|
|
|
#ifdef CONFIG_SYSFS
|
module: add per-module param_lock
Add a "param_lock" mutex to each module, and update params.c to use
the correct built-in or module mutex while locking kernel params.
Remove the kparam_block_sysfs_r/w() macros, replace them with direct
calls to kernel_param_[un]lock(module).
The kernel param code currently uses a single mutex to protect
modification of any and all kernel params. While this generally works,
there is one specific problem with it; a module callback function
cannot safely load another module, i.e. with request_module() or even
with indirect calls such as crypto_has_alg(). If the module to be
loaded has any of its params configured (e.g. with a /etc/modprobe.d/*
config file), then the attempt will result in a deadlock between the
first module param callback waiting for modprobe, and modprobe trying to
lock the single kernel param mutex to set the new module's param.
This fixes that by using per-module mutexes, so that each individual module
is protected against concurrent changes in its own kernel params, but is
not blocked by changes to other module params. All built-in modules
continue to use the built-in mutex, since they will always be loaded at
runtime and references (e.g. request_module(), crypto_has_alg()) to them
will never cause load-time param changing.
This also simplifies the interface used by modules to block sysfs access
to their params; while there are currently functions to block and unblock
sysfs param access which are split up by read and write and expect a single
kernel param to be passed, their actual operation is identical and applies
to all params, not just the one passed to them; they simply lock and unlock
the global param mutex. They are replaced with direct calls to
kernel_param_[un]lock(THIS_MODULE), which locks THIS_MODULE's param_lock, or
if the module is built-in, it locks the built-in mutex.
Suggested-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Dan Streetman <ddstreet@ieee.org>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2015-06-16 20:48:52 +00:00
|
|
|
extern void kernel_param_lock(struct module *mod);
|
|
|
|
|
extern void kernel_param_unlock(struct module *mod);
|
2010-08-12 05:04:19 +00:00
|
|
|
#else
|
module: add per-module param_lock
Add a "param_lock" mutex to each module, and update params.c to use
the correct built-in or module mutex while locking kernel params.
Remove the kparam_block_sysfs_r/w() macros, replace them with direct
calls to kernel_param_[un]lock(module).
The kernel param code currently uses a single mutex to protect
modification of any and all kernel params. While this generally works,
there is one specific problem with it; a module callback function
cannot safely load another module, i.e. with request_module() or even
with indirect calls such as crypto_has_alg(). If the module to be
loaded has any of its params configured (e.g. with a /etc/modprobe.d/*
config file), then the attempt will result in a deadlock between the
first module param callback waiting for modprobe, and modprobe trying to
lock the single kernel param mutex to set the new module's param.
This fixes that by using per-module mutexes, so that each individual module
is protected against concurrent changes in its own kernel params, but is
not blocked by changes to other module params. All built-in modules
continue to use the built-in mutex, since they will always be loaded at
runtime and references (e.g. request_module(), crypto_has_alg()) to them
will never cause load-time param changing.
This also simplifies the interface used by modules to block sysfs access
to their params; while there are currently functions to block and unblock
sysfs param access which are split up by read and write and expect a single
kernel param to be passed, their actual operation is identical and applies
to all params, not just the one passed to them; they simply lock and unlock
the global param mutex. They are replaced with direct calls to
kernel_param_[un]lock(THIS_MODULE), which locks THIS_MODULE's param_lock, or
if the module is built-in, it locks the built-in mutex.
Suggested-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Dan Streetman <ddstreet@ieee.org>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2015-06-16 20:48:52 +00:00
|
|
|
static inline void kernel_param_lock(struct module *mod)
|
2010-08-12 05:04:19 +00:00
|
|
|
{
|
|
|
|
|
}
|
module: add per-module param_lock
Add a "param_lock" mutex to each module, and update params.c to use
the correct built-in or module mutex while locking kernel params.
Remove the kparam_block_sysfs_r/w() macros, replace them with direct
calls to kernel_param_[un]lock(module).
The kernel param code currently uses a single mutex to protect
modification of any and all kernel params. While this generally works,
there is one specific problem with it; a module callback function
cannot safely load another module, i.e. with request_module() or even
with indirect calls such as crypto_has_alg(). If the module to be
loaded has any of its params configured (e.g. with a /etc/modprobe.d/*
config file), then the attempt will result in a deadlock between the
first module param callback waiting for modprobe, and modprobe trying to
lock the single kernel param mutex to set the new module's param.
This fixes that by using per-module mutexes, so that each individual module
is protected against concurrent changes in its own kernel params, but is
not blocked by changes to other module params. All built-in modules
continue to use the built-in mutex, since they will always be loaded at
runtime and references (e.g. request_module(), crypto_has_alg()) to them
will never cause load-time param changing.
This also simplifies the interface used by modules to block sysfs access
to their params; while there are currently functions to block and unblock
sysfs param access which are split up by read and write and expect a single
kernel param to be passed, their actual operation is identical and applies
to all params, not just the one passed to them; they simply lock and unlock
the global param mutex. They are replaced with direct calls to
kernel_param_[un]lock(THIS_MODULE), which locks THIS_MODULE's param_lock, or
if the module is built-in, it locks the built-in mutex.
Suggested-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Dan Streetman <ddstreet@ieee.org>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2015-06-16 20:48:52 +00:00
|
|
|
static inline void kernel_param_unlock(struct module *mod)
|
2010-08-12 05:04:19 +00:00
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-10-22 15:00:23 +00:00
|
|
|
#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
|
2010-08-12 05:04:20 +00:00
|
|
|
* @type: the type of the parameter
|
2008-10-22 15:00:23 +00:00
|
|
|
* @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) \
|
|
|
|
|
param_check_##type(name, &(var)); \
|
2014-08-26 20:52:23 +00:00
|
|
|
__module_param_call("", name, ¶m_ops_##type, &var, perm, -1, 0)
|
2015-03-30 23:20:09 +00:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* core_param_unsafe - same as core_param but taints kernel
|
|
|
|
|
*/
|
|
|
|
|
#define core_param_unsafe(name, var, type, perm) \
|
|
|
|
|
param_check_##type(name, &(var)); \
|
|
|
|
|
__module_param_call("", name, ¶m_ops_##type, &var, perm, \
|
|
|
|
|
-1, KERNEL_PARAM_FL_UNSAFE)
|
|
|
|
|
|
2008-10-22 15:00:23 +00:00
|
|
|
#endif /* !MODULE */
|
|
|
|
|
|
2010-08-12 05:04:20 +00:00
|
|
|
/**
|
|
|
|
|
* 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).
|
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
#define module_param_string(name, string, len, perm) \
|
2007-10-17 06:29:34 +00:00
|
|
|
static const struct kparam_string __param_string_##name \
|
2005-04-16 22:20:36 +00:00
|
|
|
= { len, string }; \
|
2009-06-13 03:46:57 +00:00
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, \
|
2010-08-12 05:04:12 +00:00
|
|
|
¶m_ops_string, \
|
2014-08-26 20:52:23 +00:00
|
|
|
.str = &__param_string_##name, perm, -1, 0);\
|
2005-04-16 22:20:36 +00:00
|
|
|
__MODULE_PARM_TYPE(name, "string")
|
|
|
|
|
|
2011-10-09 22:03:37 +00:00
|
|
|
/**
|
|
|
|
|
* 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);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Called on module insert or kernel boot */
|
2014-04-28 02:04:33 +00:00
|
|
|
extern char *parse_args(const char *name,
|
2005-04-16 22:20:36 +00:00
|
|
|
char *args,
|
2010-08-12 05:04:18 +00:00
|
|
|
const struct kernel_param *params,
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned num,
|
2012-03-26 02:20:51 +00:00
|
|
|
s16 level_min,
|
|
|
|
|
s16 level_max,
|
module: add extra argument for parse_params() callback
This adds an extra argument onto parse_params() to be used
as a way to make the unused callback a bit more useful and
generic by allowing the caller to pass on a data structure
of its choice. An example use case is to allow us to easily
make module parameters for every module which we will do
next.
@ parse @
identifier name, args, params, num, level_min, level_max;
identifier unknown, param, val, doing;
type s16;
@@
extern char *parse_args(const char *name,
char *args,
const struct kernel_param *params,
unsigned num,
s16 level_min,
s16 level_max,
+ void *arg,
int (*unknown)(char *param, char *val,
const char *doing
+ , void *arg
));
@ parse_mod @
identifier name, args, params, num, level_min, level_max;
identifier unknown, param, val, doing;
type s16;
@@
char *parse_args(const char *name,
char *args,
const struct kernel_param *params,
unsigned num,
s16 level_min,
s16 level_max,
+ void *arg,
int (*unknown)(char *param, char *val,
const char *doing
+ , void *arg
))
{
...
}
@ parse_args_found @
expression R, E1, E2, E3, E4, E5, E6;
identifier func;
@@
(
R =
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
func);
|
R =
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
&func);
|
R =
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
NULL);
|
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
func);
|
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
&func);
|
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
NULL);
)
@ parse_args_unused depends on parse_args_found @
identifier parse_args_found.func;
@@
int func(char *param, char *val, const char *unused
+ , void *arg
)
{
...
}
@ mod_unused depends on parse_args_found @
identifier parse_args_found.func;
expression A1, A2, A3;
@@
- func(A1, A2, A3);
+ func(A1, A2, A3, NULL);
Generated-by: Coccinelle SmPL
Cc: cocci@systeme.lip6.fr
Cc: Tejun Heo <tj@kernel.org>
Cc: Arjan van de Ven <arjan@linux.intel.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Felipe Contreras <felipe.contreras@gmail.com>
Cc: Ewan Milne <emilne@redhat.com>
Cc: Jean Delvare <jdelvare@suse.de>
Cc: Hannes Reinecke <hare@suse.de>
Cc: Jani Nikula <jani.nikula@intel.com>
Cc: linux-kernel@vger.kernel.org
Reviewed-by: Tejun Heo <tj@kernel.org>
Acked-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2015-03-30 23:20:03 +00:00
|
|
|
void *arg,
|
params: add 3rd arg to option handler callback signature
Add a 3rd arg, named "doing", to unknown-options callbacks invoked
from parse_args(). The arg is passed as:
"Booting kernel" from start_kernel(),
initcall_level_names[i] from do_initcall_level(),
mod->name from load_module(), via parse_args(), parse_one()
parse_args() already has the "name" parameter, which is renamed to
"doing" to better reflect current uses 1,2 above. parse_args() passes
it to an altered parse_one(), which now passes it down into the
unknown option handler callbacks.
The mod->name will be needed to handle dyndbg for loadable modules,
since params passed by modprobe are not qualified (they do not have a
"$modname." prefix), and by the time the unknown-param callback is
called, the module name is not otherwise available.
Minor tweaks:
Add param-name to parse_one's pr_debug(), current message doesnt
identify the param being handled, add it.
Add a pr_info to print current level and level_name of the initcall,
and number of registered initcalls at that level. This adds 7 lines
to dmesg output, like:
initlevel:6=device, 172 registered initcalls
Drop "parameters" from initcall_level_names[], its unhelpful in the
pr_info() added above. This array is passed into parse_args() by
do_initcall_level().
CC: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
Acked-by: Jason Baron <jbaron@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-04-27 20:30:34 +00:00
|
|
|
int (*unknown)(char *param, char *val,
|
module: add extra argument for parse_params() callback
This adds an extra argument onto parse_params() to be used
as a way to make the unused callback a bit more useful and
generic by allowing the caller to pass on a data structure
of its choice. An example use case is to allow us to easily
make module parameters for every module which we will do
next.
@ parse @
identifier name, args, params, num, level_min, level_max;
identifier unknown, param, val, doing;
type s16;
@@
extern char *parse_args(const char *name,
char *args,
const struct kernel_param *params,
unsigned num,
s16 level_min,
s16 level_max,
+ void *arg,
int (*unknown)(char *param, char *val,
const char *doing
+ , void *arg
));
@ parse_mod @
identifier name, args, params, num, level_min, level_max;
identifier unknown, param, val, doing;
type s16;
@@
char *parse_args(const char *name,
char *args,
const struct kernel_param *params,
unsigned num,
s16 level_min,
s16 level_max,
+ void *arg,
int (*unknown)(char *param, char *val,
const char *doing
+ , void *arg
))
{
...
}
@ parse_args_found @
expression R, E1, E2, E3, E4, E5, E6;
identifier func;
@@
(
R =
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
func);
|
R =
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
&func);
|
R =
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
NULL);
|
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
func);
|
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
&func);
|
parse_args(E1, E2, E3, E4, E5, E6,
+ NULL,
NULL);
)
@ parse_args_unused depends on parse_args_found @
identifier parse_args_found.func;
@@
int func(char *param, char *val, const char *unused
+ , void *arg
)
{
...
}
@ mod_unused depends on parse_args_found @
identifier parse_args_found.func;
expression A1, A2, A3;
@@
- func(A1, A2, A3);
+ func(A1, A2, A3, NULL);
Generated-by: Coccinelle SmPL
Cc: cocci@systeme.lip6.fr
Cc: Tejun Heo <tj@kernel.org>
Cc: Arjan van de Ven <arjan@linux.intel.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Felipe Contreras <felipe.contreras@gmail.com>
Cc: Ewan Milne <emilne@redhat.com>
Cc: Jean Delvare <jdelvare@suse.de>
Cc: Hannes Reinecke <hare@suse.de>
Cc: Jani Nikula <jani.nikula@intel.com>
Cc: linux-kernel@vger.kernel.org
Reviewed-by: Tejun Heo <tj@kernel.org>
Acked-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2015-03-30 23:20:03 +00:00
|
|
|
const char *doing, void *arg));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-31 19:05:29 +00:00
|
|
|
/* 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 */
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* 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) \
|
2014-03-17 02:48:26 +00:00
|
|
|
static inline type __always_unused *__check_##name(void) { return(p); }
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_byte;
|
2010-08-12 05:04:12 +00:00
|
|
|
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);
|
2005-04-16 22:20:36 +00:00
|
|
|
#define param_check_byte(name, p) __param_check(name, p, unsigned char)
|
|
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_short;
|
2010-08-12 05:04:12 +00:00
|
|
|
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);
|
2005-04-16 22:20:36 +00:00
|
|
|
#define param_check_short(name, p) __param_check(name, p, short)
|
|
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_ushort;
|
2010-08-12 05:04:12 +00:00
|
|
|
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);
|
2005-04-16 22:20:36 +00:00
|
|
|
#define param_check_ushort(name, p) __param_check(name, p, unsigned short)
|
|
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_int;
|
2010-08-12 05:04:12 +00:00
|
|
|
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);
|
2005-04-16 22:20:36 +00:00
|
|
|
#define param_check_int(name, p) __param_check(name, p, int)
|
|
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_uint;
|
2010-08-12 05:04:12 +00:00
|
|
|
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);
|
2005-04-16 22:20:36 +00:00
|
|
|
#define param_check_uint(name, p) __param_check(name, p, unsigned int)
|
|
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_long;
|
2010-08-12 05:04:12 +00:00
|
|
|
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);
|
2005-04-16 22:20:36 +00:00
|
|
|
#define param_check_long(name, p) __param_check(name, p, long)
|
|
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_ulong;
|
2010-08-12 05:04:12 +00:00
|
|
|
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);
|
2005-04-16 22:20:36 +00:00
|
|
|
#define param_check_ulong(name, p) __param_check(name, p, unsigned long)
|
|
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_ullong;
|
2014-06-25 13:27:37 +00:00
|
|
|
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) __param_check(name, p, unsigned long long)
|
|
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_charp;
|
2010-08-12 05:04:12 +00:00
|
|
|
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);
|
2015-11-07 00:29:12 +00:00
|
|
|
extern void param_free_charp(void *arg);
|
2005-04-16 22:20:36 +00:00
|
|
|
#define param_check_charp(name, p) __param_check(name, p, char *)
|
|
|
|
|
|
2012-01-12 23:02:28 +00:00
|
|
|
/* We used to allow int as well as bool. We're taking that away! */
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_bool;
|
2010-08-12 05:04:12 +00:00
|
|
|
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);
|
2012-01-12 23:02:28 +00:00
|
|
|
#define param_check_bool(name, p) __param_check(name, p, bool)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
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 param_check_bool
|
|
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_invbool;
|
2010-08-12 05:04:12 +00:00
|
|
|
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);
|
2009-06-13 03:46:53 +00:00
|
|
|
#define param_check_invbool(name, p) __param_check(name, p, bool)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-01-12 23:02:17 +00:00
|
|
|
/* An int, which can only be set like a bool (though it shows as an int). */
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_bint;
|
2012-01-12 23:02:17 +00:00
|
|
|
extern int param_set_bint(const char *val, const struct kernel_param *kp);
|
|
|
|
|
#define param_get_bint param_get_int
|
|
|
|
|
#define param_check_bint param_check_int
|
|
|
|
|
|
2010-08-12 05:04:20 +00:00
|
|
|
/**
|
|
|
|
|
* 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(name, 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.
|
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
#define module_param_array_named(name, array, type, nump, perm) \
|
2012-01-12 23:02:16 +00:00
|
|
|
param_check_##type(name, &(array)[0]); \
|
2007-10-17 06:29:34 +00:00
|
|
|
static const struct kparam_array __param_arr_##name \
|
2011-05-19 22:55:25 +00:00
|
|
|
= { .max = ARRAY_SIZE(array), .num = nump, \
|
|
|
|
|
.ops = ¶m_ops_##type, \
|
|
|
|
|
.elemsize = sizeof(array[0]), .elem = array }; \
|
2009-06-13 03:46:57 +00:00
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, \
|
2010-08-12 05:04:12 +00:00
|
|
|
¶m_array_ops, \
|
2009-06-13 03:46:57 +00:00
|
|
|
.arr = &__param_arr_##name, \
|
2014-08-26 20:52:23 +00:00
|
|
|
perm, -1, 0); \
|
2005-04-16 22:20:36 +00:00
|
|
|
__MODULE_PARM_TYPE(name, "array of " #type)
|
|
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_array_ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-05-27 01:39:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_string;
|
2010-08-12 05:04:12 +00:00
|
|
|
extern int param_set_copystring(const char *val, const struct kernel_param *);
|
|
|
|
|
extern int param_get_string(char *buffer, const struct kernel_param *kp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-07-02 06:05:11 +00:00
|
|
|
/* for exporting parameters in /sys/module/.../parameters */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
struct module;
|
|
|
|
|
|
2007-02-13 23:19:06 +00:00
|
|
|
#if defined(CONFIG_SYSFS) && defined(CONFIG_MODULES)
|
2005-04-16 22:20:36 +00:00
|
|
|
extern int module_param_sysfs_setup(struct module *mod,
|
2010-08-12 05:04:12 +00:00
|
|
|
const struct kernel_param *kparam,
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int num_params);
|
|
|
|
|
|
|
|
|
|
extern void module_param_sysfs_remove(struct module *mod);
|
2007-02-13 23:19:06 +00:00
|
|
|
#else
|
|
|
|
|
static inline int module_param_sysfs_setup(struct module *mod,
|
2010-08-12 05:04:12 +00:00
|
|
|
const struct kernel_param *kparam,
|
2007-02-13 23:19:06 +00:00
|
|
|
unsigned int num_params)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void module_param_sysfs_remove(struct module *mod)
|
|
|
|
|
{ }
|
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#endif /* _LINUX_MODULE_PARAMS_H */
|