2009-02-05 23:51:38 +07:00
|
|
|
#ifndef _DYNAMIC_DEBUG_H
|
|
|
|
#define _DYNAMIC_DEBUG_H
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-20 05:12:59 +07:00
|
|
|
unsigned int lineno:18;
|
2009-02-05 23:51:38 +07:00
|
|
|
/*
|
2012-04-28 03:30:33 +07:00
|
|
|
* The flags field controls the behaviour at the callsite.
|
|
|
|
* The bits here are changed dynamically when the user
|
2010-05-25 04:33:21 +07:00
|
|
|
* writes commands to <debugfs>/dynamic_debug/control
|
2009-02-05 23:51:38 +07:00
|
|
|
*/
|
2011-12-20 05:12:44 +07:00
|
|
|
#define _DPRINTK_FLAGS_NONE 0
|
|
|
|
#define _DPRINTK_FLAGS_PRINT (1<<0) /* printk() a message using the format */
|
2011-01-23 23:17:24 +07: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-20 05:11:18 +07:00
|
|
|
#if defined DEBUG
|
|
|
|
#define _DPRINTK_FLAGS_DEFAULT _DPRINTK_FLAGS_PRINT
|
|
|
|
#else
|
2009-02-05 23:51:38 +07:00
|
|
|
#define _DPRINTK_FLAGS_DEFAULT 0
|
2011-12-20 05:11:18 +07:00
|
|
|
#endif
|
2009-02-05 23:51:38 +07:00
|
|
|
unsigned int flags:8;
|
|
|
|
} __attribute__((aligned(8)));
|
|
|
|
|
|
|
|
|
|
|
|
int ddebug_add_module(struct _ddebug *tab, unsigned int n,
|
|
|
|
const char *modname);
|
|
|
|
|
|
|
|
#if defined(CONFIG_DYNAMIC_DEBUG)
|
2010-07-03 10:07:35 +07:00
|
|
|
extern int ddebug_remove_module(const char *mod_name);
|
2011-11-01 07:11:33 +07:00
|
|
|
extern __printf(2, 3)
|
|
|
|
int __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...);
|
2009-02-05 23:51:38 +07: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-28 03:30:35 +07:00
|
|
|
extern int ddebug_dyndbg_module_param_cb(char *param, char *val,
|
|
|
|
const char *modname);
|
|
|
|
|
2011-08-12 01:36:21 +07:00
|
|
|
struct device;
|
|
|
|
|
2011-11-01 07:11:33 +07:00
|
|
|
extern __printf(3, 4)
|
|
|
|
int __dynamic_dev_dbg(struct _ddebug *descriptor, const struct device *dev,
|
|
|
|
const char *fmt, ...);
|
2011-08-12 01:36:21 +07:00
|
|
|
|
2011-08-12 01:36:48 +07:00
|
|
|
struct net_device;
|
|
|
|
|
2011-11-01 07:11:33 +07:00
|
|
|
extern __printf(3, 4)
|
|
|
|
int __dynamic_netdev_dbg(struct _ddebug *descriptor,
|
|
|
|
const struct net_device *dev,
|
|
|
|
const char *fmt, ...);
|
2011-08-12 01:36:48 +07:00
|
|
|
|
2011-10-05 04:13:15 +07:00
|
|
|
#define DEFINE_DYNAMIC_DEBUG_METADATA(name, fmt) \
|
|
|
|
static struct _ddebug __used __aligned(8) \
|
|
|
|
__attribute__((section("__verbose"))) name = { \
|
|
|
|
.modname = KBUILD_MODNAME, \
|
|
|
|
.function = __func__, \
|
|
|
|
.filename = __FILE__, \
|
|
|
|
.format = (fmt), \
|
|
|
|
.lineno = __LINE__, \
|
|
|
|
.flags = _DPRINTK_FLAGS_DEFAULT, \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define dynamic_pr_debug(fmt, ...) \
|
|
|
|
do { \
|
|
|
|
DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
|
2011-12-20 05:11:13 +07:00
|
|
|
if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \
|
2011-10-05 04:13:15 +07:00
|
|
|
__dynamic_pr_debug(&descriptor, pr_fmt(fmt), \
|
|
|
|
##__VA_ARGS__); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define dynamic_dev_dbg(dev, fmt, ...) \
|
|
|
|
do { \
|
2011-12-20 05:11:13 +07:00
|
|
|
DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
|
|
|
|
if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \
|
2011-10-05 04:13:15 +07:00
|
|
|
__dynamic_dev_dbg(&descriptor, dev, fmt, \
|
|
|
|
##__VA_ARGS__); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define dynamic_netdev_dbg(dev, fmt, ...) \
|
|
|
|
do { \
|
|
|
|
DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
|
2011-12-20 05:11:13 +07:00
|
|
|
if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \
|
2011-10-05 04:13:15 +07:00
|
|
|
__dynamic_netdev_dbg(&descriptor, dev, fmt, \
|
|
|
|
##__VA_ARGS__); \
|
|
|
|
} while (0)
|
2011-08-12 01:36:48 +07:00
|
|
|
|
2009-02-05 23:51:38 +07:00
|
|
|
#else
|
|
|
|
|
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-28 03:30:35 +07:00
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
2010-07-03 10:07:35 +07:00
|
|
|
static inline int ddebug_remove_module(const char *mod)
|
2009-02-05 23:51:38 +07: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-28 03:30:35 +07:00
|
|
|
static inline int ddebug_dyndbg_module_param_cb(char *param, char *val,
|
|
|
|
const char *modname)
|
|
|
|
{
|
|
|
|
if (strstr(param, "dyndbg")) {
|
2012-05-01 18:23:12 +07: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-28 03:30:35 +07:00
|
|
|
"CONFIG_DYNAMIC_DEBUG builds\n");
|
|
|
|
return 0; /* allow and ignore */
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-12-15 09:00:14 +07:00
|
|
|
#define dynamic_pr_debug(fmt, ...) \
|
|
|
|
do { if (0) printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); } while (0)
|
2010-10-14 16:58:20 +07:00
|
|
|
#define dynamic_dev_dbg(dev, fmt, ...) \
|
2009-12-15 09:00:14 +07:00
|
|
|
do { if (0) dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__); } while (0)
|
2009-02-05 23:51:38 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|