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 14:07:57 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
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 */
|
2019-04-29 16:11:14 +00:00
|
|
|
#define __MODULE_INFO_PREFIX /* empty */
|
2005-04-16 22:20:36 +00:00
|
|
|
#else
|
2006-01-06 20:17:50 +00:00
|
|
|
#define MODULE_PARAM_PREFIX KBUILD_MODNAME "."
|
2019-04-29 16:11:14 +00:00
|
|
|
/* We cannot use MODULE_PARAM_PREFIX because some modules override it. */
|
|
|
|
|
#define __MODULE_INFO_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))
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define __MODULE_INFO(tag, name, info) \
|
2020-11-23 10:23:19 +00:00
|
|
|
static const char __UNIQUE_ID(name)[] \
|
|
|
|
|
__used __section(".modinfo") __aligned(1) \
|
|
|
|
|
= __MODULE_INFO_PREFIX __stringify(tag) "=" info
|
2019-04-29 16:11:14 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define __MODULE_PARM_TYPE(name, _type) \
|
2020-11-23 10:23:19 +00:00
|
|
|
__MODULE_INFO(parmtype, name##type, #name ":" _type)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
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
|
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 15:54:21 +00:00
|
|
|
* HWPARAM - Hardware param not permitted in lockdown mode
|
2014-08-26 20:52:23 +00: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 15:54:21 +00:00
|
|
|
KERNEL_PARAM_FL_UNSAFE = (1 << 0),
|
|
|
|
|
KERNEL_PARAM_FL_HWPARAM = (1 << 1),
|
2014-08-26 20:52:23 +00:00
|
|
|
};
|
|
|
|
|
|
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
|
2019-11-04 09:09:37 +00:00
|
|
|
* @name: the variable to alter, and exposed parameter name.
|
2010-08-12 05:04:20 +00:00
|
|
|
* @type: the type of the parameter
|
|
|
|
|
* @perm: visibility in sysfs.
|
|
|
|
|
*
|
2019-11-04 09:09:37 +00:00
|
|
|
* @name becomes the module parameter, or (prefixed by KBUILD_MODNAME and a
|
2010-08-12 05:04:20 +00:00
|
|
|
* ".") the kernel commandline parameter. Note that - is changed to _, so
|
|
|
|
|
* the user can use "foo-bar=1" even for variable "foo_bar".
|
|
|
|
|
*
|
2020-07-17 23:36:50 +00:00
|
|
|
* @perm is 0 if the variable is not to appear in sysfs, or 0444
|
2010-08-12 05:04:20 +00:00
|
|
|
* 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:
|
2020-07-03 14:29:38 +00:00
|
|
|
* byte, hexint, short, ushort, int, uint, long, ulong
|
2010-08-12 05:04:20 +00:00
|
|
|
* 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
|
2019-12-02 09:01:17 +00:00
|
|
|
* @name: the variable to alter, and exposed parameter name.
|
|
|
|
|
* @type: the type of the parameter
|
|
|
|
|
* @perm: visibility in sysfs.
|
2014-08-26 20:53:23 +00:00
|
|
|
*/
|
|
|
|
|
#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
|
2019-12-02 09:01:17 +00:00
|
|
|
* @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.
|
2014-08-26 20:53:23 +00:00
|
|
|
*/
|
|
|
|
|
#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.
|
2019-12-02 09:01:17 +00:00
|
|
|
* @arg: args for @ops
|
2010-08-12 05:04:20 +00:00
|
|
|
* @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)
|
|
|
|
|
|
2019-12-02 09:01:17 +00:00
|
|
|
#define __level_param_cb(name, ops, arg, perm, level) \
|
|
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, level, 0)
|
2012-03-26 02:20:51 +00:00
|
|
|
/**
|
2019-12-02 09:01:17 +00:00
|
|
|
* core_param_cb - general callback for a module/cmdline parameter
|
|
|
|
|
* to be evaluated before core initcall level
|
2012-03-26 02:20:51 +00:00
|
|
|
* @name: a valid C identifier which is the parameter name.
|
|
|
|
|
* @ops: the set & get operations for this parameter.
|
2019-12-02 09:01:17 +00:00
|
|
|
* @arg: args for @ops
|
2012-03-26 02:20:51 +00:00
|
|
|
* @perm: visibility in sysfs.
|
|
|
|
|
*
|
|
|
|
|
* The ops can have NULL set or get functions.
|
|
|
|
|
*/
|
|
|
|
|
#define core_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 1)
|
|
|
|
|
|
2019-12-02 09:01:17 +00:00
|
|
|
/**
|
|
|
|
|
* postcore_param_cb - general callback for a module/cmdline parameter
|
|
|
|
|
* to be evaluated before postcore initcall level
|
|
|
|
|
* @name: a valid C identifier which is the parameter name.
|
|
|
|
|
* @ops: the set & get operations for this parameter.
|
|
|
|
|
* @arg: args for @ops
|
|
|
|
|
* @perm: visibility in sysfs.
|
|
|
|
|
*
|
|
|
|
|
* The ops can have NULL set or get functions.
|
|
|
|
|
*/
|
2012-03-26 02:20:51 +00:00
|
|
|
#define postcore_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 2)
|
|
|
|
|
|
2019-12-02 09:01:17 +00:00
|
|
|
/**
|
|
|
|
|
* arch_param_cb - general callback for a module/cmdline parameter
|
|
|
|
|
* to be evaluated before arch initcall level
|
|
|
|
|
* @name: a valid C identifier which is the parameter name.
|
|
|
|
|
* @ops: the set & get operations for this parameter.
|
|
|
|
|
* @arg: args for @ops
|
|
|
|
|
* @perm: visibility in sysfs.
|
|
|
|
|
*
|
|
|
|
|
* The ops can have NULL set or get functions.
|
|
|
|
|
*/
|
2012-03-26 02:20:51 +00:00
|
|
|
#define arch_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 3)
|
|
|
|
|
|
2019-12-02 09:01:17 +00:00
|
|
|
/**
|
|
|
|
|
* subsys_param_cb - general callback for a module/cmdline parameter
|
|
|
|
|
* to be evaluated before subsys initcall level
|
|
|
|
|
* @name: a valid C identifier which is the parameter name.
|
|
|
|
|
* @ops: the set & get operations for this parameter.
|
|
|
|
|
* @arg: args for @ops
|
|
|
|
|
* @perm: visibility in sysfs.
|
|
|
|
|
*
|
|
|
|
|
* The ops can have NULL set or get functions.
|
|
|
|
|
*/
|
2012-03-26 02:20:51 +00:00
|
|
|
#define subsys_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 4)
|
|
|
|
|
|
2019-12-02 09:01:17 +00:00
|
|
|
/**
|
|
|
|
|
* fs_param_cb - general callback for a module/cmdline parameter
|
|
|
|
|
* to be evaluated before fs initcall level
|
|
|
|
|
* @name: a valid C identifier which is the parameter name.
|
|
|
|
|
* @ops: the set & get operations for this parameter.
|
|
|
|
|
* @arg: args for @ops
|
|
|
|
|
* @perm: visibility in sysfs.
|
|
|
|
|
*
|
|
|
|
|
* The ops can have NULL set or get functions.
|
|
|
|
|
*/
|
2012-03-26 02:20:51 +00:00
|
|
|
#define fs_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 5)
|
|
|
|
|
|
2019-12-02 09:01:17 +00:00
|
|
|
/**
|
|
|
|
|
* device_param_cb - general callback for a module/cmdline parameter
|
|
|
|
|
* to be evaluated before device initcall level
|
|
|
|
|
* @name: a valid C identifier which is the parameter name.
|
|
|
|
|
* @ops: the set & get operations for this parameter.
|
|
|
|
|
* @arg: args for @ops
|
|
|
|
|
* @perm: visibility in sysfs.
|
|
|
|
|
*
|
|
|
|
|
* The ops can have NULL set or get functions.
|
|
|
|
|
*/
|
2012-03-26 02:20:51 +00:00
|
|
|
#define device_param_cb(name, ops, arg, perm) \
|
|
|
|
|
__level_param_cb(name, ops, arg, perm, 6)
|
|
|
|
|
|
2019-12-02 09:01:17 +00:00
|
|
|
/**
|
|
|
|
|
* late_param_cb - general callback for a module/cmdline parameter
|
|
|
|
|
* to be evaluated before late initcall level
|
|
|
|
|
* @name: a valid C identifier which is the parameter name.
|
|
|
|
|
* @ops: the set & get operations for this parameter.
|
|
|
|
|
* @arg: args for @ops
|
|
|
|
|
* @perm: visibility in sysfs.
|
|
|
|
|
*
|
|
|
|
|
* The ops can have NULL set or get functions.
|
|
|
|
|
*/
|
2012-03-26 02:20:51 +00:00
|
|
|
#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. */
|
arch: Remove Itanium (IA-64) architecture
The Itanium architecture is obsolete, and an informal survey [0] reveals
that any residual use of Itanium hardware in production is mostly HP-UX
or OpenVMS based. The use of Linux on Itanium appears to be limited to
enthusiasts that occasionally boot a fresh Linux kernel to see whether
things are still working as intended, and perhaps to churn out some
distro packages that are rarely used in practice.
None of the original companies behind Itanium still produce or support
any hardware or software for the architecture, and it is listed as
'Orphaned' in the MAINTAINERS file, as apparently, none of the engineers
that contributed on behalf of those companies (nor anyone else, for that
matter) have been willing to support or maintain the architecture
upstream or even be responsible for applying the odd fix. The Intel
firmware team removed all IA-64 support from the Tianocore/EDK2
reference implementation of EFI in 2018. (Itanium is the original
architecture for which EFI was developed, and the way Linux supports it
deviates significantly from other architectures.) Some distros, such as
Debian and Gentoo, still maintain [unofficial] ia64 ports, but many have
dropped support years ago.
While the argument is being made [1] that there is a 'for the common
good' angle to being able to build and run existing projects such as the
Grid Community Toolkit [2] on Itanium for interoperability testing, the
fact remains that none of those projects are known to be deployed on
Linux/ia64, and very few people actually have access to such a system in
the first place. Even if there were ways imaginable in which Linux/ia64
could be put to good use today, what matters is whether anyone is
actually doing that, and this does not appear to be the case.
There are no emulators widely available, and so boot testing Itanium is
generally infeasible for ordinary contributors. GCC still supports IA-64
but its compile farm [3] no longer has any IA-64 machines. GLIBC would
like to get rid of IA-64 [4] too because it would permit some overdue
code cleanups. In summary, the benefits to the ecosystem of having IA-64
be part of it are mostly theoretical, whereas the maintenance overhead
of keeping it supported is real.
So let's rip off the band aid, and remove the IA-64 arch code entirely.
This follows the timeline proposed by the Debian/ia64 maintainer [5],
which removes support in a controlled manner, leaving IA-64 in a known
good state in the most recent LTS release. Other projects will follow
once the kernel support is removed.
[0] https://lore.kernel.org/all/CAMj1kXFCMh_578jniKpUtx_j8ByHnt=s7S+yQ+vGbKt9ud7+kQ@mail.gmail.com/
[1] https://lore.kernel.org/all/0075883c-7c51-00f5-2c2d-5119c1820410@web.de/
[2] https://gridcf.org/gct-docs/latest/index.html
[3] https://cfarm.tetaneutral.net/machines/list/
[4] https://lore.kernel.org/all/87bkiilpc4.fsf@mid.deneb.enyo.de/
[5] https://lore.kernel.org/all/ff58a3e76e5102c94bb5946d99187b358def688a.camel@physik.fu-berlin.de/
Acked-by: Tony Luck <tony.luck@intel.com>
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
2022-10-20 13:54:33 +00:00
|
|
|
#if defined(CONFIG_ALPHA) || defined(CONFIG_PPC64)
|
2008-02-13 23:03:26 +00:00
|
|
|
#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 \
|
2020-11-23 10:23:18 +00:00
|
|
|
__used __section("__param") \
|
|
|
|
|
__aligned(__alignof__(struct kernel_param)) \
|
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
|
|
|
|
module: Clarify documentation of module_param_call()
Commit 9bbb9e5a3310 ("param: use ops in struct kernel_param, rather than
get and set fns directly") added the comment that module_param_call()
was deprecated, during a large scale refactoring to bring sanity to type
casting back then. In 2017 following more cleanups, it became useful
again as it wraps a common pattern of creating an ops struct for a
given get/set pair:
b2f270e87473 ("module: Prepare to convert all module_param_call() prototypes")
ece1996a21ee ("module: Do not paper over type mismatches in module_param_call()")
static const struct kernel_param_ops __param_ops_##name = \
{ .flags = 0, .set = _set, .get = _get }; \
__module_param_call(MODULE_PARAM_PREFIX, \
name, &__param_ops_##name, arg, perm, -1, 0)
__module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1, 0)
Many users of module_param_cb() appear to be almost universally
open-coding the same thing that module_param_call() does now. Don't
discourage[1] people from using module_param_call(): clarify the comment
to show that module_param_cb() is useful if you repeatedly use the same
pair of get/set functions.
[1] https://lore.kernel.org/lkml/202308301546.5C789E5EC@keescook/
Cc: Luis Chamberlain <mcgrof@kernel.org>
Cc: Johan Hovold <johan@kernel.org>
Cc: Jessica Yu <jeyu@kernel.org>
Cc: Sagi Grimberg <sagi@grimberg.me>
Cc: Nick Desaulniers <ndesaulniers@gooogle.com>
Cc: Miguel Ojeda <ojeda@kernel.org>
Cc: Joe Perches <joe@perches.com>
Cc: linux-modules@vger.kernel.org
Reviewed-by: Miguel Ojeda <ojeda@kernel.org>
Signed-off-by: Kees Cook <keescook@chromium.org>
Signed-off-by: Luis Chamberlain <mcgrof@kernel.org>
2023-09-13 23:54:14 +00:00
|
|
|
/*
|
|
|
|
|
* Useful for describing a set/get pair used only once (i.e. for this
|
|
|
|
|
* parameter). For repeated set/get pairs (i.e. the same struct
|
|
|
|
|
* kernel_param_ops), use module_param_cb() instead.
|
|
|
|
|
*/
|
2017-10-18 02:04:43 +00:00
|
|
|
#define module_param_call(name, _set, _get, arg, perm) \
|
2017-10-18 02:04:41 +00:00
|
|
|
static const struct kernel_param_ops __param_ops_##name = \
|
2017-10-18 02:04:43 +00:00
|
|
|
{ .flags = 0, .set = _set, .get = _get }; \
|
2010-08-12 05:04:12 +00:00
|
|
|
__module_param_call(MODULE_PARAM_PREFIX, \
|
2017-10-18 02:04:41 +00:00
|
|
|
name, &__param_ops_##name, arg, perm, -1, 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
|
2019-12-02 09:01:17 +00:00
|
|
|
* @name: the name of the cmdline and sysfs parameter (often the same as var)
|
|
|
|
|
* @var: the variable
|
|
|
|
|
* @type: the type of the parameter
|
|
|
|
|
* @perm: visibility in sysfs
|
2015-03-30 23:20:09 +00:00
|
|
|
*/
|
|
|
|
|
#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);
|
|
|
|
|
|
2023-11-20 15:11:42 +00:00
|
|
|
typedef int (*parse_unknown_fn)(char *param, char *val, const char *doing, void *arg);
|
|
|
|
|
|
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,
|
2023-11-20 15:11:42 +00:00
|
|
|
void *arg, parse_unknown_fn unknown);
|
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);
|
2021-06-16 21:19:33 +00:00
|
|
|
int param_set_uint_minmax(const char *val, const struct kernel_param *kp,
|
|
|
|
|
unsigned int min, unsigned int max);
|
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)
|
|
|
|
|
|
2020-07-03 14:29:38 +00:00
|
|
|
extern const struct kernel_param_ops param_ops_hexint;
|
|
|
|
|
extern int param_set_hexint(const char *val, const struct kernel_param *kp);
|
|
|
|
|
extern int param_get_hexint(char *buffer, const struct kernel_param *kp);
|
|
|
|
|
#define param_check_hexint(name, p) param_check_uint(name, p)
|
|
|
|
|
|
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)
|
|
|
|
|
|
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 15:54:21 +00: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 13:21:56 +00: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 15:54:21 +00: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 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 */
|