dyndbg: fix dynamic-debug regression in DRM
Subsystems (6)
Jim Cromie
maintainerv8 cover dyndbg: fix dynamic-debug regression in DRM
commit aad0214f3026 ("dyndbg: add DECLARE_DYNDBG_CLASSMAP macro")
added dyndbg's "classmaps" feature, which brought dyndbg's 0-off-cost debug to DRM. Dyndbg wired to /sys/module/drm/parameters/debug, mapped its bits to classes named "DRM_UT_*", and effected the callsite enablements only on updates to the sys-node (and underlying >control).
Sadly, it hit a CI failure, resulting in:
commit bb2ff6c27bc9 ("drm: Disable dynamic debug as broken")
The regression was that drivers, when modprobed, did not get the drm.debug=0xff turn-on action, because that had already been done for drm.ko itself.
The core design bug is in the DECLARE_DYNDBG_CLASSMAP macro. Its use in both drm.ko (ie core) and all drivers.ko meant that they couldn't fundamentally distinguish their respective roles. They each "re-defined" the classmap separately, breaking K&R-101.
My ad-hoc test scripting helped to hide the error from me, by 1st testing various combos of boot-time module.dyndbg=... and drm.debug=... configurations, and then inadvertently relying upon those initializations.
This series addresses both failings:
It replaces DECLARE_DYNDBG_CLASSMAP with
- DYNAMIC_DEBUG_CLASSMAP_DEFINE: Used by core modules (e.g., drm.ko) to define their classmaps. Based upon DECLARE, it exports the classmap so USE can use it.
- DYNAMIC_DEBUG_CLASSMAP_USE: this lets other "subsystem" users create a linkage to the classmap defined elsewhere (ie drm.ko). These users can then find their "parent" and apply its settings.
It adds a selftest script, and a 2nd "sub-module" to recapitulate DRM's multi-module "subsystem" use-case, including the specific failure scenario.
It also adds minor parsing enhancements, allowing easier construction of multi-part debug configurations. These enhancements are used to test classmaps in particular, but are not otherwize required.
v7 added:
. WARN_ONCE when classmap isn't found for a class'd callsite, JBaron . reorder macro args to match kdoc, JBaron
. Doc formatting fixes, by Bagas
v8 adds:
. CC's for tools/testing, DRM, others
. p21: change _ddebug_class_user.base name to offset, for p30 . p30: amend commit-msg to explain untested, speculative nature
Thank you for your review(s) and/or Tested-by:s
P.S. Id also like to "tease" some follow-on work:
1. DRM adaptation patches, tested on my HW/boxes.
2. patchset to send pr_debugs to tracefs on +T flag
allows 63 "private" tracebufs, 1 "common" one (at 0) "drm.debug_2trace=0x1ff" is possible
from Lukasz Bartosik
NB: the private tracebufs allow test scripts to verify log content, not just counts of changed pr_debugs.
3. patchset to save 40% of dyndbg's memory footprint
move (modname,filename,function) to struct _ddebug_site save their values & descriptor intervals to 3 maple-trees add 3 accessors to fetch on descriptor, from trees move __dyndbg_sites __section to INIT_DATA.
NB: Despite the new accessors, cat control is just as fast.
Jim Cromie (31):
fixes, cleanups, simple stuff::
dyndbg: factor ddebug_match_desc out from ddebug_change
dyndbg: add stub macro for DECLARE_DYNDBG_CLASSMAP docs/dyndbg: update examples \012 to \n docs/dyndbg: explain flags parse 1st
test-dyndbg: fixup CLASSMAP usage error
dyndbg: reword "class unknown," to "class:_UNKNOWN_"
dyndbg: make ddebug_class_param union members same size
dyndbg: drop NUM_TYPE_ARRAY
dyndbg: tweak pr_fmt to avoid expansion conflicts
dyndbg: reduce verbose/debug clutter
callchain grooming, re-structs, code simplify/dedup by macros::
dyndbg: refactor param_set_dyndbg_classes and below
dyndbg: tighten fn-sig of ddebug_apply_class_bitmap
dyndbg: replace classmap list with a vector
dyndbg: macrofy a 2-index for-loop pattern dyndbg,module: make proper substructs in _ddebug_info
dyndbg: hoist classmap-filter-by-modname up to ddebug_add_module
dyndbg: move mod_name down from struct ddebug_table to _ddebug_info
dyndbg-API: remove DD_CLASS_TYPE_(DISJOINT|LEVEL)_NAMES and code
selftests-dyndbg: add a dynamic_debug run_tests target
dyndbg: change __dynamic_func_call_cls* macros into expressions
core fix, detect api misuse errors, etc::
dyndbg-API: replace DECLARE_DYNDBG_CLASSMAP
dyndbg: detect class_id reservation conflicts
dyndbg: check DYNAMIC_DEBUG_CLASSMAP_DEFINE args at compile-time
dyndbg-test: change do_prints testpoint to accept a loopct
dyndbg-API: promote DYNAMIC_DEBUG_CLASSMAP_PARAM to API
dyndbg: treat comma as a token separator
dyndbg: split multi-query strings with %
selftests-dyndbg: add test_mod_submod
dyndbg: resolve "protection" of class'd pr_debug
dyndbg: add DYNAMIC_DEBUG_CLASSMAP_USE_(dd_class_name, offset) docs/dyndbg: add classmap info to howto
Jim Cromie (31):
dyndbg: factor ddebug_match_desc out from ddebug_change
dyndbg: add stub macro for DECLARE_DYNDBG_CLASSMAP docs/dyndbg: update examples \012 to \n
docs/dyndbg: explain flags parse 1st
test-dyndbg: fixup CLASSMAP usage error
dyndbg: reword "class unknown," to "class:_UNKNOWN_"
dyndbg: make ddebug_class_param union members same size
dyndbg: drop NUM_TYPE_ARRAY
dyndbg: tweak pr_fmt to avoid expansion conflicts
dyndbg: reduce verbose/debug clutter
dyndbg: refactor param_set_dyndbg_classes and below
dyndbg: tighten fn-sig of ddebug_apply_class_bitmap
dyndbg: replace classmap list with a vector
dyndbg: macrofy a 2-index for-loop pattern dyndbg,module: make proper substructs in _ddebug_info
dyndbg: hoist classmap-filter-by-modname up to ddebug_add_module
dyndbg: move mod_name down from struct ddebug_table to _ddebug_info
dyndbg-API: remove DD_CLASS_TYPE_(DISJOINT|LEVEL)_NAMES and code
selftests-dyndbg: add a dynamic_debug run_tests target
dyndbg: change __dynamic_func_call_cls* macros into expressions
dyndbg-API: replace DECLARE_DYNDBG_CLASSMAP
dyndbg: detect class_id reservation conflicts
dyndbg: check DYNAMIC_DEBUG_CLASSMAP_DEFINE args at compile-time
dyndbg-test: change do_prints testpoint to accept a loopct
dyndbg-API: promote DYNAMIC_DEBUG_CLASSMAP_PARAM to API
dyndbg: treat comma as a token separator
dyndbg: split multi-query strings with %
selftests-dyndbg: add test_mod_submod
dyndbg: resolve "protection" of class'd pr_debug
dyndbg: add DYNAMIC_DEBUG_CLASSMAP_USE_(dd_class_name, offset) docs/dyndbg: add classmap info to howto
.../admin-guide/dynamic-debug-howto.rst | 187 ++++- MAINTAINERS | 3 +- include/asm-generic/vmlinux.lds.h | 5 +- include/linux/dynamic_debug.h | 302 +++++-- kernel/module/main.c | 15 +- lib/Kconfig.debug | 24 +- lib/Makefile | 5 + lib/dynamic_debug.c | 776 +++++++++++------- lib/test_dynamic_debug.c | 198 +++-- lib/test_dynamic_debug_submod.c | 21 + tools/testing/selftests/Makefile | 1 + .../testing/selftests/dynamic_debug/Makefile | 9 + tools/testing/selftests/dynamic_debug/config | 7 + .../dynamic_debug/dyndbg_selftest.sh | 373 +++++++++ 14 files changed, 1465 insertions(+), 461 deletions(-) create mode 100644 lib/test_dynamic_debug_submod.c create mode 100644 tools/testing/selftests/dynamic_debug/Makefile create mode 100644 tools/testing/selftests/dynamic_debug/config create mode 100755 tools/testing/selftests/dynamic_debug/dyndbg_selftest.sh
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 1/31 dyndbg: factor ddebug_match_desc out from ddebug_change
ddebug_change() is a big (~100 lines) function with a nested for loop.
The outer loop walks the per-module ddebug_tables list, and does module stuff: it filters on a query's "module FOO*" and "class BAR", failures here skip the entire inner loop.
The inner loop (60 lines) scans a module's descriptors. It starts with a long block of filters on function, line, format, and the validated "BAR" class (or the legacy/_DPRINTK_CLASS_DFLT).
These filters "continue" past pr_debugs that don't match the query criteria, before it falls through the code below that counts matches, then adjusts the flags and static-keys. This is unnecessarily hard to think about.
So move the per-descriptor filter-block into a boolean function:ddebug_match_desc(desc), and change each "continue" to "return false". This puts a clear interface in place, so any future changes are either inside, outside, or across this interface.
also fix checkpatch complaints about spaces and braces.
--- lib/dynamic_debug.c | 83 +++++++++++++++++++++++++-------------------- 1 file changed, 47 insertions(+), 36 deletions(-)
lib/dynamic_debug.c +47 -36
@@ -171,6 +171,52 @@ static struct ddebug_class_map *ddebug_find_valid_class(struct ddebug_table cons* callsites, normally the same as number of changes. If verbose, * logs the changes. Takes ddebug_lock. */ +static bool ddebug_match_desc (const struct ddebug_query *query, +struct _ddebug *dp, +int valid_class) +{ +/* match site against query-class */ +if (dp->class_id != valid_class) +return false; + +/* match against the source filename */ +if (query->filename && + !match_wildcard (query->filename, dp->filename) && + !match_wildcard (query->filename, +kbasename (dp->filename)) && + !match_wildcard (query->filename, +trim_prefix (dp->filename))) +return false; + +/* match against the function */ +if (query->function && + !match_wildcard (query->function, dp->function)) +return false; + +/* match against the format */ +if (query->format) { +if (*query->format =='^' ) { +char *p; +/* anchored search. match must be at beginning */ + p =strstr (dp->format, query->format +1 ); +if (p != dp->format) +return false; + }else if (!strstr (dp->format, query->format)) { +return false; + } + } + +/* match against the line number range */ +if (query->first_lineno && + dp->lineno < query->first_lineno) +return false; +if (query->last_lineno && + dp->lineno > query->last_lineno) +return false; + +return true; +} +static int ddebug_change (const struct ddebug_query *query,struct flag_settings *modifiers) {
@@ -203,42 +249,7 @@ static int ddebug_change(const struct ddebug_query *query,for (i =0 ; i < dt->num_ddebugs; i++) {struct _ddebug *dp = &dt->ddebugs[i]; -/* match site against query-class */ -if (dp->class_id != valid_class) -continue ; - -/* match against the source filename */ -if (query->filename && - !match_wildcard (query->filename, dp->filename) && - !match_wildcard (query->filename, -kbasename (dp->filename)) && - !match_wildcard (query->filename, -trim_prefix (dp->filename))) -continue ; - -/* match against the function */ -if (query->function && - !match_wildcard (query->function, dp->function)) -continue ; - -/* match against the format */ -if (query->format) { -if (*query->format =='^' ) { -char *p; -/* anchored search. match must be at beginning */ - p =strstr (dp->format, query->format+1 ); -if (p != dp->format) -continue ; - }else if (!strstr (dp->format, query->format)) -continue ; - } - -/* match against the line number range */ -if (query->first_lineno && - dp->lineno < query->first_lineno) -continue ; -if (query->last_lineno && - dp->lineno > query->last_lineno) +if (!ddebug_match_desc (query, dp, valid_class))continue ; nfound++;
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 2/31 dyndbg: add stub macro for DECLARE_DYNDBG_CLASSMAP
In reply to Jim CromieAdd the stub macro for !DYNAMIC_DEBUG builds, after moving the original macro-defn down under the big ifdef. Do it now so future changes have a cleaner starting point.
--- include/linux/dynamic_debug.h | 43 ++++++++++++++++++----------------- 1 file changed, 22 insertions(+), 21 deletions(-)
include/linux/dynamic_debug.h +22 -21
@@ -92,27 +92,6 @@ struct ddebug_class_map {enum class_map_type map_type; }; -/** -* DECLARE_DYNDBG_CLASSMAP - declare classnames known by a module -* @_var: a struct ddebug_class_map, passed to module_param_cb -* @_type: enum class_map_type, chooses bits/verbose, numeric/symbolic -* @_base: offset of 1st class-name. splits .class_id space -* @classes: class-names used to control class'd prdbgs -*/ -#define DECLARE_DYNDBG_CLASSMAP (_var, _maptype, _base, ...) \ - static const char *_var##_classnames[] = { __VA_ARGS__ }; \ - static struct ddebug_class_map __aligned(8) __used \ - __section("__dyndbg_classes") _var = { \ - .mod = THIS_MODULE, \ - .mod_name = KBUILD_MODNAME, \ - .base = _base, \ - .map_type = _maptype, \ - .length = NUM_TYPE_ARGS(char*, __VA_ARGS__), \ - .class_names = _var##_classnames, \ - } -#define NUM_TYPE_ARGS (eltype, ...) \ - (sizeof((eltype[]){__VA_ARGS__}) / sizeof(eltype)) -/* encapsulate linker provided built-in (or module) dyndbg data */ struct _ddebug_info {struct _ddebug *descs;
@@ -137,6 +116,27 @@ struct ddebug_class_param {#if defined(CONFIG_DYNAMIC_DEBUG ) || \ (defined(CONFIG_DYNAMIC_DEBUG_CORE ) && defined(DYNAMIC_DEBUG_MODULE )) +/** +* DECLARE_DYNDBG_CLASSMAP - declare classnames known by a module +* @_var: a struct ddebug_class_map, passed to module_param_cb +* @_type: enum class_map_type, chooses bits/verbose, numeric/symbolic +* @_base: offset of 1st class-name. splits .class_id space +* @classes: class-names used to control class'd prdbgs +*/ +#define DECLARE_DYNDBG_CLASSMAP (_var, _maptype, _base, ...) \ + static const char *_var##_classnames[] = { __VA_ARGS__ }; \ + static struct ddebug_class_map __aligned(8) __used \ + __section("__dyndbg_classes") _var = { \ + .mod = THIS_MODULE, \ + .mod_name = KBUILD_MODNAME, \ + .base = _base, \ + .map_type = _maptype, \ + .length = NUM_TYPE_ARGS(char*, __VA_ARGS__), \ + .class_names = _var##_classnames, \ + } +#define NUM_TYPE_ARGS (eltype, ...) \ + (sizeof((eltype[]) {__VA_ARGS__}) / sizeof(eltype)) + extern __printf(2, 3) void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...);
@@ -303,6 +303,7 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor,#define DEFINE_DYNAMIC_DEBUG_METADATA (name, fmt)#define DYNAMIC_DEBUG_BRANCH (descriptor) false +#define DECLARE_DYNDBG_CLASSMAP (...)#define dynamic_pr_debug (fmt, ...) \ no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 3/31 docs/dyndbg: update examples \012 to \n
In reply to Jim Cromiecommit 47ea6f99d06e ("dyndbg: use ESCAPE_SPACE for cat control") changed the control-file to display format strings with "\n" rather than "\012". Update the docs to match the new reality.
--- .../admin-guide/dynamic-debug-howto.rst | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-)
Documentation/admin-guide/dynamic-debug-howto.rst +10 -10
@@ -38,12 +38,12 @@ You can view the currently configured behaviour in the *prdbg* catalog:: :#> head -n7 /proc/dynamic_debug/control # filename:lineno [module]function flags format - init/main.c:1179 [main]initcall_blacklist =_ "blacklisting initcall %s\012 - init/main.c:1218 [main]initcall_blacklisted =_ "initcall %s blacklisted\012" - init/main.c:1424 [main]run_init_process =_ " with arguments:\012" - init/main.c:1426 [main]run_init_process =_ " %s\012" - init/main.c:1427 [main]run_init_process =_ " with environment:\012" - init/main.c:1429 [main]run_init_process =_ " %s\012" + init/main.c:1179 [main]initcall_blacklist =_ "blacklisting initcall %s\n" + init/main.c:1218 [main]initcall_blacklisted =_ "initcall %s blacklisted\n" + init/main.c:1424 [main]run_init_process =_ " with arguments:\n" + init/main.c:1426 [main]run_init_process =_ " %s\n" + init/main.c:1427 [main]run_init_process =_ " with environment:\n" + init/main.c:1429 [main]run_init_process =_ " %s\n" The 3rd space-delimited column shows the current flags, preceded by a ``=`` for easy use with grep/cut. ``=p`` shows enabled callsites.
@@ -59,10 +59,10 @@ query/commands to the control file. Example:: :#> ddcmd '-p; module main func run* +p' :#> grep =p /proc/dynamic_debug/control - init/main.c:1424 [main]run_init_process =p " with arguments:\012" - init/main.c:1426 [main]run_init_process =p " %s\012" - init/main.c:1427 [main]run_init_process =p " with environment:\012" - init/main.c:1429 [main]run_init_process =p " %s\012" + init/main.c:1424 [main]run_init_process =p " with arguments:\n" + init/main.c:1426 [main]run_init_process =p " %s\n" + init/main.c:1427 [main]run_init_process =p " with environment:\n" + init/main.c:1429 [main]run_init_process =p " %s\n" Error messages go to console/syslog::
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 4/31 docs/dyndbg: explain flags parse 1st
In reply to Jim CromieWhen writing queries to >control, flags are parsed 1st, since they are the only required field, and they require specific compositions. So if the flags draw an error (on those specifics), then keyword errors aren't reported. This can be mildly confusing/annoying, so explain it instead.
--- .../admin-guide/dynamic-debug-howto.rst | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-)
Documentation/admin-guide/dynamic-debug-howto.rst +13 -4
@@ -109,10 +109,19 @@ The match-spec's select *prdbgs* from the catalog, upon which to apply the flags-spec, all constraints are ANDed together. An absent keyword is the same as keyword "*". - -A match specification is a keyword, which selects the attribute of -the callsite to be compared, and a value to compare against. Possible -keywords are::: +Note that since the match-spec can be empty, the flags are checked 1st, +then the pairs of keyword and value. Flag errs will hide keyword errs:: + + bash-5.2# ddcmd mod bar +foo + dyndbg: read 13 bytes from userspace + dyndbg: query 0: "mod bar +foo" mod:* + dyndbg: unknown flag 'o' + dyndbg: flags parse failed + dyndbg: processed 1 queries, with 0 matches, 1 errs + +So a match-spec is a keyword, which selects the attribute of the +callsite to be compared, and a value to compare against. Possible +keywords are:: match-spec ::= 'func' string | 'file' string |
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 5/31 test-dyndbg: fixup CLASSMAP usage error
In reply to Jim Cromiecommit 6ea3bf466ac6 ("dyndbg: test DECLARE_DYNDBG_CLASSMAP, sysfs nodes")
A closer look at test_dynamic_debug.ko logging output reveals a macro usage error:
lib/test_dynamic_debug.c:105 [test_dynamic_debug]do_cats =p "LOW msg\n" class:MID lib/test_dynamic_debug.c:106 [test_dynamic_debug]do_cats =p "MID msg\n" class:HI lib/test_dynamic_debug.c:107 [test_dynamic_debug]do_cats =_ "HI msg\n" class unknown, _id:13
107 says: HI is unknown, and 105,106 have a LOW/MID and MID/HI skew.
DECLARE_DYNDBG_CLASSMAP() _base arg must equal the enum's 1st value, in this case it was _base + 1. This leaves HI class un-selectable.
NB: the macro could better validate its arguments.
--- lib/test_dynamic_debug.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/test_dynamic_debug.c +1 -1
@@ -75,7 +75,7 @@ DD_SYS_WRAP(disjoint_bits, p);DD_SYS_WRAP (disjoint_bits,T );/* symbolic input, independent bits */ -enum cat_disjoint_names {LOW =11 ,MID ,HI }; +enum cat_disjoint_names {LOW =10 ,MID ,HI };DECLARE_DYNDBG_CLASSMAP (map_disjoint_names,DD_CLASS_TYPE_DISJOINT_NAMES ,10 ,"LOW" ,"MID" ,"HI" );DD_SYS_WRAP (disjoint_names, p);
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 6/31 dyndbg: reword "class unknown," to "class:_UNKNOWN_"
In reply to Jim CromieWhen a dyndbg classname is unknown to a kernel module (as before previous patch), the callsite is un-addressable via >control queries.
The control-file displays this condition as "class unknown," currently. That spelling is sub-optimal/too-generic, so change it to "class:_UNKNOWN_" to loudly announce the erroneous situation, and to make it uniquely greppable.
--- lib/dynamic_debug.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/dynamic_debug.c +1 -1
@@ -1165,7 +1165,7 @@ static int ddebug_proc_show(struct seq_file *m, void *p)if (class)seq_printf (m," class:%s" , class);else -seq_printf (m," class unknown, _id:%d" , dp->class_id); +seq_printf (m," class:_UNKNOWN_ _id:%d" , dp->class_id); }seq_putc (m,'\n' );
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 7/31 dyndbg: make ddebug_class_param union members same size
In reply to Jim Cromiestruct ddebug_class_param keeps a ref to the state-storage of the param; make both class-types use the same unsigned long storage type.
ISTM this is simpler and safer; it avoids an irrelevant difference, and if 2 users somehow get class-type mixed up (or refer to the wrong union member), at least they will both see the same value.
--- include/linux/dynamic_debug.h | 2 +- lib/dynamic_debug.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
include/linux/dynamic_debug.h +1 -1
@@ -103,7 +103,7 @@ struct _ddebug_info {struct ddebug_class_param {union {unsigned long *bits; -unsigned int *lvl; +unsigned long *lvl; };char flags[8 ];const struct ddebug_class_map *map;
lib/dynamic_debug.c +1 -1
@@ -810,7 +810,7 @@ int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp)case DD_CLASS_TYPE_LEVEL_NAMES :case DD_CLASS_TYPE_LEVEL_NUM : -return scnprintf (buffer,PAGE_SIZE ,"%d\n" , *dcp->lvl); +return scnprintf (buffer,PAGE_SIZE ,"%ld\n" , *dcp->lvl);default :return -1 ; }
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 8/31 dyndbg: drop NUM_TYPE_ARRAY
In reply to Jim CromieARRAY_SIZE works here, since array decl is complete.
no functional change
--- include/linux/dynamic_debug.h | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
include/linux/dynamic_debug.h +1 -3
@@ -131,11 +131,9 @@ struct ddebug_class_param { .mod_name = KBUILD_MODNAME, \ .base = _base, \ .map_type = _maptype, \ - .length = NUM_TYPE_ARGS(char*, __VA_ARGS__), \ + .length = ARRAY_SIZE(_var##_classnames), \ .class_names = _var##_classnames, \ } -#define NUM_TYPE_ARGS (eltype, ...) \ - (sizeof((eltype[]) {__VA_ARGS__}) / sizeof(eltype)) extern __printf(2, 3) void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...);
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 9/31 dyndbg: tweak pr_fmt to avoid expansion conflicts
In reply to Jim CromieDisambiguate pr_fmt(fmt) arg, by changing it to _FMT_, to avoid naming confusion with many later macros also using that argname.
no functional change
--- lib/dynamic_debug.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/dynamic_debug.c +1 -1
@@ -11,7 +11,7 @@* Copyright (C) 2013 Du, Changbin <[email protected]> */ -#define pr_fmt (fmt) "dyndbg: " fmt +#define pr_fmt (_FMT_) "dyndbg: " _FMT_#include <linux/kernel.h> #include <linux/module.h>
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 10/31 dyndbg: reduce verbose/debug clutter
In reply to Jim Cromiecurrently, for verbose=3, these are logged (blank lines for clarity):
dyndbg: query 0: "class DRM_UT_CORE +p" mod:*
dyndbg: split into words: "class" "DRM_UT_CORE" "+p"
dyndbg: op='+'
dyndbg: flags=0x1
dyndbg: *flagsp=0x1 *maskp=0xffffffff
dyndbg: parsed: func="" file="" module="" format="" lineno=0-0 class=...
dyndbg: no matches for query
dyndbg: no-match: func="" file="" module="" format="" lineno=0-0 class=...
dyndbg: processed 1 queries, with 0 matches, 0 errs
That is excessive, so this patch:
- shrinks 3 lines of 2nd stanza to single line
- drops 1st 2 lines of 3rd stanza
3rd line is like 1st, with result, not procedure. 2nd line is just status, retold in 4th, with more info.
New output:
dyndbg: query 0: "class DRM_UT_CORE +p" mod:*
dyndbg: split into words: "class" "DRM_UT_CORE" "+p"
dyndbg: op='+' flags=0x1 *flagsp=0x1 *maskp=0xffffffff
dyndbg: no-match: func="" file="" module="" format="" lineno=0-0 class=...
dyndbg: processed 1 queries, with 0 matches, 0 errs
Also reduce verbose=3 messages in ddebug_add_module
When modprobing a module, dyndbg currently logs/says "add-module", and then "skipping" if the module has no prdbgs. Instead just check 1st and return quietly.
no functional change
--- lib/dynamic_debug.c | 21 ++++++--------------- 1 file changed, 6 insertions(+), 15 deletions(-)
lib/dynamic_debug.c +6 -15
@@ -275,9 +275,6 @@ static int ddebug_change(const struct ddebug_query *query, }mutex_unlock (&ddebug_lock); -if (!nfound && verbose) -pr_info ("no matches for query\n" ); -return nfound; }
@@ -510,7 +507,6 @@ static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers)pr_err ("bad flag-op %c, at start of %s\n" , *str, str);return -EINVAL ; } -v3pr_info ("op='%c'\n" , op);for (; *str ; ++str) {for (i =ARRAY_SIZE (opt_array) -1 ; i >=0 ; i--) {
@@ -524,7 +520,6 @@ static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers)return -EINVAL ; } } -v3pr_info ("flags=0x%x\n" , modifiers->flags);/* calculate final flags, mask based upon op */ switch (op) {
@@ -540,7 +535,7 @@ static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers) modifiers->flags =0 ;break ; } -v3pr_info ("*flagsp=0x%x *maskp=0x%x\n" , modifiers->flags, modifiers->mask); +v3pr_info ("op='%c' flags=0x%x maskp=0x%x\n" , op, modifiers->flags, modifiers->mask);return 0 ; }
@@ -550,7 +545,7 @@ static int ddebug_exec_query(char *query_string, const char *modname)struct flag_settings modifiers = {};struct ddebug_query query = {};#define MAXWORDS 9 -int nwords, nfound; +int nwords;char *words[MAXWORDS ]; nwords =ddebug_tokenize (query_string, words,MAXWORDS );
@@ -568,10 +563,7 @@ static int ddebug_exec_query(char *query_string, const char *modname)return -EINVAL ; }/* actually go and implement the change */ - nfound =ddebug_change (&query, &modifiers); -vpr_info_dq (&query, nfound ?"applied" :"no-match" ); - -return nfound; +return ddebug_change (&query, &modifiers); }/* handle multiple queries in query string, continue on error, return
@@ -1245,11 +1237,10 @@ static int ddebug_add_module(struct _ddebug_info *di, const char *modname) {struct ddebug_table *dt; -v3pr_info ("add-module: %s.%d sites\n" , modname, di->num_descs); -if (!di->num_descs) { -v3pr_info (" skip %s\n" , modname); +if (!di->num_descs)return 0 ; - } + +v3pr_info ("add-module: %s %d sites\n" , modname, di->num_descs); dt =kzalloc (sizeof (*dt),GFP_KERNEL );if (dt ==NULL ) {
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 11/31 dyndbg: refactor param_set_dyndbg_classes and below
In reply to Jim CromieRefactor callchain below param_set_dyndbg_classes(1) to allow mod-name specific settings. Split (1) into upper/lower fns, adding modname param to lower, and passing NULL in from upper. Below that, add the same param to ddebug_apply_class_bitmap(), and pass it thru to _ddebug_queries(), replacing NULL with the param.
This allows the callchain to update the classmap in just one module, vs just all as currently done. While the sysfs param is unlikely to ever update just one module, the callchain will be used for modprobe handling, which should update only that just-probed module.
In ddebug_apply_class_bitmap(), also check for actual changes to the bits before announcing them, to declutter logs.
No functional change.
--- lib/dynamic_debug.c | 65 ++++++++++++++++++++++++++++----------------- 1 file changed, 40 insertions(+), 25 deletions(-)
lib/dynamic_debug.c +40 -25
@@ -604,9 +604,10 @@ static int ddebug_exec_queries(char *query, const char *modname)return nfound; } -/* apply a new bitmap to the sys-knob's current bit-state */ +/* apply a new class-param setting */ static int ddebug_apply_class_bitmap (const struct ddebug_class_param *dcp, -unsigned long *new_bits,unsigned long *old_bits) +unsigned long *new_bits,unsigned long *old_bits, +const char *query_modname) {#define QUERY_SIZE 128char query[QUERY_SIZE ];
@@ -614,7 +615,9 @@ static int ddebug_apply_class_bitmap(const struct ddebug_class_param *dcp,int matches =0 ;int bi, ct; -v2pr_info ("apply: 0x%lx to: 0x%lx\n" , *new_bits, *old_bits); +if (*new_bits != *old_bits) +v2pr_info ("apply bitmap: 0x%lx to: 0x%lx for %s\n" , *new_bits, + *old_bits, query_modname ?:"'*'" );for (bi =0 ; bi < map->length; bi++) {if (test_bit (bi, new_bits) ==test_bit (bi, old_bits))
@@ -623,12 +626,16 @@ static int ddebug_apply_class_bitmap(const struct ddebug_class_param *dcp,snprintf (query,QUERY_SIZE ,"class %s %c%s" , map->class_names[bi],test_bit (bi, new_bits) ?'+' :'-' , dcp->flags); - ct =ddebug_exec_queries (query,NULL ); + ct =ddebug_exec_queries (query, query_modname); matches += ct;v2pr_info ("bit_%d: %d matches on class: %s -> 0x%lx\n" , bi, ct, map->class_names[bi], *new_bits); } +if (*new_bits != *old_bits) +v2pr_info ("applied bitmap: 0x%lx to: 0x%lx for %s\n" , *new_bits, + *old_bits, query_modname ?:"'*'" ); +return matches; }
@@ -683,7 +690,7 @@ static int param_set_dyndbg_classnames(const char *instr, const struct kernel_pacontinue ; } curr_bits ^=BIT (cls_id); - totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, dcp->bits); + totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, dcp->bits,NULL ); *dcp->bits = curr_bits;v2pr_info ("%s: changed bit %d:%s\n" ,KP_NAME (kp), cls_id, map->class_names[cls_id]);
@@ -693,7 +700,7 @@ static int param_set_dyndbg_classnames(const char *instr, const struct kernel_pa old_bits =CLASSMAP_BITMASK (*dcp->lvl); curr_bits =CLASSMAP_BITMASK (cls_id + (wanted ?1 :0 )); - totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, &old_bits); + totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, &old_bits,NULL ); *dcp->lvl = (cls_id + (wanted ?1 :0 ));v2pr_info ("%s: changed bit-%d: \"%s\" %lx->%lx\n" ,KP_NAME (kp), cls_id, map->class_names[cls_id], old_bits, curr_bits);
@@ -707,18 +714,9 @@ static int param_set_dyndbg_classnames(const char *instr, const struct kernel_pareturn 0 ; } -/** -* param_set_dyndbg_classes - class FOO >control -* @instr: string echo>d to sysfs, input depends on map_type -* @kp: kp->arg has state: bits/lvl, map, map_type -* -* Enable/disable prdbgs by their class, as given in the arguments to -* DECLARE_DYNDBG_CLASSMAP. For LEVEL map-types, enforce relative -* levels by bitpos. -* -* Returns: 0 or <0 if error. -*/ -int param_set_dyndbg_classes (const char *instr,const struct kernel_param *kp) +static int param_set_dyndbg_module_classes (const char *instr, +const struct kernel_param *kp, +const char *mod_name) {const struct ddebug_class_param *dcp = kp->arg;const struct ddebug_class_map *map = dcp->map;
@@ -755,8 +753,8 @@ int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp) KP_NAME(kp), inrep, CLASSMAP_BITMASK(map->length)); inrep &=CLASSMAP_BITMASK (map->length); } -v2pr_info ("bits:%lx > %s\n" , inrep,KP_NAME (kp)); - totct +=ddebug_apply_class_bitmap (dcp, &inrep, dcp->bits); +v2pr_info ("bits:0x%lx > %s.%s\n" , inrep, mod_name ?:"*" ,KP_NAME (kp)); + totct +=ddebug_apply_class_bitmap (dcp, &inrep, dcp->bits, mod_name); *dcp->bits = inrep;break ;case DD_CLASS_TYPE_LEVEL_NUM :
@@ -769,7 +767,7 @@ int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp) old_bits =CLASSMAP_BITMASK (*dcp->lvl); new_bits =CLASSMAP_BITMASK (inrep);v2pr_info ("lvl:%ld bits:0x%lx > %s\n" , inrep, new_bits,KP_NAME (kp)); - totct +=ddebug_apply_class_bitmap (dcp, &new_bits, &old_bits); + totct +=ddebug_apply_class_bitmap (dcp, &new_bits, &old_bits, mod_name); *dcp->lvl = inrep;break ;default :
@@ -778,16 +776,33 @@ int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp)vpr_info ("%s: total matches: %d\n" ,KP_NAME (kp), totct);return 0 ; } + +/** +* param_set_dyndbg_classes - classmap kparam setter +* @instr: string echo>d to sysfs, input depends on map_type +* @kp: kp->arg has state: bits/lvl, map, map_type +* +* enable/disable all class'd pr_debugs in the classmap. For LEVEL +* map-types, enforce * relative levels by bitpos. +* +* Returns: 0 or <0 if error. +*/ +int param_set_dyndbg_classes (const char *instr,const struct kernel_param *kp) +{ +return param_set_dyndbg_module_classes (instr, kp,NULL ); +}EXPORT_SYMBOL (param_set_dyndbg_classes);/** -* param_get_dyndbg_classes - classes reader +* param_get_dyndbg_classes - classmap kparam getter * @buffer: string description of controlled bits -> classes * @kp: kp->arg has state: bits, map * -* Reads last written state, underlying prdbg state may have been -* altered by direct >control. Displays 0x for DISJOINT, 0-N for -* LEVEL Returns: #chars written or <0 on error +* Reads last written state, underlying pr_debug states may have been +* altered by direct >control. Displays 0x for DISJOINT classmap +* types, 0-N for LEVEL types. +* +* Returns: ct of chars written or <0 on error */ int param_get_dyndbg_classes (char *buffer,const struct kernel_param *kp) {
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 12/31 dyndbg: tighten fn-sig of ddebug_apply_class_bitmap
In reply to Jim Cromieold_bits arg is currently a pointer to the input bits, but this could allow inadvertent changes to the input by the fn. Disallow this. And constify new_bits while here.
--- lib/dynamic_debug.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-)
lib/dynamic_debug.c +11 -10
@@ -606,7 +606,8 @@ static int ddebug_exec_queries(char *query, const char *modname)/* apply a new class-param setting */ static int ddebug_apply_class_bitmap (const struct ddebug_class_param *dcp, -unsigned long *new_bits,unsigned long *old_bits, +const unsigned long *new_bits, +const unsigned long old_bits,const char *query_modname) {#define QUERY_SIZE 128
@@ -615,12 +616,12 @@ static int ddebug_apply_class_bitmap(const struct ddebug_class_param *dcp,int matches =0 ;int bi, ct; -if (*new_bits != *old_bits) +if (*new_bits != old_bits)v2pr_info ("apply bitmap: 0x%lx to: 0x%lx for %s\n" , *new_bits, - *old_bits, query_modname ?:"'*'" ); + old_bits, query_modname ?:"'*'" );for (bi =0 ; bi < map->length; bi++) { -if (test_bit (bi, new_bits) ==test_bit (bi, old_bits)) +if (test_bit (bi, new_bits) ==test_bit (bi, &old_bits))continue ; snprintf(query, QUERY_SIZE, "class %s %c%s", map->class_names[bi],
@@ -632,9 +633,9 @@ static int ddebug_apply_class_bitmap(const struct ddebug_class_param *dcp,v2pr_info ("bit_%d: %d matches on class: %s -> 0x%lx\n" , bi, ct, map->class_names[bi], *new_bits); } -if (*new_bits != *old_bits) +if (*new_bits != old_bits)v2pr_info ("applied bitmap: 0x%lx to: 0x%lx for %s\n" , *new_bits, - *old_bits, query_modname ?:"'*'" ); + old_bits, query_modname ?:"'*'" );return matches; }
@@ -690,7 +691,7 @@ static int param_set_dyndbg_classnames(const char *instr, const struct kernel_pacontinue ; } curr_bits ^=BIT (cls_id); - totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, dcp->bits,NULL ); + totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, *dcp->bits,NULL ); *dcp->bits = curr_bits;v2pr_info ("%s: changed bit %d:%s\n" ,KP_NAME (kp), cls_id, map->class_names[cls_id]);
@@ -700,7 +701,7 @@ static int param_set_dyndbg_classnames(const char *instr, const struct kernel_pa old_bits =CLASSMAP_BITMASK (*dcp->lvl); curr_bits =CLASSMAP_BITMASK (cls_id + (wanted ?1 :0 )); - totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, &old_bits,NULL ); + totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, old_bits,NULL ); *dcp->lvl = (cls_id + (wanted ?1 :0 ));v2pr_info ("%s: changed bit-%d: \"%s\" %lx->%lx\n" ,KP_NAME (kp), cls_id, map->class_names[cls_id], old_bits, curr_bits);
@@ -754,7 +755,7 @@ static int param_set_dyndbg_module_classes(const char *instr, inrep &=CLASSMAP_BITMASK (map->length); }v2pr_info ("bits:0x%lx > %s.%s\n" , inrep, mod_name ?:"*" ,KP_NAME (kp)); - totct +=ddebug_apply_class_bitmap (dcp, &inrep, dcp->bits, mod_name); + totct +=ddebug_apply_class_bitmap (dcp, &inrep, *dcp->bits, mod_name); *dcp->bits = inrep;break ;case DD_CLASS_TYPE_LEVEL_NUM :
@@ -767,7 +768,7 @@ static int param_set_dyndbg_module_classes(const char *instr, old_bits =CLASSMAP_BITMASK (*dcp->lvl); new_bits =CLASSMAP_BITMASK (inrep);v2pr_info ("lvl:%ld bits:0x%lx > %s\n" , inrep, new_bits,KP_NAME (kp)); - totct +=ddebug_apply_class_bitmap (dcp, &new_bits, &old_bits, mod_name); + totct +=ddebug_apply_class_bitmap (dcp, &new_bits, old_bits, mod_name); *dcp->lvl = inrep;break ;default :
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 13/31 dyndbg: replace classmap list with a vector
In reply to Jim CromieClassmaps are stored in an elf section/array, but currently are individually list-linked onto dyndbg's per-module ddebug_table for operation. This is unnecessary.
Just like dyndbg's descriptors, classes are packed in compile order; so even with many builtin modules employing multiple classmaps, each modules' maps are packed contiguously, and can be treated as a array-start-address & array-length.
So this drops the whole list building operation done in ddebug_attach_module_classes(), and removes the list-head members. The "select-by-modname" condition is reused to find the start,end of the subrange.
NOTE: This "filter-by-modname" on classmaps should really be done in ddebug_add_module(1); ie at least one step closer to ddebug_init(2), which already splits up pr-debug descriptors into subranges by modname, then calls (1) on each. (2) knows nothing of classmaps currently, and doesn't need to. For now, just add comment.
--- include/linux/dynamic_debug.h | 1 - lib/dynamic_debug.c | 62 ++++++++++++++++++----------------- 2 files changed, 32 insertions(+), 31 deletions(-)
include/linux/dynamic_debug.h +0 -1
@@ -83,7 +83,6 @@ enum class_map_type { };struct ddebug_class_map { -struct list_head link;struct module *mod;const char *mod_name;/* needed for builtins */ const char **class_names;
lib/dynamic_debug.c +32 -30
125 lines not on this page · raw message
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 14/31 dyndbg: macrofy a 2-index for-loop pattern
In reply to Jim Cromiedynamic-debug currently has 2 __sections (__dyndbg, __dyndb_classes), struct _ddebug_info keeps track of them both, with 2 members each:_vec and _vec#_len.
We need to loop over these sections, with index and record pointer, making ref to both _vec and _vec_len. This is already fiddly and error-prone, and will get worse as we add a 3rd section.
Lets instead embed/abstract the fiddly-ness in the for_subvec() macro, and avoid repeating it going forward.
This is a for-loop macro expander, so it syntactically expects to precede either a single statement or a { block } of them, and the usual typeof or do-while-0 tricks are unavailable to fix the multiple-expansion warning.
The macro needs a lot from its caller: it needs 2 local vars, 1 of which is a ref to a contained struct with named members. To support these requirements, add:
1. __ASSERT_IS_LVALUE(_X):
ie: ((void)sizeof((void)0, &(x)))
2. __ASSERT_HAS_VEC_MEMBERS(_X, _Y):
compile-time check that the _Y "vector" exists
ie: _X->_Y and _X->num##_Y are lvalues.
The for_subvec() macro then invokes these before the for-loop itself; they disappear at runtime. They do cause a "complex macro" CHECK from checkpatch --strict.
--- lib/dynamic_debug.c | 27 ++++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-)
lib/dynamic_debug.c +24 -3
@@ -128,6 +128,28 @@ do { \#define v3pr_info (fmt, ...) vnpr_info(3, fmt, ##__VA_ARGS__)#define v4pr_info (fmt, ...) vnpr_info(4, fmt, ##__VA_ARGS__) +/* +* simplify a repeated for-loop pattern walking N steps in a T _vec +* member inside a struct _box. It expects int i and T *_sp to be +* declared in the caller. +* @_i: caller provided counter. +* @_sp: cursor into _vec, to examine each item. +* @_box: ptr to a struct containing @_vec member +* @_vec: name of a member in @_box +*/ +#define __ASSERT_IS_LVALUE (x) ((void)sizeof((void)0, &(x))) +#define __ASSERT_HAS_VEC_MEMBER (_box, _vec) ({ \ + (void)sizeof((_box)->_vec); \ + (void)sizeof((_box)->num_##_vec); \ +}) +#define for_subvec (_i, _sp, _box, _vec) \ + __ASSERT_IS_LVALUE(_i); \ + __ASSERT_IS_LVALUE(_sp); \ + __ASSERT_HAS_VEC_MEMBER(_box, _vec); \ + for ((_i) = 0, (_sp) = (_box)->_vec; \ + (_i) < (_box)->num_##_vec; \ + (_i)++, (_sp)++) +static void vpr_info_dq (const struct ddebug_query *query,const char *msg) {/* trim any trailing newlines */
@@ -155,7 +177,7 @@ static struct ddebug_class_map *ddebug_find_valid_class(struct ddebug_table consstruct ddebug_class_map *map;int i, idx; -for (map = dt->classes, i =0 ; i < dt->num_classes; i++, map++) { + for_subvec(i, map, dt, classes) { idx =match_string (map->class_names, map->length, class_string);if (idx >=0 ) { *class_id = idx + map->base;
@@ -1231,8 +1253,7 @@ static void ddebug_attach_module_classes(struct ddebug_table *dt, struct _ddebug* the builtin/modular classmap vector/section. Save the start * and length of the subrange at its edges. */ -for (cm = di->classes, i =0 ; i < di->num_classes; i++, cm++) { - + for_subvec(i, cm, di, classes) {if (!strcmp (cm->mod_name, dt->mod_name)) {if (!nc) { v2pr_info("start subrange, class[%d]: module:%s base:%d len:%d ty:%d\n",
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 15/31 dyndbg,module: make proper substructs in _ddebug_info
In reply to Jim Cromierecompose struct _ddebug_info, inserting proper sub-structs.
The struct _ddebug_info has 2 pairs of _vec, num##_vec fields, for descs and classes respectively. for_subvec() makes walking these vectors less cumbersome, now lets move those field pairs into their own "vec" structs: _ddebug_descs & _ddebug_class_maps, and re-compose struct _ddebug_info to contain them cleanly. This also lets us rid for_subvec() of its num##_vec paste-up.
Also recompose struct ddebug_table to contain a _ddebug_info. This reinforces its use as a cursor into relevant data for a builtin module, and access to the full _ddebug state for modules.
NOTES:
Invariant: These vectors ref a contiguous subrange of __section memory in builtin/DATA or in loadable modules via mod->dyndbg_info; with guaranteed life-time for us.
Fixup names: Normalize all struct names to "struct _ddebug_*" eliminating the minor/stupid variations created in classmaps-v1. Also normalize the __section names to "__dyndbg_*".
struct module contains a _ddebug_info field and module/main.c sets it up, so that gets adjusted rather obviously.
--- include/asm-generic/vmlinux.lds.h | 4 +- include/linux/dynamic_debug.h | 42 ++++++---- kernel/module/main.c | 12 +-- lib/dynamic_debug.c | 127 +++++++++++++++--------------- lib/test_dynamic_debug.c | 2 +- 5 files changed, 100 insertions(+), 87 deletions(-)
include/asm-generic/vmlinux.lds.h +2 -2
@@ -366,8 +366,8 @@ defined(CONFIG_AUTOFDO_CLANG) || defined(CONFIG_PROPELLER_CLANG) *(__tracepoints) \/* implement dynamic printk debug */ \ . = ALIGN(8); \ - BOUNDED_SECTION_BY(__dyndbg_classes, ___dyndbg_classes) \ - BOUNDED_SECTION_BY(__dyndbg, ___dyndbg) \ + BOUNDED_SECTION_BY(__dyndbg_class_maps, ___dyndbg_class_maps) \ + BOUNDED_SECTION_BY(__dyndbg_descriptors, ___dyndbg_descs) \ CODETAG_SECTIONS() \ LIKELY_PROFILE() \BRANCH_PROFILE () \
include/linux/dynamic_debug.h +27 -15
86 lines not on this page · raw message
kernel/module/main.c +6 -6
@@ -2710,12 +2710,12 @@ static int find_module_sections(struct module *mod, struct load_info *info)pr_warn ("%s: Ignoring obsolete parameters\n" , mod->name);#ifdef CONFIG_DYNAMIC_DEBUG_CORE - mod->dyndbg_info.descs =section_objs (info,"__dyndbg" , -sizeof (*mod->dyndbg_info.descs), - &mod->dyndbg_info.num_descs); - mod->dyndbg_info.classes =section_objs (info,"__dyndbg_classes" , -sizeof (*mod->dyndbg_info.classes), - &mod->dyndbg_info.num_classes); + mod->dyndbg_info.descs.start =section_objs (info,"__dyndbg_descriptors" , +sizeof (*mod->dyndbg_info.descs.start), + &mod->dyndbg_info.descs.len); + mod->dyndbg_info.maps.start =section_objs (info,"__dyndbg_class_maps" , +sizeof (*mod->dyndbg_info.maps.start), + &mod->dyndbg_info.maps.len);#endif return 0 ;
lib/dynamic_debug.c +64 -63
312 lines not on this page · raw message
lib/test_dynamic_debug.c +1 -1
@@ -41,7 +41,7 @@ module_param_cb(do_prints, ¶m_ops_do_prints, NULL, 0600);*/ #define DD_SYS_WRAP (_model, _flags) \ static unsigned long bits_##_model; \ - static struct ddebug_class_param _flags##_model = { \ + static struct _ddebug_class_param _flags##_model = { \ .bits = &bits_##_model, \ .flags = #_flags, \ .map = &map_##_model, \
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 16/31 dyndbg: hoist classmap-filter-by-modname up to ddebug_add_module
In reply to Jim CromieThe body of ddebug_attach_module_classes() is dominated by a code-block that finds the contiguous subrange of classmaps matching on modname, and saves it into the ddebug_table's info record.
Implement this block in a macro to accommodate different component vectors in the "box" (as named in the for_subvec macro). We will reuse this macro shortly.
And hoist its invocation out of ddebug_attach_module_classes() up into ddebug_add_module(). This moves the filtering step up closer to dynamic_debug_init(), which already segments the builtin pr_debug descriptors on their mod_name boundaries.
---
reordered params to match kdoc
--- lib/dynamic_debug.c | 57 ++++++++++++++++++++++++++------------------- 1 file changed, 33 insertions(+), 24 deletions(-)
lib/dynamic_debug.c +33 -24
@@ -170,8 +170,8 @@ static void vpr_info_dq(const struct ddebug_query *query, const char *msg) }static struct _ddebug_class_map *ddebug_find_valid_class (struct ddebug_table const *dt, -const char *class_string, -int *class_id) +const char *class_string, +int *class_id) {struct _ddebug_class_map *map;int i, idx;
@@ -1247,30 +1247,35 @@ static const struct proc_ops proc_fops = {static void ddebug_attach_module_classes (struct ddebug_table *dt,struct _ddebug_info *di) { -struct _ddebug_class_map *cm; -int i, nc =0 ; - -/* -* Find this module's classmaps in a subrange/wholerange of -* the builtin/modular classmap vector/section. Save the start -* and length of the subrange at its edges. -*/ - for_subvec(i, cm, di, maps) { -if (!strcmp (cm->mod_name, dt->mod_name)) { -if (!nc) { -v2pr_info ("start subrange, class[%d]: module:%s base:%d len:%d ty:%d\n" , - i, cm->mod_name, cm->base, cm->length, cm->map_type); - dt->info.maps.start = cm; - } - nc++; - } - } -if (nc) { - dt->info.maps.len = nc; -vpr_info ("module:%s attached %d classes\n" , dt->mod_name, nc); - } +vpr_info ("module:%s attached %d classes\n" , dt->mod_name, dt->info.maps.len); } +/* +* Walk the @_box->@_vec member, over @_vec.start[0..len], and find +* the contiguous subrange of elements matching on ->mod_name. Copy +* the subrange into @_dst. This depends on vars defd by caller. +* +* @_i: caller provided counter var, init'd by macro +* @_sp: cursor into @_vec. +* @_box: contains member named @_vec +* @_vec: member-name of a type with: .start .len fields. +* @_dst: an array-ref: to remember the module's subrange +*/ +#define dd_mark_vector_subrange(_i, _sp, _box, _vec, _dst) ({ \ + typeof(_dst) __dst = (_dst); \ + int __nc = 0; \ + for_subvec(_i, _sp, _box, _vec) { \ + if (!strcmp((_sp)->mod_name, (_dst)->mod_name)) { \ + if (!__nc++) \ + (__dst)->info._vec.start = (_sp); \ + } else { \ + if (__nc) \ + break; /* end of consecutive matches */ \ + } \ + } \ + (__dst)->info._vec.len = __nc; \ +}) +/* * Allocate a new ddebug_table for the given module * and add it to the global list.
@@ -1278,6 +1283,8 @@ static void ddebug_attach_module_classes(struct ddebug_table *dt, struct _ddebugstatic int ddebug_add_module (struct _ddebug_info *di,const char *modname) {struct ddebug_table *dt; +struct _ddebug_class_map *cm; +int i;if (!di->descs.len)return 0 ;
@@ -1300,6 +1307,8 @@ static int ddebug_add_module(struct _ddebug_info *di, const char *modname)INIT_LIST_HEAD (&dt->link); +dd_mark_vector_subrange (i, cm, di, maps, dt); +if (di->maps.len)ddebug_attach_module_classes (dt, di);
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 17/31 dyndbg: move mod_name down from struct ddebug_table to _ddebug_info
In reply to Jim Cromiestruct _ddebug_info already has most of dyndbg's info for a module; push debug_table.mod_name down into it, finishing the encapsulation.
This allows refactoring several callchains, passing &_ddebug_info instead of &ddebug_table, and hoisting the "&dt->info" deref up instead of repeating it thru the callchans
ddebug_table contains a _ddebug_info member, so its users keep access to mod_name, just now with "->info." added in.
In static ddebug_add_module(&di), reinforce the cursor-model by dropping the modname arg, and setting di->mod_name at each caller.
--- include/linux/dynamic_debug.h | 1 + lib/dynamic_debug.c | 50 ++++++++++++++++++----------------- 2 files changed, 27 insertions(+), 24 deletions(-)
include/linux/dynamic_debug.h +1 -0
@@ -107,6 +107,7 @@ struct _ddebug_class_maps { };struct _ddebug_info { +const char *mod_name;struct _ddebug_descs descs;struct _ddebug_class_maps maps; };
lib/dynamic_debug.c +26 -24
159 lines not on this page · raw message
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 18/31 dyndbg-API: remove DD_CLASS_TYPE_(DISJOINT|LEVEL)_NAMES and code
In reply to Jim CromieRemove the DD_CLASS_TYPE_*_NAMES classmap types and code.
These 2 classmap types accept class names at the PARAM interface, for example:
echo +DRM_UT_CORE,-DRM_UT_KMS > /sys/module/drm/parameters/debug_names
The code works, but its only used by test-dynamic-debug, and wasn't asked for by anyone else, so reduce LOC & test-surface; simplify things.
Also rename enum class_map_type to enum ddebug_class_map_type.
--- include/linux/dynamic_debug.h | 23 ++------ lib/dynamic_debug.c | 102 +++------------------------------- lib/test_dynamic_debug.c | 26 --------- 3 files changed, 14 insertions(+), 137 deletions(-)
include/linux/dynamic_debug.h +6 -17
@@ -58,27 +58,16 @@ struct _ddebug {#endif } __attribute__((aligned(8))); -enum class_map_type { +enum ddebug_class_map_type {DD_CLASS_TYPE_DISJOINT_BITS ,/** -* DD_CLASS_TYPE_DISJOINT_BITS: classes are independent, one per bit. -* expecting hex input. Built for drm.debug, basis for other types. +* DD_CLASS_TYPE_DISJOINT_BITS: classes are independent, mapped to bits[0..N]. +* Expects hex input. Built for drm.debug, basis for other types. */ DD_CLASS_TYPE_LEVEL_NUM ,/** -* DD_CLASS_TYPE_LEVEL_NUM: input is numeric level, 0-N. -* N turns on just bits N-1 .. 0, so N=0 turns all bits off. -*/ -DD_CLASS_TYPE_DISJOINT_NAMES , -/** -* DD_CLASS_TYPE_DISJOINT_NAMES: input is a CSV of [+-]CLASS_NAMES, -* classes are independent, like _DISJOINT_BITS. -*/ -DD_CLASS_TYPE_LEVEL_NAMES , -/** -* DD_CLASS_TYPE_LEVEL_NAMES: input is a CSV of [+-]CLASS_NAMES, -* intended for names like: INFO,DEBUG,TRACE, with a module prefix -* avoid EMERG,ALERT,CRIT,ERR,WARNING: they're not debug +* DD_CLASS_TYPE_LEVEL_NUM: input is numeric level, 0..N. +* Input N turns on bits 0..N-1 */ };
@@ -88,7 +77,7 @@ struct _ddebug_class_map {const char **class_names;const int length;const int base;/* index of 1st .class_id, allows split/shared space */ -enum class_map_type map_type; +enum ddebug_class_map_type map_type; };/*
lib/dynamic_debug.c +8 -94
125 lines not on this page · raw message
lib/test_dynamic_debug.c +0 -26
@@ -74,13 +74,6 @@ DECLARE_DYNDBG_CLASSMAP(map_disjoint_bits, DD_CLASS_TYPE_DISJOINT_BITS, 0,DD_SYS_WRAP (disjoint_bits, p);DD_SYS_WRAP (disjoint_bits,T ); -/* symbolic input, independent bits */ -enum cat_disjoint_names {LOW =10 ,MID ,HI }; -DECLARE_DYNDBG_CLASSMAP (map_disjoint_names,DD_CLASS_TYPE_DISJOINT_NAMES ,10 , -"LOW" ,"MID" ,"HI" ); -DD_SYS_WRAP (disjoint_names, p); -DD_SYS_WRAP (disjoint_names,T ); -/* numeric verbosity, V2 > V1 related */ enum cat_level_num {V0 =14 ,V1 ,V2 ,V3 ,V4 ,V5 ,V6 ,V7 }; DECLARE_DYNDBG_CLASSMAP(map_level_num, DD_CLASS_TYPE_LEVEL_NUM, 14,
@@ -88,13 +81,6 @@ DECLARE_DYNDBG_CLASSMAP(map_level_num, DD_CLASS_TYPE_LEVEL_NUM, 14,DD_SYS_WRAP (level_num, p);DD_SYS_WRAP (level_num,T ); -/* symbolic verbosity */ -enum cat_level_names {L0 =22 ,L1 ,L2 ,L3 ,L4 ,L5 ,L6 ,L7 }; -DECLARE_DYNDBG_CLASSMAP (map_level_names,DD_CLASS_TYPE_LEVEL_NAMES ,22 , -"L0" ,"L1" ,"L2" ,"L3" ,"L4" ,"L5" ,"L6" ,"L7" ); -DD_SYS_WRAP (level_names, p); -DD_SYS_WRAP (level_names,T ); -/* stand-in for all pr_debug etc */ #define prdbg (SYM ) __pr_debug_cls(SYM, #SYM " msg\n")
@@ -102,10 +88,6 @@ static void do_cats(void) {pr_debug ("doing categories\n" ); -prdbg (LOW ); -prdbg (MID ); -prdbg (HI ); -prdbg (D2_CORE );prdbg (D2_DRIVER );prdbg (D2_KMS );
@@ -129,14 +111,6 @@ static void do_levels(void)prdbg (V5 );prdbg (V6 );prdbg (V7 ); - -prdbg (L1 ); -prdbg (L2 ); -prdbg (L3 ); -prdbg (L4 ); -prdbg (L5 ); -prdbg (L6 ); -prdbg (L7 ); }static void do_prints (void )
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 19/31 selftests-dyndbg: add a dynamic_debug run_tests target
In reply to Jim CromieAdd a selftest script for dynamic-debug. The config requires CONFIG_TEST_DYNAMIC_DEBUG=m and CONFIG_TEST_DYNAMIC_DEBUG_SUBMOD=m, which tacitly requires either CONFIG_DYNAMIC_DEBUG=y or CONFIG_DYNAMIC_DEBUG_CORE=y
ATM this has just basic_tests(), which modify pr_debug() flags in the builtin params module. This means they're available to manipulate and observe the effects in "cat control".
This is backported from another feature branch; the support-fns (thx Lukas) have unused features at the moment, they'll get used shortly.
The script enables simple virtme-ng testing:
[jimc@gandalf b0-ftrace]$ vrun_t
virtme-ng 1.32+115.g07b109d
doing: vng --name v6.14-rc4-60-gd5f48427de0c \ --user root -v -p 4 -a dynamic_debug.verbose=3 V=1 \ -- ../tools/testing/selftests/dynamic_debug/dyndbg_selftest.sh
virtme: waiting for virtiofsd to start
..
And add dynamic_debug to TARGETS, so make run_tests sees it properly For the impatient, set TARGETS explicitly:
[root@v6 selftests]# make TARGETS=dynamic_debug run_tests make[1]: Nothing to be done for 'all'.
TAP version 13
1..1
# timeout set to 45 # selftests: dynamic_debug: dyndbg_selftest.sh # # BASIC_TESTS 95.422122] dyndbg: query 0: 0"=_" mod:* ...
NOTES
check KCONFIG_CONFIG to avoid silly fails
Several tests are dependent upon config choices. Lets avoid failing where that is noise.
The KCONFIG_CONFIG var exists to convey the config-file around. If the var names a file, read it and extract the relevant CONFIG items, and use them to skip the dependent tests, thus avoiding the fails that would follow, and the disruption to whatever CI is running these selftests.
If the envar doesn't name a config-file, ".config" is assumed.
CONFIG_DYNAMIC_DEBUG=y:
basic-tests() and comma-terminator-tests() test for the presence of the builtin pr_debugs in module/main.c, which I deemed stable and therefore safe to count. That said, the test fails if only CONFIG_DYNAMIC_DEBUG_CORE=y is set. It could be rewritten to test against test-dynamic-debug.ko, but that just trades one config dependence for another.
CONFIG_TEST_DYNAMIC_DEBUG=m
As written, test_percent_splitting() modprobes test_dynamic_debug, enables several classes, and counts them. It could be re-written to work for the builtin module also, but builtin test modules are not a common or desirable build/config.
--- MAINTAINERS | 1 + tools/testing/selftests/Makefile | 1 + .../testing/selftests/dynamic_debug/Makefile | 9 + tools/testing/selftests/dynamic_debug/config | 7 + .../dynamic_debug/dyndbg_selftest.sh | 257 ++++++++++++++++++ 5 files changed, 275 insertions(+) create mode 100644 tools/testing/selftests/dynamic_debug/Makefile create mode 100644 tools/testing/selftests/dynamic_debug/config create mode 100755 tools/testing/selftests/dynamic_debug/dyndbg_selftest.sh
MAINTAINERS +1 -0
@@ -8772,6 +8772,7 @@ S: Maintained F: include/linux/dynamic_debug.h F: lib/dynamic_debug.c F: lib/test_dynamic_debug.c +F: tools/testing/selftests/dynamic_debug/* DYNAMIC INTERRUPT MODERATION M: Tal Gilboa <[email protected]>
tools/testing/selftests/Makefile +1 -0
@@ -26,6 +26,7 @@ TARGETS += drivers/net/team TARGETS += drivers/net/virtio_net TARGETS += drivers/platform/x86/intel/ifs TARGETS += dt +TARGETS += dynamic_debug TARGETS += efivarfs TARGETS += exec TARGETS += fchmodat2
tools/testing/selftests/dynamic_debug/Makefile new file +9 -0
@@ -0,0 +1,9 @@ +# SPDX-License-Identifier: GPL-2.0-only +# borrowed from Makefile for user memory selftests + +# No binaries, but make sure arg-less "make" doesn't trigger "run_tests" +all: + +TEST_PROGS := dyndbg_selftest.sh + +include ../lib.mk
tools/testing/selftests/dynamic_debug/config new file +7 -0
@@ -0,0 +1,7 @@ + +# basic tests ref the builtin params module +CONFIG_DYNAMIC_DEBUG=m + +# more testing is possible with these +# CONFIG_TEST_DYNAMIC_DEBUG=m +# CONFIG_TEST_DYNAMIC_DEBUG_SUBMOD=m
tools/testing/selftests/dynamic_debug/dyndbg_selftest.sh new file +257 -0
257 lines not on this page · raw message
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 20/31 dyndbg: change __dynamic_func_call_cls* macros into expressions
In reply to Jim CromieThe Xe driver's XE_IOCTL_DBG macro calls drm_dbg() from inside an if (expression). This breaks when CONFIG_DRM_USE_DYNAMIC_DEBUG=y because the invoked macro has a do-while-0 wrapper, and is not an expression.
if (cond && (drm_dbg("expr-form"),1)) {
... do some more stuff
}Fix for this usage by changing __dynamic_func_call_cls{,_no_desc} macros into expressions, by replacing the do-while-0s with a ({ }) wrapper. In the common usage, the trailing ';' converts the expression into a statement.
drm_dbg("statement form");--- include/linux/dynamic_debug.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
include/linux/dynamic_debug.h +4 -4
@@ -217,20 +217,20 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor,* (|_cls): adds in _DPRINT_CLASS_DFLT as needed * (|_no_desc): former gets callsite descriptor as 1st arg (for prdbgs) */ -#define __dynamic_func_call_cls (id, cls, fmt, func, ...) do { \ +#define __dynamic_func_call_cls (id, cls, fmt, func, ...) ({ \ DEFINE_DYNAMIC_DEBUG_METADATA_CLS(id, cls, fmt); \ if (DYNAMIC_DEBUG_BRANCH(id)) \ func(&id, ##__VA_ARGS__); \ -} while (0) +})#define __dynamic_func_call (id, fmt, func, ...) \ __dynamic_func_call_cls(id, _DPRINTK_CLASS_DFLT, fmt, \ func, ##__VA_ARGS__) -#define __dynamic_func_call_cls_no_desc (id, cls, fmt, func, ...) do { \ +#define __dynamic_func_call_cls_no_desc (id, cls, fmt, func, ...) ({ \ DEFINE_DYNAMIC_DEBUG_METADATA_CLS(id, cls, fmt); \ if (DYNAMIC_DEBUG_BRANCH(id)) \ func(__VA_ARGS__); \ -} while (0) +})#define __dynamic_func_call_no_desc (id, fmt, func, ...) \ __dynamic_func_call_cls_no_desc(id, _DPRINTK_CLASS_DFLT, \ fmt, func, ##__VA_ARGS__)
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 21/31 dyndbg-API: replace DECLARE_DYNDBG_CLASSMAP
In reply to Jim Cromiecommit aad0214f3026 ("dyndbg: add DECLARE_DYNDBG_CLASSMAP macro")
DECLARE_DYNDBG_CLASSMAP() has a design error; its usage fails a basic K&R rule: "define once, refer many times".
When CONFIG_DRM_USE_DYNAMIC_DEBUG=y, it is used across DRM core & drivers; each invocation allocates/inits the classmap understood by that module. They *all* must match for the DRM modules to respond consistently when drm.debug categories are enabled. This is at least a maintenance hassle.
Worse, its the root-cause of the CONFIG_DRM_USE_DYNAMIC_DEBUG=Y regression; its use in both core & drivers obfuscates the 2 roles, muddling the design, yielding an incomplete initialization when modprobing drivers:
1st drm.ko loads, and dyndbg initializes its drm.debug callsites, then a drm-driver loads, but too late for the drm.debug enablement.
And that gave us:
commit bb2ff6c27bc9 ("drm: Disable dynamic debug as broken")
So retire it, replace with 2 macros:
DYNAMIC_DEBUG_CLASSMAP_DEFINE - invoked once from core - drm.ko
DYNAMIC_DEBUG_CLASSMAP_USE - from all drm drivers and helpers.
NB: name-space de-noise
DYNAMIC_DEBUG_CLASSMAP_DEFINE: this reworks DECLARE_DYNDBG_CLASSMAP, basically by dropping the static qualifier on the classmap, and exporting it instead.
DYNAMIC_DEBUG_CLASSMAP_USE: then refers to the exported var by name:
used from drivers, helper-mods
lets us drop the repetitive "classname" declarations
fixes 2nd-defn problem
creates a ddebug_class_user record in new __dyndbg_class_users section new section is scanned "differently"
DECLARE_DYNDBG_CLASSMAP is preserved temporarily, to decouple DRM adaptation work and avoid compile-errs before its done.
The DEFINE,USE distinction, and the separate classmap-use record, allows dyndbg to initialize the driver's & helper's drm.debug callsites separately after each is modprobed.
Basically, the classmap initial scan is repeated for classmap-users.
dyndbg's existing __dyndbg_classes[] section does:
. catalogs the module's classmaps
. tells dyndbg about them, allowing >control
. DYNAMIC_DEBUG_CLASSMAP_DEFINE creates section records. . we rename it to: __dyndbg_class_maps[]
this patch adds __dyndbg_class_users[] section:
. catalogs users of classmap definitions from elsewhere . authorizes dyndbg to >control user's class'd prdbgs . DYNAMIC_DEBUG_CLASSMAP_USE() creates section records.
Now ddebug_add_module(etal) can handle classmap-uses similar to (and after) classmaps; when a dependent module is loaded, if it has classmap-uses (to a classmap-def in another module), that module's kernel params are scanned to find if it has a kparam that is wired to dyndbg's param-ops, and whose classmap is the one being ref'd.
To support this, theres a few data/header changes:
new struct ddebug_class_user
contains: user-module-name, &classmap-defn
it records drm-driver's use of a classmap in the section, allowing lookup
struct ddebug_info gets 2 new fields for the new sections:
class_users, num_class_users.
set by dynamic_debug_init() for builtins.
or by kernel/module/main:load_info() for loadable modules.
vmlinux.lds.h: new BOUNDED_SECTION for __dyndbg_class_users. this creates start,len C symbol-names for the section.
TLDR ?
dynamic_debug.c: 2 changes from ddebug_add_module() & ddebug_change():
ddebug_add_module():
ddebug_attach_module_classes() is reworked/renamed/split into debug_apply_class_maps(), ddebug_apply_class_users(), which both call ddebug_apply_params().
ddebug_apply_params(new fn):
It scans module's/builtin kernel-params, calls ddebug_match_apply_kparam for each to find any params/sysfs-nodes which may be wired to a classmap.
ddebug_match_apply_kparam(new fn):
1st, it tests the kernel-param.ops is dyndbg's; this guarantees that the attached arg is a struct ddebug_class_param, which has a ref to the param's state, and to the classmap defining the param's handling.
2nd, it requires that the classmap ref'd by the kparam is the one we've been called for; modules can use many separate classmaps (as test_dynamic_debug does).
Then apply the "parent" kparam's setting to the dependent module, using ddebug_apply_class_bitmap().
ddebug_change(and callees) also gets adjustments:
ddebug_find_valid_class(): This does a search over the module's classmaps, looking for the class FOO echo'd to >control. So now it searches over __dyndbg_class_users[] after __dyndbg_classes[].
ddebug_class_name(): return class-names for defined OR used classes.
test_dynamic_debug.c, test_dynamic_debug_submod.c:
This demonstrates the 2 types of classmaps & sysfs-params, following the 4-part recipe:
0. define an enum for the classmap's class_ids
drm.debug gives us DRM_UT_<*> (aka <T>)
multiple classmaps in a module(s) must share 0-62 classid space.
1. DYNAMIC_DEBUG_CLASSMAP_DEFINE(classmap_name, .. "<T>") names the classes, maps them to consecutive class-ids. convention here is stringified ENUM_SYMBOLS these become API/ABI if 2 is done.
2. DYNAMIC_DEBUG_CLASSMAP_PARAM* (classmap_name)
adds a controlling kparam to the class
3. DYNAMIC_DEBUG_CLASSMAP_USE(classmap_name)
for subsystem/group/drivers to use extern created by 1.
Move all the enum declarations together, to better explain how they share the 0..62 class-id space available to a module (non-overlapping subranges).
reorg macros 2,3 by name. This gives a tabular format, making it easy to see the pattern of repetition, and the points of change.
And extend the test to replicate the 2-module (parent & dependent) scenario which caused the CONFIG_DRM_USE_DYNAMIC_DEBUG=y regression seen in drm & drivers.
The _submod.c is a 2-line file: #define _SUBMOD, #include parent.
This gives identical complements of prdbgs in parent & _submod, and thus identical print behavior when all of: >control, >params, and parent->_submod propagation are working correctly.
It also puts all the parent/_submod declarations together in the same source; the new ifdef _SUBMOD block invokes DYNAMIC_DEBUG_CLASSMAP_USE for the 2 test-interfaces. I think this is clearer.
These 2 modules are both tristate, allowing 3 super/sub combos: Y/Y, Y/M, M/M (not N/Y, since this is disallowed by dependence).
Y/Y, Y/M testing once exposed a missing __align(8) in the _METADATA macro, which M/M didn't see, probably because the module-loader memory placement constrained it from misalignment.
---
replace di with &dt->info, since di becomes stale fix dd_mark_vector_subrange macro param ordering to match kdoc s/base/offset/ in _ddebug_class_user, to reduce later churn
--- MAINTAINERS | 2 +- include/asm-generic/vmlinux.lds.h | 1 + include/linux/dynamic_debug.h | 138 +++++++++++++++++++++--- kernel/module/main.c | 3 + lib/Kconfig.debug | 24 ++++- lib/Makefile | 5 + lib/dynamic_debug.c | 172 +++++++++++++++++++++++++----- lib/test_dynamic_debug.c | 132 ++++++++++++++++------- lib/test_dynamic_debug_submod.c | 14 +++ 9 files changed, 412 insertions(+), 79 deletions(-) create mode 100644 lib/test_dynamic_debug_submod.c
MAINTAINERS +1 -1
@@ -8771,7 +8771,7 @@ M: Jim Cromie <[email protected]> S: Maintained F: include/linux/dynamic_debug.h F: lib/dynamic_debug.c -F: lib/test_dynamic_debug.c +F: lib/test_dynamic_debug*.c F: tools/testing/selftests/dynamic_debug/* DYNAMIC INTERRUPT MODERATION
include/asm-generic/vmlinux.lds.h +1 -0
@@ -367,6 +367,7 @@ defined(CONFIG_AUTOFDO_CLANG) || defined(CONFIG_PROPELLER_CLANG)/* implement dynamic printk debug */ \ . = ALIGN(8); \ BOUNDED_SECTION_BY(__dyndbg_class_maps, ___dyndbg_class_maps) \ + BOUNDED_SECTION_BY(__dyndbg_class_users, ___dyndbg_class_users) \ BOUNDED_SECTION_BY(__dyndbg_descriptors, ___dyndbg_descs) \ CODETAG_SECTIONS() \LIKELY_PROFILE () \
include/linux/dynamic_debug.h +125 -13
197 lines not on this page · raw message
kernel/module/main.c +3 -0
@@ -2716,6 +2716,9 @@ static int find_module_sections(struct module *mod, struct load_info *info) mod->dyndbg_info.maps.start =section_objs (info,"__dyndbg_class_maps" ,sizeof (*mod->dyndbg_info.maps.start), &mod->dyndbg_info.maps.len); + mod->dyndbg_info.users.start =section_objs (info,"__dyndbg_class_users" , +sizeof (*mod->dyndbg_info.users.start), + &mod->dyndbg_info.users.len);#endif return 0 ;
lib/Kconfig.debug +19 -5
@@ -2979,12 +2979,26 @@ config TEST_STATIC_KEYS If unsure, say N. config TEST_DYNAMIC_DEBUG - tristate "Test DYNAMIC_DEBUG" - depends on DYNAMIC_DEBUG + tristate "Build test-dynamic-debug module" + depends on DYNAMIC_DEBUG || DYNAMIC_DEBUG_CORE help - This module registers a tracer callback to count enabled - pr_debugs in a 'do_debugging' function, then alters their - enablements, calls the function, and compares counts. + This module exercises/demonstrates dyndbg's classmap API, by + creating 2 classes: a DISJOINT classmap (supporting DRM.debug) + and a LEVELS/VERBOSE classmap (like verbose2 > verbose1). + + If unsure, say N. + +config TEST_DYNAMIC_DEBUG_SUBMOD + tristate "Build test-dynamic-debug submodule" + default m + depends on DYNAMIC_DEBUG || DYNAMIC_DEBUG_CORE + depends on TEST_DYNAMIC_DEBUG + help + This sub-module uses a classmap defined and exported by the + parent module, recapitulating drm & driver's shared use of + drm.debug to control enabled debug-categories. + It is tristate, independent of parent, to allow testing all + proper combinations of parent=y/m submod=y/m. If unsure, say N.
lib/Makefile +5 -0
@@ -82,6 +82,9 @@ obj-$(CONFIG_TEST_RHASHTABLE) += test_rhashtable.o obj-$(CONFIG_TEST_STATIC_KEYS) += test_static_keys.o obj-$(CONFIG_TEST_STATIC_KEYS) += test_static_key_base.o obj-$(CONFIG_TEST_DYNAMIC_DEBUG) += test_dynamic_debug.o +obj-$(CONFIG_TEST_DYNAMIC_DEBUG_SUBMOD) += test_dynamic_debug_submod.o +obj-$(CONFIG_TEST_PRINTF) += test_printf.o +obj-$(CONFIG_TEST_SCANF) += test_scanf.o obj-$(CONFIG_TEST_BITMAP) += test_bitmap.o ifeq ($(CONFIG_CC_IS_CLANG)$(CONFIG_KASAN),yy)
@@ -204,6 +207,8 @@ obj-$(CONFIG_ARCH_NEED_CMPXCHG_1_EMU) += cmpxchg-emu.o obj-$(CONFIG_DYNAMIC_DEBUG_CORE) += dynamic_debug.o #ensure exported functions have prototypes CFLAGS_dynamic_debug.o := -DDYNAMIC_DEBUG_MODULE +CFLAGS_test_dynamic_debug.o := -DDYNAMIC_DEBUG_MODULE +CFLAGS_test_dynamic_debug_submod.o := -DDYNAMIC_DEBUG_MODULE obj-$(CONFIG_SYMBOLIC_ERRNAME) += errname.o
lib/dynamic_debug.c +148 -24
282 lines not on this page · raw message
lib/test_dynamic_debug.c +96 -36
163 lines not on this page · raw message
lib/test_dynamic_debug_submod.c new file +14 -0
@@ -0,0 +1,14 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Kernel module for testing dynamic_debug +* +* Authors: +* Jim Cromie <[email protected]> +*/ + +/* +* clone the parent, inherit all the properties, for consistency and +* simpler accounting in test expectations. +*/ +#define TEST_DYNAMIC_DEBUG_SUBMOD +#include "test_dynamic_debug.c"
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 22/31 dyndbg: detect class_id reservation conflicts
In reply to Jim CromieIf a module _DEFINEs 2 or more classmaps, it must devise them to share the per-module 0..62 class-id space; ie their respective base,+length reservations cannot overlap.
To detect conflicts at modprobe, add ddebug_class_range_overlap(), call it from ddebug_add_module(), and WARN and return -EINVAL when they're detected.
This insures that class_id -> classname lookup has just 1 answer, so the 1st-found search in find-class-name works properly.
test_dynamic_debug.c:
If built with -DFORCE_CLASSID_CONFLICT, the test-modules invoke 2 conflicting DYNAMIC_DEBUG_CLASSMAP_DEFINE() declarations, into parent and the _submod. These conflict with one of the good ones in the parent (D2_CORE..etc), causing the modprobe(s) to warn
--- lib/dynamic_debug.c | 10 ++++++++++ lib/test_dynamic_debug.c | 8 ++++++++ 2 files changed, 18 insertions(+)
lib/dynamic_debug.c +10 -0
@@ -1317,6 +1317,7 @@ static int ddebug_add_module(struct _ddebug_info *di)struct ddebug_table *dt;struct _ddebug_class_map *cm;struct _ddebug_class_user *cli; +u64 reserved_ids =0 ;int i;if (!di->descs.len)
@@ -1341,6 +1342,11 @@ static int ddebug_add_module(struct _ddebug_info *di)dd_mark_vector_subrange (i, cli, &dt->info, users, dt);/* now di is stale */ +/* insure 2+ classmaps share the per-module 0..62 class_id space */ + for_subvec(i, cm, &dt->info, maps) +if (ddebug_class_range_overlap (cm, &reserved_ids)) + goto cleanup; +mutex_lock (&ddebug_lock);list_add_tail (&dt->link, &ddebug_tables);mutex_unlock (&ddebug_lock);
@@ -1353,6 +1359,10 @@ static int ddebug_add_module(struct _ddebug_info *di)vpr_info ("%3u debug prints in module %s\n" , dt->info.descs.len, dt->info.mod_name);return 0 ; +cleanup: +WARN_ONCE ("dyndbg multi-classmap conflict in %s\n" , di->mod_name); +kfree (dt); +return -EINVAL ; }/* helper for ddebug_dyndbg_(boot|module)_param_cb */
lib/test_dynamic_debug.c +8 -0
@@ -128,6 +128,14 @@ DYNAMIC_DEBUG_CLASSMAP_DEFINE(map_level_num, DD_CLASS_TYPE_LEVEL_NUM,DYNAMIC_DEBUG_CLASSMAP_PARAM (disjoint_bits, p);DYNAMIC_DEBUG_CLASSMAP_PARAM (level_num, p); +#ifdef FORCE_CLASSID_CONFLICT +/* +* Enable with -Dflag on compile to test overlapping class-id range +* detection. This should warn on modprobes. +*/ +DYNDBG_CLASSMAP_DEFINE (classid_range_conflict,0 ,D2_CORE +1 ,"D3_CORE" ); +#endif +#else /* TEST_DYNAMIC_DEBUG_SUBMOD */ /*
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 23/31 dyndbg: check DYNAMIC_DEBUG_CLASSMAP_DEFINE args at compile-time
In reply to Jim CromieAdd __DYNAMIC_DEBUG_CLASSMAP_CHECK to implement the following arg-checks at compile-time:
0 <= _base < 63 class_names is not empty class_names[0] is a string (class_names.length + _base) < 63
These compile-time checks will prevent several simple misuses, and will issue obvious errors if violated.
4 such examples are added to test_dynamic_debug_submod.ko, and will fail compilation if -DDD_MACRO_ARGCHECK is added to cflags. This wouldn't be a useful CONFIG_ item, since it breaks the build.
--- include/linux/dynamic_debug.h | 9 +++++++++ lib/test_dynamic_debug.c | 13 ++++++++++++- 2 files changed, 21 insertions(+), 1 deletion(-)
include/linux/dynamic_debug.h +9 -0
@@ -180,6 +180,14 @@ struct _ddebug_class_param {* __pr_debug_cls(22, "no such class"); compiles but is not reachable */ +#define __DYNAMIC_DEBUG_CLASSMAP_CHECK (_clnames, _base) \ + static_assert(((_base) >= 0 && (_base) < _DPRINTK_CLASS_DFLT), \ + "_base must be in 0..62"); \ + static_assert(ARRAY_SIZE(_clnames) > 0, \ + "classnames array size must be > 0"); \ + static_assert((ARRAY_SIZE(_clnames) + (_base)) < _DPRINTK_CLASS_DFLT, \ + "_base + classnames.length exceeds range") +/** * DYNAMIC_DEBUG_CLASSMAP_DEFINE - define debug classes used by a module. * @_var: name of the classmap, exported for other modules coordinated use.
@@ -193,6 +201,7 @@ struct _ddebug_class_param {*/ #define DYNAMIC_DEBUG_CLASSMAP_DEFINE (_var, _mapty, _base, ...) \ static const char *_var##_classnames[] = { __VA_ARGS__ }; \ + __DYNAMIC_DEBUG_CLASSMAP_CHECK(_var##_classnames, (_base)); \ extern struct _ddebug_class_map _var; \ struct _ddebug_class_map __aligned(8) __used \ __section("__dyndbg_class_maps") _var = { \
lib/test_dynamic_debug.c +12 -1
@@ -133,7 +133,7 @@ DYNAMIC_DEBUG_CLASSMAP_PARAM(level_num, p);* Enable with -Dflag on compile to test overlapping class-id range * detection. This should warn on modprobes. */ -DYNDBG_CLASSMAP_DEFINE (classid_range_conflict,0 ,D2_CORE +1 ,"D3_CORE" ); +DYNAMIC_DEBUG_CLASSMAP_DEFINE (classid_range_conflict,0 ,D2_CORE +1 ,"D3_CORE" );#endif #else /* TEST_DYNAMIC_DEBUG_SUBMOD */
@@ -146,8 +146,19 @@ DYNDBG_CLASSMAP_DEFINE(classid_range_conflict, 0, D2_CORE + 1, "D3_CORE");DYNAMIC_DEBUG_CLASSMAP_USE (map_disjoint_bits);DYNAMIC_DEBUG_CLASSMAP_USE (map_level_num); +#if defined(DD_MACRO_ARGCHECK ) +/* +* Exersize compile-time arg-checks in DYNAMIC_DEBUG_CLASSMAP_DEFINE. +* These will break compilation. +*/ +DYNAMIC_DEBUG_CLASSMAP_DEFINE (fail_base_neg,0 ,-1 ,"NEGATIVE_BASE_ARG" ); +DYNAMIC_DEBUG_CLASSMAP_DEFINE (fail_base_big,0 ,100 ,"TOOBIG_BASE_ARG" ); +DYNAMIC_DEBUG_CLASSMAP_DEFINE (fail_str_type,0 ,0 ,1 /* not a string */ ); +DYNAMIC_DEBUG_CLASSMAP_DEFINE (fail_emptyclass,0 ,0 /* ,empty */ );#endif +#endif /* TEST_DYNAMIC_DEBUG_SUBMOD */ +/* stand-in for all pr_debug etc */ #define prdbg (SYM ) __pr_debug_cls(SYM, #SYM " msg\n")
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 24/31 dyndbg-test: change do_prints testpoint to accept a loopct
In reply to Jim Cromieecho 1000 > /sys/module/test_dynamic_debug/parameters/do_prints
This allows its use as a scriptable load generator, to generate dynamic-prefix-emits for flag combinations vs undecorated messages. This will make it easy to assess the cost of the prefixing.
Reading the ./do_prints node also prints messages (once) to the-log.
--- lib/test_dynamic_debug.c | 32 +++++++++++++++++++++----------- 1 file changed, 21 insertions(+), 11 deletions(-)
lib/test_dynamic_debug.c +21 -11
@@ -29,18 +29,25 @@#include <linux/module.h> -/* re-gen output by reading or writing sysfs node: do_prints */ - -static void do_prints (void );/* device under test */ +/* re-trigger debug output by reading or writing sysfs node: do_prints */ +static void do_prints (unsigned int );/* device under test */ static int param_set_do_prints (const char *instr,const struct kernel_param *kp) { -do_prints (); +int rc; +unsigned int ct; + + rc =kstrtouint (instr,0 , &ct); +if (rc) { +pr_err ("expecting numeric input, using 1 instead\n" ); + ct =1 ; + } +do_prints (ct);return 0 ; }static int param_get_do_prints (char *buffer,const struct kernel_param *kp) { -do_prints (); -return scnprintf (buffer,PAGE_SIZE ,"did do_prints\n" ); +do_prints (1 ); +return scnprintf (buffer,PAGE_SIZE ,"did 1 do_prints\n" ); }static const struct kernel_param_ops param_ops_do_prints = { .set = param_set_do_prints,
@@ -191,17 +198,20 @@ static void do_levels(void)prdbg (V7 ); } -static void do_prints (void ) +static void do_prints (unsigned int ct) { -pr_debug ("do_prints:\n" ); -do_cats (); -do_levels (); +/* maybe clamp this */ +pr_debug ("do-prints %d times:\n" , ct); +for (; ct; ct--) { +do_cats (); +do_levels (); + } }static int __init test_dynamic_debug_init (void ) {pr_debug ("init start\n" ); -do_prints (); +do_prints (1 );pr_debug ("init done\n" );return 0 ; }
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 25/31 dyndbg-API: promote DYNAMIC_DEBUG_CLASSMAP_PARAM to API
In reply to Jim Cromiemove the DYNAMIC_DEBUG_CLASSMAP_PARAM macro from test-dynamic-debug.c into the header, and refine it, by distinguishing the 2 use cases:
1.DYNAMIC_DEBUG_CLASSMAP_PARAM_REF
for DRM, to pass in extern __drm_debug by name. dyndbg keeps bits in it, so drm can still use it as before
2.DYNAMIC_DEBUG_CLASSMAP_PARAM
new user (test_dynamic_debug) doesn't need to share state, decls a static long unsigned int to store the bitvec.
__DYNAMIC_DEBUG_CLASSMAP_PARAM
bottom layer - allocate,init a ddebug-class-param, module-param-cb.
Modify ddebug_sync_classbits() argtype deref inside the fn, to give access to all kp members.
Also add stub macros, clean up and improve comments in test-code, and add MODULE_DESCRIPTIONs.
--- include/linux/dynamic_debug.h | 40 ++++++++++++++++++++++ lib/dynamic_debug.c | 60 ++++++++++++++++++++++----------- lib/test_dynamic_debug.c | 47 ++++++++++---------------- lib/test_dynamic_debug_submod.c | 9 ++++- 4 files changed, 106 insertions(+), 50 deletions(-)
include/linux/dynamic_debug.h +40 -0
@@ -250,6 +250,44 @@ struct _ddebug_class_param { .offset = _offset \ } +/** +* DYNAMIC_DEBUG_CLASSMAP_PARAM - control a ddebug-classmap from a sys-param +* @_name: sysfs node name +* @_var: name of the classmap var defining the controlled classes/bits +* @_flags: flags to be toggled, typically just 'p' +* +* Creates a sysfs-param to control the classes defined by the +* exported classmap, with bits 0..N-1 mapped to the classes named. +* This version keeps class-state in a private long int. +*/ +#define DYNAMIC_DEBUG_CLASSMAP_PARAM (_name, _var, _flags) \ + static unsigned long _name##_bvec; \ + __DYNAMIC_DEBUG_CLASSMAP_PARAM(_name, _name##_bvec, _var, _flags) + +/** +* DYNAMIC_DEBUG_CLASSMAP_PARAM_REF - wrap a classmap with a controlling sys-param +* @_name: sysfs node name +* @_bits: name of the module's unsigned long bit-vector, ex: __drm_debug +* @_var: name of the (exported) classmap var defining the classes/bits +* @_flags: flags to be toggled, typically just 'p' +* +* Creates a sysfs-param to control the classes defined by the +* exported clasmap, with bits 0..N-1 mapped to the classes named. +* This version keeps class-state in user @_bits. This lets drm check +* __drm_debug elsewhere too. +*/ +#define DYNAMIC_DEBUG_CLASSMAP_PARAM_REF (_name, _bits, _var, _flags) \ + __DYNAMIC_DEBUG_CLASSMAP_PARAM(_name, _bits, _var, _flags) + +#define __DYNAMIC_DEBUG_CLASSMAP_PARAM (_name, _bits, _var, _flags) \ + static struct _ddebug_class_param _name##_##_flags = { \ + .bits = &(_bits), \ + .flags = #_flags, \ + .map = &(_var), \ + }; \ + module_param_cb(_name, ¶m_ops_dyndbg_classes, \ + &_name##_##_flags, 0600) + extern __printf(2, 3) void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...);
@@ -422,6 +460,8 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor,#define DYNAMIC_DEBUG_CLASSMAP_DEFINE (_var, _mapty, _base, ...)#define DYNAMIC_DEBUG_CLASSMAP_USE (_var) +#define DYNAMIC_DEBUG_CLASSMAP_PARAM (_name, _var, _flags) +#define DYNAMIC_DEBUG_CLASSMAP_PARAM_REF (_name, _var, _flags)#define DEFINE_DYNAMIC_DEBUG_METADATA (name, fmt)#define DYNAMIC_DEBUG_BRANCH (descriptor) false#define DECLARE_DYNDBG_CLASSMAP (...)
lib/dynamic_debug.c +41 -19
88 lines not on this page · raw message
lib/test_dynamic_debug.c +17 -30
88 lines not on this page · raw message
lib/test_dynamic_debug_submod.c +8 -1
@@ -1,6 +1,9 @@// SPDX-License-Identifier: GPL-2.0 /* -* Kernel module for testing dynamic_debug +* Kernel module to test/demonstrate dynamic_debug features, +* particularly classmaps and their support for subsystems, like DRM, +* which defines its drm_debug classmap in drm module, and uses it in +* helpers & drivers. * * Authors: * Jim Cromie <[email protected]>
@@ -12,3 +15,7 @@*/ #define TEST_DYNAMIC_DEBUG_SUBMOD #include "test_dynamic_debug.c" + +MODULE_DESCRIPTION ("test/demonstrate dynamic-debug subsystem support" ); +MODULE_AUTHOR ("Jim Cromie <[email protected]>" ); +MODULE_LICENSE ("GPL" );
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 26/31 dyndbg: treat comma as a token separator
In reply to Jim CromieTreat comma as a token terminator, just like a space. This allows a user to avoid quoting hassles when spaces are otherwise needed:
:#> modprobe drm dyndbg=class,DRM_UT_CORE,+p\;class,DRM_UT_KMS,+p
or as a boot arg:
drm.dyndbg=class,DRM_UT_CORE,+p # todo: support multi-query here
Given the many ways a boot-line +args can be assembled and then passed in/down/around shell based tools, this may allow side-stepping all sorts of quoting hassles thru those layers.
existing query format:
modprobe test_dynamic_debug dyndbg="class D2_CORE +p"
new format:
modprobe test_dynamic_debug dyndbg=class,D2_CORE,+p
ALSO
selftests-dyndbg: add comma_terminator_tests
New fn validates parsing and effect of queries using combinations of commas and spaces to delimit the tokens.
It manipulates pr-debugs in builtin module/params, so might have deps I havent foreseen on odd configurations.
--- .../admin-guide/dynamic-debug-howto.rst | 9 +++++--- lib/dynamic_debug.c | 17 +++++++++++---- .../dynamic_debug/dyndbg_selftest.sh | 21 ++++++++++++++++++- 3 files changed, 39 insertions(+), 8 deletions(-)
Documentation/admin-guide/dynamic-debug-howto.rst +6 -3
@@ -78,11 +78,12 @@ Command Language Reference ========================== At the basic lexical level, a command is a sequence of words separated -by spaces or tabs. So these are all equivalent:: +by spaces, tabs, or commas. So these are all equivalent:: :#> ddcmd file svcsock.c line 1603 +p :#> ddcmd "file svcsock.c line 1603 +p" :#> ddcmd ' file svcsock.c line 1603 +p ' + :#> ddcmd file,svcsock.c,line,1603,+p Command submissions are bounded by a write() system call. Multiple commands can be written together, separated by ``;`` or ``\n``::
@@ -167,9 +168,11 @@ module The given string is compared against the module name of each callsite. The module name is the string as seen in ``lsmod``, i.e. without the directory or the ``.ko`` - suffix and with ``-`` changed to ``_``. Examples:: + suffix and with ``-`` changed to ``_``. - module sunrpc + Examples:: + + module,sunrpc # with ',' as token separator module nfsd module drm* # both drm, drm_kms_helper
lib/dynamic_debug.c +13 -4
@@ -320,6 +320,14 @@ static int ddebug_change(const struct ddebug_query *query, struct flag_settingsreturn nfound; } +static char *skip_spaces_and_commas (const char *str) +{ + str =skip_spaces (str); +while (*str ==',' ) + str =skip_spaces (++str); +return (char *)str; +} +/* * Split the buffer `buf' into space-separated words. * Handles simple " and ' quoting, i.e. without nested,
@@ -333,8 +341,8 @@ static int ddebug_tokenize(char *buf, char *words[], int maxwords)while (*buf) {char *end; -/* Skip leading whitespace */ - buf =skip_spaces (buf); +/* Skip leading whitespace and comma */ + buf =skip_spaces_and_commas (buf);if (!*buf)break ;/* oh, it was trailing whitespace */ if (*buf =='#' )
@@ -350,7 +358,7 @@ static int ddebug_tokenize(char *buf, char *words[], int maxwords)return -EINVAL ;/* unclosed quote */ } }else { -for (end = buf; *end && !isspace (*end); end++) +for (end = buf; *end && !isspace (*end) && *end !=',' ; end++) ;if (end == buf) { pr_err("parse err after word:%d=%s\n", nwords,
@@ -622,7 +630,8 @@ static int ddebug_exec_queries(char *query, const char *modname)if (split) *split++ ='\0' ; - query =skip_spaces (query); + query =skip_spaces_and_commas (query); +if (!query || !*query || *query =='#' )continue ;
tools/testing/selftests/dynamic_debug/dyndbg_selftest.sh +20 -1
@@ -216,7 +216,7 @@ function check_err_msg() { function basic_tests { echo -e "${GREEN}# BASIC_TESTS ${NC}" if [ $LACK_DD_BUILTIN -eq 1 ]; then - echo "SKIP" + echo "SKIP - test requires params, which is a builtin module" return fi ddcmd =_ # zero everything
@@ -238,8 +238,27 @@ EOF ddcmd =_ } +function comma_terminator_tests { + echo -e "${GREEN}# COMMA_TERMINATOR_TESTS ${NC}" + if [ $LACK_DD_BUILTIN -eq 1 ]; then + echo "SKIP - test requires params, which is a builtin module" + return + fi + # try combos of spaces & commas + check_match_ct '\[params\]' 4 -r + ddcmd module,params,=_ # commas as spaces + ddcmd module,params,+mpf # turn on module's pr-debugs + check_match_ct =pmf 4 + ddcmd ,module ,, , params, -p + check_match_ct =mf 4 + ddcmd " , module ,,, , params, -m" # + check_match_ct =f 4 + ddcmd =_ +} + tests_list=( basic_tests + comma_terminator_tests ) # Run tests
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 27/31 dyndbg: split multi-query strings with %
In reply to Jim CromieSince commit85f7f6c0edb8 ("dynamic_debug: process multiple debug-queries on a line")
Multi-query commands have been allowed:
modprobe drm dyndbg="class DRM_UT_CORE +p; class DRM_UT_KMS +p" modprobe drm dyndbg=<<EOX
class DRM_UT_CORE +p
class DRM_UT_KMS +p
EOX
More recently, the need for quoting was avoided by treating a comma like a space/token-terminator:
modprobe drm dyndbg=class,DRM_UT_CORE,+p\;class,DRM_UT_KMS,+p
That works, but it needs the escaped semicolon, which is a shell special-char (one of the bash control operators), so it is brittle when passed in/down/around scripts. In particular, it fails when passed to vng (virtme-ng).
So this patch adds '%' to the existing ';' and '\n' multi-command separators, which is more shell-friendly, so you can more fully avoid quoting and escaping hassles.
NOTE: it does break format matching on '%' patterns:
bash-5.2# ddcmd 'format "find-me: %foo" +p'
[ 203.900581] dyndbg: read 26 bytes from userspace [ 203.900883] dyndbg: query 0: "format "find-me: " mod:* [ 203.901118] dyndbg: unclosed quote: find-me: [ 203.901355] dyndbg: tokenize failed [ 203.901529] dyndbg: query 1: "foo" +p" mod:* [ 203.901957] dyndbg: split into words: "foo"" "+p" [ 203.902243] dyndbg: op='+' flags=0x1 maskp=0xffffffff [ 203.902458] dyndbg: expecting pairs of match-spec <value> [ 203.902703] dyndbg: query parse failed [ 203.902871] dyndbg: processed 2 queries, with 0 matches, 2 errs
bash: echo: write error: Invalid argument
The '%' splits the input into 2 queries, and both fail. Given the limited utility of matching against the working parts of a format string "foo: %d bar %s", nothing is actually lost here.
selftests-dyndbg: test_percent_splitting
This does basic testing of classmaps using '%' separated multi-queries. It modprobes test_dynamic_debug with several classes enabled, and counts to verify that the expected sites show the enablement in the control file.
--- .../admin-guide/dynamic-debug-howto.rst | 8 ++++--- lib/dynamic_debug.c | 2 +- .../dynamic_debug/dyndbg_selftest.sh | 24 +++++++++++++++++++ 3 files changed, 30 insertions(+), 4 deletions(-)
Documentation/admin-guide/dynamic-debug-howto.rst +5 -3
@@ -85,10 +85,12 @@ by spaces, tabs, or commas. So these are all equivalent:: :#> ddcmd ' file svcsock.c line 1603 +p ' :#> ddcmd file,svcsock.c,line,1603,+p -Command submissions are bounded by a write() system call. -Multiple commands can be written together, separated by ``;`` or ``\n``:: +Command submissions are bounded by a write() system call. Multiple +commands can be written together, separated by ``%``, ``;`` or ``\n``:: - :#> ddcmd "func pnpacpi_get_resources +p; func pnp_assign_mem +p" + :#> ddcmd func foo +p % func bar +p + :#> ddcmd func foo +p \; func bar +p + :#> ddcmd "func foo +p ; func bar +p" :#> ddcmd <<"EOC" func pnpacpi_get_resources +p func pnp_assign_mem +p
lib/dynamic_debug.c +1 -1
@@ -626,7 +626,7 @@ static int ddebug_exec_queries(char *query, const char *modname)int i, errs =0 , exitcode =0 , rc, nfound =0 ;for (i =0 ; query; query = split) { - split =strpbrk (query,";\n" ); + split =strpbrk (query,"%;\n" );if (split) *split++ ='\0' ;
tools/testing/selftests/dynamic_debug/dyndbg_selftest.sh +24 -0
@@ -256,9 +256,33 @@ function comma_terminator_tests { ddcmd =_ } +function test_percent_splitting { + echo -e "${GREEN}# TEST_PERCENT_SPLITTING - multi-command splitting on % ${NC}" + if [ $LACK_TMOD -eq 1 ]; then + echo "SKIP - test requires test-dynamic-debug.ko" + return + fi + ifrmmod test_dynamic_debug_submod + ifrmmod test_dynamic_debug + ddcmd =_ + modprobe test_dynamic_debug dyndbg=class,D2_CORE,+pf%class,D2_KMS,+pt%class,D2_ATOMIC,+pm + check_match_ct =pf 1 + check_match_ct =pt 1 + check_match_ct =pm 1 + check_match_ct test_dynamic_debug 23 -r + # add flags to those callsites + ddcmd class,D2_CORE,+mf%class,D2_KMS,+lt%class,D2_ATOMIC,+ml + check_match_ct =pmf 1 + check_match_ct =plt 1 + check_match_ct =pml 1 + check_match_ct test_dynamic_debug 23 -r + ifrmmod test_dynamic_debug +} + tests_list=( basic_tests comma_terminator_tests + test_percent_splitting ) # Run tests
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 28/31 selftests-dyndbg: add test_mod_submod
In reply to Jim CromieThis new test-fn runs 3 module/submodule modprobe scenarios, variously using both the generic dyndbg=<queries> modprobe arg, and the test-module's classmap-params to manipulate the test-mod*'s pr_debugs. In all cases, the current flag-settings are counted and tested vs expectations.
The 3rd scenario recapitulates the DRM_USE_DYNAMIC_DEBUG=y failure.
1. 2 modprobes (super then sub), with separate dyndbg=class-settings check module specific flag settings
2. modprobe submod, supermod is auto-loaded
set supermod class-params
check expected enablements in super & submod
3. modprobe super, with param=setting (like drm.debug=0x1ef) modprobe submod
validate submod's class'd pr_debugs get properly enabled
The test uses multi-queries, with both commas and percents (to avoid spaces and quoting). This is the main reason the test wasn't earlier in the patchset, closer to the classmap patches its validating.
With some tedium, the tests could be refactored to split out early tests which avoid multi-cmds, and test only the class-params.
--- .../dynamic_debug/dyndbg_selftest.sh | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+)
tools/testing/selftests/dynamic_debug/dyndbg_selftest.sh +73 -0
@@ -279,10 +279,83 @@ function test_percent_splitting { ifrmmod test_dynamic_debug } +function test_mod_submod { + echo -e "${GREEN}# TEST_MOD_SUBMOD ${NC}" + if [ $LACK_TMOD -eq 1 ]; then + echo "SKIP - test requires test-dynamic-debug.ko" + return + fi + ifrmmod test_dynamic_debug_submod + ifrmmod test_dynamic_debug + ddcmd =_ + + # modprobe with class enablements + modprobe test_dynamic_debug \ + dyndbg=class,D2_CORE,+pf%class,D2_KMS,+pt%class,D2_ATOMIC,+pm + + check_match_ct '\[test_dynamic_debug\]' 23 -r + check_match_ct =pf 1 + check_match_ct =pt 1 + check_match_ct =pm 1 + + modprobe test_dynamic_debug_submod + check_match_ct test_dynamic_debug_submod 23 -r + check_match_ct '\[test_dynamic_debug\]' 23 -r + check_match_ct test_dynamic_debug 46 -r + + # no enablements propagate here + check_match_ct =pf 1 + check_match_ct =pt 1 + check_match_ct =pm 1 + + # change classes again, this time submod too + ddcmd class,D2_CORE,+mf%class,D2_KMS,+lt%class,D2_ATOMIC,+ml "# add some prefixes" + check_match_ct =pmf 1 + check_match_ct =plt 1 + check_match_ct =pml 1 + # submod changed too + check_match_ct =mf 1 + check_match_ct =lt 1 + check_match_ct =ml 1 + + # now work the classmap-params + # fresh start, to clear all above flags (test-fn limits) + ifrmmod test_dynamic_debug_submod + ifrmmod test_dynamic_debug + modprobe test_dynamic_debug_submod # get supermod too + + echo 1 > /sys/module/test_dynamic_debug/parameters/p_disjoint_bits + echo 4 > /sys/module/test_dynamic_debug/parameters/p_level_num + # 2 mods * ( V1-3 + D2_CORE ) + check_match_ct =p 8 + echo 3 > /sys/module/test_dynamic_debug/parameters/p_disjoint_bits + echo 0 > /sys/module/test_dynamic_debug/parameters/p_level_num + # 2 mods * ( D2_CORE, D2_DRIVER ) + check_match_ct =p 4 + echo 0x16 > /sys/module/test_dynamic_debug/parameters/p_disjoint_bits + echo 0 > /sys/module/test_dynamic_debug/parameters/p_level_num + # 2 mods * ( D2_DRIVER, D2_KMS, D2_ATOMIC ) + check_match_ct =p 6 + + # recap DRM_USE_DYNAMIC_DEBUG regression + ifrmmod test_dynamic_debug_submod + ifrmmod test_dynamic_debug + # set super-mod params + modprobe test_dynamic_debug p_disjoint_bits=0x16 p_level_num=5 + check_match_ct =p 7 + modprobe test_dynamic_debug_submod + # see them picked up by submod + check_match_ct =p 14 + ifrmmod test_dynamic_debug_submod + ifrmmod test_dynamic_debug +} + tests_list=( basic_tests + # these require test_dynamic_debug*.ko comma_terminator_tests test_percent_splitting + test_mod_submod ) # Run tests
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 29/31 dyndbg: resolve "protection" of class'd pr_debug
In reply to Jim Cromieclassmap-v1 code protected class'd pr_debugs from unintended changes by unclassed/_DFLT queries:
# - to declutter examples:
alias ddcmd='echo $* > /proc/dynamic_debug/control'
# IOW, this should NOT alter drm.debug settings
ddcmd -p
# Instead, you must name the class to change it. # Protective but tedious
ddcmd class DRM_UT_CORE +p
# Or do it the (old school) subsystem way
# This is ABI !!
echo 1 > /sys/module/drm/parameters/debug
Since the debug sysfs-node is ABI, if dyndbg is going to implement it, it must also honor its settings; it must at least protect against accidental changes to its classes from legacy queries.
The protection allows all previously conceived queries to work the way they always have; ie select the same set of pr_debugs, despite the inclusion of whole new classes of pr_debugs.
But that choice has 2 downsides:
1. "name the class to change it" makes a tedious long-winded interface, needing many commands to set DRM_UT_* one at a time.
2. It makes the class keyword special in some sense; the other keywords skip only on query mismatch, otherwise the code falls thru to adjust the pr-debug site.
Jason Baron didn't like v1 on point 2.
Louis Chauvet didn't like recent rev on point 1 tedium.
But that said: /sys/ is ABI, so this must be reliable:
#> echo 0x1f > /sys/module/drm/parameters/debug
It 'just works' without dyndbg underneath; we must deliver that same stability. Convenience is secondary.
The new resolution:
If ABI is the blocking issue, then no ABI means no blocking issue. IOW, if the classmap has no presence under /sys/*, ie no PARAM, there is no ABI to guard, and no reason to enforce a tedious interface.
In the future, if DRM wants to alter this protection, that is practical, but I think default-on is the correct mode.
So atm classes without a PARAM are unprotected at >control, allowing admins their shortcuts. I think this could satisfy all viewpoints.
That said, theres also a possibility of wildcard classes:
#> ddcmd class '*' +p
Currently, the query-class is exact-matched against each module's classmaps.names. This gives precise behavior, a good basis.
But class wildcards are possible, they just did'nt appear useful for DRM, whose classmap names are a flat DRM_UT_* namespace.
IOW, theres no useful selectivity there:
#> ddcmd class "DRM_*" +p # these enable every DRM_* class
#> ddcmd class "DRM_UT_*" +p
#> ddcmd class "DRM_UT_V*" +p # finally select just 1: DRM_UT_VBL
#> ddcmd class "DRM_UT_D*" +p # but this gets 3
#> ddcmd class "D*V*" +p # here be dragons
But there is debatable utility in the feature.
#> ddcmd class __DEFAULT__ -p # what about this ?
#> ddcmd -p # thats what this does. automatically
Anyway, this patch does:
1. adds link field from _ddebug_class_map to the .controlling_param
2. sets it in ddebug_match_apply_kparam(), during modprobe/init, when options like drm.debug=VAL are handled.
3. ddebug_class_has_param() now checks .controlling_param
4. ddebug_class_wants_protection() macro renames 3. this frames it as a separable policy decision
5. ddebug_match_desc() gets the most attention:
a. move classmap consideration to the bottom
this insures all other constraints act 1st.
allows simpler 'final' decisions.
b. split class choices cleanly on query:
class FOO vs none, and class'd vs _DPRINTK_CLASS_DFLT site.
c. calls 4 when applying a class-less query to a class'd pr_debug
here we need a new fn to find the classmap with this .class_id
d. calls new ddebug_find_classmap_by_class_id().
when class-less query looks at a class'd pr_debug.
finds classmap, which can then decide, currently by PARAM existence.
NOTES:
protection is only against class-less queries, explicit "class FOO" adjustments are allowed (that is the mechanism).
The drm.debug sysfs-node heavily under-specifies the class'd pr_debugs it controls; none of the +mfls prefixing flags have any effect, and each callsite remains individually controllable. drm.debug just toggles the +p flag for all the modules' class'd pr_debugs.
--- include/linux/dynamic_debug.h | 14 ++-- lib/dynamic_debug.c | 127 +++++++++++++++++++++++++++------- 2 files changed, 110 insertions(+), 31 deletions(-)
include/linux/dynamic_debug.h +9 -5
@@ -75,6 +75,7 @@ enum ddebug_class_map_type {* map @class_names 0..N to consecutive constants starting at @base. */ struct _ddebug_class_map { +struct _ddebug_class_param *controlling_param;const struct module *mod;/* NULL for builtins */ const char *mod_name;const char **class_names;
@@ -258,7 +259,12 @@ struct _ddebug_class_param {* * Creates a sysfs-param to control the classes defined by the * exported classmap, with bits 0..N-1 mapped to the classes named. -* This version keeps class-state in a private long int. +* +* Since sysfs-params are ABI, this also protects the classmap'd +* pr_debugs from un-class'd `echo -p > /proc/dynamic_debug/control` +* changes. +* +* This keeps class-state in a private long int. */ #define DYNAMIC_DEBUG_CLASSMAP_PARAM (_name, _var, _flags) \ static unsigned long _name##_bvec; \
@@ -271,10 +277,8 @@ struct _ddebug_class_param {* @_var: name of the (exported) classmap var defining the classes/bits * @_flags: flags to be toggled, typically just 'p' * -* Creates a sysfs-param to control the classes defined by the -* exported clasmap, with bits 0..N-1 mapped to the classes named. -* This version keeps class-state in user @_bits. This lets drm check -* __drm_debug elsewhere too. +* Like DYNAMIC_DEBUG_CLASSMAP_PARAM, but maintains param-state in +* extern @_bits. This lets DRM check __drm_debug elsewhere too. */ #define DYNAMIC_DEBUG_CLASSMAP_PARAM_REF (_name, _bits, _var, _flags) \ __DYNAMIC_DEBUG_CLASSMAP_PARAM(_name, _bits, _var, _flags)
lib/dynamic_debug.c +101 -26
207 lines not on this page · raw message
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 30/31 dyndbg: add DYNAMIC_DEBUG_CLASSMAP_USE_(dd_class_name, offset)
In reply to Jim CromieAllow a module to use 2 classmaps together that would otherwise have a class_id range conflict.
Suppose a drm-driver does:
DYNAMIC_DEBUG_CLASSMAP_USE(drm_debug_classes); DYNAMIC_DEBUG_CLASSMAP_USE(drm_accel_xfer_debug);
If (for some reason) drm-accel will not define their constants to avoid DRM's 0..10 reservations, we have a reserved-ids conflict. This seems unlikely.
I don't think this potential conflict would become an issue until we have at least a 3-X-3 of classmap-defns X classmap-users.
This is an untested interface extension, so drop this patch if it feels too speculative, knowing theres at least a notional solution should the situation arise.
--- include/linux/dynamic_debug.h | 27 ++++++++++++++++++++++----- lib/dynamic_debug.c | 19 ++++++++++++------- 2 files changed, 34 insertions(+), 12 deletions(-)
include/linux/dynamic_debug.h +22 -5
@@ -87,7 +87,7 @@ struct _ddebug_class_map {struct _ddebug_class_user {char *mod_name;struct _ddebug_class_map *map; -const int offset;/* user offset to re-number the used map */ +const int offset;/* offset from map->base */ };/*
@@ -238,11 +238,28 @@ struct _ddebug_class_param {* * This tells dyndbg that the module has prdbgs with classids defined * in the named classmap. This qualifies "class NAME" >controls on -* the user module, and ignores unknown names. +* the user module, and ignores unknown names. This is a wrapper for +* DYNAMIC_DEBUG_CLASSMAP_USE_() with a base offset of 0. */ -#define DYNAMIC_DEBUG_CLASSMAP_USE (_var) \ - DYNAMIC_DEBUG_CLASSMAP_USE_(_var, 0, __UNIQUE_ID(_ddebug_class_user)) -#define DYNAMIC_DEBUG_CLASSMAP_USE_ (_var, _offset, _uname) \ +#define DYNAMIC_DEBUG_CLASSMAP_USE (_var) \ + DYNAMIC_DEBUG_CLASSMAP_USE_(_var, 0) + +/** +* DYNAMIC_DEBUG_CLASSMAP_USE_ - refer to a classmap with a manual offset. +* @_var: name of the exported classmap var to use. +* @_offset: an integer offset to add to the class IDs of the used map. +* +* This is an extended version of DYNAMIC_DEBUG_CLASSMAP_USE(). It should +* only be used to resolve class ID conflicts when a module uses multiple +* classmaps that have overlapping ID ranges. +* +* The final class IDs for the used map will be calculated as: +* original_map_base + class_index + @_offset. +*/ +#define DYNAMIC_DEBUG_CLASSMAP_USE_ (_var, _offset) \ + __DYNAMIC_DEBUG_CLASSMAP_USE(_var, _offset, __UNIQUE_ID(_ddebug_class_user)) + +#define __DYNAMIC_DEBUG_CLASSMAP_USE (_var, _offset, _uname) \ extern struct _ddebug_class_map _var; \ static struct _ddebug_class_user __aligned(8) __used \ __section("__dyndbg_class_users") _uname = { \
lib/dynamic_debug.c +12 -7
@@ -198,7 +198,7 @@ ddebug_find_valid_class(struct _ddebug_info const *di, const char *query_class,if (idx >=0 ) {vpr_di_info (di,"class-ref: %s -> %s.%s " , cli->mod_name, cli->map->mod_name, query_class); - *class_id = idx + cli->map->base; + *class_id = idx + cli->map->base - cli->offset;return cli->map; } }
@@ -206,12 +206,17 @@ ddebug_find_valid_class(struct _ddebug_info const *di, const char *query_class,return NULL ; } -static bool ddebug_class_in_range (const int class_id,const struct _ddebug_class_map *map) +static bool ddebug_class_map_in_range (const int class_id,const struct _ddebug_class_map *map) {return (class_id >= map->base && class_id < map->base + map->length); } +static bool ddebug_class_user_in_range (const int class_id,const struct _ddebug_class_user *user) +{ +return ddebug_class_map_in_range (class_id - user->offset, user->map); +} +static struct _ddebug_class_map *ddebug_find_map_by_class_id (struct _ddebug_info *di,int class_id) {
@@ -220,11 +225,11 @@ ddebug_find_map_by_class_id(struct _ddebug_info *di, int class_id)int i; for_subvec(i, map, di, maps) -if (ddebug_class_in_range (class_id, map)) +if (ddebug_class_map_in_range (class_id, map))return map; for_subvec(i, cli, di, users) -if (ddebug_class_in_range (class_id, cli->map)) +if (ddebug_class_user_in_range (class_id, cli))return cli->map;return NULL ;
@@ -1177,12 +1182,12 @@ static const char *ddebug_class_name(struct _ddebug_info *di, struct _ddebug *dpint i; for_subvec(i, map, di, maps) -if (ddebug_class_in_range (dp->class_id, map)) +if (ddebug_class_map_in_range (dp->class_id, map))return map->class_names[dp->class_id - map->base]; for_subvec(i, cli, di, users) -if (ddebug_class_in_range (dp->class_id, cli->map)) -return cli->map->class_names[dp->class_id - cli->map->base]; +if (ddebug_class_user_in_range (dp->class_id, cli)) +return cli->map->class_names[dp->class_id - cli->map->base - cli->offset];return NULL ; }
Signature · 1 line
2.52.0
Jim Cromie
maintainerPATCH v8 31/31 docs/dyndbg: add classmap info to howto
In reply to Jim CromieDescribe the 3 API macros providing dynamic_debug's classmaps
DYNAMIC_DEBUG_CLASSMAP_DEFINE - create & export a classmapDYNAMIC_DEBUG_CLASSMAP_USE - refer to exported mapDYNAMIC_DEBUG_CLASSMAP_PARAM - bind control param to the classmap DYNAMIC_DEBUG_CLASSMAP_PARAM_REF + use module's storage - __drm_debug
NB: The _DEFINE & _USE model makes the user dependent on the definer, just like EXPORT_SYMBOL(__drm_debug) already does.
--- .../admin-guide/dynamic-debug-howto.rst | 135 ++++++++++++++++-- 1 file changed, 123 insertions(+), 12 deletions(-)
Documentation/admin-guide/dynamic-debug-howto.rst +123 -12
@@ -146,6 +146,9 @@ keywords are:: "1-30" is valid range but "1 - 30" is not. +Keywords +-------- + The meanings of each keyword are: func
@@ -194,16 +197,6 @@ format format "nfsd: SETATTR" // a neater way to match a format with whitespace format 'nfsd: SETATTR' // yet another way to match a format with whitespace -class - The given class_name is validated against each module, which may - have declared a list of known class_names. If the class_name is - found for a module, callsite & class matching and adjustment - proceeds. Examples:: - - class DRM_UT_KMS # a DRM.debug category - class JUNK # silent non-match - // class TLD_* # NOTICE: no wildcard in class names - line The given line number or range of line numbers is compared against the line number of each ``pr_debug()`` callsite. A single
@@ -218,6 +211,25 @@ line line -1605 // the 1605 lines from line 1 to line 1605 line 1600- // all lines from line 1600 to the end of the file +class + + The given class_name is validated against each module, which may + have declared a list of class_names it accepts. If the class_name + accepted by a module, callsite & class matching and adjustment + proceeds. Examples:: + + class DRM_UT_KMS # a drm.debug category + class JUNK # silent non-match + // class TLD_* # NOTICE: no wildcard in class names + +.. note:: + + Unlike other keywords, classes are "name-to-change", not + "omitting-constraint-allows-change". See Dynamic Debug Classmaps + +Flags +----- + The flags specification comprises a change operation followed by one or more flag characters. The change operation is one of the characters::
@@ -238,11 +250,15 @@ The flags are:: s Include the source file name l Include line number +.. note:: + + * To query without changing ``+_`` or ``-_``. + * To clear all flags ``=_`` or ``-fslmpt``. + For ``print_hex_dump_debug()`` and ``print_hex_dump_bytes()``, only the ``p`` flag has meaning, other flags are ignored. -Note the regexp ``^[-+=][fslmpt_]+$`` matches a flags specification. -To clear all flags at once, use ``=_`` or ``-fslmpt``. +The regexp ``^[-+=][fslmpt_]+$`` matches a flags specification. Debug messages during Boot Process
@@ -394,3 +410,98 @@ just a shortcut for ``print_hex_dump(KERN_DEBUG)``. For ``print_hex_dump_debug()``/``print_hex_dump_bytes()``, format string is its ``prefix_str`` argument, if it is constant string; or ``hexdump`` in case ``prefix_str`` is built dynamically. + +.. _dyndbg-classmaps: + +Dynamic Debug Classmaps +======================= + +The "class" keyword selects prdbgs based on author supplied, +domain-oriented names. This complements the nested-scope keywords: +module, file, function, line. + +The main difference from the others: classes must be named to be +changed. This protects them from unintended overwrite:: + + # IOW this cannot undo any drm.debug settings + :#> ddcmd -p + +This protection is needed; /sys/module/drm/parameters/debug is ABI. +drm.debug is authoritative when dyndbg is not used, dyndbg-under-DRM +is an implementation detail, and must not behave erratically, just +because another admin fed >control something unrelated. + +So each class must be enabled individually (no wildcards):: + + :#> ddcmd class DRM_UT_CORE +p + :#> ddcmd class DRM_UT_KMS +p + # or more selectively + :#> ddcmd class DRM_UT_CORE module drm +p + +That makes direct >control wordy and annoying, but it is a secondary +interface; it is not intended to replace the ABI, just slide in +underneath and reimplement the guaranteed behavior. So DRM would keep +using the convenient way, and be able to trust it:: + + :#> echo 0x1ff > /sys/module/drm/parameters/debug + +That said, since the sysfs/kparam is the ABI, if the author omits the +CLASSMAP_PARAM, theres no ABI to guard, and he probably wants a less +pedantic >control interface. In this case, protection is dropped. + +Dynamic Debug Classmap API +========================== + +DYNAMIC_DEBUG_CLASSMAP_DEFINE(clname,type,_base,classnames) - this maps +classnames (a list of strings) onto class-ids consecutively, starting +at _base. + +DYNAMIC_DEBUG_CLASSMAP_USE(clname) & _USE_(clname,_base) - modules +call this to refer to the var _DEFINEd elsewhere (and exported). + +DYNAMIC_DEBUG_CLASSMAP_PARAM(clname) - creates the sysfs/kparam, +maps/exposes bits 0..N as class-names. + +Classmaps are opt-in: modules invoke _DEFINE or _USE to authorize +dyndbg to update those named classes. "class FOO" queries are +validated against the classes defined or used by the module, this +finds the classid to alter; classes are not directly selectable by +their classid. + +Classnames are global in scope, so subsystems (module-groups) should +prepend a subsystem name; unqualified names like "CORE" are discouraged. + +NB: It is an inherent API limitation (due to class_id's int type) that +the following are possible: + + // these errors should be caught in review + __pr_debug_cls(0, "fake DRM_UT_CORE msg"); // this works + __pr_debug_cls(62, "un-known classid msg"); // this compiles, does nothing + +There are 2 types of classmaps: + +* DD_CLASS_TYPE_DISJOINT_BITS: classes are independent, like drm.debug +* DD_CLASS_TYPE_LEVEL_NUM: classes are relative, ordered (V3 > V2) + +DYNAMIC_DEBUG_CLASSMAP_PARAM - modelled after module_param_cb, it +refers to a DEFINEd classmap, and associates it to the param's +data-store. This state is then applied to DEFINEr and USEr modules +when they're modprobed. + +The PARAM interface also enforces the DD_CLASS_TYPE_LEVEL_NUM relation +amongst the contained classnames; all classes are independent in the +control parser itself. There is no implied meaning in names like "V4" +or "PL_ERROR" vs "PL_WARNING". + +Modules or subsystems (drm & drivers) can define multiple classmaps, +as long as they (all the classmaps) share the limited 0..62 +per-module-group _class_id range, without overlap. + +If a module encounters a conflict between 2 classmaps it is _USEing or +_DEFINEing, it can invoke the extended _USE_(name,_base) macro to +de-conflict the respective ranges. + +``#define DEBUG`` will enable all pr_debugs in scope, including any +class'd ones. This won't be reflected in the PARAM readback value, +but the class'd pr_debug callsites can be forced off by toggling the +classmap-kparam all-on then all-off.
Signature · 1 line
2.52.0