License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 21:07:57 +07:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-04-17 05:20:36 +07: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-07 03:17:50 +07:00
|
|
|
#define MODULE_PARAM_PREFIX KBUILD_MODNAME "."
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
|
|
2008-10-22 22:00:22 +07:00
|
|
|
/* Chosen so that structs with an unsigned long line up. */
|
|
|
|
|
#define MAX_PARAM_PREFIX_LEN (64 - sizeof(unsigned long))
|
|
|
|
|
|
2011-01-05 19:27:04 +07:00
|
|
|
#ifdef MODULE
|
2005-04-17 05:20:36 +07:00
|
|
|
#define __MODULE_INFO(tag, name, info) \
|
2012-11-22 09:00:25 +07:00
|
|
|
static const char __UNIQUE_ID(name)[] \
|
2010-10-27 04:22:26 +07:00
|
|
|
__used __attribute__((section(".modinfo"), unused, aligned(1))) \
|
|
|
|
|
= __stringify(tag) "=" info
|
2005-04-17 05:20:36 +07:00
|
|
|
#else /* !MODULE */
|
2011-01-05 19:27:04 +07:00
|
|
|
/* This struct is here for syntactic coherency, it is not used */
|
|
|
|
|
#define __MODULE_INFO(tag, name, info) \
|
2012-11-22 09:00:25 +07:00
|
|
|
struct __UNIQUE_ID(name) {}
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
|
#define __MODULE_PARM_TYPE(name, _type) \
|
|
|
|
|
__MODULE_INFO(parmtype, name##type, #name ":" _type)
|
|
|
|
|
|
2011-08-30 22:24:44 +07: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-17 05:20:36 +07:00
|
|
|
struct kernel_param;
|
|
|
|
|
|
2013-08-20 13:03:19 +07:00
|
|
|
/*
|
|
|
|
|
* Flags available for kernel_param_ops
|
|
|
|
|
*
|
|
|
|
|
* NOARG - the parameter allows for no argument (foo instead of foo=1)
|
|
|
|
|
*/
|
|
|
|
|
enum {
|
2014-08-27 03:51:23 +07:00
|
|
|
KERNEL_PARAM_OPS_FL_NOARG = (1 << 0)
|
2013-08-20 13:03:19 +07:00
|
|
|
};
|
|
|
|
|
|
2010-08-12 12:04:12 +07:00
|
|
|
struct kernel_param_ops {
|
2013-08-20 13:03:19 +07:00
|
|
|
/* How the ops should behave */
|
|
|
|
|
unsigned int flags;
|
2010-08-12 12:04:12 +07: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 12:04:17 +07:00
|
|
|
/* Optional function to free kp->arg when module unloaded. */
|
|
|
|
|
void (*free)(void *arg);
|
2010-08-12 12:04:12 +07:00
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-08-27 03:52:23 +07:00
|
|
|
/*
|
|
|
|
|
* Flags available for kernel_param
|
|
|
|
|
*
|
|
|
|
|
* UNSAFE - the parameter is dangerous and setting it will taint the kernel
|
Annotate module params that specify hardware parameters (eg. ioport)
Provided an annotation for module parameters that specify hardware
parameters (such as io ports, iomem addresses, irqs, dma channels, fixed
dma buffers and other types).
This will enable such parameters to be locked down in the core parameter
parser for secure boot support.
I've also included annotations as to what sort of hardware configuration
each module is dealing with for future use. Some of these are
straightforward (ioport, iomem, irq, dma), but there are also:
(1) drivers that switch the semantics of a parameter between ioport and
iomem depending on a second parameter,
(2) drivers that appear to reserve a CPU memory buffer at a fixed address,
(3) other parameters, such as bus types and irq selection bitmasks.
For the moment, the hardware configuration type isn't actually stored,
though its validity is checked.
Signed-off-by: David Howells <dhowells@redhat.com>
2017-04-04 22:54:21 +07:00
|
|
|
* HWPARAM - Hardware param not permitted in lockdown mode
|
2014-08-27 03:52:23 +07:00
|
|
|
*/
|
|
|
|
|
enum {
|
Annotate module params that specify hardware parameters (eg. ioport)
Provided an annotation for module parameters that specify hardware
parameters (such as io ports, iomem addresses, irqs, dma channels, fixed
dma buffers and other types).
This will enable such parameters to be locked down in the core parameter
parser for secure boot support.
I've also included annotations as to what sort of hardware configuration
each module is dealing with for future use. Some of these are
straightforward (ioport, iomem, irq, dma), but there are also:
(1) drivers that switch the semantics of a parameter between ioport and
iomem depending on a second parameter,
(2) drivers that appear to reserve a CPU memory buffer at a fixed address,
(3) other parameters, such as bus types and irq selection bitmasks.
For the moment, the hardware configuration type isn't actually stored,
though its validity is checked.
Signed-off-by: David Howells <dhowells@redhat.com>
2017-04-04 22:54:21 +07:00
|
|
|
KERNEL_PARAM_FL_UNSAFE = (1 << 0),
|
|
|
|
|
KERNEL_PARAM_FL_HWPARAM = (1 << 1),
|
2014-08-27 03:52:23 +07:00
|
|
|
};
|
|
|
|
|
|
2005-04-17 05:20:36 +07: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-17 03:48:52 +07:00
|
|
|
struct module *mod;
|
2010-08-12 12:04:12 +07:00
|
|
|
const struct kernel_param_ops *ops;
|
2015-06-17 03:47:52 +07:00
|
|
|
const u16 perm;
|
2014-08-27 03:52:23 +07:00
|
|
|
s8 level;
|
|
|
|
|
u8 flags;
|
2007-10-17 13:29:34 +07:00
|
|
|
union {
|
|
|
|
|
void *arg;
|
|
|
|
|
const struct kparam_string *str;
|
|
|
|
|
const struct kparam_array *arr;
|
|
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
2014-10-14 05:55:44 +07:00
|
|
|
extern const struct kernel_param __start___param[], __stop___param[];
|
|
|
|
|
|
2005-04-17 05:20:36 +07: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-20 05:55:25 +07:00
|
|
|
unsigned int elemsize;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned int *num;
|
2010-08-12 12:04:12 +07:00
|
|
|
const struct kernel_param_ops *ops;
|
2005-04-17 05:20:36 +07:00
|
|
|
void *elem;
|
|
|
|
|
};
|
|
|
|
|
|
2010-08-12 12:04:20 +07: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-17 03:48:52 +07:00
|
|
|
* is writable, you may need to use kernel_param_lock() around
|
2010-08-12 12:04:20 +07: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-27 03:53:23 +07: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 12:04:20 +07: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-27 03:53:23 +07: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 12:04:20 +07: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-27 03:52:23 +07:00
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1, 0)
|
2012-03-26 09:20:51 +07:00
|
|
|
|
2014-08-27 03:53:23 +07: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 09:20:51 +07: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-27 03:52:23 +07:00
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, level, 0)
|
2012-03-26 09:20:51 +07: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 12:04:20 +07:00
|
|
|
|
2008-02-14 06:03:26 +07: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-17 05:20:36 +07:00
|
|
|
/* This is the fundamental function for registering boot/module
|
2010-08-12 12:04:20 +07:00
|
|
|
parameters. */
|
2014-08-27 03:52:23 +07: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 11:36:56 +07: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-17 03:48:52 +07:00
|
|
|
static const char __param_str_##name[] = prefix #name; \
|
2008-02-14 06:03:26 +07:00
|
|
|
static struct kernel_param __moduleparam_const __param_##name \
|
2008-01-25 04:16:20 +07:00
|
|
|
__used \
|
2005-04-17 05:20:36 +07: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-17 03:48:52 +07:00
|
|
|
= { __param_str_##name, THIS_MODULE, ops, \
|
|
|
|
|
VERIFY_OCTAL_PERMISSIONS(perm), level, flags, { arg } }
|
2010-08-12 12:04:12 +07:00
|
|
|
|
|
|
|
|
/* Obsolete - use module_param_cb() */
|
2017-10-18 09:04:43 +07:00
|
|
|
#define module_param_call(name, _set, _get, arg, perm) \
|
2017-10-18 09:04:41 +07:00
|
|
|
static const struct kernel_param_ops __param_ops_##name = \
|
2017-10-18 09:04:43 +07:00
|
|
|
{ .flags = 0, .set = _set, .get = _get }; \
|
2010-08-12 12:04:12 +07:00
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, \
|
2017-10-18 09:04:41 +07:00
|
|
|
name, &__param_ops_##name, arg, perm, -1, 0)
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-08-12 12:04:19 +07: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-17 03:48:52 +07:00
|
|
|
extern void kernel_param_lock(struct module *mod);
|
|
|
|
|
extern void kernel_param_unlock(struct module *mod);
|
2010-08-12 12:04:19 +07: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-17 03:48:52 +07:00
|
|
|
static inline void kernel_param_lock(struct module *mod)
|
2010-08-12 12:04:19 +07: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-17 03:48:52 +07:00
|
|
|
static inline void kernel_param_unlock(struct module *mod)
|
2010-08-12 12:04:19 +07:00
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-10-22 22:00:23 +07: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 12:04:20 +07:00
|
|
|
* @type: the type of the parameter
|
2008-10-22 22:00:23 +07: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-27 03:52:23 +07:00
|
|
|
__module_param_call("", name, ¶m_ops_##type, &var, perm, -1, 0)
|
2015-03-31 06:20:09 +07: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 22:00:23 +07:00
|
|
|
#endif /* !MODULE */
|
|
|
|
|
|
2010-08-12 12:04:20 +07: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-17 05:20:36 +07:00
|
|
|
#define module_param_string(name, string, len, perm) \
|
2007-10-17 13:29:34 +07:00
|
|
|
static const struct kparam_string __param_string_##name \
|
2005-04-17 05:20:36 +07:00
|
|
|
= { len, string }; \
|
2009-06-13 10:46:57 +07:00
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, \
|
2010-08-12 12:04:12 +07:00
|
|
|
¶m_ops_string, \
|
2014-08-27 03:52:23 +07:00
|
|
|
.str = &__param_string_##name, perm, -1, 0);\
|
2005-04-17 05:20:36 +07:00
|
|
|
__MODULE_PARM_TYPE(name, "string")
|
|
|
|
|
|
2011-10-10 05:03:37 +07: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-17 05:20:36 +07:00
|
|
|
/* Called on module insert or kernel boot */
|
2014-04-28 09:04:33 +07:00
|
|
|
extern char *parse_args(const char *name,
|
2005-04-17 05:20:36 +07:00
|
|
|
char *args,
|
2010-08-12 12:04:18 +07:00
|
|
|
const struct kernel_param *params,
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned num,
|
2012-03-26 09:20:51 +07: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-31 06:20:03 +07: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-28 03:30:34 +07: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-31 06:20:03 +07:00
|
|
|
const char *doing, void *arg));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-04-01 02:05:29 +07: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-17 05:20:36 +07: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 09:48:26 +07:00
|
|
|
static inline type __always_unused *__check_##name(void) { return(p); }
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_byte;
|
2010-08-12 12:04:12 +07: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-17 05:20:36 +07:00
|
|
|
#define param_check_byte(name, p) __param_check(name, p, unsigned char)
|
|
|
|
|
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_short;
|
2010-08-12 12:04:12 +07: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-17 05:20:36 +07:00
|
|
|
#define param_check_short(name, p) __param_check(name, p, short)
|
|
|
|
|
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_ushort;
|
2010-08-12 12:04:12 +07: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-17 05:20:36 +07:00
|
|
|
#define param_check_ushort(name, p) __param_check(name, p, unsigned short)
|
|
|
|
|
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_int;
|
2010-08-12 12:04:12 +07: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-17 05:20:36 +07:00
|
|
|
#define param_check_int(name, p) __param_check(name, p, int)
|
|
|
|
|
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_uint;
|
2010-08-12 12:04:12 +07: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-17 05:20:36 +07:00
|
|
|
#define param_check_uint(name, p) __param_check(name, p, unsigned int)
|
|
|
|
|
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_long;
|
2010-08-12 12:04:12 +07: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-17 05:20:36 +07:00
|
|
|
#define param_check_long(name, p) __param_check(name, p, long)
|
|
|
|
|
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_ulong;
|
2010-08-12 12:04:12 +07: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-17 05:20:36 +07:00
|
|
|
#define param_check_ulong(name, p) __param_check(name, p, unsigned long)
|
|
|
|
|
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_ullong;
|
2014-06-25 20:27:37 +07: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 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_charp;
|
2010-08-12 12:04:12 +07: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 07:29:12 +07:00
|
|
|
extern void param_free_charp(void *arg);
|
2005-04-17 05:20:36 +07:00
|
|
|
#define param_check_charp(name, p) __param_check(name, p, char *)
|
|
|
|
|
|
2012-01-13 06:02:28 +07:00
|
|
|
/* We used to allow int as well as bool. We're taking that away! */
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_bool;
|
2010-08-12 12:04:12 +07: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-13 06:02:28 +07:00
|
|
|
#define param_check_bool(name, p) __param_check(name, p, bool)
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2015-05-27 08:39:38 +07: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 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_invbool;
|
2010-08-12 12:04:12 +07: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 10:46:53 +07:00
|
|
|
#define param_check_invbool(name, p) __param_check(name, p, bool)
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-01-13 06:02:17 +07:00
|
|
|
/* An int, which can only be set like a bool (though it shows as an int). */
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_bint;
|
2012-01-13 06:02:17 +07: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 12:04:20 +07: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-17 05:20:36 +07:00
|
|
|
#define module_param_array_named(name, array, type, nump, perm) \
|
2012-01-13 06:02:16 +07:00
|
|
|
param_check_##type(name, &(array)[0]); \
|
2007-10-17 13:29:34 +07:00
|
|
|
static const struct kparam_array __param_arr_##name \
|
2011-05-20 05:55:25 +07:00
|
|
|
= { .max = ARRAY_SIZE(array), .num = nump, \
|
|
|
|
|
.ops = ¶m_ops_##type, \
|
|
|
|
|
.elemsize = sizeof(array[0]), .elem = array }; \
|
2009-06-13 10:46:57 +07:00
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, \
|
2010-08-12 12:04:12 +07:00
|
|
|
¶m_array_ops, \
|
2009-06-13 10:46:57 +07:00
|
|
|
.arr = &__param_arr_##name, \
|
2014-08-27 03:52:23 +07:00
|
|
|
perm, -1, 0); \
|
2005-04-17 05:20:36 +07:00
|
|
|
__MODULE_PARM_TYPE(name, "array of " #type)
|
|
|
|
|
|
Annotate module params that specify hardware parameters (eg. ioport)
Provided an annotation for module parameters that specify hardware
parameters (such as io ports, iomem addresses, irqs, dma channels, fixed
dma buffers and other types).
This will enable such parameters to be locked down in the core parameter
parser for secure boot support.
I've also included annotations as to what sort of hardware configuration
each module is dealing with for future use. Some of these are
straightforward (ioport, iomem, irq, dma), but there are also:
(1) drivers that switch the semantics of a parameter between ioport and
iomem depending on a second parameter,
(2) drivers that appear to reserve a CPU memory buffer at a fixed address,
(3) other parameters, such as bus types and irq selection bitmasks.
For the moment, the hardware configuration type isn't actually stored,
though its validity is checked.
Signed-off-by: David Howells <dhowells@redhat.com>
2017-04-04 22:54:21 +07:00
|
|
|
enum hwparam_type {
|
|
|
|
|
hwparam_ioport, /* Module parameter configures an I/O port */
|
|
|
|
|
hwparam_iomem, /* Module parameter configures an I/O mem address */
|
|
|
|
|
hwparam_ioport_or_iomem, /* Module parameter could be either, depending on other option */
|
2017-07-02 20:21:56 +07:00
|
|
|
hwparam_irq, /* Module parameter configures an IRQ */
|
Annotate module params that specify hardware parameters (eg. ioport)
Provided an annotation for module parameters that specify hardware
parameters (such as io ports, iomem addresses, irqs, dma channels, fixed
dma buffers and other types).
This will enable such parameters to be locked down in the core parameter
parser for secure boot support.
I've also included annotations as to what sort of hardware configuration
each module is dealing with for future use. Some of these are
straightforward (ioport, iomem, irq, dma), but there are also:
(1) drivers that switch the semantics of a parameter between ioport and
iomem depending on a second parameter,
(2) drivers that appear to reserve a CPU memory buffer at a fixed address,
(3) other parameters, such as bus types and irq selection bitmasks.
For the moment, the hardware configuration type isn't actually stored,
though its validity is checked.
Signed-off-by: David Howells <dhowells@redhat.com>
2017-04-04 22:54:21 +07:00
|
|
|
hwparam_dma, /* Module parameter configures a DMA channel */
|
|
|
|
|
hwparam_dma_addr, /* Module parameter configures a DMA buffer address */
|
|
|
|
|
hwparam_other, /* Module parameter configures some other value */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* module_param_hw_named - A parameter representing a hw parameters
|
|
|
|
|
* @name: a valid C identifier which is the parameter name.
|
|
|
|
|
* @value: the actual lvalue to alter.
|
|
|
|
|
* @type: the type of the parameter
|
|
|
|
|
* @hwtype: what the value represents (enum hwparam_type)
|
|
|
|
|
* @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_hw_named(name, value, type, hwtype, perm) \
|
|
|
|
|
param_check_##type(name, &(value)); \
|
|
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, \
|
|
|
|
|
¶m_ops_##type, &value, \
|
|
|
|
|
perm, -1, \
|
|
|
|
|
KERNEL_PARAM_FL_HWPARAM | (hwparam_##hwtype & 0)); \
|
|
|
|
|
__MODULE_PARM_TYPE(name, #type)
|
|
|
|
|
|
|
|
|
|
#define module_param_hw(name, type, hwtype, perm) \
|
|
|
|
|
module_param_hw_named(name, name, type, hwtype, perm)
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* module_param_hw_array - A parameter representing an array of hw parameters
|
|
|
|
|
* @name: the name of the array variable
|
|
|
|
|
* @type: the type, as per module_param()
|
|
|
|
|
* @hwtype: what the value represents (enum hwparam_type)
|
|
|
|
|
* @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_hw_array(name, type, hwtype, nump, perm) \
|
|
|
|
|
param_check_##type(name, &(name)[0]); \
|
|
|
|
|
static const struct kparam_array __param_arr_##name \
|
|
|
|
|
= { .max = ARRAY_SIZE(name), .num = nump, \
|
|
|
|
|
.ops = ¶m_ops_##type, \
|
|
|
|
|
.elemsize = sizeof(name[0]), .elem = name }; \
|
|
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, \
|
|
|
|
|
¶m_array_ops, \
|
|
|
|
|
.arr = &__param_arr_##name, \
|
|
|
|
|
perm, -1, \
|
|
|
|
|
KERNEL_PARAM_FL_HWPARAM | (hwparam_##hwtype & 0)); \
|
|
|
|
|
__MODULE_PARM_TYPE(name, "array of " #type)
|
|
|
|
|
|
|
|
|
|
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_array_ops;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2015-05-27 08:39:38 +07:00
|
|
|
extern const struct kernel_param_ops param_ops_string;
|
2010-08-12 12:04:12 +07: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-17 05:20:36 +07:00
|
|
|
|
2013-07-02 13:05:11 +07:00
|
|
|
/* for exporting parameters in /sys/module/.../parameters */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
struct module;
|
|
|
|
|
|
2007-02-14 06:19:06 +07:00
|
|
|
#if defined(CONFIG_SYSFS) && defined(CONFIG_MODULES)
|
2005-04-17 05:20:36 +07:00
|
|
|
extern int module_param_sysfs_setup(struct module *mod,
|
2010-08-12 12:04:12 +07:00
|
|
|
const struct kernel_param *kparam,
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned int num_params);
|
|
|
|
|
|
|
|
|
|
extern void module_param_sysfs_remove(struct module *mod);
|
2007-02-14 06:19:06 +07:00
|
|
|
#else
|
|
|
|
|
static inline int module_param_sysfs_setup(struct module *mod,
|
2010-08-12 12:04:12 +07:00
|
|
|
const struct kernel_param *kparam,
|
2007-02-14 06:19:06 +07:00
|
|
|
unsigned int num_params)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void module_param_sysfs_remove(struct module *mod)
|
|
|
|
|
{ }
|
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
#endif /* _LINUX_MODULE_PARAMS_H */
|