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 */
|
2009-02-05 16:51:38 +00:00
|
|
|
#ifndef _DYNAMIC_DEBUG_H
|
|
|
|
#define _DYNAMIC_DEBUG_H
|
|
|
|
|
2018-12-30 15:14:15 +00:00
|
|
|
#if defined(CONFIG_JUMP_LABEL)
|
2016-08-03 20:46:39 +00:00
|
|
|
#include <linux/jump_label.h>
|
|
|
|
#endif
|
|
|
|
|
2009-02-05 16:51:38 +00:00
|
|
|
/*
|
|
|
|
* An instance of this structure is created in a special
|
|
|
|
* ELF section at every dynamic debug callsite. At runtime,
|
|
|
|
* the special section is treated as an array of these.
|
|
|
|
*/
|
|
|
|
struct _ddebug {
|
|
|
|
/*
|
|
|
|
* These fields are used to drive the user interface
|
|
|
|
* for selecting and displaying debug callsites.
|
|
|
|
*/
|
|
|
|
const char *modname;
|
|
|
|
const char *function;
|
|
|
|
const char *filename;
|
|
|
|
const char *format;
|
2011-12-19 22:12:59 +00:00
|
|
|
unsigned int lineno:18;
|
2009-02-05 16:51:38 +00:00
|
|
|
/*
|
2012-04-27 20:30:33 +00:00
|
|
|
* The flags field controls the behaviour at the callsite.
|
|
|
|
* The bits here are changed dynamically when the user
|
2010-05-24 21:33:21 +00:00
|
|
|
* writes commands to <debugfs>/dynamic_debug/control
|
2009-02-05 16:51:38 +00:00
|
|
|
*/
|
2011-12-19 22:12:44 +00:00
|
|
|
#define _DPRINTK_FLAGS_NONE 0
|
|
|
|
#define _DPRINTK_FLAGS_PRINT (1<<0) /* printk() a message using the format */
|
2011-01-23 16:17:24 +00:00
|
|
|
#define _DPRINTK_FLAGS_INCL_MODNAME (1<<1)
|
|
|
|
#define _DPRINTK_FLAGS_INCL_FUNCNAME (1<<2)
|
|
|
|
#define _DPRINTK_FLAGS_INCL_LINENO (1<<3)
|
|
|
|
#define _DPRINTK_FLAGS_INCL_TID (1<<4)
|
2011-12-19 22:11:18 +00:00
|
|
|
#if defined DEBUG
|
|
|
|
#define _DPRINTK_FLAGS_DEFAULT _DPRINTK_FLAGS_PRINT
|
|
|
|
#else
|
2009-02-05 16:51:38 +00:00
|
|
|
#define _DPRINTK_FLAGS_DEFAULT 0
|
2011-12-19 22:11:18 +00:00
|
|
|
#endif
|
2009-02-05 16:51:38 +00:00
|
|
|
unsigned int flags:8;
|
2018-12-30 15:14:15 +00:00
|
|
|
#ifdef CONFIG_JUMP_LABEL
|
2016-08-03 20:46:39 +00:00
|
|
|
union {
|
|
|
|
struct static_key_true dd_key_true;
|
|
|
|
struct static_key_false dd_key_false;
|
|
|
|
} key;
|
|
|
|
#endif
|
2009-02-05 16:51:38 +00:00
|
|
|
} __attribute__((aligned(8)));
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-06-08 04:40:14 +00:00
|
|
|
#if defined(CONFIG_DYNAMIC_DEBUG_CORE)
|
dyndbg: refine export, rename to dynamic_debug_exec_queries()
commit 4c0d77828d4f ("dyndbg: export ddebug_exec_queries") had a few
problems:
- broken non DYNAMIC_DEBUG_CORE configs, sparse warning
- the exported function modifies query string, breaks on RO strings.
- func name follows internal convention, shouldn't be exposed as is.
1st is fixed in header with ifdefd function prototype or stub defn.
Also remove an obsolete HAVE-symbol ifdef-comment, and add others.
Fix others by wrapping existing internal function with a new one,
named in accordance with module-prefix naming convention, before
export hits v5.9.0. In new function, copy query string to a local
buffer, so users can pass hard-coded/RO queries, and internal function
can be used unchanged.
Fixes: 4c0d77828d4f ("dyndbg: export ddebug_exec_queries")
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
Link: https://lore.kernel.org/r/20200831182210.850852-3-jim.cromie@gmail.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2020-08-31 18:22:09 +00:00
|
|
|
|
|
|
|
/* exported for module authors to exercise >control */
|
|
|
|
int dynamic_debug_exec_queries(const char *query, const char *modname);
|
|
|
|
|
2019-03-08 00:27:52 +00:00
|
|
|
int ddebug_add_module(struct _ddebug *tab, unsigned int n,
|
|
|
|
const char *modname);
|
2010-07-03 03:07:35 +00:00
|
|
|
extern int ddebug_remove_module(const char *mod_name);
|
2011-11-01 00:11:33 +00:00
|
|
|
extern __printf(2, 3)
|
2014-09-24 18:17:56 +00:00
|
|
|
void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...);
|
2009-02-05 16:51:38 +00:00
|
|
|
|
dynamic_debug: make dynamic-debug work for module initialization
This introduces a fake module param $module.dyndbg. Its based upon
Thomas Renninger's $module.ddebug boot-time debugging patch from
https://lkml.org/lkml/2010/9/15/397
The 'fake' module parameter is provided for all modules, whether or
not they need it. It is not explicitly added to each module, but is
implemented in callbacks invoked from parse_args.
For builtin modules, dynamic_debug_init() now directly calls
parse_args(..., &ddebug_dyndbg_boot_params_cb), to process the params
undeclared in the modules, just after the ddebug tables are processed.
While its slightly weird to reprocess the boot params, parse_args() is
already called repeatedly by do_initcall_levels(). More importantly,
the dyndbg queries (given in ddebug_query or dyndbg params) cannot be
activated until after the ddebug tables are ready, and reusing
parse_args is cleaner than doing an ad-hoc parse. This reparse would
break options like inc_verbosity, but they probably should be params,
like verbosity=3.
ddebug_dyndbg_boot_params_cb() handles both bare dyndbg (aka:
ddebug_query) and module-prefixed dyndbg params, and ignores all other
parameters. For example, the following will enable pr_debug()s in 4
builtin modules, in the order given:
dyndbg="module params +p; module aio +p" module.dyndbg=+p pci.dyndbg
For loadable modules, parse_args() in load_module() calls
ddebug_dyndbg_module_params_cb(). This handles bare dyndbg params as
passed from modprobe, and errors on other unknown params.
Note that modprobe reads /proc/cmdline, so "modprobe foo" grabs all
foo.params, strips the "foo.", and passes these to the kernel.
ddebug_dyndbg_module_params_cb() is again called for the unknown
params; it handles dyndbg, and errors on others. The "doing" arg
added previously contains the module name.
For non CONFIG_DYNAMIC_DEBUG builds, the stub function accepts
and ignores $module.dyndbg params, other unknowns get -ENOENT.
If no param value is given (as in pci.dyndbg example above), "+p" is
assumed, which enables all pr_debug callsites in the module.
The dyndbg fake parameter is not shown in /sys/module/*/parameters,
thus it does not use any resources. Changes to it are made via the
control file.
Also change pr_info in ddebug_exec_queries to vpr_info,
no need to see it all the time.
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
CC: Thomas Renninger <trenn@suse.de>
CC: Rusty Russell <rusty@rustcorp.com.au>
Acked-by: Jason Baron <jbaron@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-04-27 20:30:35 +00:00
|
|
|
extern int ddebug_dyndbg_module_param_cb(char *param, char *val,
|
|
|
|
const char *modname);
|
|
|
|
|
2011-08-11 18:36:21 +00:00
|
|
|
struct device;
|
|
|
|
|
2011-11-01 00:11:33 +00:00
|
|
|
extern __printf(3, 4)
|
2014-09-24 18:17:56 +00:00
|
|
|
void __dynamic_dev_dbg(struct _ddebug *descriptor, const struct device *dev,
|
|
|
|
const char *fmt, ...);
|
2011-08-11 18:36:21 +00:00
|
|
|
|
2011-08-11 18:36:48 +00:00
|
|
|
struct net_device;
|
|
|
|
|
2011-11-01 00:11:33 +00:00
|
|
|
extern __printf(3, 4)
|
2014-09-24 18:17:56 +00:00
|
|
|
void __dynamic_netdev_dbg(struct _ddebug *descriptor,
|
|
|
|
const struct net_device *dev,
|
|
|
|
const char *fmt, ...);
|
2011-08-11 18:36:48 +00:00
|
|
|
|
2019-05-01 10:48:13 +00:00
|
|
|
struct ib_device;
|
|
|
|
|
|
|
|
extern __printf(3, 4)
|
|
|
|
void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
|
|
|
|
const struct ib_device *ibdev,
|
|
|
|
const char *fmt, ...);
|
|
|
|
|
2019-03-08 00:27:33 +00:00
|
|
|
#define DEFINE_DYNAMIC_DEBUG_METADATA(name, fmt) \
|
2012-10-18 19:07:03 +00:00
|
|
|
static struct _ddebug __aligned(8) \
|
2020-10-22 02:36:07 +00:00
|
|
|
__section("__dyndbg") name = { \
|
2011-10-04 21:13:15 +00:00
|
|
|
.modname = KBUILD_MODNAME, \
|
|
|
|
.function = __func__, \
|
|
|
|
.filename = __FILE__, \
|
|
|
|
.format = (fmt), \
|
|
|
|
.lineno = __LINE__, \
|
2016-08-03 20:46:39 +00:00
|
|
|
.flags = _DPRINTK_FLAGS_DEFAULT, \
|
2019-03-08 00:27:33 +00:00
|
|
|
_DPRINTK_KEY_INIT \
|
2011-10-04 21:13:15 +00:00
|
|
|
}
|
|
|
|
|
2018-12-30 15:14:15 +00:00
|
|
|
#ifdef CONFIG_JUMP_LABEL
|
2016-08-03 20:46:39 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
2019-03-08 00:27:33 +00:00
|
|
|
|
|
|
|
#define _DPRINTK_KEY_INIT .key.dd_key_true = (STATIC_KEY_TRUE_INIT)
|
2016-08-03 20:46:39 +00:00
|
|
|
|
|
|
|
#define DYNAMIC_DEBUG_BRANCH(descriptor) \
|
|
|
|
static_branch_likely(&descriptor.key.dd_key_true)
|
|
|
|
#else
|
2019-03-08 00:27:33 +00:00
|
|
|
#define _DPRINTK_KEY_INIT .key.dd_key_false = (STATIC_KEY_FALSE_INIT)
|
2016-08-03 20:46:39 +00:00
|
|
|
|
|
|
|
#define DYNAMIC_DEBUG_BRANCH(descriptor) \
|
|
|
|
static_branch_unlikely(&descriptor.key.dd_key_false)
|
|
|
|
#endif
|
|
|
|
|
dyndbg: refine export, rename to dynamic_debug_exec_queries()
commit 4c0d77828d4f ("dyndbg: export ddebug_exec_queries") had a few
problems:
- broken non DYNAMIC_DEBUG_CORE configs, sparse warning
- the exported function modifies query string, breaks on RO strings.
- func name follows internal convention, shouldn't be exposed as is.
1st is fixed in header with ifdefd function prototype or stub defn.
Also remove an obsolete HAVE-symbol ifdef-comment, and add others.
Fix others by wrapping existing internal function with a new one,
named in accordance with module-prefix naming convention, before
export hits v5.9.0. In new function, copy query string to a local
buffer, so users can pass hard-coded/RO queries, and internal function
can be used unchanged.
Fixes: 4c0d77828d4f ("dyndbg: export ddebug_exec_queries")
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
Link: https://lore.kernel.org/r/20200831182210.850852-3-jim.cromie@gmail.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2020-08-31 18:22:09 +00:00
|
|
|
#else /* !CONFIG_JUMP_LABEL */
|
2016-08-03 20:46:39 +00:00
|
|
|
|
2019-03-08 00:27:33 +00:00
|
|
|
#define _DPRINTK_KEY_INIT
|
2016-08-03 20:46:39 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
#define DYNAMIC_DEBUG_BRANCH(descriptor) \
|
|
|
|
likely(descriptor.flags & _DPRINTK_FLAGS_PRINT)
|
|
|
|
#else
|
|
|
|
#define DYNAMIC_DEBUG_BRANCH(descriptor) \
|
|
|
|
unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)
|
|
|
|
#endif
|
|
|
|
|
dyndbg: refine export, rename to dynamic_debug_exec_queries()
commit 4c0d77828d4f ("dyndbg: export ddebug_exec_queries") had a few
problems:
- broken non DYNAMIC_DEBUG_CORE configs, sparse warning
- the exported function modifies query string, breaks on RO strings.
- func name follows internal convention, shouldn't be exposed as is.
1st is fixed in header with ifdefd function prototype or stub defn.
Also remove an obsolete HAVE-symbol ifdef-comment, and add others.
Fix others by wrapping existing internal function with a new one,
named in accordance with module-prefix naming convention, before
export hits v5.9.0. In new function, copy query string to a local
buffer, so users can pass hard-coded/RO queries, and internal function
can be used unchanged.
Fixes: 4c0d77828d4f ("dyndbg: export ddebug_exec_queries")
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
Link: https://lore.kernel.org/r/20200831182210.850852-3-jim.cromie@gmail.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2020-08-31 18:22:09 +00:00
|
|
|
#endif /* CONFIG_JUMP_LABEL */
|
2016-08-03 20:46:39 +00:00
|
|
|
|
2019-03-08 00:27:56 +00:00
|
|
|
#define __dynamic_func_call(id, fmt, func, ...) do { \
|
|
|
|
DEFINE_DYNAMIC_DEBUG_METADATA(id, fmt); \
|
|
|
|
if (DYNAMIC_DEBUG_BRANCH(id)) \
|
|
|
|
func(&id, ##__VA_ARGS__); \
|
2011-10-04 21:13:15 +00:00
|
|
|
} while (0)
|
|
|
|
|
2019-03-08 00:27:56 +00:00
|
|
|
#define __dynamic_func_call_no_desc(id, fmt, func, ...) do { \
|
|
|
|
DEFINE_DYNAMIC_DEBUG_METADATA(id, fmt); \
|
|
|
|
if (DYNAMIC_DEBUG_BRANCH(id)) \
|
|
|
|
func(__VA_ARGS__); \
|
2011-10-04 21:13:15 +00:00
|
|
|
} while (0)
|
|
|
|
|
2019-03-08 00:27:56 +00:00
|
|
|
/*
|
|
|
|
* "Factory macro" for generating a call to func, guarded by a
|
2020-07-19 23:10:45 +00:00
|
|
|
* DYNAMIC_DEBUG_BRANCH. The dynamic debug descriptor will be
|
2019-03-08 00:27:56 +00:00
|
|
|
* initialized using the fmt argument. The function will be called with
|
|
|
|
* the address of the descriptor as first argument, followed by all
|
|
|
|
* the varargs. Note that fmt is repeated in invocations of this
|
|
|
|
* macro.
|
|
|
|
*/
|
|
|
|
#define _dynamic_func_call(fmt, func, ...) \
|
|
|
|
__dynamic_func_call(__UNIQUE_ID(ddebug), fmt, func, ##__VA_ARGS__)
|
|
|
|
/*
|
|
|
|
* A variant that does the same, except that the descriptor is not
|
|
|
|
* passed as the first argument to the function; it is only called
|
|
|
|
* with precisely the macro's varargs.
|
|
|
|
*/
|
|
|
|
#define _dynamic_func_call_no_desc(fmt, func, ...) \
|
|
|
|
__dynamic_func_call_no_desc(__UNIQUE_ID(ddebug), fmt, func, ##__VA_ARGS__)
|
2011-08-11 18:36:48 +00:00
|
|
|
|
2019-03-08 00:27:56 +00:00
|
|
|
#define dynamic_pr_debug(fmt, ...) \
|
|
|
|
_dynamic_func_call(fmt, __dynamic_pr_debug, \
|
|
|
|
pr_fmt(fmt), ##__VA_ARGS__)
|
|
|
|
|
|
|
|
#define dynamic_dev_dbg(dev, fmt, ...) \
|
|
|
|
_dynamic_func_call(fmt,__dynamic_dev_dbg, \
|
|
|
|
dev, fmt, ##__VA_ARGS__)
|
|
|
|
|
|
|
|
#define dynamic_netdev_dbg(dev, fmt, ...) \
|
|
|
|
_dynamic_func_call(fmt, __dynamic_netdev_dbg, \
|
|
|
|
dev, fmt, ##__VA_ARGS__)
|
|
|
|
|
2019-05-01 10:48:13 +00:00
|
|
|
#define dynamic_ibdev_dbg(dev, fmt, ...) \
|
|
|
|
_dynamic_func_call(fmt, __dynamic_ibdev_dbg, \
|
|
|
|
dev, fmt, ##__VA_ARGS__)
|
|
|
|
|
2019-03-08 00:27:56 +00:00
|
|
|
#define dynamic_hex_dump(prefix_str, prefix_type, rowsize, \
|
|
|
|
groupsize, buf, len, ascii) \
|
|
|
|
_dynamic_func_call_no_desc(__builtin_constant_p(prefix_str) ? prefix_str : "hexdump", \
|
|
|
|
print_hex_dump, \
|
|
|
|
KERN_DEBUG, prefix_str, prefix_type, \
|
|
|
|
rowsize, groupsize, buf, len, ascii)
|
2012-12-05 21:48:27 +00:00
|
|
|
|
dyndbg: refine export, rename to dynamic_debug_exec_queries()
commit 4c0d77828d4f ("dyndbg: export ddebug_exec_queries") had a few
problems:
- broken non DYNAMIC_DEBUG_CORE configs, sparse warning
- the exported function modifies query string, breaks on RO strings.
- func name follows internal convention, shouldn't be exposed as is.
1st is fixed in header with ifdefd function prototype or stub defn.
Also remove an obsolete HAVE-symbol ifdef-comment, and add others.
Fix others by wrapping existing internal function with a new one,
named in accordance with module-prefix naming convention, before
export hits v5.9.0. In new function, copy query string to a local
buffer, so users can pass hard-coded/RO queries, and internal function
can be used unchanged.
Fixes: 4c0d77828d4f ("dyndbg: export ddebug_exec_queries")
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
Link: https://lore.kernel.org/r/20200831182210.850852-3-jim.cromie@gmail.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2020-08-31 18:22:09 +00:00
|
|
|
#else /* !CONFIG_DYNAMIC_DEBUG_CORE */
|
2009-02-05 16:51:38 +00:00
|
|
|
|
dynamic_debug: make dynamic-debug work for module initialization
This introduces a fake module param $module.dyndbg. Its based upon
Thomas Renninger's $module.ddebug boot-time debugging patch from
https://lkml.org/lkml/2010/9/15/397
The 'fake' module parameter is provided for all modules, whether or
not they need it. It is not explicitly added to each module, but is
implemented in callbacks invoked from parse_args.
For builtin modules, dynamic_debug_init() now directly calls
parse_args(..., &ddebug_dyndbg_boot_params_cb), to process the params
undeclared in the modules, just after the ddebug tables are processed.
While its slightly weird to reprocess the boot params, parse_args() is
already called repeatedly by do_initcall_levels(). More importantly,
the dyndbg queries (given in ddebug_query or dyndbg params) cannot be
activated until after the ddebug tables are ready, and reusing
parse_args is cleaner than doing an ad-hoc parse. This reparse would
break options like inc_verbosity, but they probably should be params,
like verbosity=3.
ddebug_dyndbg_boot_params_cb() handles both bare dyndbg (aka:
ddebug_query) and module-prefixed dyndbg params, and ignores all other
parameters. For example, the following will enable pr_debug()s in 4
builtin modules, in the order given:
dyndbg="module params +p; module aio +p" module.dyndbg=+p pci.dyndbg
For loadable modules, parse_args() in load_module() calls
ddebug_dyndbg_module_params_cb(). This handles bare dyndbg params as
passed from modprobe, and errors on other unknown params.
Note that modprobe reads /proc/cmdline, so "modprobe foo" grabs all
foo.params, strips the "foo.", and passes these to the kernel.
ddebug_dyndbg_module_params_cb() is again called for the unknown
params; it handles dyndbg, and errors on others. The "doing" arg
added previously contains the module name.
For non CONFIG_DYNAMIC_DEBUG builds, the stub function accepts
and ignores $module.dyndbg params, other unknowns get -ENOENT.
If no param value is given (as in pci.dyndbg example above), "+p" is
assumed, which enables all pr_debug callsites in the module.
The dyndbg fake parameter is not shown in /sys/module/*/parameters,
thus it does not use any resources. Changes to it are made via the
control file.
Also change pr_info in ddebug_exec_queries to vpr_info,
no need to see it all the time.
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
CC: Thomas Renninger <trenn@suse.de>
CC: Rusty Russell <rusty@rustcorp.com.au>
Acked-by: Jason Baron <jbaron@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-04-27 20:30:35 +00:00
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/errno.h>
|
dyndbg: refine export, rename to dynamic_debug_exec_queries()
commit 4c0d77828d4f ("dyndbg: export ddebug_exec_queries") had a few
problems:
- broken non DYNAMIC_DEBUG_CORE configs, sparse warning
- the exported function modifies query string, breaks on RO strings.
- func name follows internal convention, shouldn't be exposed as is.
1st is fixed in header with ifdefd function prototype or stub defn.
Also remove an obsolete HAVE-symbol ifdef-comment, and add others.
Fix others by wrapping existing internal function with a new one,
named in accordance with module-prefix naming convention, before
export hits v5.9.0. In new function, copy query string to a local
buffer, so users can pass hard-coded/RO queries, and internal function
can be used unchanged.
Fixes: 4c0d77828d4f ("dyndbg: export ddebug_exec_queries")
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
Link: https://lore.kernel.org/r/20200831182210.850852-3-jim.cromie@gmail.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2020-08-31 18:22:09 +00:00
|
|
|
#include <linux/printk.h>
|
dynamic_debug: make dynamic-debug work for module initialization
This introduces a fake module param $module.dyndbg. Its based upon
Thomas Renninger's $module.ddebug boot-time debugging patch from
https://lkml.org/lkml/2010/9/15/397
The 'fake' module parameter is provided for all modules, whether or
not they need it. It is not explicitly added to each module, but is
implemented in callbacks invoked from parse_args.
For builtin modules, dynamic_debug_init() now directly calls
parse_args(..., &ddebug_dyndbg_boot_params_cb), to process the params
undeclared in the modules, just after the ddebug tables are processed.
While its slightly weird to reprocess the boot params, parse_args() is
already called repeatedly by do_initcall_levels(). More importantly,
the dyndbg queries (given in ddebug_query or dyndbg params) cannot be
activated until after the ddebug tables are ready, and reusing
parse_args is cleaner than doing an ad-hoc parse. This reparse would
break options like inc_verbosity, but they probably should be params,
like verbosity=3.
ddebug_dyndbg_boot_params_cb() handles both bare dyndbg (aka:
ddebug_query) and module-prefixed dyndbg params, and ignores all other
parameters. For example, the following will enable pr_debug()s in 4
builtin modules, in the order given:
dyndbg="module params +p; module aio +p" module.dyndbg=+p pci.dyndbg
For loadable modules, parse_args() in load_module() calls
ddebug_dyndbg_module_params_cb(). This handles bare dyndbg params as
passed from modprobe, and errors on other unknown params.
Note that modprobe reads /proc/cmdline, so "modprobe foo" grabs all
foo.params, strips the "foo.", and passes these to the kernel.
ddebug_dyndbg_module_params_cb() is again called for the unknown
params; it handles dyndbg, and errors on others. The "doing" arg
added previously contains the module name.
For non CONFIG_DYNAMIC_DEBUG builds, the stub function accepts
and ignores $module.dyndbg params, other unknowns get -ENOENT.
If no param value is given (as in pci.dyndbg example above), "+p" is
assumed, which enables all pr_debug callsites in the module.
The dyndbg fake parameter is not shown in /sys/module/*/parameters,
thus it does not use any resources. Changes to it are made via the
control file.
Also change pr_info in ddebug_exec_queries to vpr_info,
no need to see it all the time.
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
CC: Thomas Renninger <trenn@suse.de>
CC: Rusty Russell <rusty@rustcorp.com.au>
Acked-by: Jason Baron <jbaron@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-04-27 20:30:35 +00:00
|
|
|
|
2019-03-08 00:27:52 +00:00
|
|
|
static inline int ddebug_add_module(struct _ddebug *tab, unsigned int n,
|
|
|
|
const char *modname)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-07-03 03:07:35 +00:00
|
|
|
static inline int ddebug_remove_module(const char *mod)
|
2009-02-05 16:51:38 +00:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
dynamic_debug: make dynamic-debug work for module initialization
This introduces a fake module param $module.dyndbg. Its based upon
Thomas Renninger's $module.ddebug boot-time debugging patch from
https://lkml.org/lkml/2010/9/15/397
The 'fake' module parameter is provided for all modules, whether or
not they need it. It is not explicitly added to each module, but is
implemented in callbacks invoked from parse_args.
For builtin modules, dynamic_debug_init() now directly calls
parse_args(..., &ddebug_dyndbg_boot_params_cb), to process the params
undeclared in the modules, just after the ddebug tables are processed.
While its slightly weird to reprocess the boot params, parse_args() is
already called repeatedly by do_initcall_levels(). More importantly,
the dyndbg queries (given in ddebug_query or dyndbg params) cannot be
activated until after the ddebug tables are ready, and reusing
parse_args is cleaner than doing an ad-hoc parse. This reparse would
break options like inc_verbosity, but they probably should be params,
like verbosity=3.
ddebug_dyndbg_boot_params_cb() handles both bare dyndbg (aka:
ddebug_query) and module-prefixed dyndbg params, and ignores all other
parameters. For example, the following will enable pr_debug()s in 4
builtin modules, in the order given:
dyndbg="module params +p; module aio +p" module.dyndbg=+p pci.dyndbg
For loadable modules, parse_args() in load_module() calls
ddebug_dyndbg_module_params_cb(). This handles bare dyndbg params as
passed from modprobe, and errors on other unknown params.
Note that modprobe reads /proc/cmdline, so "modprobe foo" grabs all
foo.params, strips the "foo.", and passes these to the kernel.
ddebug_dyndbg_module_params_cb() is again called for the unknown
params; it handles dyndbg, and errors on others. The "doing" arg
added previously contains the module name.
For non CONFIG_DYNAMIC_DEBUG builds, the stub function accepts
and ignores $module.dyndbg params, other unknowns get -ENOENT.
If no param value is given (as in pci.dyndbg example above), "+p" is
assumed, which enables all pr_debug callsites in the module.
The dyndbg fake parameter is not shown in /sys/module/*/parameters,
thus it does not use any resources. Changes to it are made via the
control file.
Also change pr_info in ddebug_exec_queries to vpr_info,
no need to see it all the time.
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
CC: Thomas Renninger <trenn@suse.de>
CC: Rusty Russell <rusty@rustcorp.com.au>
Acked-by: Jason Baron <jbaron@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-04-27 20:30:35 +00:00
|
|
|
static inline int ddebug_dyndbg_module_param_cb(char *param, char *val,
|
|
|
|
const char *modname)
|
|
|
|
{
|
|
|
|
if (strstr(param, "dyndbg")) {
|
2012-05-01 11:23:12 +00:00
|
|
|
/* avoid pr_warn(), which wants pr_fmt() fully defined */
|
|
|
|
printk(KERN_WARNING "dyndbg param is supported only in "
|
dynamic_debug: make dynamic-debug work for module initialization
This introduces a fake module param $module.dyndbg. Its based upon
Thomas Renninger's $module.ddebug boot-time debugging patch from
https://lkml.org/lkml/2010/9/15/397
The 'fake' module parameter is provided for all modules, whether or
not they need it. It is not explicitly added to each module, but is
implemented in callbacks invoked from parse_args.
For builtin modules, dynamic_debug_init() now directly calls
parse_args(..., &ddebug_dyndbg_boot_params_cb), to process the params
undeclared in the modules, just after the ddebug tables are processed.
While its slightly weird to reprocess the boot params, parse_args() is
already called repeatedly by do_initcall_levels(). More importantly,
the dyndbg queries (given in ddebug_query or dyndbg params) cannot be
activated until after the ddebug tables are ready, and reusing
parse_args is cleaner than doing an ad-hoc parse. This reparse would
break options like inc_verbosity, but they probably should be params,
like verbosity=3.
ddebug_dyndbg_boot_params_cb() handles both bare dyndbg (aka:
ddebug_query) and module-prefixed dyndbg params, and ignores all other
parameters. For example, the following will enable pr_debug()s in 4
builtin modules, in the order given:
dyndbg="module params +p; module aio +p" module.dyndbg=+p pci.dyndbg
For loadable modules, parse_args() in load_module() calls
ddebug_dyndbg_module_params_cb(). This handles bare dyndbg params as
passed from modprobe, and errors on other unknown params.
Note that modprobe reads /proc/cmdline, so "modprobe foo" grabs all
foo.params, strips the "foo.", and passes these to the kernel.
ddebug_dyndbg_module_params_cb() is again called for the unknown
params; it handles dyndbg, and errors on others. The "doing" arg
added previously contains the module name.
For non CONFIG_DYNAMIC_DEBUG builds, the stub function accepts
and ignores $module.dyndbg params, other unknowns get -ENOENT.
If no param value is given (as in pci.dyndbg example above), "+p" is
assumed, which enables all pr_debug callsites in the module.
The dyndbg fake parameter is not shown in /sys/module/*/parameters,
thus it does not use any resources. Changes to it are made via the
control file.
Also change pr_info in ddebug_exec_queries to vpr_info,
no need to see it all the time.
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
CC: Thomas Renninger <trenn@suse.de>
CC: Rusty Russell <rusty@rustcorp.com.au>
Acked-by: Jason Baron <jbaron@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2012-04-27 20:30:35 +00:00
|
|
|
"CONFIG_DYNAMIC_DEBUG builds\n");
|
|
|
|
return 0; /* allow and ignore */
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-12-15 02:00:14 +00:00
|
|
|
#define dynamic_pr_debug(fmt, ...) \
|
|
|
|
do { if (0) printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); } while (0)
|
2010-10-14 09:58:20 +00:00
|
|
|
#define dynamic_dev_dbg(dev, fmt, ...) \
|
2009-12-15 02:00:14 +00:00
|
|
|
do { if (0) dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__); } while (0)
|
2019-09-18 19:55:11 +00:00
|
|
|
#define dynamic_hex_dump(prefix_str, prefix_type, rowsize, \
|
|
|
|
groupsize, buf, len, ascii) \
|
|
|
|
do { if (0) \
|
|
|
|
print_hex_dump(KERN_DEBUG, prefix_str, prefix_type, \
|
|
|
|
rowsize, groupsize, buf, len, ascii); \
|
|
|
|
} while (0)
|
dyndbg: refine export, rename to dynamic_debug_exec_queries()
commit 4c0d77828d4f ("dyndbg: export ddebug_exec_queries") had a few
problems:
- broken non DYNAMIC_DEBUG_CORE configs, sparse warning
- the exported function modifies query string, breaks on RO strings.
- func name follows internal convention, shouldn't be exposed as is.
1st is fixed in header with ifdefd function prototype or stub defn.
Also remove an obsolete HAVE-symbol ifdef-comment, and add others.
Fix others by wrapping existing internal function with a new one,
named in accordance with module-prefix naming convention, before
export hits v5.9.0. In new function, copy query string to a local
buffer, so users can pass hard-coded/RO queries, and internal function
can be used unchanged.
Fixes: 4c0d77828d4f ("dyndbg: export ddebug_exec_queries")
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
Link: https://lore.kernel.org/r/20200831182210.850852-3-jim.cromie@gmail.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2020-08-31 18:22:09 +00:00
|
|
|
|
|
|
|
static inline int dynamic_debug_exec_queries(const char *query, const char *modname)
|
|
|
|
{
|
|
|
|
pr_warn("kernel not built with CONFIG_DYNAMIC_DEBUG_CORE\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* !CONFIG_DYNAMIC_DEBUG_CORE */
|
2009-02-05 16:51:38 +00:00
|
|
|
|
|
|
|
#endif
|