DYNDBG: opt-in class'd debug for modules, use in drm.
Subsystems (11)
Jim Cromie
maintainerv5 cover DYNDBG: opt-in class'd debug for modules, use in drm.
Hi Jason, Greg, DRM-folk,
heres V5. Diffs vs V4:
1st 9 have Jason's Ack
10 is new: simple var cleanup
11 new struct, to contain future addins. touches kernel/module/
dyndbg-param callbacks moved to last (of dyndbg patches) they're where the uncertainty is,
and the bulk of the API addition (class keyword is small)
patches between the move are the guts of the "class foo" feature. exposure of feature is only via >control, until sysfs parts added
DRM chunk:
included here to see how patchwork's merge & test proceeds. categories -> classes re-work is unchanged - feels pretty solid. nouveau & LEVEL made some progress, still WIP.
I left out tracefs bits for now.
UNCERTAINTIES / RFC:
1st is my "sharing" technique, across DRM's multi modules. Its literally duplicated decls, by each participating module, each adding static data in its own special section. I didn't try at all to shrink or unify this any further. There might be a perfect place to add a single decl, but that quest will require a pony.
Sharing by class-names lacks the compiler support that varnames get; "incomplete" enables will probably happen if one of the declarations miss-spells one of the classnames.
That said, see the how-to below: stringifying va-args in the macro would allow direct use of the enum-consts, and cc will insist that those consts are defined, eliminating part of the un-support.
I could split the _BITS,_NUM handling out from _NAMES (ie split drm.debug style patch); theres no user-demand for the _NAMES feature ATM, and theres probably some legit API-bikeshedding to do.
PATCHSET DESCRIPTION
This patchset adds 'typed' "class FOO" support to dynamic-debug, where 'typed' means either DISJOINT_BITS, like drm_dbg(DRM_UT_CORE,..), or LEVEL_NUM (like nouveau debug-levels). Use it in DRM modules: core, helpers, and in drivers i915, amdgpu, nouveau.
If a module is using class'd prdbgs (pr_debug_class, dev_dbg_class, or adapted drm_dbg_<category>) or similar in its code, it can "opt in" to allow dyndbg to manipulate those class'd prdebugs, by declaring in a c-file:
DECLARE_DYNDBG_CLASSMAP(drm_debug_classes,
DD_CLASS_TYPE_DISJOINT_BITS, 0,
"DRM_UT_CORE",
"DRM_UT_DRIVER",
"DRM_UT_KMS",
"DRM_UT_PRIME",
"DRM_UT_ATOMIC",
"DRM_UT_VBL",
"DRM_UT_STATE",
"DRM_UT_LEASE",
"DRM_UT_DP",
"DRM_UT_DRMRES");
// how-to stringify __va_args inside the macro ?By doing this, a module tells dyndbg that it:
- is using class-ids [0..N] in prdbg callsites
( 0..N == DRM_UT_CORE..DRM_UT_DRMRES )
- wants to refer to them by class-names [0..N]
- is mapping those names to those class-ids
- expects users to enable them via >control or >parameter/knob
Then, a user can enable the prdbgs by their class:
:#> echo class DRM_UT_KMS +p > /proc/dynamic_debug/control
And with another 3-line bitmap param decl/init, wrapping the drm_debug_classes var in a module-param-cb:
:#> echo 0x1 > /sys/module/drm/parameters/debug
and optionally using classnames:
:#> echo +DRM_UT_CORE,-DRM_UT_KMS \
> /sys/module/drm/parameters/debug_cats
DYNAMIC_DEBUG gets:
struct _ddebug gets a new .class_id:5 field, big enough to represent drm_debug_category (after squeezing). It defaults to 31 for all existing prdbgs. class_id also supports verbose uses.
classmaps (as declared by macro above) are in their own linker section, are loaded by kernel/module, and handled by add_module, which attaches classmaps to their module's ddebug table.
ddebug_change() handles a class FOO query by validating that FOO is known by each module in the loop. The query is skipped unless the module knows FOO, so no changes are possible w/o a good classname.
Without class FOO in a query/command, only ids=31 can be changed by that query. This protects all class'd prdbgs from changes by legacy class-less user queries.
With this support, the module opt-in approach means that:
- modules declare classnames they like, meaningful names: DRM_UT_* these are numbered [0..N]
- modules call pr_debug_class(N, "fmt..",...)
or drm_dbg(CAT, "fmt..",...) - same form.
- class-id space, while limited:0-30, is private to each module
- "class FOO" is only way to select a class'd prdbg
- unrelated modules use 0..N separately, for different purposes.
- modules "share" classnames by separate decls (uses of macro) all drm modules reuse the above declaration.
then they respond together to a >control
4 CLASS_TYPES are defined; they split behavior on 2 factors:
1. independent bits vs related:(X<Y) bits [0-N]
2. input form: number/hex vs CSV-list: [+-]CLASS_NAMES
DD_CLASS_TYPE_DISJOINT_BITS independent bits, 0x1f input is clearest
DD_CLASS_TYPE_LEVEL_NUM (x<y), input is level, not bitvec
DD_CLASS_TYPE_DISJOINT_NAMES csv-list of independent +-CLASS_NAMEs
DD_CLASS_TYPE_LEVEL_NAMES csv-list of related +-CLASS_NAMEs, only 1 term needed
Splitting up behavior this way is safe, and flexible:
- no bitmap-vs-level > sysknob ambiguity
as was case when both were accepted on same knob
- narrower interfaces
uint is uint
- can defer DISJOINT_NAMES handling, but keep the enums. it has no users ...
- can later add 2 more ENUMS allowing both inputs
in separate LEVEL_NUM & DISJOINT_BITS choices
then authors choice if they want to accept mixed input
- can enumerate "wierd" relations if needed DISJOINT_BITS|LEVEL_NUM should cover everything I can forsee but theres room for DD_CLASS_TYPE_STOCHASTIC (over the garage)
DISJOINT & LEVEL cover the space; 1st is independent, 2nd is related. The relation could differ from (x<y), but atm I can't think of another that makes any sensible distinction from (x<y).
Quick review of debug logging:
DRM is biggest use-case: 23 macros, issuing 10 exclusive categories of messages, from ~5100 callsites, across core (drm, _*helpers), and 3+ drivers (Im working amdgpu, i915, more recently nouveau). These mostly flow to drm_debug_enabled(category) for a print/no decision.
nouveau has minimum direct use of the DRM.debug macros, but does use pr_debug (in VMM iirc), and drm_debug_enabled() in ~50 places via macros, and another ~50 iirc due to NOUVEAU_DEBUG_MMU=y
What nouveau has most of is log-levels: there are ~800 uses of them; nvkm_(fatal|error|warn|info|debug|trace|spam), they all flow thru nvkm_printk_. Even excluding some levels as "always-on" and not appropriate for dyndbg's extra resources and complexity, theres ~450 callsites.
A reported smattering of raw/adhoc debug code. all but unknown to me.
Like any debug logging, they're mostly off, and should have close to 0-off-cost. This is what dyndbg (with/on jump-label) was made for.
Bottom line: in order to unify more potential (drm,etc) use-cases, dyndbg needs to support both debug classification schemes:
RELATED/LEVEL_NUM and INDEPENDENT/DISJOINT_BITS.
This is rev3. rev2 is here:
https://lore.kernel.org/lkml/[email protected]/
summary of diffs:
- rebased on 5.19-rc6 to pick up kernel/module changes
- tracfs bits now use __vstring, __vstr_assign, from S.Rostedt
- 4 class-map-types - as outlined above
now supports LEVEL_NUM semantics, WIP nouveau integration. v2 became the DISJOINT_BITS use case
Lots of API-ish surface area here *RFC*
- class-maps now in section("__dyndbg_classes") class FOO queries are available at earlyboot / module-load drop (un)?register_classes()
- test-dynamic-debug module
tests the 4 CLASS-TYPES
good place to bikeshed / paintshop the API
- nouveau - start poking - WIP
NV_PRINT -> dev_dbg (creates 632 prdbgs, but not class'd) LEVEL_NUM classes declared to see how they "fit", unused yet.
Summary:
- plenty of new stuff here.
- plenty of new API surface area.
- exposes CLASSNAMES to user, via control, >symbolic-sysknob
More on LEVEL_NUM:
dyndbg's class scheme is names-based, so even for LEVEL_NUM with numeric input, there must be a "V0" name; a name with which to turn off "V1". And don't do 'pr_dbg_class(0,..)'.
LEVEL_NUM is an overlay on DISJOINT_BITS; the callback reads the input as a level, and computes and applies the bitmap to enforce it. Yes it wastes "V0" bit. That might matter if an author wanted many separate verbose-knobs with a few levels each, but that seems fairly unlikely.
More importantly, it means that relative verbosity is not enforced at the >control input; IOW this is allowed:
:#> echo class V1 -p > /proc/dynamic_debug/control :#> echo class V3 +p > /proc/dynamic_debug/control
2nd line doesn't undo 1st, as it would if changed via sysfs-knob:
:#> echo 3 > /sys/module/drm/parameters/debug
ISTM this is fine, the "relative" meaning is added at the interface, where it presents to a user. Doing otherwise means surgery to ddebug_change, which seems unnecessary given an option.
CLASS NAMESPACE and DRM
The class namespace is flat and wide, so "V1" is a poor choice, other than for demonstration (as in test_dynamic_debug module). If every module had a "V1", turning them all on would issue lots of unrelated noise.
Instead, class DRM_UT_CORE has a name with a specific sub-system wide (ie multi-module) meaning, and can (and should) be responded to by all cooperating modules.
For DRM, this means 4-5 duplicate uses of DEFINE_DYNDBG_CLASSMAP, from multiple drivers' "*_{drm,dev,main}.c" files; all of them agreeing on the classnames, map-type and base. Though repetitive, and a bit fiddly when multiple classes share the module's id-space, it is simple, and consistent with the "static struct foo = {INIT_expr}" pattern used in the macro. Im open to simpler ways, initializing an extern sounded like a maze w/o cheese.
For core, drm_print.c has an additional task; it defines and initializes the bitmap sysknob that converts bits to a query:
static struct ddebug_classes_bitmap_param drm_debug_bitmap = {
.bits = &__drm_debug,
.flags = "p",
.map = &drm_debug_classes,
};
module_param_cb(debug, ¶m_ops_dyndbg_classes,
&drm_debug_bitmap, 0600);then the callback converts bit-toggles on input into something like:
:#> echo class DRM_UT_KMS +p > control
which enables all drm_dbg_kms() callsites in all modules that declared that classname as known.
NB: classmaps and classes_bitmap_params are different structs. this allows the former to be shared by 2 of latter, each toggling 'p' & 'T' flags, to control output to syslog or tracelog independently.
NBB: while "V1" isnt a good classname, "EMERG" and and other KERN-LEVEL names have a legacy. That said, dyndbg shouldnt be involved in EMERG actions.
NOUVEAU and multiple LEVEL_NUM knobs ?
One thing nouveau has that I havent yet grokked is 2|3 independent verbose levels, in {,cli,sub}->debug (see subdev.h). But Ive coded them as 2 more macro invocations; using bases 10, 15 to avoid/respect the 0-9 mapping of DRM.debug categories to those class-ids.
With this, the drm subsystem uses 20/31 of its class-id range, perhaps 63 is better, despite the cumbersome 0x-64bit interface. Note that the sysfs-knobs do not expose the base/offset (its an inward-facing .class_id offset); each sysfs-knob gets its own 0..N bitmap, the base maps it to the 0..30 subrange allocated (manually, via the base arg to macro) for this class-map.
anyway, heres how modprobe nouveau goes with dynamic_debug.verbose=3
[86512.693954] dyndbg: class[0]: module:nouveau base:15 len:5 ty:1 [86512.693958] dyndbg: 15: 0 NV_SUBDEV_DBG_OFF # aka V0 [86512.693959] dyndbg: 16: 1 NV_SUBDEV_DBG_INFO [86512.693960] dyndbg: 17: 2 NV_SUBDEV_DBG_DEBUG [86512.693960] dyndbg: 18: 3 NV_SUBDEV_DBG_TRACE [86512.693960] dyndbg: 19: 4 NV_SUBDEV_DBG_SPAM [86512.693961] dyndbg: class[1]: module:nouveau base:10 len:5 ty:1 [86512.693961] dyndbg: 10: 0 NV_CLI_DBG_OFF [86512.693962] dyndbg: 11: 1 NV_CLI_DBG_INFO [86512.693962] dyndbg: 12: 2 NV_CLI_DBG_DEBUG [86512.693963] dyndbg: 13: 3 NV_CLI_DBG_TRACE [86512.693963] dyndbg: 14: 4 NV_CLI_DBG_SPAM [86512.693963] dyndbg: class[2]: module:nouveau base:0 len:10 ty:0 [86512.693964] dyndbg: 0: 0 DRM_UT_CORE [86512.693964] dyndbg: 1: 1 DRM_UT_DRIVER [86512.693965] dyndbg: 2: 2 DRM_UT_KMS [86512.693965] dyndbg: 3: 3 DRM_UT_PRIME [86512.693965] dyndbg: 4: 4 DRM_UT_ATOMIC [86512.693966] dyndbg: 5: 5 DRM_UT_VBL [86512.693966] dyndbg: 6: 6 DRM_UT_STATE [86512.693966] dyndbg: 7: 7 DRM_UT_LEASE [86512.693967] dyndbg: 8: 8 DRM_UT_DP [86512.693967] dyndbg: 9: 9 DRM_UT_DRMRES [86512.693968] dyndbg: module:nouveau attached 3 classes [86512.693968] dyndbg: 632 debug prints in module nouveau
They are not yet wired by class; the nv-printks are using dev_dbg for now, so they can be enabled with standard selections (module, func, etc).
DYNDBG API
I added __pr_debug_cls to make things testable, I wanted to keep it private/un-api, because drm already has drm_dbg_<cat>(cat, fmt..), and that seemed a pretty good model to follow: enums with strong names for class_id constants, and same names for classes.
ie: __pr_debug_cls(DRM_UT_KMS, "Whats the Matter with KMS: %s\n", reason);
But now nouveau probably wants/needs it, perhaps others too.
pr_dbg_cls / dev_dbg_cls ? class or debug spelled out ?
MORE TESTING with DRM & TRACEFS
Most dev & testing has been on virtme, with test-dynamic-debug module doing an api-validation-demonstration. The test module proves multiple sysknobs, but cannot prove real multi-module sharing of the class-name space. The DRM.debug adaptation must (and does) do that.
Now Im running on real gpu/drm hw; on both an amdgpu desktop, and this amdgpu+nouveau laptop. Its stable enough to type on, browse, build more kernels, etc.
:#> uname -r
5.18.0-f2-00038-g61d300083196
:#> wc /proc/dynamic_debug/control
11554 95556 1442827 /proc/dynamic_debug/control
:#> lsmod | grep drm
drm_buddy 20480 1 i915 drm_ttm_helper 16384 2 amdgpu,nouveau ttm 86016 4 amdgpu,drm_ttm_helper,i915,nouveau drm_dp_helper 184320 3 amdgpu,i915,nouveau drm_kms_helper 208896 6 drm_dp_helper,amdgpu,i915,nouveau drm 655360 16 gpu_sched,drm_dp_helper,drm_kms_helper,drm_buddy,amdgpu,drm_ttm_helper,i915,ttm,nouveau cec 49152 2 drm_dp_helper,i915
I've never turned on DRM.debug in frustration (or curiousity until recently); I dunno what normal traffic looks like. So I wrote a script to toggle each category: on/off for 1 sec, so I could 'more' thru the output to see the partitioned streams.
Different runs (of '10' sec of active tracing) produce between 330-3500 lines of logging, depending upon mousing/screen activity. Heres a bit of a many-window-select run: wc trace gives "size" of the category's stream.
:#> trc_classes
12 /sys/kernel/tracing/trace
doing class DRM_UT_CORE +/- T 1394 13941 141614 /sys/kernel/tracing/trace
doing class DRM_UT_DRIVER +/- T 1396 13959 141816 /sys/kernel/tracing/trace
doing class DRM_UT_KMS +/- T 1482 14521 148246 /sys/kernel/tracing/trace
doing class DRM_UT_PRIME +/- T 1484 14539 148446 /sys/kernel/tracing/trace
doing class DRM_UT_ATOMIC +/- T 2984 31658 396064 /sys/kernel/tracing/trace
doing class DRM_UT_VBL +/- T 3411 37321 449848 /sys/kernel/tracing/trace
doing class DRM_UT_STATE +/- T 3413 37339 450048 /sys/kernel/tracing/trace
doing class DRM_UT_LEASE +/- T 3415 37357 450248 /sys/kernel/tracing/trace
doing class DRM_UT_DP +/- T 3417 37375 450442 /sys/kernel/tracing/trace
doing class DRM_UT_DRMRES +/- T 3419 37393 450644 /sys/kernel/tracing/trace
and some mid-run output from a quiet run, with less repetition.
bash-96790 [006] ..... 410237.432255: tracing_mark_write: doing class DRM_UT_DRIVER +T
bash-96790 [006] ..... 410238.610319: tracing_mark_write: doing class DRM_UT_DRIVER -T
bash-96790 [006] ..... 410239.776285: tracing_mark_write: doing class DRM_UT_KMS +T
gnome-shell-2101 [003] ..... 410239.923029: drm_debug: [FB:98]
kworker/u32:10-367584 [010] ..... 410239.924627: drm_debug: Allow idle optimizations (MALL): 0
kworker/u32:0-364714 [008] ..... 410239.935126: drm_debug: Allow idle optimizations (MALL): 1
gnome-shell-2101 [003] ..... 410240.527186: drm_debug: [FB:100]
kworker/u32:0-364714 [008] ..... 410240.528686: drm_debug: Allow idle optimizations (MALL): 0
kworker/u32:10-367584 [010] ..... 410240.539378: drm_debug: Allow idle optimizations (MALL): 1
bash-96790 [006] ..... 410240.957921: tracing_mark_write: doing class DRM_UT_KMS -T
bash-96790 [006] ..... 410242.199120: tracing_mark_write: doing class DRM_UT_PRIME +T
bash-96790 [006] ..... 410243.301988: tracing_mark_write: doing class DRM_UT_PRIME -T
bash-96790 [006] ..... 410244.416400: tracing_mark_write: doing class DRM_UT_ATOMIC +T
gnome-shell-2101 [003] ..... 410244.653372: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] Allocated atomic state 000000001f1e6cb6
gnome-shell-2101 [003] ..... 410244.653381: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] Added [PLANE:55:plane-3] 00000000785ae904 state to 000000001f1e6cb6
gnome-shell-2101 [003] ..... 410244.653384: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] Added [CRTC:67:crtc-0] 00000000b06ca618 state to 000000001f1e6cb6
gnome-shell-2101 [003] ..... 410244.653389: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] Set [FB:98] for [PLANE:55:plane-3] state 00000000785ae904
gnome-shell-2101 [003] ..... 410244.653392: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] checking 000000001f1e6cb6
gnome-shell-2101 [003] ..... 410244.653407: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] committing 000000001f1e6cb6 nonblocking
kworker/u32:0-364714 [010] ..... 410244.653729: drm_debug: amdgpu_crtc id:0 crtc_state_flags: enable:1, active:1, planes_changed:1, mode_changed:0,active_changed:0,connectors_changed:0
kworker/u32:0-364714 [010] ..... 410244.654642: drm_debug: plane: id=3 dcc_en=0a few things to note in the trace output:
. the event-name: drm_(debug|devdbg) is not very informative
. drm_devdbg fmt has cat:%d, it could be the classname, but that should
replace event-name, not supplement it. this pertains to drm_debug too.
. drm_devdbg has lots of (dev-info), that could be optional on a new flag(s)
If anyone wants to repeat the above with the patchset, the .rc file follows:
events_3() {
local a=$1
local b=$2
local c=$3
echo $a > /sys/kernel/tracing/events/dyndbg/enable # avoid drm_vblank*, its noisy
echo $b > /sys/kernel/tracing/events/drm/drm_debug/enable echo $c > /sys/kernel/tracing/events/drm/drm_devdbg/enable
}
flags_class() {
local flgs=$1;
local cls=$2;
echo class $cls $flgs > /proc/dynamic_debug/control
}# turn on each DRM_UT_* for 1 second each. # kinda shows relative traffic of each category # separated into blocks to get flavor of each
drm_classes() {
local flgs=$1
[ -z $flgs ] && flgs="p"
#echo > /sys/kernel/tracing/trace
#wc /sys/kernel/tracing/trace
for cls in DRM_UT_CORE DRM_UT_DRIVER DRM_UT_KMS DRM_UT_PRIME DRM_UT_ATOMIC \
DRM_UT_VBL DRM_UT_STATE DRM_UT_LEASE DRM_UT_DP \
DRM_UT_DRMRES;
do
echo -n doing class $cls " "
echo doing class $cls +$flgs
sleep .1
flags_class +$flgs $cls
sleep 1
echo doing class $cls -$flgs
sleep .1
flags_class -$flgs $cls
sleep 1
#wc /sys/kernel/tracing/trace
done
}
# like above but with T flag, and markers, trace/enable
trc_classes() {
local flgs=$1
[ -z $flgs ] && flgs="T" echo > /sys/kernel/tracing/trace
wc -l /sys/kernel/tracing/trace
events_3 1 1 1
for cls in DRM_UT_CORE DRM_UT_DRIVER DRM_UT_KMS DRM_UT_PRIME \
DRM_UT_ATOMIC \
DRM_UT_VBL DRM_UT_STATE DRM_UT_LEASE DRM_UT_DP \
DRM_UT_DRMRES;
do
echo -n doing class $cls +/- $flgs " "
echo doing class $cls +$flgs > /sys/kernel/tracing/trace_marker sleep .1
flags_class +$flgs $cls
sleep 1
echo doing class $cls -$flgs > /sys/kernel/tracing/trace_marker sleep .1
flags_class -$flgs $cls
sleep 1
wc /sys/kernel/tracing/trace
done
events_3 0 0 0
}
Jim Cromie (33):
1st, a group of "cleanups"
dyndbg: fix static_branch manipulation
dyndbg: fix module.dyndbg handling
dyndbg: show both old and new in change-info
dyndbg: reverse module walk in cat control
dyndbg: reverse module.callsite walk in cat control
dyndbg: use ESCAPE_SPACE for cat control
dyndbg: let query-modname override actual module name
dyndbg: add test_dynamic_debug module
dyndbg: drop EXPORTed dynamic_debug_exec_queries
dyndbg: cleanup local vars in ddebug_init
dyndbg: create and use struct _ddebug_info
class FOO support
dyndbg: add class_id to pr_debug callsites
dyndbg: add __pr_debug_cls for testing
dyndbg: add DECLARE_DYNDBG_CLASSMAP macro kernel/module: add __dyndbg_classes section
dyndbg: add ddebug_attach_module_classes
dyndbg: validate class FOO by checking with module
doc-dyndbg: describe "class CLASS_NAME" query support
doc-dyndbg: edit dynamic-debug-howto for brevity, audience
add dyndbg-class-param support
dyndbg: add drm.debug style (drm/parameters/debug) bitmap support
dyndbg: test DECLARE_DYNDBG_CLASSMAP, sysfs nodes
drm.debug adaptation
drm_print: condense enum drm_debug_category
drm: POC drm on dyndbg - use in core, 2 helpers, 3 drivers.
drm_print: interpose drm_*dbg with forwarding macros
drm_print: wrap drm_*_dbg in dyndbg descriptor factory macro drm-print.h: include dyndbg header
drm-print: add drm_dbg_driver to improve namespace symmetry
drm_print: refine drm_debug_enabled for jump-label
drm_print: prefer bare printk KERN_DEBUG on generic fn
drm_print: add _ddebug descriptor to drm_*dbg prototypes
nouveau-LEVEL_NUM integration: WIP/exploratory.
nouveau: change nvkm_debug/trace to use dev_dbg POC
nouveau: adapt NV_DEBUG, NV_ATOMIC to use DRM.debug
nouveau: WIP add 2 LEVEL_NUM classmaps for CLI, SUBDEV
.../admin-guide/dynamic-debug-howto.rst | 246 +++++----- MAINTAINERS | 2 + drivers/gpu/drm/Kconfig | 12 + drivers/gpu/drm/Makefile | 2 + drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c | 14 + drivers/gpu/drm/display/drm_dp_helper.c | 13 + drivers/gpu/drm/drm_crtc_helper.c | 13 + drivers/gpu/drm/drm_print.c | 48 +- drivers/gpu/drm/i915/i915_params.c | 12 + .../gpu/drm/nouveau/include/nvkm/core/debug.h | 16 + .../drm/nouveau/include/nvkm/core/subdev.h | 17 +- drivers/gpu/drm/nouveau/nouveau_drm.c | 20 + drivers/gpu/drm/nouveau/nouveau_drv.h | 16 +- drivers/gpu/drm/nouveau/nvkm/core/subdev.c | 23 + include/asm-generic/vmlinux.lds.h | 3 + include/drm/drm_print.h | 85 +++- include/linux/dynamic_debug.h | 176 +++++-- kernel/module/internal.h | 4 +- kernel/module/main.c | 20 +- lib/Kconfig.debug | 10 + lib/Makefile | 1 + lib/dynamic_debug.c | 450 +++++++++++++++--- lib/test_dynamic_debug.c | 165 +++++++ 23 files changed, 1099 insertions(+), 269 deletions(-) create mode 100644 lib/test_dynamic_debug.c
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 1/33 dyndbg: fix static_branch manipulation
In https://lore.kernel.org/lkml/[email protected]/
Vincent's patch commented on, and worked around, a bug toggling static_branch's, when a 2nd PRINTK-ish flag was added. The bug results in a premature static_branch_disable when the 1st of 2 flags was disabled.
The cited commit computed newflags, but then in the JUMP_LABEL block, failed to use that result, instead using just one of the terms in it. Using newflags instead made the code work properly.
This is Vincents test-case, reduced. It needs the 2nd flag to demonstrate the bug, but it's explanatory here.
pt_test() {
echo 5 > /sys/module/dynamic_debug/verbose
site="module tcp" # just one callsite
echo " $site =_ " > /proc/dynamic_debug/control # clear it
# A B ~A ~B
for flg in +T +p "-T #broke here" -p; do
echo " $site $flg " > /proc/dynamic_debug/control
done;
# A B ~B ~A
for flg in +T +p "-p #broke here" -T; do
echo " $site $flg " > /proc/dynamic_debug/control
done
}pt_test
---
.drop @stable, no exposed bug.
.add jbaron ack
--- lib/dynamic_debug.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
lib/dynamic_debug.c +3 -2
@@ -211,10 +211,11 @@ static int ddebug_change(const struct ddebug_query *query,continue ;#ifdef CONFIG_JUMP_LABEL if (dp->flags & _DPRINTK_FLAGS_PRINT) { -if (!(modifiers->flags & _DPRINTK_FLAGS_PRINT)) +if (!(newflags & _DPRINTK_FLAGS_PRINT))static_branch_disable (&dp->key.dd_key_true); - }else if (modifiers->flags & _DPRINTK_FLAGS_PRINT) + }else if (newflags & _DPRINTK_FLAGS_PRINT) {static_branch_enable (&dp->key.dd_key_true); + }#endif dp->flags = newflags; v4pr_info("changed %s:%d [%s]%s =%s\n",
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 2/33 dyndbg: fix module.dyndbg handling
In reply to Jim CromieFor CONFIG_DYNAMIC_DEBUG=N, the ddebug_dyndbg_module_param_cb() stub-fn is too permissive:
bash-5.1# modprobe drm JUNKdyndbg
bash-5.1# modprobe drm dyndbgJUNK
[ 42.933220] dyndbg param is supported only in CONFIG_DYNAMIC_DEBUG builds [ 42.937484] ACPI: bus type drm_connector registered
This caused no ill effects, because unknown parameters are either ignored by default with an "unknown parameter" warning, or ignored because dyndbg allows its no-effect use on non-dyndbg builds.
But since the code has an explicit feedback message, it should be issued accurately. Fix with strcmp for exact param-name match.
--- include/linux/dynamic_debug.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
include/linux/dynamic_debug.h +1 -1
@@ -201,7 +201,7 @@ static inline int ddebug_remove_module(const char *mod)static inline int ddebug_dyndbg_module_param_cb (char *param,char *val,const char *modname) { -if (strstr (param,"dyndbg" )) { +if (!strcmp (param,"dyndbg" )) {/* avoid pr_warn(), which wants pr_fmt() fully defined */ printk (KERN_WARNING "dyndbg param is supported only in " "CONFIG_DYNAMIC_DEBUG builds\n" );
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 3/33 dyndbg: show both old and new in change-info
In reply to Jim Cromieprint "old => new" flag values to the info("change") message.
no functional change.
--- lib/dynamic_debug.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
lib/dynamic_debug.c +6 -5
@@ -156,7 +156,7 @@ static int ddebug_change(const struct ddebug_query *query,struct ddebug_table *dt;unsigned int newflags;unsigned int nfound =0 ; -struct flagsbuf fbuf; +struct flagsbuf fbuf, nbuf;/* search for matching ddebugs */ mutex_lock (&ddebug_lock);
@@ -217,11 +217,12 @@ static int ddebug_change(const struct ddebug_query *query, static_branch_enable(&dp->key.dd_key_true); }#endif +v4pr_info ("changed %s:%d [%s]%s %s => %s\n" , +trim_prefix (dp->filename), dp->lineno, + dt->mod_name, dp->function, +ddebug_describe_flags (dp->flags, &fbuf), +ddebug_describe_flags (newflags, &nbuf)); dp->flags = newflags; -v4pr_info ("changed %s:%d [%s]%s =%s\n" , -trim_prefix (dp->filename), dp->lineno, - dt->mod_name, dp->function, -ddebug_describe_flags (dp->flags, &fbuf)); } }mutex_unlock (&ddebug_lock);
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 4/33 dyndbg: reverse module walk in cat control
In reply to Jim Cromie/proc/dynamic_debug/control walks the prdbg catalog in "reverse", fix this by adding new ddebug_tables to tail of list.
This puts init/main.c entries 1st, which looks more than coincidental.
no functional changes.
--- lib/dynamic_debug.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/dynamic_debug.c +1 -1
@@ -970,7 +970,7 @@ int ddebug_add_module(struct _ddebug *tab, unsigned int n, dt->ddebugs = tab;mutex_lock (&ddebug_lock); -list_add (&dt->link, &ddebug_tables); +list_add_tail (&dt->link, &ddebug_tables);mutex_unlock (&ddebug_lock);vpr_info ("%3u debug prints in module %s\n" , n, dt->mod_name);
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 5/33 dyndbg: reverse module.callsite walk in cat control
In reply to Jim CromieWalk the module's vector of callsites backwards; ie N..0. This "corrects" the backwards appearance of a module's prdbg vector when walked 0..N. I think this is due to linker mechanics, which I'm inclined to treat as immutable, and the order is fixable in display.
No functional changes.
Combined with previous commit, which reversed tables-list, we get:
:#> 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"
--- lib/dynamic_debug.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
lib/dynamic_debug.c +6 -6
@@ -59,7 +59,7 @@ struct ddebug_query {struct ddebug_iter {struct ddebug_table *table; -unsigned int idx; +int idx; };struct flag_settings {
@@ -805,13 +805,12 @@ static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter) {if (list_empty (&ddebug_tables)) { iter->table =NULL ; - iter->idx =0 ;return NULL ; } iter->table =list_entry (ddebug_tables.next, struct ddebug_table, link); - iter->idx =0 ; -return &iter->table->ddebugs[iter->idx]; + iter->idx = iter->table->num_ddebugs; +return &iter->table->ddebugs[--iter->idx]; }/*
@@ -824,15 +823,16 @@ static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter) {if (iter->table ==NULL )return NULL ; -if (++iter->idx == iter->table->num_ddebugs) { +if (--iter->idx <0 ) {/* iterate to next table */ - iter->idx =0 ;if (list_is_last (&iter->table->link, &ddebug_tables)) { iter->table =NULL ;return NULL ; } iter->table =list_entry (iter->table->link.next, struct ddebug_table, link); + iter->idx = iter->table->num_ddebugs; + --iter->idx; }return &iter->table->ddebugs[iter->idx]; }
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 6/33 dyndbg: use ESCAPE_SPACE for cat control
In reply to Jim Cromiecat control currently does octal escape, so '\n' becomes "\012". Change this to display as "\n" instead, which reads much cleaner.
:#> head -n7 /proc/dynamic_debug/control
# filename:lineno [module]function flags format 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"
--- lib/dynamic_debug.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/dynamic_debug.c +1 -1
@@ -900,7 +900,7 @@ static int ddebug_proc_show(struct seq_file *m, void *p)trim_prefix (dp->filename), dp->lineno, iter->table->mod_name, dp->function, ddebug_describe_flags(dp->flags, &flags)); -seq_escape (m, dp->format,"\t\r\n\"" ); +seq_escape_str (m, dp->format,ESCAPE_SPACE ,"\t\r\n\"" );seq_puts (m,"\"\n" );return 0 ;
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 7/33 dyndbg: let query-modname override actual module name
In reply to Jim Cromiedyndbg's control-parser: ddebug_parse_query(), requires that search
terms: module, func, file, lineno, are used only once in a query; a thing cannot be named both foo and bar.
The cited commit added an overriding module modname, taken from the module loader, which is authoritative. So it set query.module 1st, which disallowed its use in the query-string.
But now, its useful to allow a module-load to enable classes across a whole (or part of) a subsystem at once.
# enable (dynamic-debug in) drm only modprobe drm dyndbg="class DRM_UT_CORE +p"
# get drm_helper too modprobe drm dyndbg="class DRM_UT_CORE module drm* +p"
# get everything that knows DRM_UT_CORE modprobe drm dyndbg="class DRM_UT_CORE module * +p"
# also for boot-args: drm.dyndbg="class DRM_UT_CORE module * +p"
So convert the override into a default, by filling it only when/after the query-string omitted the module.
NB: the query class FOO handling is forthcoming.
--- lib/dynamic_debug.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
lib/dynamic_debug.c +7 -4
@@ -385,10 +385,6 @@ static int ddebug_parse_query(char *words[], int nwords,return -EINVAL ; } -if (modname) -/* support $modname.dyndbg=<multiple queries> */ - query->module = modname; -for (i =0 ; i < nwords; i +=2 ) {char *keyword = words[i];char *arg = words[i+1 ];
@@ -429,6 +425,13 @@ static int ddebug_parse_query(char *words[], int nwords,if (rc)return rc; } +if (!query->module && modname) +/* +* support $modname.dyndbg=<multiple queries>, when +* not given in the query itself +*/ + query->module = modname; +vpr_info_dq (query,"parsed" );return 0 ; }
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 8/33 dyndbg: add test_dynamic_debug module
In reply to Jim CromieProvide a simple module to allow testing DYNAMIC_DEBUG behavior. It calls do_prints() from module-init, and with a sysfs-node.
dmesg -C
dmesg -w &
modprobe test_dynamic_debug dyndbg=+p
echo 1 > /sys/module/dynamic_debug/parameters/verbose
cat /sys/module/test_dynamic_debug/parameters/do_prints echo module test_dynamic_debug +mftl > /proc/dynamic_debug/control echo junk > /sys/module/test_dynamic_debug/parameters/do_prints
--- MAINTAINERS | 2 ++ lib/Kconfig.debug | 10 ++++++ lib/Makefile | 1 + lib/test_dynamic_debug.c | 70 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 83 insertions(+) create mode 100644 lib/test_dynamic_debug.c
MAINTAINERS +2 -0
@@ -7093,6 +7093,8 @@ M: Jason Baron <[email protected]> S: Maintained F: include/linux/dynamic_debug.h F: lib/dynamic_debug.c +M: Jim Cromie <[email protected]> +F: lib/test_dynamic_debug.c DYNAMIC INTERRUPT MODERATION M: Tal Gilboa <[email protected]>
lib/Kconfig.debug +10 -0
@@ -2529,6 +2529,16 @@ config TEST_STATIC_KEYS If unsure, say N. +config TEST_DYNAMIC_DEBUG + tristate "Test DYNAMIC_DEBUG" + depends on DYNAMIC_DEBUG + 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. + + If unsure, say N. + config TEST_KMOD tristate "kmod stress tester" depends on m
lib/Makefile +1 -0
@@ -82,6 +82,7 @@ obj-$(CONFIG_TEST_SORT) += test_sort.o obj-$(CONFIG_TEST_USER_COPY) += test_user_copy.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_PRINTF) += test_printf.o obj-$(CONFIG_TEST_SCANF) += test_scanf.o obj-$(CONFIG_TEST_BITMAP) += test_bitmap.o
lib/test_dynamic_debug.c new file +70 -0
70 lines not on this page · raw message
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 9/33 dyndbg: drop EXPORTed dynamic_debug_exec_queries
In reply to Jim CromieThis exported fn is unused, and will not be needed. Lets dump it.
The export was added to let drm control pr_debugs, as part of using them to avoid drm_debug_enabled overheads. But its better to just implement the drm.debug bitmap interface, then its available for everyone.
--- include/linux/dynamic_debug.h | 9 --------- lib/dynamic_debug.c | 29 ----------------------------- 2 files changed, 38 deletions(-)
include/linux/dynamic_debug.h +0 -9
@@ -55,9 +55,6 @@ struct _ddebug {#if defined(CONFIG_DYNAMIC_DEBUG_CORE ) -/* exported for module authors to exercise >control */ -int dynamic_debug_exec_queries (const char *query,const char *modname); -int ddebug_add_module (struct _ddebug *tab,unsigned int n,const char *modname);extern int ddebug_remove_module (const char *mod_name);
@@ -221,12 +218,6 @@ static inline int ddebug_dyndbg_module_param_cb(char *param, char *val, rowsize, groupsize, buf, len, ascii); \ } while (0) -static inline int dynamic_debug_exec_queries(const char *query, const char *modname) -{ -pr_warn ("kernel not built with CONFIG_DYNAMIC_DEBUG_CORE\n" ); -return 0 ; -} -#endif /* !CONFIG_DYNAMIC_DEBUG_CORE */ #endif
lib/dynamic_debug.c +0 -29
@@ -558,35 +558,6 @@ static int ddebug_exec_queries(char *query, const char *modname)return nfound; } -/** -* dynamic_debug_exec_queries - select and change dynamic-debug prints -* @query: query-string described in admin-guide/dynamic-debug-howto -* @modname: string containing module name, usually &module.mod_name -* -* This uses the >/proc/dynamic_debug/control reader, allowing module -* authors to modify their dynamic-debug callsites. The modname is -* canonically struct module.mod_name, but can also be null or a -* module-wildcard, for example: "drm*". -*/ -int dynamic_debug_exec_queries (const char *query,const char *modname) -{ -int rc; -char *qry;/* writable copy of query */ - -if (!query) { -pr_err ("non-null query/command string expected\n" ); -return -EINVAL ; - } - qry =kstrndup (query,PAGE_SIZE ,GFP_KERNEL ); -if (!qry) -return -ENOMEM ; - - rc =ddebug_exec_queries (qry, modname); -kfree (qry); -return rc; -} -EXPORT_SYMBOL_GPL (dynamic_debug_exec_queries); -#define PREFIX_SIZE 64static int remaining (int wrote)
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 10/33 dyndbg: cleanup local vars in ddebug_init
In reply to Jim Cromierework var-names for clarity, regularity
rename variables
- n to mod_sites - it counts sites-per-module
- entries to i - display only
- iter_start to iter_mod_start - marks start of each module's subrange
- modct to mod_ct - stylistic
new iterator var:
- site - cursor parallel to iter
this allows 'demotion' of iter->site (for removal later)
treat vars as iters:
- drop init at top
init just above for-loop, in a textual block
--- lib/dynamic_debug.c | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-)
lib/dynamic_debug.c +17 -16
@@ -1059,11 +1059,10 @@ static int __init dynamic_debug_init_control(void)static int __init dynamic_debug_init (void ) { -struct _ddebug *iter, *iter_start; -const char *modname =NULL ; +struct _ddebug *iter, *iter_mod_start; +int ret, i, mod_sites, mod_ct; +const char *modname;char *cmdline; -int ret =0 ; -int n =0 , entries =0 , modct =0 ;if (&__start___dyndbg == &__stop___dyndbg) {if (IS_ENABLED (CONFIG_DYNAMIC_DEBUG )) {
@@ -1074,30 +1073,32 @@ static int __init dynamic_debug_init(void) ddebug_init_success =1 ;return 0 ; } - iter = __start___dyndbg; + + iter = iter_mod_start = __start___dyndbg; modname = iter->modname; - iter_start = iter; -for (; iter < __stop___dyndbg; iter++) { - entries++; + i = mod_sites = mod_ct =0 ; + +for (; iter < __stop___dyndbg; iter++, i++, mod_sites++) { +if (strcmp (modname, iter->modname)) { - modct++; - ret =ddebug_add_module (iter_start, n, modname); + mod_ct++; + ret =ddebug_add_module (iter_mod_start, mod_sites, modname);if (ret) goto out_err; - n =0 ; + + mod_sites =0 ; modname = iter->modname; - iter_start = iter; + iter_mod_start = iter; } - n++; } - ret =ddebug_add_module (iter_start, n, modname); + ret =ddebug_add_module (iter_mod_start, mod_sites, modname);if (ret) goto out_err; ddebug_init_success =1 ;vpr_info ("%d prdebugs in %d modules, %d KiB in ddebug tables, %d kiB in __dyndbg section\n" , - entries, modct, (int )((modct *sizeof (struct ddebug_table )) >>10 ), - (int )((entries *sizeof (struct _ddebug )) >>10 )); + i, mod_ct, (int )((mod_ct *sizeof (struct ddebug_table )) >>10 ), + (int )((i *sizeof (struct _ddebug )) >>10 ));/* now that ddebug tables are loaded, process all boot args * again to find and activate queries given in dyndbg params.
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 11/33 dyndbg: create and use struct _ddebug_info
In reply to Jim Cromiethis new struct gathers the linker provided vectors/sections:
descs - the vector of descriptors in __dyndbg section. num_descs - length of the data/section
Use it as follows:
In lib/dynamic_debug.c:
Alter ddebug_add_module() params-list, replacing descriptor-table and its length with a single _ddebug_info object containing them. This future-proofs the function against the looming addition of class-map info, for either the builtin module set, or the loaded module.
In dynamic_debug_init(): add & initialize an auto struct _ddebug_info var, and use it like a cursor / multi-part iterator. Re-initialize the var's component values before each call to ddebug_add_module(). This gives us the inch-worm walk thru the modules in the built-in __dyndbgs data section.
In kernel/module/{main.c,internal.h}:
Embed a struct _ddebug_info into struct load_info, replacing the 2 fields it contains. Populate its members in find_module_sections.
Also adjust dynamic_debug_setup/remove() to match the change to ddebug_add_module().
Note: this adds an include dynamic_debug, and might be prone to include loops, since its also smuggled in by printk.h. Nothing has puked in robot-land.
--- include/linux/dynamic_debug.h | 13 +++++++----- kernel/module/internal.h | 4 ++-- kernel/module/main.c | 18 ++++++++-------- lib/dynamic_debug.c | 40 +++++++++++++++++++++++++++-------- 4 files changed, 50 insertions(+), 25 deletions(-)
include/linux/dynamic_debug.h +8 -5
@@ -51,12 +51,16 @@ struct _ddebug {#endif } __attribute__((aligned(8))); - +/* encapsulate linker provided built-in (or module) dyndbg data */ +struct _ddebug_info { +struct _ddebug *descs; +unsigned int num_descs; +};#if defined(CONFIG_DYNAMIC_DEBUG_CORE ) -int ddebug_add_module (struct _ddebug *tab,unsigned int n, -const char *modname); +int ddebug_add_module (struct _ddebug_info *dyndbg,const char *modname); +extern int ddebug_remove_module (const char *mod_name); extern __printf(2, 3) void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...);
@@ -184,8 +188,7 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor,#include <linux/errno.h> #include <linux/printk.h> -static inline int ddebug_add_module (struct _ddebug *tab,unsigned int n, -const char *modname) +static inline int ddebug_add_module (struct _ddebug_info *dinfo,const char *modname) {return 0 ; }
kernel/module/internal.h +2 -2
@@ -53,6 +53,7 @@ extern const struct kernel_symbol __stop___ksymtab_gpl[];extern const s32 __start___kcrctab[];extern const s32 __start___kcrctab_gpl[]; +#include <linux/dynamic_debug.h> struct load_info {const char *name;/* pointer to module in temporary copy, freed at end of load_module() */
@@ -62,8 +63,7 @@ struct load_info {Elf_Shdr *sechdrs;char *secstrings, *strtab;unsigned long symoffs, stroffs, init_typeoffs, core_typeoffs; -struct _ddebug *debug; -unsigned int num_debug; +struct _ddebug_info dyndbg;bool sig_ok;#ifdef CONFIG_KALLSYMS unsigned long mod_kallsyms_init_off;
kernel/module/main.c +9 -9
@@ -1593,16 +1593,16 @@ static void free_modinfo(struct module *mod) } } -static void dynamic_debug_setup (struct module *mod,struct _ddebug *debug,unsigned int num) +static void dynamic_debug_setup (struct module *mod,struct _ddebug_info *dyndbg) { -if (!debug) +if (!dyndbg->num_descs)return ; -ddebug_add_module (debug, num, mod->name); +ddebug_add_module (dyndbg, mod->name); } -static void dynamic_debug_remove (struct module *mod,struct _ddebug *debug) +static void dynamic_debug_remove (struct module *mod,struct _ddebug_info *dyndbg) { -if (debug) +if (dyndbg->num_descs)ddebug_remove_module (mod->name); }
@@ -2093,8 +2093,8 @@ static int find_module_sections(struct module *mod, struct load_info *info)if (section_addr (info,"__obsparm" ))pr_warn ("%s: Ignoring obsolete parameters\n" , mod->name); - info->debug =section_objs (info,"__dyndbg" , -sizeof (*info->debug), &info->num_debug); + info->dyndbg.descs =section_objs (info,"__dyndbg" , +sizeof (*info->dyndbg.descs), &info->dyndbg.num_descs);return 0 ; }
@@ -2783,7 +2783,7 @@ static int load_module(struct load_info *info, const char __user *uargs, }init_build_id (mod, info); -dynamic_debug_setup (mod, info->debug, info->num_debug); +dynamic_debug_setup (mod, &info->dyndbg);/* Ftrace init must be called in the MODULE_STATE_UNFORMED state */ ftrace_module_init (mod);
@@ -2845,7 +2845,7 @@ static int load_module(struct load_info *info, const char __user *uargs, ddebug_cleanup:ftrace_release_mod (mod); -dynamic_debug_remove (mod, info->debug); +dynamic_debug_remove (mod, &info->dyndbg);synchronize_rcu ();kfree (mod->args); free_arch_cleanup:
lib/dynamic_debug.c +31 -9
@@ -923,14 +923,20 @@ static const struct proc_ops proc_fops = {* Allocate a new ddebug_table for the given module * and add it to the global list. */ -int ddebug_add_module (struct _ddebug *tab,unsigned int n, -const char *name) +static int __ddebug_add_module (struct _ddebug_info *di,unsigned int base, +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); +return 0 ; + } + dt =kzalloc (sizeof (*dt),GFP_KERNEL );if (dt ==NULL ) { -pr_err ("error adding module: %s\n" , name); +pr_err ("error adding module: %s\n" , modname);return -ENOMEM ; }/*
@@ -939,18 +945,25 @@ int ddebug_add_module(struct _ddebug *tab, unsigned int n,* member of struct module, which lives at least as long as * this struct ddebug_table. */ - dt->mod_name = name; - dt->num_ddebugs = n; - dt->ddebugs = tab; + dt->mod_name = modname; + dt->ddebugs = di->descs; + dt->num_ddebugs = di->num_descs; + +INIT_LIST_HEAD (&dt->link);mutex_lock (&ddebug_lock);list_add_tail (&dt->link, &ddebug_tables);mutex_unlock (&ddebug_lock); -vpr_info ("%3u debug prints in module %s\n" , n, dt->mod_name); +vpr_info ("%3u debug prints in module %s\n" , di->num_descs, modname);return 0 ; } +int ddebug_add_module (struct _ddebug_info *di,const char *modname) +{ +return __ddebug_add_module (di,0 , modname); +} +/* helper for ddebug_dyndbg_(boot|module)_param_cb */ static int ddebug_dyndbg_param_cb (char *param,char *val,const char *modname,int on_err)
@@ -1064,6 +1077,11 @@ static int __init dynamic_debug_init(void)const char *modname;char *cmdline; +struct _ddebug_info di = { + .descs = __start___dyndbg, + .num_descs = __stop___dyndbg - __start___dyndbg, + }; +if (&__start___dyndbg == &__stop___dyndbg) {if (IS_ENABLED (CONFIG_DYNAMIC_DEBUG )) {pr_warn ("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n" );
@@ -1082,7 +1100,9 @@ static int __init dynamic_debug_init(void)if (strcmp (modname, iter->modname)) { mod_ct++; - ret =ddebug_add_module (iter_mod_start, mod_sites, modname); + di.num_descs = mod_sites; + di.descs = iter_mod_start; + ret =__ddebug_add_module (&di, i, modname);if (ret) goto out_err;
@@ -1091,7 +1111,9 @@ static int __init dynamic_debug_init(void) iter_mod_start = iter; } } - ret =ddebug_add_module (iter_mod_start, mod_sites, modname); + di.num_descs = mod_sites; + di.descs = iter_mod_start; + ret =__ddebug_add_module (&di, i, modname);if (ret) goto out_err;
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 12/33 dyndbg: add class_id to pr_debug callsites
In reply to Jim CromieDRM issues ~10 exclusive categories of debug messages; to represent this directly in dyndbg, add a new field: struct _ddebug.class_id:5.
This gives us 32 classes, which is a practical usability limit with a bitmap interface:
#> echo 0x012345678 > /sys/module/drm/parameters/debug
All existing callsites are initialized with _DPRINTK_CLASS_DFLT, which is 2^5-1. This reserves 0-30 for use in new categorized/class'd pr_debugs, which fits perfectly with natural enums (ints: 0..N).
Then extend the init macro: DEFINE_DYNAMIC_DEBUG_METADATA() with _CLS(cls, ...), and redef old name using extended name.
And extend the factory macro callchain with _cls() versions to provide the callsite.class_id, with old-names passing _DPRINTK_CLASS_DFLT.
This sets us up to create class'd prdebug callsites (class'd callsites are those with .class_id != _DPRINTK_CLASS_DFLT).
No behavior change.
--- include/linux/dynamic_debug.h | 71 +++++++++++++++++++++++++++-------- 1 file changed, 55 insertions(+), 16 deletions(-)
include/linux/dynamic_debug.h +55 -16
@@ -6,6 +6,8 @@#include <linux/jump_label.h> #endif +#include <linux/build_bug.h> +/* * An instance of this structure is created in a special * ELF section at every dynamic debug callsite. At runtime,
@@ -21,6 +23,9 @@ struct _ddebug {const char *filename;const char *format; unsigned int lineno:18; +#define CLS_BITS 5 + unsigned int class_id:CLS_BITS; +#define _DPRINTK_CLASS_DFLT ((1 << CLS_BITS) - 1)/* * The flags field controls the behaviour at the callsite. * The bits here are changed dynamically when the user
@@ -88,7 +93,7 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor,const struct ib_device *ibdev, const char *fmt, ...); -#define DEFINE_DYNAMIC_DEBUG_METADATA (name, fmt) \ +#define DEFINE_DYNAMIC_DEBUG_METADATA_CLS (name, cls, fmt) \ static struct _ddebug __aligned(8) \ __section("__dyndbg") name = { \ .modname = KBUILD_MODNAME, \
@@ -97,8 +102,14 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor, .format = (fmt), \ .lineno = __LINE__, \ .flags = _DPRINTK_FLAGS_DEFAULT, \ + .class_id = cls, \ _DPRINTK_KEY_INIT \ - } + }; \ +BUILD_BUG_ON_MSG (cls > _DPRINTK_CLASS_DFLT, \ + "classid value overflow") + +#define DEFINE_DYNAMIC_DEBUG_METADATA (name, fmt) \ + DEFINE_DYNAMIC_DEBUG_METADATA_CLS(name, _DPRINTK_CLASS_DFLT, fmt)#ifdef CONFIG_JUMP_LABEL
@@ -129,17 +140,34 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor,#endif /* CONFIG_JUMP_LABEL */ -#define __dynamic_func_call (id, fmt, func, ...) do { \ - DEFINE_DYNAMIC_DEBUG_METADATA(id, fmt); \ - if (DYNAMIC_DEBUG_BRANCH(id)) \ - func(&id, ##__VA_ARGS__); \ -} while (0) - -#define __dynamic_func_call_no_desc (id, fmt, func, ...) do { \ - DEFINE_DYNAMIC_DEBUG_METADATA(id, fmt); \ +/* +* Factory macros: ($prefix)dynamic_func_call($suffix) +* +* Lower layer (with __ prefix) gets the callsite metadata, and wraps +* the func inside a debug-branch/static-key construct. Upper layer +* (with _ prefix) does the UNIQUE_ID once, so that lower can ref the +* name/label multiple times, and tie the elements together. +* Multiple flavors: +* (|_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_DEBUG_METADATA_CLS(id, cls, fmt); \ if (DYNAMIC_DEBUG_BRANCH(id)) \ - func(__VA_ARGS__); \ + 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_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__)/* * "Factory macro" for generating a call to func, guarded by a
@@ -149,22 +177,33 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor,* the varargs. Note that fmt is repeated in invocations of this * macro. */ +#define _dynamic_func_call_cls (cls, fmt, func, ...) \ + __dynamic_func_call_cls(__UNIQUE_ID(ddebug), cls, fmt, func, ##__VA_ARGS__)#define _dynamic_func_call (fmt, func, ...) \ - __dynamic_func_call(__UNIQUE_ID(ddebug), fmt, func, ##__VA_ARGS__) + _dynamic_func_call_cls(_DPRINTK_CLASS_DFLT, fmt, func, ##__VA_ARGS__) +/* * A variant that does the same, except that the descriptor is not * passed as the first argument to the function; it is only called * with precisely the macro's varargs. */ -#define _dynamic_func_call_no_desc (fmt, func, ...) \ - __dynamic_func_call_no_desc(__UNIQUE_ID(ddebug), fmt, func, ##__VA_ARGS__) +#define _dynamic_func_call_cls_no_desc (cls, fmt, func, ...) \ + __dynamic_func_call_cls_no_desc(__UNIQUE_ID(ddebug), cls, fmt, \ + func, ##__VA_ARGS__) +#define _dynamic_func_call_no_desc (fmt, func, ...) \ + _dynamic_func_call_cls_no_desc(_DPRINTK_CLASS_DFLT, fmt, \ + func, ##__VA_ARGS__) + +#define dynamic_pr_debug_cls (cls, fmt, ...) \ + _dynamic_func_call_cls(cls, fmt, __dynamic_pr_debug, \ + pr_fmt(fmt), ##__VA_ARGS__)#define dynamic_pr_debug (fmt, ...) \ - _dynamic_func_call(fmt, __dynamic_pr_debug, \ + _dynamic_func_call(fmt, __dynamic_pr_debug, \ pr_fmt(fmt), ##__VA_ARGS__)#define dynamic_dev_dbg (dev, fmt, ...) \ - _dynamic_func_call(fmt,__dynamic_dev_dbg, \ + _dynamic_func_call(fmt, __dynamic_dev_dbg, \ dev, fmt, ##__VA_ARGS__)#define dynamic_netdev_dbg (dev, fmt, ...) \
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 13/33 dyndbg: add __pr_debug_cls for testing
In reply to Jim CromieFor selftest purposes, add __pr_debug_cls(class, fmt, ...)
I didn't think we'd need to define this, since DRM effectively has it already in drm_dbg, drm_devdbg. But test_dynamic_debug needs it in order to demonstrate all the moving parts.
Note the __ prefix; its not intended for general use, at least until a need emerges. ISTM the drm.debug model (macro wrappers inserting enum const 1st arg) is the baseline approach.
That said, nouveau might want it for easy use in its debug macros. TBD.
NB: it does require a builtin-constant class, __pr_debug_cls(i++, ...) is disallowed by compiler.
--- include/linux/dynamic_debug.h | 7 +++++++ 1 file changed, 7 insertions(+)
include/linux/dynamic_debug.h +7 -0
@@ -221,6 +221,13 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor, KERN_DEBUG, prefix_str, prefix_type, \ rowsize, groupsize, buf, len, ascii) +/* for test only, generally expect drm.debug style macro wrappers */ +#define __pr_debug_cls (cls, fmt, ...) do { \ + BUILD_BUG_ON_MSG(!__builtin_constant_p(cls), \ + "expecting constant class int/enum"); \ + dynamic_pr_debug_cls(cls, fmt, ##__VA_ARGS__); \ + } while (0) +#else /* !CONFIG_DYNAMIC_DEBUG_CORE */ #include <linux/string.h>
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 14/33 dyndbg: add DECLARE_DYNDBG_CLASSMAP macro
In reply to Jim CromieWith DECLARE_DYNDBG_CLASSMAP modules can declare up to 31 classnames. By doing so, they authorize dyndbg to manipulate class'd prdbgs (ie:__pr_debug_cls, and soon drm_*dbg)
:#> echo class DRM_UT_KMS +p > /proc/dynamic_debug/control
The macro declares and initializes a static struct ddebug_class_map:
- maps approved class-names to class_ids used in module, by array order. forex: DRM_UT_*
- class-name vals allow validation of "class FOO" queries using macro is opt-in
- enum class_map_type - determines interface, behavior
Each module has its own .class_id space, and only known class-names will be authorized for a manipulation. Only DRM stuff should know this:
:#> echo class DRM_UT_CORE +p > control # across all modules
pr_debugs (with default class_id) are still controllable as before.
DECLARE_DYNDBG_CLASSMAP(_var, _maptype, _base, classes...) is::
_var: name of the static struct var. user passes to module_param_cb()
if they want a sysfs node.
_maptype: this is hard-coded to DD_CLASS_TYPE_DISJOINT_BITS for now.
_base: usually 0, it allows splitting 31 classes into subranges, so
that multiple classes / sysfs-nodes can share the module's class-id space.
classes: list of class_name strings, these are mapped to class-ids
starting at _base. This class-names list must have a corresponding ENUM, with SYMBOLS that match the literals, and 1st enum val = _base.
enum class_map_type has 4 values, on 2 factors::
- classes are disjoint/independent vs relative/x<y/verbosity. disjoint is basis, verbosity by overlay.
- input NUMBERS vs [+-]CLASS_NAMES
uints, ideally hex. vs +DRM_UT_CORE,-DRM_UT_KMS
DD_CLASS_TYPE_DISJOINT_BITS: classes are separate, one per bit.
expecting hex input. built for drm.debug, basis for other types.
DD_CLASS_TYPE_DISJOINT_NAMES: input is a CSV of [+-]CLASS_NAMES,
classes are independent, like DISJOINT
DD_CLASS_TYPE_LEVEL_NUM: input is numeric level, 0-N.
0 implies silence. use printk to break that. relative levels applied on bitmaps.
DD_CLASS_TYPE_LEVEL_NAMES: input is a CSV of [+-]CLASS_NAMES,
names like: ERR,WARNING,NOTICE,INFO,DEBUG avoiding EMERG,ALERT,CRIT,ERR - no point.
NOTES:
The macro places the initialized struct ddebug_class_map into the __dyndbg_classes section. That draws a 'orphan' warning which we handle in next commit. The struct attributes are necessary:__aligned(8) stopped null-ptr derefs (why?), __used is needed by drm drivers, which declare class-maps, but don't also declare a sysfs-param, and thus dont ref the classmap; __used insures that the linkage is made, then the class-map is found at load-time.
While its possible to handle both NAMES and NUMBERS in the same sys-interface, there is ambiguity to avoid, by disallowing them together. Later, if ambiguities are resolved, 2 new enums can permit both inputs, on verbose & independent types separately, and authors can select the interface they like.
The plan is to implement LEVELS in the callbacks, outside of ddebug_exec_query(), which for simplicity will treat the CLASSES in the map as disjoint. The callbacks can see map-type, and apply ++/-- loops (or bitops) to force the relative meanings across the class-bitmap.
RFC: That leaves 2 issues:
1. doing LEVELs in callbacks means that the native >control interface doesn't enforce the LEVELS relationship, so you could confusingly have V3 enabled, but V1 disabled. OTOH, the control iface already allows infinite tweaking of the underlying callsites; sysfs node readback can only tell the user what they previously wrote.
2. All dyndbg >control reduces to a query/command, includes +/-, which is at-root a kernel patching operation with +/- semantics. And the _NAMES handling exposes it to the user, making it API-adjacent.
And its not just >control where +/- gets used (which is settled), the new place is with sysfs-nodes exposing _*_NAMES classes, and here its subtly different.
_DISJOINT_NAMES: is simple, independent_LEVEL_NAMES: masks-on bits 0 .. N-1, N..max off
# turn on L3,L2,L1 others off echo +L3 > /sys/module/test_dynamic_debug/parameters/p_level_names
# turn on L2,L1 others off echo -L3 > /sys/module/test_dynamic_debug/parameters/p_level_names
IOW, the - changes the threshold-on bitpos by 1.
Alternatively, we could treat the +/- as half-duplex, where -L3 turns off L>2 (and ignores L1), and +L2 would turn on L<=2 (and ignore others).
---
. revised DD_CLASS_TYPE_{DISJOINT,LEVEL}_* names . reorder-enum by necessity - _NAMES feature is extra.
--- include/linux/dynamic_debug.h | 56 +++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+)
include/linux/dynamic_debug.h +56 -0
@@ -56,6 +56,62 @@ struct _ddebug {#endif } __attribute__((aligned(8))); +enum 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_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. Model user +* would be /sys/module/drm/parameters/debug_categories. +*/ +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 +*/ +}; + +struct ddebug_class_map { +struct list_head link; +struct module *mod; +const char *mod_name;/* needed for builtins */ +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; +}; + +/** +* 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;
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 15/33 kernel/module: add __dyndbg_classes section
In reply to Jim CromieAdd __dyndbg_classes section, using __dyndbg as a model. Use it:
vmlinux.lds.h:
KEEP the new section, which also silences orphan section warning on loadable modules. Add (__start_/__stop_)__dyndbg_classes linker symbols for the c externs (below).
kernel/module/main.c:
- fill new fields in find_module_sections(), using section_objs()
- extend callchain prototypes
to pass classes, length
load_module(): pass new info to dynamic_debug_setup() dynamic_debug_setup(): new params, pass through to ddebug_add_module()
dynamic_debug.c:
- add externs to the linker symbols.
ddebug_add_module():
- It currently builds a debug_table, and *will* find and attach classes.
dynamic_debug_init():
- add class fields to the _ddebug_info cursor var: di.
--- include/asm-generic/vmlinux.lds.h | 3 +++ include/linux/dynamic_debug.h | 2 ++ kernel/module/main.c | 2 ++ lib/dynamic_debug.c | 7 +++++++ 4 files changed, 14 insertions(+)
include/asm-generic/vmlinux.lds.h +3 -0
@@ -345,6 +345,9 @@ *(__tracepoints) \/* implement dynamic printk debug */ \ . = ALIGN(8); \ + __start___dyndbg_classes = .; \ + KEEP(*(__dyndbg_classes)) \ + __stop___dyndbg_classes = .; \ __start___dyndbg = .; \ KEEP(*(__dyndbg)) \ __stop___dyndbg = .; \
include/linux/dynamic_debug.h +2 -0
@@ -115,7 +115,9 @@ struct ddebug_class_map {/* encapsulate linker provided built-in (or module) dyndbg data */ struct _ddebug_info {struct _ddebug *descs; +struct ddebug_class_map *classes;unsigned int num_descs; +unsigned int num_classes; };#if defined(CONFIG_DYNAMIC_DEBUG_CORE )
kernel/module/main.c +2 -0
@@ -2095,6 +2095,8 @@ static int find_module_sections(struct module *mod, struct load_info *info) info->dyndbg.descs =section_objs (info,"__dyndbg" ,sizeof (*info->dyndbg.descs), &info->dyndbg.num_descs); + info->dyndbg.classes =section_objs (info,"__dyndbg_classes" , +sizeof (*info->dyndbg.classes), &info->dyndbg.num_classes);return 0 ; }
lib/dynamic_debug.c +7 -0
@@ -41,6 +41,8 @@extern struct _ddebug __start___dyndbg[];extern struct _ddebug __stop___dyndbg[]; +extern struct ddebug_class_map __start___dyndbg_classes[]; +extern struct ddebug_class_map __stop___dyndbg_classes[];struct ddebug_table {struct list_head link;
@@ -1079,7 +1081,9 @@ static int __init dynamic_debug_init(void)struct _ddebug_info di = { .descs = __start___dyndbg, + .classes = __start___dyndbg_classes, .num_descs = __stop___dyndbg - __start___dyndbg, + .num_classes = __stop___dyndbg_classes - __start___dyndbg_classes, };if (&__start___dyndbg == &__stop___dyndbg) {
@@ -1122,6 +1126,9 @@ static int __init dynamic_debug_init(void) i, mod_ct, (int )((mod_ct *sizeof (struct ddebug_table )) >>10 ), (int)((i * sizeof(struct _ddebug)) >> 10)); +if (di.num_classes) +v2pr_info (" %d builtin ddebug class-maps\n" , di.num_classes); +/* now that ddebug tables are loaded, process all boot args * again to find and activate queries given in dyndbg params. * While this has already been done for known boot params, it
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 16/33 dyndbg: add ddebug_attach_module_classes
In reply to Jim CromieAdd ddebug_attach_module_classes(), call it from ddebug_add_module(). It scans the classes/section its given, finds records where the module-name matches the module being added, and adds them to the module's maps list. No locking here, since the record isn't yet linked into the ddebug_tables list.
It is called indirectly from 2 sources:
- from load_module(), where it scans the module's __dyndbg_classes section, which contains DYNAMIC_DEBUG_CLASSES definitions from just the module.
- from dynamic_debug_init(), where all DYNAMIC_DEBUG_CLASSES definitions of each builtin module have been packed together. This is why ddebug_attach_module_classes() checks module-name.
NOTES
Its (highly) likely that builtin classes will be ordered by module name (just like prdbg descriptors are in the __dyndbg section). So the list can be replaced by a vector (ptr + length), which will work for loaded modules too. This would imitate whats currently done for the _ddebug descriptors.
That said, converting to vector,len is close to pointless; a small minority of modules will ever define a class-map, and almost all of them will have only 1 or 2 class-maps, so theres only a couple dozen pointers to save.
--- lib/dynamic_debug.c | 34 +++++++++++++++++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-)
lib/dynamic_debug.c +33 -1
@@ -45,7 +45,7 @@ extern struct ddebug_class_map __start___dyndbg_classes[];extern struct ddebug_class_map __stop___dyndbg_classes[];struct ddebug_table { -struct list_head link; +struct list_head link, maps;const char *mod_name;unsigned int num_ddebugs;struct _ddebug *ddebugs;
@@ -921,6 +921,32 @@ static const struct proc_ops proc_fops = { .proc_write = ddebug_proc_write }; +static void ddebug_attach_module_classes (struct ddebug_table *dt, +struct ddebug_class_map *classes, +int num_classes) +{ +struct ddebug_class_map *cm; +int i, j, ct =0 ; + +for (cm = classes, i =0 ; i < num_classes; i++, cm++) { + +if (!strcmp (cm->mod_name, dt->mod_name)) { + +v2pr_info ("class[%d]: module:%s base:%d len:%d ty:%d\n" , i, + cm->mod_name, cm->base, cm->length, cm->map_type); + +for (j =0 ; j < cm->length; j++) +v3pr_info (" %d: %d %s\n" , j + cm->base, j, + cm->class_names[j]); + +list_add (&cm->link, &dt->maps); + ct++; + } + } +if (ct) +vpr_info ("module:%s attached %d classes\n" , dt->mod_name, ct); +} +/* * Allocate a new ddebug_table for the given module * and add it to the global list.
@@ -953,6 +979,12 @@ static int __ddebug_add_module(struct _ddebug_info *di, unsigned int base,INIT_LIST_HEAD (&dt->link); +INIT_LIST_HEAD (&dt->link); +INIT_LIST_HEAD (&dt->maps); + +if (classes && num_classes) +ddebug_attach_module_classes (dt, classes, num_classes); +mutex_lock (&ddebug_lock);list_add_tail (&dt->link, &ddebug_tables);mutex_unlock (&ddebug_lock);
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 17/33 dyndbg: validate class FOO by checking with module
In reply to Jim CromieAdd module-to-class validation:
#> echo class DRM_UT_KMS +p > /proc/dynamic_debug/control
If a query has "class FOO", then ddebug_find_valid_class(), called from ddebug_change(), requires that FOO is known to module X, otherwize the query is skipped entirely for X. This protects each module's class-space, other than the default:31.
The authors' choice of FOO is highly selective, giving isolation and/or coordinated sharing of FOOs. For example, only DRM modules should know and respond to DRM_UT_KMS.
So this, combined with module's opt-in declaration of known classes, effectively privatizes the .class_id space for each module (or coordinated set of modules).
Notes:
For all "class FOO" queries, ddebug_find_valid_class() is called, it returns the map matching the query, and sets valid_class via an *outvar).
If no "class FOO" is supplied, valid_class = _CLASS_DFLT. This insures that legacy queries do not trample on new class'd callsites, as they get added.
Also add a new column to control-file output, displaying non-default class-name (when found) or the "unknown _id:", if it has not been (correctly) declared with one of the declarator macros.
--- lib/dynamic_debug.c | 76 ++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 68 insertions(+), 8 deletions(-)
lib/dynamic_debug.c +68 -8
@@ -56,6 +56,7 @@ struct ddebug_query {const char *module;const char *function;const char *format; +const char *class_string;unsigned int first_lineno, last_lineno; };
@@ -136,15 +137,33 @@ static void vpr_info_dq(const struct ddebug_query *query, const char *msg) fmtlen--; } -v3pr_info ("%s: func=\"%s\" file=\"%s\" module=\"%s\" format=\"%.*s\" lineno=%u-%u\n" , - msg, - query->function ?:"" , - query->filename ?:"" , - query->module ?:"" , - fmtlen, query->format ?:"" , - query->first_lineno, query->last_lineno); +v3pr_info ("%s: func=\"%s\" file=\"%s\" module=\"%s\" format=\"%.*s\" lineno=%u-%u class=%s\n" , + msg, + query->function ?:"" , + query->filename ?:"" , + query->module ?:"" , + fmtlen, query->format ?:"" , + query->first_lineno, query->last_lineno, query->class_string); } +static struct ddebug_class_map *ddebug_find_valid_class (struct ddebug_table const *dt, +const char *class_string,int *class_id) +{ +struct ddebug_class_map *map; +int idx; + +list_for_each_entry (map, &dt->maps, link) { + idx =match_string (map->class_names, map->length, class_string); +if (idx >=0 ) { + *class_id = idx + map->base; +return map; + } + } + *class_id = -ENOENT ; +return NULL ; +} + +#define __outvar/* filled by callee */ /* * Search the tables for _ddebug's which match the given `query' and * apply the `flags' and `mask' to them. Returns number of matching
@@ -159,6 +178,8 @@ static int ddebug_change(const struct ddebug_query *query,unsigned int newflags;unsigned int nfound =0 ;struct flagsbuf fbuf, nbuf; +struct ddebug_class_map *map =NULL ; + int __outvar valid_class;/* search for matching ddebugs */ mutex_lock (&ddebug_lock);
@@ -169,9 +190,22 @@ static int ddebug_change(const struct ddebug_query *query, !match_wildcard(query->module, dt->mod_name)) continue; +if (query->class_string) { + map =ddebug_find_valid_class (dt, query->class_string, &valid_class); +if (!map) +continue ; + }else { +/* constrain query, do not touch class'd callsites */ + valid_class = _DPRINTK_CLASS_DFLT; + } +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) &&
@@ -420,6 +454,8 @@ static int ddebug_parse_query(char *words[], int nwords, }else if (!strcmp (keyword,"line" )) {if (parse_linerange (query, arg))return -EINVAL ; + }else if (!strcmp (keyword,"class" )) { + rc =check_set (&query->class_string, arg,"class" ); }else {pr_err ("unknown keyword \"%s\"\n" , keyword);return -EINVAL ;
@@ -854,6 +890,20 @@ static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)return dp; } +#define class_in_range (class_id, map) \ + (class_id >= map->base && class_id < map->base + map->length) + +static const char *ddebug_class_name (struct ddebug_iter *iter,struct _ddebug *dp) +{ +struct ddebug_class_map *map; + +list_for_each_entry (map, &iter->table->maps, link) +if (class_in_range (dp->class_id, map)) +return map->class_names[dp->class_id - map->base]; + +return NULL ; +} +/* * Seq_ops show method. Called several times within a read() * call from userspace, with ddebug_lock held. Formats the
@@ -865,6 +915,7 @@ static int ddebug_proc_show(struct seq_file *m, void *p)struct ddebug_iter *iter = m->private;struct _ddebug *dp = p;struct flagsbuf flags; +char const *class;if (p ==SEQ_START_TOKEN ) { seq_puts(m,
@@ -877,7 +928,16 @@ static int ddebug_proc_show(struct seq_file *m, void *p) iter->table->mod_name, dp->function, ddebug_describe_flags(dp->flags, &flags));seq_escape_str (m, dp->format,ESCAPE_SPACE ,"\t\r\n\"" ); -seq_puts (m,"\"\n" ); +seq_puts (m,"\"" ); + +if (dp->class_id != _DPRINTK_CLASS_DFLT) { + class =ddebug_class_name (iter, dp); +if (class) +seq_printf (m," class:%s" , class); +else +seq_printf (m," class unknown, _id:%d" , dp->class_id); + } +seq_puts (m,"\n" );return 0 ; }
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 18/33 doc-dyndbg: describe "class CLASS_NAME" query support
In reply to Jim CromieAdd an explanation of the new "class CLASS_NAME" syntax and meaning, noting that the module determines if CLASS_NAME applies to it.
--- Documentation/admin-guide/dynamic-debug-howto.rst | 11 +++++++++++ 1 file changed, 11 insertions(+)
Documentation/admin-guide/dynamic-debug-howto.rst +11 -0
@@ -35,6 +35,7 @@ Dynamic debug has even more useful features: - line number (including ranges of line numbers) - module name - format string + - class name (as known/declared by each module) * Provides a debugfs control file: ``<debugfs>/dynamic_debug/control`` which can be read to display the complete list of known debug
@@ -142,6 +143,7 @@ against. Possible keywords are::: 'file' string | 'module' string | 'format' string | + 'class' string | 'line' line-range line-range ::= lineno |
@@ -203,6 +205,15 @@ 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 + line The given line number or range of line numbers is compared against the line number of each ``pr_debug()`` callsite. A single
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 19/33 doc-dyndbg: edit dynamic-debug-howto for brevity, audience
In reply to Jim CromieRework/modernize docs:
- use /proc/dynamic_debug/control in examples
its *always* there (when dyndbg is config'd), even when <debugfs> is not. drop <debugfs> talk, its a distraction here.
- alias ddcmd='echo $* > /proc/dynamic_debug/control focus on args: declutter, hide boilerplate, make pwd independent.
- swap sections: Viewing before Controlling. control file as Catalog.
- focus on use by a system administrator
add an alias to make examples more readable
drop grep-101 lessons, admins know this.
- use init/main.c as 1st example, thread it thru doc where useful. everybodys kernel boots, runs these.
- add *prdbg* api section
to the bottom of the file, its for developers more than admins. move list of api functions there.
- simplify - drop extra words, phrases, sentences.
- add "decorator" flags line to unify "prefix", trim fmlt descriptions
---
fixup-doc: trailing colons for block headers, trim fedora numbers. Bagas
--- .../admin-guide/dynamic-debug-howto.rst | 235 +++++++++--------- 1 file changed, 117 insertions(+), 118 deletions(-)
Documentation/admin-guide/dynamic-debug-howto.rst +117 -118
@@ -5,30 +5,19 @@ Dynamic debug Introduction ============ -This document describes how to use the dynamic debug (dyndbg) feature. +Dynamic debug allows you to dynamically enable/disable kernel +debug-print code to obtain additional kernel information. -Dynamic debug is designed to allow you to dynamically enable/disable -kernel code to obtain additional kernel information. Currently, if -``CONFIG_DYNAMIC_DEBUG`` is set, then all ``pr_debug()``/``dev_dbg()`` and -``print_hex_dump_debug()``/``print_hex_dump_bytes()`` calls can be dynamically -enabled per-callsite. +If ``/proc/dynamic_debug/control`` exists, your kernel has dynamic +debug. You'll need root access (sudo su) to use this. -If you do not want to enable dynamic debug globally (i.e. in some embedded -system), you may set ``CONFIG_DYNAMIC_DEBUG_CORE`` as basic support of dynamic -debug and add ``ccflags := -DDYNAMIC_DEBUG_MODULE`` into the Makefile of any -modules which you'd like to dynamically debug later. +Dynamic debug provides: -If ``CONFIG_DYNAMIC_DEBUG`` is not set, ``print_hex_dump_debug()`` is just -shortcut for ``print_hex_dump(KERN_DEBUG)``. + * a Catalog of all *prdbgs* in your kernel. + ``cat /proc/dynamic_debug/control`` to see them. -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. - -Dynamic debug has even more useful features: - - * Simple query language allows turning on and off debugging - statements by matching any combination of 0 or 1 of: + * a Simple query/command language to alter *prdbgs* by selecting on + any combination of 0 or 1 of: - source filename - function name
@@ -37,107 +26,88 @@ Dynamic debug has even more useful features: - format string - class name (as known/declared by each module) - * Provides a debugfs control file: ``<debugfs>/dynamic_debug/control`` - which can be read to display the complete list of known debug - statements, to help guide you - -Controlling dynamic debug Behaviour -=================================== - -The behaviour of ``pr_debug()``/``dev_dbg()`` are controlled via writing to a -control file in the 'debugfs' filesystem. Thus, you must first mount -the debugfs filesystem, in order to make use of this feature. -Subsequently, we refer to the control file as: -``<debugfs>/dynamic_debug/control``. For example, if you want to enable -printing from source file ``svcsock.c``, line 1603 you simply do:: - - nullarbor:~ # echo 'file svcsock.c line 1603 +p' > - <debugfs>/dynamic_debug/control - -If you make a mistake with the syntax, the write will fail thus:: - - nullarbor:~ # echo 'file svcsock.c wtf 1 +p' > - <debugfs>/dynamic_debug/control - -bash: echo: write error: Invalid argument - -Note, for systems without 'debugfs' enabled, the control file can be -found in ``/proc/dynamic_debug/control``. - Viewing Dynamic Debug Behaviour =============================== -You can view the currently configured behaviour of all the debug -statements via:: +You can view the currently configured behaviour in the *prdbg* catalog:: - nullarbor:~ # cat <debugfs>/dynamic_debug/control + :#> head -n7 /proc/dynamic_debug/control # filename:lineno [module]function flags format - net/sunrpc/svc_rdma.c:323 [svcxprt_rdma]svc_rdma_cleanup =_ "SVCRDMA Module Removed, deregister RPC RDMA transport\012" - net/sunrpc/svc_rdma.c:341 [svcxprt_rdma]svc_rdma_init =_ "\011max_inline : %d\012" - net/sunrpc/svc_rdma.c:340 [svcxprt_rdma]svc_rdma_init =_ "\011sq_depth : %d\012" - net/sunrpc/svc_rdma.c:338 [svcxprt_rdma]svc_rdma_init =_ "\011max_requests : %d\012" - ... + 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" +The 3rd space-delimited column shows the current flags, preceded by +a ``=`` for easy use with grep/cut. ``=p`` shows enabled callsites. -You can also apply standard Unix text manipulation filters to this -data, e.g.:: +Controlling dynamic debug Behaviour +=================================== - nullarbor:~ # grep -i rdma <debugfs>/dynamic_debug/control | wc -l - 62 +The behaviour of *prdbg* sites are controlled by writing +query/commands to the control file. Example:: - nullarbor:~ # grep -i tcp <debugfs>/dynamic_debug/control | wc -l - 42 + # grease the interface + :#> alias ddcmd='echo $* > /proc/dynamic_debug/control' -The third column shows the currently enabled flags for each debug -statement callsite (see below for definitions of the flags). The -default value, with no flags enabled, is ``=_``. So you can view all -the debug statement callsites with any non-default flags:: + :#> 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" - nullarbor:~ # awk '$3 != "=_"' <debugfs>/dynamic_debug/control - # filename:lineno [module]function flags format - net/sunrpc/svcsock.c:1603 [sunrpc]svc_send p "svc_process: st_sendto returned %d\012" +Error messages go to console/syslog:: + + :#> ddcmd mode foo +p + dyndbg: unknown keyword "mode" + dyndbg: query parse failed + bash: echo: write error: Invalid argument + +If debugfs is also enabled and mounted, ``dynamic_debug/control`` is +also under the mount-dir, typically ``/sys/kernel/debug/``. Command Language Reference ========================== -At the lexical level, a command comprises a sequence of words separated +At the basic lexical level, a command is a sequence of words separated by spaces or tabs. So these are all equivalent:: - nullarbor:~ # echo -n 'file svcsock.c line 1603 +p' > - <debugfs>/dynamic_debug/control - nullarbor:~ # echo -n ' file svcsock.c line 1603 +p ' > - <debugfs>/dynamic_debug/control - nullarbor:~ # echo -n 'file svcsock.c line 1603 +p' > - <debugfs>/dynamic_debug/control + :#> 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``:: - ~# echo "func pnpacpi_get_resources +p; func pnp_assign_mem +p" \ - > <debugfs>/dynamic_debug/control - -If your query set is big, you can batch them too:: - - ~# cat query-batch-file > <debugfs>/dynamic_debug/control + :#> ddcmd "func pnpacpi_get_resources +p; func pnp_assign_mem +p" + :#> ddcmd <<"EOC" + func pnpacpi_get_resources +p + func pnp_assign_mem +p + EOC + :#> cat query-batch-file > /proc/dynamic_debug/control -Another way is to use wildcards. The match rule supports ``*`` (matches -zero or more characters) and ``?`` (matches exactly one character). For -example, you can match all usb drivers:: +You can also use wildcards in each query term. The match rule supports +``*`` (matches zero or more characters) and ``?`` (matches exactly one +character). For example, you can match all usb drivers:: - ~# echo "file drivers/usb/* +p" > <debugfs>/dynamic_debug/control + :#> ddcmd file "drivers/usb/*" +p # "" to suppress shell expansion -At the syntactical level, a command comprises a sequence of match -specifications, followed by a flags change specification:: +Syntactically, a command is pairs of keyword values, followed by a +flags change or setting:: command ::= match-spec* flags-spec -The match-spec's are used to choose a subset of the known pr_debug() -callsites to which to apply the flags-spec. Think of them as a query -with implicit ANDs between each pair. Note that an empty list of -match-specs will select all debug statement callsites. +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 comprises a keyword, which controls the -attribute of the callsite to be compared, and a value to compare -against. Possible keywords are::: + +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::: match-spec ::= 'func' string | 'file' string |
@@ -213,6 +183,7 @@ class 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
@@ -239,17 +210,16 @@ of the characters:: The flags are:: p enables the pr_debug() callsite. - f Include the function name in the printed message - l Include line number in the printed message - m Include module name in the printed message - t Include thread ID in messages not generated from interrupt context - _ No flags are set. (Or'd with others on input) + _ enables no flags. -For ``print_hex_dump_debug()`` and ``print_hex_dump_bytes()``, only ``p`` flag -have meaning, other flags ignored. + Decorator flags add to the message-prefix, in order: + t Include thread ID, or <intr> + m Include module name + f Include the function name + l Include line number -For display, the flags are preceded by ``=`` -(mnemonic: what the flags are currently equal to). +For ``print_hex_dump_debug()`` and ``print_hex_dump_bytes()``, only +the ``p`` flag has meaning, other flags are ignored. Note the regexp ``^[-+=][flmpt_]+$`` matches a flags specification. To clear all flags at once, use ``=_`` or ``-flmpt``.
@@ -324,7 +294,7 @@ For ``CONFIG_DYNAMIC_DEBUG`` kernels, any settings given at boot-time (or enabled by ``-DDEBUG`` flag during compilation) can be disabled later via the debugfs interface if the debug messages are no longer needed:: - echo "module module_name -p" > <debugfs>/dynamic_debug/control + echo "module module_name -p" > /proc/dynamic_debug/control Examples ========
@@ -332,37 +302,31 @@ Examples :: // enable the message at line 1603 of file svcsock.c - nullarbor:~ # echo -n 'file svcsock.c line 1603 +p' > - <debugfs>/dynamic_debug/control + :#> ddcmd 'file svcsock.c line 1603 +p' // enable all the messages in file svcsock.c - nullarbor:~ # echo -n 'file svcsock.c +p' > - <debugfs>/dynamic_debug/control + :#> ddcmd 'file svcsock.c +p' // enable all the messages in the NFS server module - nullarbor:~ # echo -n 'module nfsd +p' > - <debugfs>/dynamic_debug/control + :#> ddcmd 'module nfsd +p' // enable all 12 messages in the function svc_process() - nullarbor:~ # echo -n 'func svc_process +p' > - <debugfs>/dynamic_debug/control + :#> ddcmd 'func svc_process +p' // disable all 12 messages in the function svc_process() - nullarbor:~ # echo -n 'func svc_process -p' > - <debugfs>/dynamic_debug/control + :#> ddcmd 'func svc_process -p' // enable messages for NFS calls READ, READLINK, READDIR and READDIR+. - nullarbor:~ # echo -n 'format "nfsd: READ" +p' > - <debugfs>/dynamic_debug/control + :#> ddcmd 'format "nfsd: READ" +p' // enable messages in files of which the paths include string "usb" - nullarbor:~ # echo -n 'file *usb* +p' > <debugfs>/dynamic_debug/control + :#> ddcmd 'file *usb* +p' > /proc/dynamic_debug/control // enable all messages - nullarbor:~ # echo -n '+p' > <debugfs>/dynamic_debug/control + :#> ddcmd '+p' > /proc/dynamic_debug/control // add module, function to all enabled messages - nullarbor:~ # echo -n '+mf' > <debugfs>/dynamic_debug/control + :#> ddcmd '+mf' > /proc/dynamic_debug/control // boot-args example, with newlines and comments for readability Kernel command line: ...
@@ -375,3 +339,38 @@ Examples dyndbg="file init/* +p #cmt ; func parse_one +p" // enable pr_debugs in 2 functions in a module loaded later pc87360.dyndbg="func pc87360_init_device +p; func pc87360_find +p" + +Kernel Configuration +==================== + +Dynamic Debug is enabled via kernel config items:: + + CONFIG_DYNAMIC_DEBUG=y # build catalog, enables CORE + CONFIG_DYNAMIC_DEBUG_CORE=y # enable mechanics only, skip catalog + +If you do not want to enable dynamic debug globally (i.e. in some embedded +system), you may set ``CONFIG_DYNAMIC_DEBUG_CORE`` as basic support of dynamic +debug and add ``ccflags := -DDYNAMIC_DEBUG_MODULE`` into the Makefile of any +modules which you'd like to dynamically debug later. + + +Kernel *prdbg* API +================== + +The following functions are cataloged and controllable when dynamic +debug is enabled:: + + pr_debug() + dev_dbg() + print_hex_dump_debug() + print_hex_dump_bytes() + +Otherwise, they are off by default; ``ccflags += -DDEBUG`` or +``#define DEBUG`` in a source file will enable them appropriately. + +If ``CONFIG_DYNAMIC_DEBUG`` is not set, ``print_hex_dump_debug()`` is +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.
Signature · 1 line
2.37.1
Re: [PATCH v5 19/33] doc-dyndbg: edit dynamic-debug-howto for brevity, audience
Quoted 22 lines · Jim Cromie
Rework/modernize docs:
- use
/proc/dynamic_debug/controlin examples
its *always* there (when dyndbg is config'd), even when <debugfs> is not. drop <debugfs> talk, its a distraction here.- alias ddcmd='echo $* >
/proc/dynamic_debug/controlfocus on args: declutter, hide boilerplate, make pwd independent.- swap sections: Viewing before Controlling. control file as Catalog.
- focus on use by a system administrator
add an alias to make examples more readable
drop grep-101 lessons, admins know this.- use
init/main.cas 1st example, thread it thru doc where useful. everybodys kernel boots, runs these.- add *prdbg* api section
to the bottom of the file, its for developers more than admins. move list of api functions there.
Quoted 7 lines
- simplify - drop extra words, phrases, sentences.
- add "decorator" flags line to unify "prefix", trim fmlt descriptions
Signed-off-by Jim Cromie <[email protected]>
The documentation LGTM (no new warnings).
Signature · 1 line
An old man doll... just what I always wanted! - Clara
Jim Cromie
maintainerPATCH v5 20/33 dyndbg: add drm.debug style (drm/parameters/debug) bitmap support
In reply to Jim CromieAdd kernel_param_ops and callbacks to use a class-map to validate and apply input to a sysfs-node, which allows users to control classes defined in that class-map. This supports uses like:
echo 0x3 > /sys/module/drm/parameters/debug
IE add these:
- int param_set_dyndbg_classes()
- int param_get_dyndbg_classes()
- struct kernel_param_ops param_ops_dyndbg_classes
Following the model of kernel/params.c STANDARD_PARAM_DEFS, these are non-static and exported. This might be unnecessary here.
get/set use an augmented kernel_param; the arg refs a new struct ddebug_class_param, which contains:
A union of &ulong bits, level; which points to user module's ulong storing the module's debug-state. By ref'g the client's bit-state _var, code coordinates with existing code (like drm_debug_enabled) which uses it, so existing works unchanged. Changing to a ulong allows use of BIT() etc.
FLAGS: dyndbg.flags toggled by changes to bitmap. Usually just "p".
MAP: a pointer to struct ddebug_classes_map, which maps those class-names to .class_ids 0..N that the module is using. This class-map is declared & initialized by DECLARE_DYNDBG_CLASSMAP.
map-type: 4 enums DD_CLASS_TYPE_* select 2 input forms and 2 meanings.
numeric input:
DD_CLASS_TYPE_DISJOINT_BITS integer input, independent bits. ie: drm.debug
DD_CLASS_TYPE_LEVEL_NUM integer input, 0..N levels
classnames-list (comma separated) input:
DD_CLASS_TYPE_DISJOINT_NAMES each name affects a bit, others preserved
DD_CLASS_TYPE_LEVEL_NAMES names have level meanings, like kern_levels.h
_NAMES - comma-separated classnames (with optional +-) _NUM - numeric input, 0-N expected _BITS - numeric input, 0x1F bitmap form expected
_DISJOINT - bits are independent_LEVEL - (x<y) on bit-pos.
_DISJOINT treats input like a bit-vector (ala drm.debug), and sets each bit accordingly. LEVEL is layered on top of this.
_LEVEL treats input like a bit-pos:N, then sets bits(0..N)=1, and bits(N+1..max)=0. This applies (bit<N) semantics on top of disjoint bits.
USAGES:
A potentially typical _DISJOINT_NAMES use:
echo +DRM_UT_CORE,+DRM_UT_KMS,-DRM_UT_DRIVER,-DRM_UT_ATOMIC \
> /sys/module/drm/parameters/debug_catnamesA standard _LEVEL_NAMES use, with one class, that sets all in the class-map according to (x<y):
: problem seen
echo +L7 > /sys/module/test_dynamic_debug/parameters/p_level_names : problem solved
echo -L1 > /sys/module/test_dynamic_debug/parameters/p_level_names
Note this artifact:
: this is same as prev cmd (due to +/-)
echo L0 > /sys/module/test_dynamic_debug/parameters/p_level_names
: this is "even-more" off, but same wo __pr_debug_class(L0, ".."). echo -L0 > /sys/module/test_dynamic_debug/parameters/p_level_names
A stress-test/make-work usage (kid toggling a light switch):
echo +L7,L0,L7,L0,L7,L0,L7,L0,L7,L0,L7,L0,L7 \
> /sys/module/test_dynamic_debug/parameters/p_level_namesddebug_apply_class_bitmap(): inside-fn, works on bitmaps, receives new-bits, finds diffs vs client-bitvector holding "current" state, and issues exec_query to commit the adjustment.
param_set_dyndbg_classes(): interface fn, sends _NAMES to param_set_dyndbg_classnames() and returns, falls thru to handle _BITS, _NUM internally, and calls ddebug_apply_class_bitmap(). Finishes by updating state.
param_set_dyndbg_classnames(): handles classnames-list in loop, calls ddebug_apply_class_bitmap for each, then updates state.
NOTES:
_LEVEL_ is overlay on _DISJOINT_; inputs are converted to a bitmask, and is done by callbacks. IOW this is possible, and possibly confusing:
echo class V3 +p > control
echo class V1 -p > control
IMO thats ok, relative verbosity is an interface property.
_LEVEL_NUM maps still need class-names, even though the names are not usable at the sysfs interface (unlike with _NAMES style). The names are the only way to >control the classes.
- It must have a "V0" name,
something below "V1" to turn "V1" off. __pr_debug_cls(V0,..) is printk, don't do that.
- "class names" is required at the >control interface.
- relative levels are not enforced at >control
_LEVEL_NAMES bear +/- signs, which alters the on-bit-pos by 1. IOW, +L2 means L0,L1,L2, and -L2 means just L0,L1. This kinda spoils the readback fidelity, since the L0 bit gets turned on by any use of any L*, except "-L0".
All the interface uncertainty here pertains to the _NAMES features. Nobody has actually asked for this, so its practical (if a little tedious) to split it out.
---
. drop kp->mod->name as unneeded (build-dependent) <lkp> . param_set_dyndbg_classnames, not _class_strings
. DD_CLASS_TYPE_* name changes, per Jason
. callbacks:
extend comments on DD_CLASS_TYPE_* handling, flow notes varname changes
. kdoc tweaks
. add stub macro: #define KP_NAME(kp) kp->name
later, add "$module." prefix when config doesn't do it
. s/struct ddebug_classes_bitmap_param/struct ddebug_class_param/ . fix levels state handling
v4 had trouble where level-type's state was fouled by conversion to bitmap form given to apply-bitmap. fix by:
(simplify/clarify)
add old-bits, new-bits to sysfs-iface&support
use CLASSMAP_BITMASK more
in param_set_dyndbg_class{es,names}():
move state-saving inside switches, and tailor it to type. this preserves lvl-state, vs -v4 which didnt.
I could "hack" in an offset, but the problem feels deeper.
The root-problem may be the ambiguity wrt 0x0 > knob; per a input-is-assert-bitpos interpretation, it turns on bit 0.
Thus far, code has avoided this ambiguity, by recommending against coding pr_dbg_cls(V0|L0, ""), which makes "+L0" & "-L0" equivalent, and "0" silent.
That might be "too clever by 1/2"; accepting an int, so -1 means all-bits-off as well as verbosity-off, might be the better way.
--- include/linux/dynamic_debug.h | 20 ++++ lib/dynamic_debug.c | 218 +++++++++++++++++++++++++++++++++- 2 files changed, 234 insertions(+), 4 deletions(-)
include/linux/dynamic_debug.h +20 -0
@@ -120,6 +120,14 @@ struct _ddebug_info {unsigned int num_classes; }; +struct ddebug_class_param { +union {unsigned long *bits; +unsigned long *lvl; + }; +char flags[8 ]; +const struct ddebug_class_map *map; +}; +#if defined(CONFIG_DYNAMIC_DEBUG_CORE )int ddebug_add_module (struct _ddebug_info *dyndbg,const char *modname);
@@ -279,6 +287,10 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor, KERN_DEBUG, prefix_str, prefix_type, \ rowsize, groupsize, buf, len, ascii) +struct kernel_param ; +int param_set_dyndbg_classes (const char *instr,const struct kernel_param *kp); +int param_get_dyndbg_classes (char *buffer,const struct kernel_param *kp); +/* for test only, generally expect drm.debug style macro wrappers */ #define __pr_debug_cls (cls, fmt, ...) do { \ BUILD_BUG_ON_MSG(!__builtin_constant_p(cls), \
@@ -325,6 +337,14 @@ static inline int ddebug_dyndbg_module_param_cb(char *param, char *val, rowsize, groupsize, buf, len, ascii); \ } while (0) +struct kernel_param; +static inline int param_set_dyndbg_classes (const char *instr,const struct kernel_param *kp) +{return 0 ; } +static inline int param_get_dyndbg_classes (char *buffer,const struct kernel_param *kp) +{return 0 ; } +#endif /* !CONFIG_DYNAMIC_DEBUG_CORE */ +extern const struct kernel_param_ops param_ops_dyndbg_classes; +#endif
lib/dynamic_debug.c +214 -4
233 lines not on this page · raw message
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 21/33 dyndbg: test DECLARE_DYNDBG_CLASSMAP, sysfs nodes
In reply to Jim CromieDemonstrate use of DECLARE_DYNDBG_CLASSMAP macro, and expose them as sysfs-nodes for testing.
For each of the 4 class-map-types:
- declare a class-map of that type,
- declare the enum corresponding to those class-names
- share _base across 0..30 range
- add a __pr_debug_cls() call for each class-name
- declare 2 sysnodes for each class-map
for 'p' flag, and future 'T' flag
These declarations create the following sysfs parameter interface:
:#> pwd
/sys/module/test_dynamic_debug/parameters
:#> ls
T_disjoint_bits T_disjoint_names T_level_names T_level_num do_prints p_disjoint_bits p_disjoint_names p_level_names p_level_num
NOTES:
The local wrapper macro is an api candidate, but there are already too many parameters. OTOH, maybe related enum should be in there too, since it has _base inter-dependencies.
The T_* params control the (future) T flag on the same class'd pr_debug callsites as their p* counterparts. Using them will fail, until the dyndbg-trace patches are added in.
:#> echo 1 > T_disjoint
[ 28.792489] dyndbg: disjoint: 0x1 > test_dynamic_debug.T_D2 [ 28.793848] dyndbg: query 0: "class D2_CORE +T" mod:* [ 28.795086] dyndbg: split into words: "class" "D2_CORE" "+T" [ 28.796467] dyndbg: op='+' [ 28.797148] dyndbg: unknown flag 'T' [ 28.798021] dyndbg: flags parse failed [ 28.798947] dyndbg: processed 1 queries, with 0 matches, 1 errs [ 28.800378] dyndbg: bit_0: -22 matches on class: D2_CORE -> 0x1 [ 28.801959] dyndbg: test_dynamic_debug.T_D2: updated 0x0 -> 0x1 [ 28.803974] dyndbg: total matches: -22
--- lib/test_dynamic_debug.c | 125 ++++++++++++++++++++++++++++++++++----- 1 file changed, 110 insertions(+), 15 deletions(-)
lib/test_dynamic_debug.c +110 -15
@@ -10,57 +10,152 @@#include <linux/module.h> -static void do_prints (void );/* device under test */ - -/* run tests by reading or writing sysfs node */ +/* run tests by reading or writing sysfs node: do_prints */ +static void do_prints (void );/* device under test */ static int param_set_do_prints (const char *instr,const struct kernel_param *kp) {do_prints ();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" ); } -static const struct kernel_param_ops param_ops_do_prints = { .set = param_set_do_prints, .get = param_get_do_prints, }; -module_param_cb (do_prints, ¶m_ops_do_prints,NULL ,0600 ); -static void do_alpha (void ) +/* +* Using the CLASSMAP api: +* - classmaps must have corresponding enum +* - enum symbols must match/correlate with class-name strings in the map. +* - base must equal enum's 1st value +* - multiple maps must set their base to share the 0-30 class_id space !! +* (build-bug-on tips welcome) +* Additionally, here: +* - tie together sysname, mapname, bitsname, flagsname +*/ +#define DD_SYS_WRAP (_model, _flags) \ + static unsigned long bits_##_model; \ + static struct ddebug_class_param _flags##_model = { \ + .bits = &bits_##_model, \ + .flags = #_flags, \ + .map = &map_##_model, \ + }; \ + module_param_cb(_flags##_##_model, ¶m_ops_dyndbg_classes, &_flags##_model, 0600) + +/* numeric input, independent bits */ +enum cat_disjoint_bits { +D2_CORE =0 , +D2_DRIVER , +D2_KMS , +D2_PRIME , +D2_ATOMIC , +D2_VBL , +D2_STATE , +D2_LEASE , +D2_DP , +D2_DRMRES }; +DECLARE_DYNDBG_CLASSMAP (map_disjoint_bits,DD_CLASS_TYPE_DISJOINT_BITS ,0 , +"D2_CORE" , +"D2_DRIVER" , +"D2_KMS" , +"D2_PRIME" , +"D2_ATOMIC" , +"D2_VBL" , +"D2_STATE" , +"D2_LEASE" , +"D2_DP" , +"D2_DRMRES" ); +DD_SYS_WRAP (disjoint_bits, p); +DD_SYS_WRAP (disjoint_bits,T ); + +/* symbolic input, independent bits */ +enum cat_disjoint_names {LOW =11 ,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 , +"V0" ,"V1" ,"V2" ,"V3" ,"V4" ,"V5" ,"V6" ,"V7" ); +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") + +static void do_cats (void ) { -pr_debug ("do alpha\n" ); +pr_debug ("doing categories\n" ); + +prdbg (LOW ); +prdbg (MID ); +prdbg (HI ); + +prdbg (D2_CORE ); +prdbg (D2_DRIVER ); +prdbg (D2_KMS ); +prdbg (D2_PRIME ); +prdbg (D2_ATOMIC ); +prdbg (D2_VBL ); +prdbg (D2_STATE ); +prdbg (D2_LEASE ); +prdbg (D2_DP ); +prdbg (D2_DRMRES ); } -static void do_beta (void ) + +static void do_levels (void ) { -pr_debug ("do beta\n" ); +pr_debug ("doing levels\n" ); + +prdbg (V1 ); +prdbg (V2 ); +prdbg (V3 ); +prdbg (V4 ); +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 ) { -do_alpha (); -do_beta (); +do_cats (); +do_levels (); }static int __init test_dynamic_debug_init (void ) {pr_debug ("init start\n" ); -do_prints (); -pr_debug ("init done\n" );return 0 ; } static void __exit test_dynamic_debug_exit(void) { -pr_debug ("exiting\n" ); +pr_debug ("exited\n" ); }module_init (test_dynamic_debug_init);
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 22/33 drm_print: condense enum drm_debug_category
In reply to Jim Cromieenum drm_debug_category has 10 categories, but is initialized with bitmasks which require 10 bits of underlying storage. By using natural enumeration, and moving the BIT(cat) into drm_debug_enabled(), the enum fits in 4 bits, allowing the category to be represented directly in pr_debug callsites, via the ddebug.class_id field.
While this slightly pessimizes the bit-test in drm_debug_enabled(), using dyndbg with JUMP_LABEL will avoid the function entirely.
NOTE: this change forecloses the possibility of doing:
drm_dbg(DRM_UT_CORE|DRM_UT_KMS, "weird 2-cat experiment")
but thats already strongly implied by the use of the enum itself; its not a normal enum if it can be 2 values simultaneously.
--- include/drm/drm_print.h | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-)
include/drm/drm_print.h +11 -11
@@ -279,49 +279,49 @@ enum drm_debug_category {* @DRM_UT_CORE: Used in the generic drm code: drm_ioctl.c, drm_mm.c, * drm_memory.c, ... */ -DRM_UT_CORE =0x01 , +DRM_UT_CORE ,/** * @DRM_UT_DRIVER: Used in the vendor specific part of the driver: i915, * radeon, ... macro. */ -DRM_UT_DRIVER =0x02 , +DRM_UT_DRIVER ,/** * @DRM_UT_KMS: Used in the modesetting code. */ -DRM_UT_KMS =0x04 , +DRM_UT_KMS ,/** * @DRM_UT_PRIME: Used in the prime code. */ -DRM_UT_PRIME =0x08 , +DRM_UT_PRIME ,/** * @DRM_UT_ATOMIC: Used in the atomic code. */ -DRM_UT_ATOMIC =0x10 , +DRM_UT_ATOMIC ,/** * @DRM_UT_VBL: Used for verbose debug message in the vblank code. */ -DRM_UT_VBL =0x20 , +DRM_UT_VBL ,/** * @DRM_UT_STATE: Used for verbose atomic state debugging. */ -DRM_UT_STATE =0x40 , +DRM_UT_STATE ,/** * @DRM_UT_LEASE: Used in the lease code. */ -DRM_UT_LEASE =0x80 , +DRM_UT_LEASE ,/** * @DRM_UT_DP: Used in the DP code. */ -DRM_UT_DP =0x100 , +DRM_UT_DP ,/** * @DRM_UT_DRMRES: Used in the drm managed resources code. */ - DRM_UT_DRMRES = 0x200, +DRM_UT_DRMRES };static inline bool drm_debug_enabled (enum drm_debug_category category) { -return unlikely (__drm_debug & category); +return unlikely (__drm_debug &BIT (category)); }/*
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 23/33 drm: POC drm on dyndbg - use in core, 2 helpers, 3 drivers.
In reply to Jim CromieUse DECLARE_DYNDBG_CLASSMAP across DRM:
- in .c files, since macro defines/initializes a record
- in drivers, $mod_{drv,drm,param}.c
ie where param setup is done, since a classmap is param related
- in drm/drm_print.c
since existing __drm_debug param is defined there, and we ifdef it, and provide an elaborated alternative.
- in drm_*_helper modules:
dp/drm_dp - 1st item in makefile target drivers/gpu/drm/drm_crtc_helper.c - random pick iirc.
Since these modules all use identical CLASSMAP declarations (ie: names and .class_id's) they will all respond together to "class DRM_UT_*" query-commands:
:#> echo class DRM_UT_KMS +p > /proc/dynamic_debug/control
NOTES:
This changes __drm_debug from int to ulong, so BIT() is usable on it.
DRM's enum drm_debug_category values need to sync with the index of their respective class-names here. Then .class_id == category, and dyndbg's class FOO mechanisms will enable drm_dbg(DRM_UT_KMS, ...).
Though DRM needs consistent categories across all modules, thats not generally needed; modules X and Y could define FOO differently (ie a different NAME => class_id mapping), changes are made according to each module's private class-map.
No callsites are actually selected by this patch, since none are class'd yet.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c | 14 +++++++++++++ drivers/gpu/drm/display/drm_dp_helper.c | 13 ++++++++++++ drivers/gpu/drm/drm_crtc_helper.c | 13 ++++++++++++ drivers/gpu/drm/drm_print.c | 27 +++++++++++++++++++++++-- drivers/gpu/drm/i915/i915_params.c | 12 +++++++++++ drivers/gpu/drm/nouveau/nouveau_drm.c | 13 ++++++++++++ include/drm/drm_print.h | 3 ++- 7 files changed, 92 insertions(+), 3 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +14 -0
@@ -38,6 +38,8 @@#include <linux/mmu_notifier.h> #include <linux/suspend.h> #include <linux/cc_platform.h> +#include <linux/fb.h> +#include <linux/dynamic_debug.h> #include "amdgpu.h" #include "amdgpu_irq.h"
@@ -183,6 +185,18 @@ int amdgpu_vcnfw_log;static void amdgpu_drv_delayed_reset_work_handler (struct work_struct *work); +DECLARE_DYNDBG_CLASSMAP (drm_debug_classes,DD_CLASS_TYPE_DISJOINT_BITS ,0 , +"DRM_UT_CORE" , +"DRM_UT_DRIVER" , +"DRM_UT_KMS" , +"DRM_UT_PRIME" , +"DRM_UT_ATOMIC" , +"DRM_UT_VBL" , +"DRM_UT_STATE" , +"DRM_UT_LEASE" , +"DRM_UT_DP" , +"DRM_UT_DRMRES" ); +struct amdgpu_mgpu_info mgpu_info = { .mutex =__MUTEX_INITIALIZER (mgpu_info.mutex), .delayed_reset_work = __DELAYED_WORK_INITIALIZER(
drivers/gpu/drm/display/drm_dp_helper.c +13 -0
@@ -29,6 +29,7 @@#include <linux/sched.h> #include <linux/seq_file.h> #include <linux/string_helpers.h> +#include <linux/dynamic_debug.h> #include <drm/display/drm_dp_helper.h> #include <drm/display/drm_dp_mst_helper.h>
@@ -38,6 +39,18 @@#include "drm_dp_helper_internal.h" +DECLARE_DYNDBG_CLASSMAP (drm_debug_classes,DD_CLASS_TYPE_DISJOINT_BITS ,0 , +"DRM_UT_CORE" , +"DRM_UT_DRIVER" , +"DRM_UT_KMS" , +"DRM_UT_PRIME" , +"DRM_UT_ATOMIC" , +"DRM_UT_VBL" , +"DRM_UT_STATE" , +"DRM_UT_LEASE" , +"DRM_UT_DP" , +"DRM_UT_DRMRES" ); +struct dp_aux_backlight {struct backlight_device *base;struct drm_dp_aux *aux;
drivers/gpu/drm/drm_crtc_helper.c +13 -0
@@ -32,6 +32,7 @@#include <linux/export.h> #include <linux/kernel.h> #include <linux/moduleparam.h> +#include <linux/dynamic_debug.h> #include <drm/drm_atomic.h> #include <drm/drm_atomic_helper.h>
@@ -50,6 +51,18 @@#include "drm_crtc_helper_internal.h" +DECLARE_DYNDBG_CLASSMAP (drm_debug_classes,DD_CLASS_TYPE_DISJOINT_BITS ,0 , +"DRM_UT_CORE" , +"DRM_UT_DRIVER" , +"DRM_UT_KMS" , +"DRM_UT_PRIME" , +"DRM_UT_ATOMIC" , +"DRM_UT_VBL" , +"DRM_UT_STATE" , +"DRM_UT_LEASE" , +"DRM_UT_DP" , +"DRM_UT_DRMRES" ); +/** * DOC: overview *
drivers/gpu/drm/drm_print.c +25 -2
@@ -40,7 +40,7 @@* __drm_debug: Enable debug output. * Bitmask of DRM_UT_x. See include/drm/drm_print.h for details. */ -unsigned int __drm_debug; +unsigned long __drm_debug;EXPORT_SYMBOL (__drm_debug); MODULE_PARM_DESC(debug, "Enable debug output, where each bit enables a debug category.\n"
@@ -52,7 +52,30 @@ MODULE_PARM_DESC(debug, "Enable debug output, where each bit enables a debug cat"\t\tBit 5 (0x20) will enable VBL messages (vblank code)\n" "\t\tBit 7 (0x80) will enable LEASE messages (leasing code)\n" "\t\tBit 8 (0x100) will enable DP messages (displayport code)"); -module_param_named (debug, __drm_debug, int,0600 ); + +#if !defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) +module_param_named (debug, __drm_debug, ulong,0600 ); +#else +/* classnames must match vals of enum drm_debug_category */ +DECLARE_DYNDBG_CLASSMAP (drm_debug_classes,DD_CLASS_TYPE_DISJOINT_BITS ,0 , +"DRM_UT_CORE" , +"DRM_UT_DRIVER" , +"DRM_UT_KMS" , +"DRM_UT_PRIME" , +"DRM_UT_ATOMIC" , +"DRM_UT_VBL" , +"DRM_UT_STATE" , +"DRM_UT_LEASE" , +"DRM_UT_DP" , +"DRM_UT_DRMRES" ); + +static struct ddebug_class_param drm_debug_bitmap = { + .bits = &__drm_debug, + .flags ="p" , + .map = &drm_debug_classes, +}; +module_param_cb (debug, ¶m_ops_dyndbg_classes, &drm_debug_bitmap,0600 ); +#endif void __drm_puts_coredump (struct drm_printer *p,const char *str) {
drivers/gpu/drm/i915/i915_params.c +12 -0
@@ -29,6 +29,18 @@#include "i915_params.h" #include "i915_drv.h" +DECLARE_DYNDBG_CLASSMAP (drm_debug_classes,DD_CLASS_TYPE_DISJOINT_BITS ,0 , +"DRM_UT_CORE" , +"DRM_UT_DRIVER" , +"DRM_UT_KMS" , +"DRM_UT_PRIME" , +"DRM_UT_ATOMIC" , +"DRM_UT_VBL" , +"DRM_UT_STATE" , +"DRM_UT_LEASE" , +"DRM_UT_DP" , +"DRM_UT_DRMRES" ); +#define i915_param_named (name,T , perm, desc) \ module_param_named(name, i915_modparams.name, T, perm); \ MODULE_PARM_DESC(name, desc)
drivers/gpu/drm/nouveau/nouveau_drm.c +13 -0
@@ -28,6 +28,7 @@#include <linux/pm_runtime.h> #include <linux/vga_switcheroo.h> #include <linux/mmu_notifier.h> +#include <linux/dynamic_debug.h> #include <drm/drm_aperture.h> #include <drm/drm_crtc_helper.h>
@@ -70,6 +71,18 @@#include "nouveau_svm.h" #include "nouveau_dmem.h" +DECLARE_DYNDBG_CLASSMAP (drm_debug_classes,DD_CLASS_TYPE_DISJOINT_BITS ,0 , +"DRM_UT_CORE" , +"DRM_UT_DRIVER" , +"DRM_UT_KMS" , +"DRM_UT_PRIME" , +"DRM_UT_ATOMIC" , +"DRM_UT_VBL" , +"DRM_UT_STATE" , +"DRM_UT_LEASE" , +"DRM_UT_DP" , +"DRM_UT_DRMRES" ); +MODULE_PARM_DESC (config,"option string to pass to driver core" );static char *nouveau_config;module_param_named (config, nouveau_config, charp,0400 );
include/drm/drm_print.h +2 -1
@@ -35,7 +35,7 @@#include <drm/drm.h> /* Do *not* use outside of drm_print.[ch]! */ -extern unsigned int __drm_debug; +extern unsigned long __drm_debug;/** * DOC: print
@@ -275,6 +275,7 @@ static inline struct drm_printer drm_err_printer(const char *prefix)* */ enum drm_debug_category { +/* These names must match those in DYNAMIC_DEBUG_CLASSBITS */ /** * @DRM_UT_CORE: Used in the generic drm code: drm_ioctl.c, drm_mm.c, * drm_memory.c, ...
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 24/33 drm_print: interpose drm_*dbg with forwarding macros
In reply to Jim Cromiechange drm_dev_dbg & drm_dbg to macros, which forward to the renamed functions (with __ prefix added).
Those functions sit below the categorized layer of macros implementing the DRM debug.category API, and implement most of it. These are good places to insert dynamic-debug jump-label mechanics, which will allow DRM to avoid the runtime cost of drm_debug_enabled().
no functional changes.
memory cost baseline: (unchanged)
bash-5.1# drms_load
[ 9.220389] dyndbg: 1 debug prints in module drm [ 9.224426] ACPI: bus type drm_connector registered [ 9.302192] dyndbg: 2 debug prints in module ttm [ 9.305033] dyndbg: 8 debug prints in module video [ 9.627563] dyndbg: 127 debug prints in module i915 [ 9.721505] AMD-Vi: AMD IOMMUv2 functionality not available on this system - This is not a bug. [ 10.091345] dyndbg: 2196 debug prints in module amdgpu [ 10.106589] [drm] amdgpu kernel modesetting enabled. [ 10.107270] amdgpu: CRAT table not found [ 10.107926] amdgpu: Virtual CRAT table created for CPU [ 10.108398] amdgpu: Topology: Add CPU node [ 10.168507] dyndbg: 3 debug prints in module wmi [ 10.329587] dyndbg: 3 debug prints in module nouveau
--- drivers/gpu/drm/drm_print.c | 10 +++++----- include/drm/drm_print.h | 9 +++++++-- 2 files changed, 12 insertions(+), 7 deletions(-)
drivers/gpu/drm/drm_print.c +5 -5
@@ -279,8 +279,8 @@ void drm_dev_printk(const struct device *dev, const char *level, }EXPORT_SYMBOL (drm_dev_printk); -void drm_dev_dbg (const struct device *dev,enum drm_debug_category category, -const char *format, ...) +void __drm_dev_dbg (const struct device *dev,enum drm_debug_category category, +const char *format, ...) {struct va_format vaf;va_list args;
@@ -301,9 +301,9 @@ void drm_dev_dbg(const struct device *dev, enum drm_debug_category category,va_end (args); } -EXPORT_SYMBOL (drm_dev_dbg); +EXPORT_SYMBOL (__drm_dev_dbg); -void __drm_dbg (enum drm_debug_category category,const char *format, ...) +void ___drm_dbg (enum drm_debug_category category,const char *format, ...) {struct va_format vaf;va_list args;
@@ -320,7 +320,7 @@ void __drm_dbg(enum drm_debug_category category, const char *format, ...)va_end (args); } -EXPORT_SYMBOL (__drm_dbg); +EXPORT_SYMBOL (___drm_dbg);void __drm_err (const char *format, ...) {
include/drm/drm_print.h +7 -2
@@ -335,7 +335,7 @@ __printf(3, 4)void drm_dev_printk (const struct device *dev,const char *level,const char *format, ...); __printf(3, 4) -void drm_dev_dbg (const struct device *dev,enum drm_debug_category category, +void __drm_dev_dbg (const struct device *dev,enum drm_debug_category category,const char *format, ...);/**
@@ -384,6 +384,9 @@ void drm_dev_dbg(const struct device *dev, enum drm_debug_category category, } \ }) +#define drm_dev_dbg (dev, cat, fmt, ...) \ + __drm_dev_dbg(dev, cat, fmt, ##__VA_ARGS__) +/** * DRM_DEV_DEBUG() - Debug output for generic drm code *
@@ -485,10 +488,12 @@ void drm_dev_dbg(const struct device *dev, enum drm_debug_category category,*/ __printf(2, 3) -void __drm_dbg (enum drm_debug_category category,const char *format, ...); +void ___drm_dbg (enum drm_debug_category category,const char *format, ...); __printf(1, 2)void __drm_err (const char *format, ...); +#define __drm_dbg (fmt, ...) ___drm_dbg(fmt, ##__VA_ARGS__) +/* Macros to make printk easier */ #define _DRM_PRINTK (once, level, fmt, ...) \
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 25/33 drm_print: wrap drm_*_dbg in dyndbg descriptor factory macro
In reply to Jim CromieFor CONFIG_DRM_USE_DYNAMIC_DEBUG=y, wrap __drm_dbg() & __drm_dev_dbg() in one of dyndbg's Factory macros: _dynamic_func_call_no_desc().
This adds the callsite descriptor into the code, and an entry for each into /proc/dynamic_debug/control.
#> echo class DRM_UT_ATOMIC +p > /proc/dynamic_debug/control
CONFIG_DRM_USE_DYNAMIC_DEBUG=y/n is configurable because of the .data footprint cost of per-callsite control; 56 bytes/site * ~2k for i915, ~4k callsites for amdgpu. This is large enough that a kernel builder might not want it.
--- drivers/gpu/drm/Kconfig | 12 ++++++++++++ drivers/gpu/drm/Makefile | 2 ++ include/drm/drm_print.h | 12 ++++++++++++ 3 files changed, 26 insertions(+)
drivers/gpu/drm/Kconfig +12 -0
@@ -50,6 +50,18 @@ config DRM_DEBUG_MM If in doubt, say "N". +config DRM_USE_DYNAMIC_DEBUG + bool "use dynamic debug to implement drm.debug" + default y + depends on DRM + depends on DYNAMIC_DEBUG || DYNAMIC_DEBUG_CORE + depends on JUMP_LABEL + help + Use dynamic-debug to avoid drm_debug_enabled() runtime overheads. + Due to callsite counts in DRM drivers (~4k in amdgpu) and 56 + bytes per callsite, the .data costs can be substantial, and + are therefore configurable. + config DRM_DEBUG_SELFTEST tristate "kselftests for DRM" depends on DRM
drivers/gpu/drm/Makefile +2 -0
@@ -3,6 +3,8 @@ # Makefile for the drm device driver. This driver provides support for the # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher. +CFLAGS-$(CONFIG_DRM_USE_DYNAMIC_DEBUG) += -DDYNAMIC_DEBUG_MODULE + drm-y := drm_aperture.o drm_auth.o drm_cache.o \ drm_file.o drm_gem.o drm_ioctl.o \ drm_drv.o \
include/drm/drm_print.h +12 -0
@@ -384,8 +384,14 @@ void __drm_dev_dbg(const struct device *dev, enum drm_debug_category category, } \ }) +#if !defined(CONFIG_DRM_USE_DYNAMIC_DEBUG )#define drm_dev_dbg (dev, cat, fmt, ...) \ __drm_dev_dbg(dev, cat, fmt, ##__VA_ARGS__) +#else +#define drm_dev_dbg (dev, cat, fmt, ...) \ + _dynamic_func_call_no_desc(fmt, __drm_dev_dbg, \ + dev, cat, fmt, ##__VA_ARGS__) +#endif /** * DRM_DEV_DEBUG() - Debug output for generic drm code
@@ -492,7 +498,13 @@ void ___drm_dbg(enum drm_debug_category category, const char *format, ...); __printf(1, 2)void __drm_err (const char *format, ...); +#if !defined(CONFIG_DRM_USE_DYNAMIC_DEBUG )#define __drm_dbg (fmt, ...) ___drm_dbg(fmt, ##__VA_ARGS__) +#else +#define __drm_dbg (cat, fmt, ...) \ + _dynamic_func_call_no_desc(fmt, ___drm_dbg, \ + cat, fmt, ##__VA_ARGS__) +#endif /* Macros to make printk easier */
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 26/33 drm-print.h: include dyndbg header
In reply to Jim Cromielkp robot told me:
Quoted 1 line
Quoted 1 line
drivers/gpu/drm/drm_ioc32.c:989:2:
error: call to undeclared function '_dynamic_func_call_cls'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
DRM_DEBUG("comm=\"%s\", pid=%d, dev=0x%lx, auth=%d, %s\n",Since that macro is defined in drm_print.h, and under DRM_USE_DYN*=y configs, invokes dyndbg-factory macros, include dynamic_debug.h from there too, so that those configs have the definitions of all the macros in the callchain.
This is done as a separate patch mostly to see how lkp sorts it.
--- include/drm/drm_print.h | 1 + 1 file changed, 1 insertion(+)
include/drm/drm_print.h +1 -0
@@ -31,6 +31,7 @@#include <linux/seq_file.h> #include <linux/device.h> #include <linux/debugfs.h> +#include <linux/dynamic_debug.h> #include <drm/drm.h>
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 27/33 drm-print: add drm_dbg_driver to improve namespace symmetry
In reply to Jim Cromiedrm_print defines all of these:
drm_dbg_{core,kms,prime,atomic,vbl,lease,_dp,_drmres}but not drm_dbg_driver itself, since it was the original drm_dbg.
To improve namespace symmetry, change the drm_dbg defn to drm_dbg_driver, and redef grandfathered name to symmetric one.
This will help with nouveau, which uses its own stack of macros to construct calls to dev_info, dev_dbg, etc, for which adaptation means drm_dbg_##driver constructs.
--- include/drm/drm_print.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
include/drm/drm_print.h +2 -1
@@ -468,7 +468,7 @@ void __drm_dev_dbg(const struct device *dev, enum drm_debug_category category,#define drm_dbg_core (drm, fmt, ...) \ drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_CORE, fmt, ##__VA_ARGS__) -#define drm_dbg (drm, fmt, ...) \ +#define drm_dbg_driver (drm, fmt, ...) \ drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_DRIVER, fmt, ##__VA_ARGS__)#define drm_dbg_kms (drm, fmt, ...) \ drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_KMS, fmt, ##__VA_ARGS__)
@@ -487,6 +487,7 @@ void __drm_dev_dbg(const struct device *dev, enum drm_debug_category category,#define drm_dbg_drmres (drm, fmt, ...) \ drm_dev_dbg((drm) ? (drm)->dev : NULL, DRM_UT_DRMRES, fmt, ##__VA_ARGS__) +#define drm_dbg (drm, fmt, ...) drm_dbg_driver(drm, fmt, ##__VA_ARGS__)/* * printk based logging
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 28/33 drm_print: refine drm_debug_enabled for jump-label
In reply to Jim CromieIn order to use dynamic-debug's jump-label optimization in drm-debug, its clarifying to refine drm_debug_enabled into 3 uses:
1. drm_debug_enabled - legacy, public
2. __drm_debug_enabled - optimized for dyndbg jump-label enablement.
3. _drm_debug_enabled - pr_debug instrumented, observable
1. The legacy version always checks the bits.
2. is privileged, for use by __drm_dbg(), __drm_dev_dbg(), which do an early return unless the category is enabled. For dyndbg builds, debug callsites are selectively "pre-enabled", so __drm_debug_enabled() short-circuits to true there. Remaining callers of 1 may be able to use 2, case by case.
3. is 1st wrapped in a macro, with a pr_debug, which reports each usage in /proc/dynamic_debug/control, making it observable in the logs. The macro lets the pr_debug see the real caller, not an inline function.
When plugged into 1, 3 identified ~10 remaining callers of the function, leading to the follow-on cleanup patch, and would allow activating the pr_debugs, estimating the callrate, and the potential savings by using the wrapper macro. It is unused ATM, but it fills out the picture.
--- drivers/gpu/drm/drm_print.c | 4 ++-- include/drm/drm_print.h | 28 ++++++++++++++++++++++++++++ 2 files changed, 30 insertions(+), 2 deletions(-)
drivers/gpu/drm/drm_print.c +2 -2
@@ -285,7 +285,7 @@ void __drm_dev_dbg(const struct device *dev, enum drm_debug_category category,struct va_format vaf;va_list args; -if (!drm_debug_enabled (category)) +if (!__drm_debug_enabled (category))return ;va_start (args, format);
@@ -308,7 +308,7 @@ void ___drm_dbg(enum drm_debug_category category, const char *format, ...)struct va_format vaf;va_list args; -if (!drm_debug_enabled (category)) +if (!__drm_debug_enabled (category))return ;va_start (args, format);
include/drm/drm_print.h +28 -0
@@ -321,11 +321,39 @@ enum drm_debug_category { DRM_UT_DRMRES }; +/* +* 3 name flavors of drm_debug_enabled: +* drm_debug_enabled - public/legacy, always checks bits +* _drm_debug_enabled - instrumented to observe call-rates, est overheads. +* __drm_debug_enabled - privileged - knows jump-label state, can short-circuit +*/ static inline bool drm_debug_enabled (enum drm_debug_category category) {return unlikely (__drm_debug &BIT (category)); } +/* +* Wrap fn in macro, so that the pr_debug sees the actual caller, not +* the inline fn. Using this name creates a callsite entry / control +* point in /proc/dynamic_debug/control. +*/ +#define _drm_debug_enabled (category) \ + ({ \ + pr_debug("todo: maybe avoid via dyndbg\n"); \ + drm_debug_enabled(category); \ + }) + +#if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) +/* +* dyndbg is wrapping the drm.debug API, so as to avoid the runtime +* bit-test overheads of drm_debug_enabled() in those api calls. +* In this case, executed callsites are known enabled, so true. +*/ +#define __drm_debug_enabled (category) true +#else +#define __drm_debug_enabled (category) drm_debug_enabled(category) +#endif +/* * struct device based logging *
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 29/33 drm_print: prefer bare printk KERN_DEBUG on generic fn
In reply to Jim Cromiedrm_print.c calls pr_debug() just once, from __drm_printfn_debug(), which is a generic/service fn. The callsite is compile-time enabled by DEBUG in both DYNAMIC_DEBUG=y/n builds.
For dyndbg builds, reverting this callsite back to bare printk is correcting a few anti-features:
1- callsite is generic, serves multiple drm users.
it is soft-wired on currently by #define DEBUG could accidentally: #> echo -p > /proc/dynamic_debug/control
2- optional "decorations" by dyndbg are unhelpful/misleading here,
they describe only the generic site, not end users
IOW, 1,2 are unhelpful at best, and possibly confusing.
reverting yields a nominal data and text shrink:
text data bss dec hex filename
462583 36604 54592 553779 87333 /kernel/drivers/gpu/drm/drm.ko 462515 36532 54592 553639 872a7 -dirty/kernel/drivers/gpu/drm/drm.ko
--- drivers/gpu/drm/drm_print.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
drivers/gpu/drm/drm_print.c +2 -3
@@ -23,8 +23,6 @@* Rob Clark <[email protected]> */ -#define DEBUG /* for pr_debug() */ -#include <linux/stdarg.h> #include <linux/io.h>
@@ -185,7 +183,8 @@ EXPORT_SYMBOL(__drm_printfn_info);void __drm_printfn_debug (struct drm_printer *p,struct va_format *vaf) { -pr_debug ("%s %pV" , p->prefix, vaf); +/* pr_debug callsite decorations are unhelpful here */ +printk (KERN_DEBUG "%s %pV" , p->prefix, vaf); }EXPORT_SYMBOL (__drm_printfn_debug);
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 30/33 drm_print: add _ddebug descriptor to drm_*dbg prototypes
In reply to Jim Cromieupgrade the callchain to drm_dbg() and drm_dev_dbg(); add a struct _ddebug ptr parameter to them, and supply that additional param by replacing the '_no_desc' flavor of dyndbg Factory macro currently used with the flavor that supplies the descriptor.
NOTES:
The descriptor gives these fns access to the decorator flags, but does none of the dynamic-prefixing done by __dynamic_emit_prefix().
DRM already has conventions for logging/messaging; just tossing optional decorations on top may not help. Instead, existing flags (or new ones) can be used to make current conventions optional.
For CONFIG_DRM_USE_DYNAMIC_DEBUG=N, just pass null.
Note: desc->class_id is redundant with category parameter, but its availability is dependent on desc.
--- drivers/gpu/drm/drm_print.c | 8 +++++--- include/drm/drm_print.h | 23 ++++++++++++----------- 2 files changed, 17 insertions(+), 14 deletions(-)
drivers/gpu/drm/drm_print.c +5 -3
@@ -29,6 +29,7 @@#include <linux/moduleparam.h> #include <linux/seq_file.h> #include <linux/slab.h> +#include <linux/dynamic_debug.h> #include <drm/drm.h> #include <drm/drm_drv.h>
@@ -278,8 +279,8 @@ void drm_dev_printk(const struct device *dev, const char *level, }EXPORT_SYMBOL (drm_dev_printk); -void __drm_dev_dbg (const struct device *dev,enum drm_debug_category category, -const char *format, ...) +void __drm_dev_dbg (struct _ddebug *desc,const struct device *dev, +enum drm_debug_category category,const char *format, ...) {struct va_format vaf;va_list args;
@@ -287,6 +288,7 @@ void __drm_dev_dbg(const struct device *dev, enum drm_debug_category category,if (!__drm_debug_enabled (category))return ; +/* we know we are printing for either syslog, tracefs, or both */ va_start (args, format); vaf.fmt = format; vaf.va = &args;
@@ -302,7 +304,7 @@ void __drm_dev_dbg(const struct device *dev, enum drm_debug_category category, }EXPORT_SYMBOL (__drm_dev_dbg); -void ___drm_dbg (enum drm_debug_category category,const char *format, ...) +void ___drm_dbg (struct _ddebug *desc,enum drm_debug_category category,const char *format, ...) {struct va_format vaf;va_list args;
include/drm/drm_print.h +12 -11
@@ -363,9 +363,10 @@ static inline bool drm_debug_enabled(enum drm_debug_category category) __printf(3, 4)void drm_dev_printk (const struct device *dev,const char *level,const char *format, ...); -__printf(3, 4) -void __drm_dev_dbg (const struct device *dev,enum drm_debug_category category, -const char *format, ...); +struct _ddebug ; +__printf(4, 5) +void __drm_dev_dbg (struct _ddebug *desc,const struct device *dev, +enum drm_debug_category category,const char *format, ...);/** * DRM_DEV_ERROR() - Error output.
@@ -415,11 +416,11 @@ void __drm_dev_dbg(const struct device *dev, enum drm_debug_category category,#if !defined(CONFIG_DRM_USE_DYNAMIC_DEBUG )#define drm_dev_dbg (dev, cat, fmt, ...) \ - __drm_dev_dbg(dev, cat, fmt, ##__VA_ARGS__) + __drm_dev_dbg(NULL, dev, cat, fmt, ##__VA_ARGS__)#else #define drm_dev_dbg (dev, cat, fmt, ...) \ - _dynamic_func_call_no_desc(fmt, __drm_dev_dbg, \ - dev, cat, fmt, ##__VA_ARGS__) + _dynamic_func_call_cls(cat, fmt, __drm_dev_dbg, \ + dev, cat, fmt, ##__VA_ARGS__)#endif /**
@@ -523,17 +524,17 @@ void __drm_dev_dbg(const struct device *dev, enum drm_debug_category category,* Prefer drm_device based logging over device or prink based logging. */ -__printf(2, 3) -void ___drm_dbg (enum drm_debug_category category,const char *format, ...); +__printf(3, 4) +void ___drm_dbg (struct _ddebug *desc,enum drm_debug_category category,const char *format, ...); __printf(1, 2)void __drm_err (const char *format, ...);#if !defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) -#define __drm_dbg (fmt, ...) ___drm_dbg(fmt, ##__VA_ARGS__) +#define __drm_dbg (fmt, ...) ___drm_dbg(NULL, fmt, ##__VA_ARGS__)#else #define __drm_dbg (cat, fmt, ...) \ - _dynamic_func_call_no_desc(fmt, ___drm_dbg, \ - cat, fmt, ##__VA_ARGS__) + _dynamic_func_call_cls(cat, fmt, ___drm_dbg, \ + cat, fmt, ##__VA_ARGS__)#endif /* Macros to make printk easier */
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 31/33 nouveau: change nvkm_debug/trace to use dev_dbg POC
In reply to Jim CromieThese 2 macros formerly used dev_info, and they still check subdev->debug to gate the printing. So dyndbg control is redundant ATM (and possibly confusing, since its off by default).
prdbg count is up from 3, or from 65 (with VMM_DEBUG here)
[ 7.765379] dyndbg: 516 debug prints in module nouveau
Its possible to control error, warn, info callsites too, but they're usually on, and the .data overheads on ~450 more callsites (56 bytes each) would just be wasted.
$ for l in fatal error warn info debug trace spam; do
echo $l; ack nvkm_$l drivers/gpu |wc; done
fatal
3 19 335
error
289 1956 30651
warn
84 513 8860
info
14 88 1502
debug
387 2339 40844
trace
31 219 3368
spam
1 7 123bash-5.1# echo $(( 516-65-387-31-1 ))
32
Thats approximate; not accounting #defines and doc/comment mentions.
NOTE: this patch changes the log-level of the macro-issued messages from KERN_INFO to KERN_DEBUG. Adding a .kern_lvl field to struct _ddebug could fix that.
RFC: dyndbg & subdev->debug
Separate class-maps for each subdev are possible; except for the coordinated use of _base, each is independent, including choice of DISJOINT or LEVELS, as long as class-names don't conflict. So theres some flexibility.
--- drivers/gpu/drm/nouveau/include/nvkm/core/subdev.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/gpu/drm/nouveau/include/nvkm/core/subdev.h +2 -2
@@ -59,8 +59,8 @@ void nvkm_subdev_intr(struct nvkm_subdev *); #define nvkm_error(s,f,a...) nvkm_printk((s), ERROR, err, f, ##a) #define nvkm_warn(s,f,a...) nvkm_printk((s), WARN, notice, f, ##a) #define nvkm_info(s,f,a...) nvkm_printk((s), INFO, info, f, ##a) -#define nvkm_debug(s,f,a...) nvkm_printk((s), DEBUG, info, f, ##a) -#define nvkm_trace(s,f,a...) nvkm_printk((s), TRACE, info, f, ##a) +#define nvkm_debug(s,f,a...) nvkm_printk((s), DEBUG, dbg, f, ##a) +#define nvkm_trace(s,f,a...) nvkm_printk((s), TRACE, dbg, f, ##a) #define nvkm_spam(s,f,a...) nvkm_printk((s), SPAM, dbg, f, ##a) #define nvkm_error_ratelimited(s,f,a...) nvkm_printk((s), ERROR, err_ratelimited, f, ##a)
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 32/33 nouveau: adapt NV_DEBUG, NV_ATOMIC to use DRM.debug
In reply to Jim CromieThese 2 macros used drm_debug_enabled() on DRM_UT_{DRIVER,ATOMIC} respectively, replace those with drm_dbg_##cat invocations.
this results in new class'd prdbg callsites:
:#> grep nouveau /proc/dynamic_debug/control | grep class | wc
116 1130 15584
:#> grep nouveau /proc/dynamic_debug/control | grep class | grep DRIVER | wc
74 704 9709
:#> grep nouveau /proc/dynamic_debug/control | grep class | grep ATOMIC | wc
31 307 4237
:#> grep nouveau /proc/dynamic_debug/control | grep class | grep KMS | wc
11 119 1638the KMS entries are due to existing uses of drm_dbg_kms().
--- drivers/gpu/drm/nouveau/nouveau_drv.h | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-)
drivers/gpu/drm/nouveau/nouveau_drv.h +10 -6
@@ -39,6 +39,7 @@*/ #include <linux/notifier.h> +#include <linux/dynamic_debug.h> #include <nvif/client.h> #include <nvif/device.h>
@@ -264,13 +265,16 @@ void nouveau_drm_device_remove(struct drm_device *dev); #define NV_WARN(drm,f,a...) NV_PRINTK(warn, &(drm)->client, f, ##a) #define NV_INFO(drm,f,a...) NV_PRINTK(info, &(drm)->client, f, ##a) -#define NV_DEBUG(drm,f,a...) do { \ - if (drm_debug_enabled(DRM_UT_DRIVER)) \ - NV_PRINTK(info, &(drm)->client, f, ##a); \ +#define NV_DRMDBG(cat,c,f,a...) do { \ + struct nouveau_cli *_cli = (c); \ + drm_dbg_##cat(_cli->drm->dev, "%s: "f, _cli->name, ##a); \ } while(0) -#define NV_ATOMIC(drm,f,a...) do { \ - if (drm_debug_enabled(DRM_UT_ATOMIC)) \ - NV_PRINTK(info, &(drm)->client, f, ##a); \ + +#define NV_DEBUG(drm,f,a...) do { \ + NV_DRMDBG(driver, &(drm)->client, f, ##a); \ +} while(0) +#define NV_ATOMIC(drm,f,a...) do { \ + NV_DRMDBG(atomic, &(drm)->client, f, ##a); \ } while(0) #define NV_PRINTK_ONCE(l,c,f,a...) NV_PRINTK(l##_once,c,f, ##a)
Signature · 1 line
2.37.1
Jim Cromie
maintainerPATCH v5 33/33 nouveau: WIP add 2 LEVEL_NUM classmaps for CLI, SUBDEV
In reply to Jim Cromieclone the nvkm_printk,_,__ macro ladder into nvkm_drmdbg,_,__. And alter the debug, trace, spam macros to use the renamed ladder.
This *sets-up* (not done yet) to remove the _subdev->debug >= (l) condition, once the bitmap-param is wired up correctly, and figured into dyndbg's jump-label enablement. WIP.
Then undo the 1-line change that reduced count of prdbgs from 632 to 119.
ie: s/NV_SUBDEV_DBG_##l/NV_DBG_##l/
So heres what happened: new symbol is 15 (or 10), and fails this macro test, so gets compiled out, and the dev_dbg is excluded.
if (CONFIG_NOUVEAU_DEBUG >= (l) && _subdev->debug >= (l)) \
dev_dbg(_subdev->device->dev, "%s: "f, _subdev->name, ##a); \I could hack this, by doing (l + base), but base is pretty distant.
OTOH, the whole CONFIG_NOUVEAU_DEBUG check could be reworked; given that trace is minumum recommended, theres not that many callsites elided (SPAM only iirc) at compile-time, and dyndbg means keeping them has "zero" run-cost (and 56 bytes per callsite). So this config item doesnt do much when DRM_USE_DYNAMIC_DEBUG=y.
So this is a useful place to stop and look around, try to guess which trail to take..
nouveau has additional debug variables to consider:
drivers/gpu/drm/nouveau/include/nvkm/core/device.h
131: if (_device->debug >= (l)) \
drivers/gpu/drm/nouveau/include/nvkm/core/client.h
39: if (_client->debug >= NV_DBG_##l) \
drivers/gpu/drm/nouveau/include/nvkm/core/subdev.h
54: if (CONFIG_NOUVEAU_DEBUG >= (l) && _subdev->debug >= (l)) \
This is another baby-step, that seems not to break, so lets get a snapshot.
whats done here:
In nouveau_drm.c, do DECLARE_DYNDBG_CLASSMAP(LEVEL_NUM type) 2x more, for cli and subdev, right after the drm DECLARE. Adjust base for each, to share the 0..30 classid-space.
These declare class-names: NV_CLI_DBG_* NV_SUBDEV_DBG_* accordingly.
Note: class-name-space is flat and wide, so super-generic names like INFO should be prefixed; who could predict what a generic V3 does across all modules.
s should be included
adjusting the base to avoid each other, and the 0-10 already mapped to drm-debug-categorys (just above this addition).
In nvkm/core/debug.h, add enums to match the names, with initial values to match the bases.
In nvkm/core/subdev.h, alter (recently added) nvkm_drmdbg_() to use NV_SUBDEV_DBG_* instead of NV_DBG_*.
NB: in both classmaps, Ive left FATAL..WARN out, they're not really optional the way INFO..SPAM are; dyndbg shouldn't be able to turn them off.
bash-5.1# modprobe nouveau
[ 966.107833] dyndbg: 3 debug prints in module wmi [ 966.342188] dyndbg: class[0]: module:nouveau base:15 len:5 ty:1 [ 966.342873] dyndbg: 15: 0 NV_SUBDEV_DBG_OFF [ 966.343352] dyndbg: 16: 1 NV_SUBDEV_DBG_INFO [ 966.343912] dyndbg: 17: 2 NV_SUBDEV_DBG_DEBUG [ 966.344443] dyndbg: 18: 3 NV_SUBDEV_DBG_TRACE [ 966.344938] dyndbg: 19: 4 NV_SUBDEV_DBG_SPAM [ 966.345402] dyndbg: class[1]: module:nouveau base:10 len:5 ty:1 [ 966.346011] dyndbg: 10: 0 NV_CLI_DBG_OFF [ 966.346477] dyndbg: 11: 1 NV_CLI_DBG_INFO [ 966.346989] dyndbg: 12: 2 NV_CLI_DBG_DEBUG [ 966.347442] dyndbg: 13: 3 NV_CLI_DBG_TRACE [ 966.347875] dyndbg: 14: 4 NV_CLI_DBG_SPAM [ 966.348284] dyndbg: class[2]: module:nouveau base:0 len:10 ty:0 [ 966.348888] dyndbg: 0: 0 DRM_UT_CORE [ 966.349310] dyndbg: 1: 1 DRM_UT_DRIVER [ 966.349694] dyndbg: 2: 2 DRM_UT_KMS [ 966.350083] dyndbg: 3: 3 DRM_UT_PRIME [ 966.350482] dyndbg: 4: 4 DRM_UT_ATOMIC [ 966.351016] dyndbg: 5: 5 DRM_UT_VBL [ 966.351475] dyndbg: 6: 6 DRM_UT_STATE [ 966.351899] dyndbg: 7: 7 DRM_UT_LEASE [ 966.352309] dyndbg: 8: 8 DRM_UT_DP [ 966.352678] dyndbg: 9: 9 DRM_UT_DRMRES [ 966.353104] dyndbg: module:nouveau attached 3 classes [ 966.353759] dyndbg: 119 debug prints in module nouveau
NOTE: it was 632 with previous commit, switching NV_DEBUG to use NV_SUBDEV_DBG_DEBUG instead of NV_DBG_DEBUG may be the cause.
--- .../gpu/drm/nouveau/include/nvkm/core/debug.h | 16 +++++++++++++ .../drm/nouveau/include/nvkm/core/subdev.h | 17 ++++++++++---- drivers/gpu/drm/nouveau/nouveau_drm.c | 7 ++++++ drivers/gpu/drm/nouveau/nvkm/core/subdev.c | 23 +++++++++++++++++++ 4 files changed, 59 insertions(+), 4 deletions(-)
drivers/gpu/drm/nouveau/include/nvkm/core/debug.h +16 -0
@@ -9,4 +9,20 @@#define NV_DBG_TRACE 5#define NV_DBG_PARANOIA 6#define NV_DBG_SPAM 7 + +enum nv_cli_dbg_verbose { +NV_CLI_DBG_OFF =10 , +NV_CLI_DBG_INFO , +NV_CLI_DBG_DEBUG , +NV_CLI_DBG_TRACE , +NV_CLI_DBG_SPAM +}; +enum nv_subdev_dbg_verbose { +NV_SUBDEV_DBG_OFF =15 , +NV_SUBDEV_DBG_INFO , +NV_SUBDEV_DBG_DEBUG , +NV_SUBDEV_DBG_TRACE , +NV_SUBDEV_DBG_SPAM +}; +#endif
drivers/gpu/drm/nouveau/include/nvkm/core/subdev.h +13 -4
@@ -2,6 +2,7 @@#ifndef __NVKM_SUBDEV_H__#define __NVKM_SUBDEV_H__#include <core/device.h> +#include <core/debug.h> enum nvkm_subdev_type {#define NVKM_LAYOUT_ONCE(t,s,p,...) t,
@@ -18,7 +19,7 @@ struct nvkm_subdev {enum nvkm_subdev_type type;int inst;char name[16 ]; -u32 debug; +unsigned long debug;struct list_head head;void **pself;
@@ -59,9 +60,17 @@ void nvkm_subdev_intr(struct nvkm_subdev *); #define nvkm_error(s,f,a...) nvkm_printk((s), ERROR, err, f, ##a) #define nvkm_warn(s,f,a...) nvkm_printk((s), WARN, notice, f, ##a) #define nvkm_info(s,f,a...) nvkm_printk((s), INFO, info, f, ##a) -#define nvkm_debug(s,f,a...) nvkm_printk((s), DEBUG, dbg, f, ##a) -#define nvkm_trace(s,f,a...) nvkm_printk((s), TRACE, dbg, f, ##a) -#define nvkm_spam(s,f,a...) nvkm_printk((s), SPAM, dbg, f, ##a) + +#define nvkm_drmdbg__(s,l,p,f,a...) do { \ + const struct nvkm_subdev *_subdev = (s); \ + if (CONFIG_NOUVEAU_DEBUG >= (l) && _subdev->debug >= (l)) \ + dev_dbg(_subdev->device->dev, "%s: "f, _subdev->name, ##a); \ +} while(0) +#define nvkm_drmdbg_(s,l,f,a...) nvkm_drmdbg__((s), NV_SUBDEV_DBG_##l, dbg, f, ##a) +#define nvkm_debug(s,f,a...) nvkm_drmdbg_((s), DEBUG, f, ##a) +#define nvkm_trace(s,f,a...) nvkm_drmdbg_((s), TRACE, f, ##a) +#define nvkm_spam(s,f,a...) nvkm_drmdbg_((s), SPAM, f, ##a) #define nvkm_error_ratelimited(s,f,a...) nvkm_printk((s), ERROR, err_ratelimited, f, ##a) +#endif
drivers/gpu/drm/nouveau/nouveau_drm.c +7 -0
@@ -83,6 +83,13 @@ DECLARE_DYNDBG_CLASSMAP(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0,"DRM_UT_DP" , "DRM_UT_DRMRES"); +DECLARE_DYNDBG_CLASSMAP (nv_cli_debug_verbose,DD_CLASS_TYPE_LEVEL_NUM ,10 , +"NV_CLI_DBG_OFF" , +"NV_CLI_DBG_INFO" , +"NV_CLI_DBG_DEBUG" , +"NV_CLI_DBG_TRACE" , +"NV_CLI_DBG_SPAM" ); +MODULE_PARM_DESC (config,"option string to pass to driver core" );static char *nouveau_config;module_param_named (config, nouveau_config, charp,0400 );
drivers/gpu/drm/nouveau/nvkm/core/subdev.c +23 -0
@@ -26,6 +26,27 @@#include <core/option.h> #include <subdev/mc.h> +#include <linux/dynamic_debug.h> +#include <linux/module.h> + +#define DEBUG + +DECLARE_DYNDBG_CLASSMAP (nv_subdev_debug_verbose,DD_CLASS_TYPE_LEVEL_NAMES ,15 , +"NV_SUBDEV_DBG_OFF" , +"NV_SUBDEV_DBG_INFO" , +"NV_SUBDEV_DBG_DEBUG" , +"NV_SUBDEV_DBG_TRACE" , +"NV_SUBDEV_DBG_SPAM" ); + +static struct ddebug_class_param nv_subdev_verbose = { + .bits =NULL ,// wants &_subdev->debug + .flags ="p" , + .map = &nv_subdev_debug_verbose, +}; +module_param_cb (debug_subdev, ¶m_ops_dyndbg_classes, &nv_subdev_verbose,0600 ); + + +const char * nvkm_subdev_type[NVKM_SUBDEV_NR ] = { #define NVKM_LAYOUT_ONCE(type,data,ptr,...) [type] = #ptr,
@@ -180,6 +201,8 @@ nvkm_subdev_ctor(const struct nvkm_subdev_func *func, struct nvkm_device *deviceelse strscpy (subdev->name, nvkm_subdev_type[type],sizeof (subdev->name)); subdev->debug =nvkm_dbgopt (device->dbgopt, subdev->name); + nv_subdev_verbose.bits = &subdev->debug; +pr_debug ("updated bitmap: %px\n" , &nv_subdev_verbose.bits);list_add_tail (&subdev->head, &device->subdev); }
Signature · 1 line
2.37.1
Patchwork
CI[Intel-gfx] ✗ Fi.CI.BUILD: failure for DYNDBG: opt-in class'd debug for modules, use in drm. (rev3)
In reply to Jim Cromie== Series Details ==
== Series Details ==
Series: DYNDBG: opt-in class'd debug for modules, use in drm. (rev3)
URL : https://patchwork.freedesktop.org/series/106427/
State : failure
== Summary ==
Error: patch https://patchwork.freedesktop.org/api/1.0/series/106427/revisions/3/mbox/ not applied
Applying: dyndbg: fix static_branch manipulation
Applying: dyndbg: fix module.dyndbg handling
Applying: dyndbg: show both old and new in change-info
Applying: dyndbg: reverse module walk in cat control
Applying: dyndbg: reverse module.callsite walk in cat control
Applying: dyndbg: use ESCAPE_SPACE for cat control
Applying: dyndbg: let query-modname override actual module name
Applying: dyndbg: add test_dynamic_debug module
Applying: dyndbg: drop EXPORTed dynamic_debug_exec_queries
Applying: dyndbg: cleanup local vars in ddebug_init
Applying: dyndbg: create and use struct _ddebug_info
Applying: dyndbg: add class_id to pr_debug callsites
Applying: dyndbg: add __pr_debug_cls for testing
Applying: dyndbg: add DECLARE_DYNDBG_CLASSMAP macro
Applying: kernel/module: add __dyndbg_classes section
Applying: dyndbg: add ddebug_attach_module_classes
Applying: dyndbg: validate class FOO by checking with module
Applying: doc-dyndbg: describe "class CLASS_NAME" query support
Applying: doc-dyndbg: edit dynamic-debug-howto for brevity, audience
Applying: dyndbg: add drm.debug style (drm/parameters/debug) bitmap support
Applying: dyndbg: test DECLARE_DYNDBG_CLASSMAP, sysfs nodes
Applying: drm_print: condense enum drm_debug_category
Applying: drm: POC drm on dyndbg - use in core, 2 helpers, 3 drivers.
Applying: drm_print: interpose drm_*dbg with forwarding macros
Applying: drm_print: wrap drm_*_dbg in dyndbg descriptor factory macro
Using index info to reconstruct a base tree...
M drivers/gpu/drm/Kconfig
M drivers/gpu/drm/Makefile
Falling back to patching base and 3-way merge...
Auto-merging drivers/gpu/drm/Makefile
Auto-merging drivers/gpu/drm/Kconfig
CONFLICT (content): Merge conflict in drivers/gpu/drm/Kconfig
error: Failed to merge in the changes.
hint: Use 'git am --show-current-patch=diff' to see the failed patch
Patch failed at 0025 drm_print: wrap drm_*_dbg in dyndbg descriptor factory macro When you have resolved this problem, run "git am --continue".
If you prefer to skip this patch, run "git am --skip" instead.
To restore the original branch and stop patching, run "git am --abort".
[Catching up on mails]
Did you see the feedback form Steven from tracing side of things? Does this version have that taken into account already?
I think once we have that and acks from dyndbg maintainers then I think we should just land this and polish from there? Maybe some acks from drm drivrer folks (cros people where once interested), but otherwise I'm a bit afraid this might be stuck in limbo too much for too long and we just need to get going :-/
-Daniel
Quoted 578 lines · Jim Cromie
Hi Jason, Greg, DRM-folk,
heres V5. Diffs vs V4:
1st 9 have Jason's Ack
10 is new: simple var cleanup
11 new struct, to contain future addins. toucheskernel/module/dyndbg-param callbacks moved to last (of dyndbg patches) they're where the uncertainty is,
and the bulk of the API addition (class keyword is small)patches between the move are the guts of the "class foo" feature. exposure of feature is only via >control, until sysfs parts added
DRM chunk:
included here to see how patchwork's merge & test proceeds. categories -> classes re-work is unchanged - feels pretty solid. nouveau & LEVEL made some progress, still WIP.I left out tracefs bits for now.
UNCERTAINTIES / RFC:
1st is my "sharing" technique, across DRM's multi modules. Its literally duplicated decls, by each participating module, each adding static data in its own special section. I didn't try at all to shrink or unify this any further. There might be a perfect place to add a single decl, but that quest will require a pony.
Sharing by class-names lacks the compiler support that varnames get; "incomplete" enables will probably happen if one of the declarations miss-spells one of the classnames.
That said, see the how-to below: stringifying va-args in the macro would allow direct use of the enum-consts, and cc will insist that those consts are defined, eliminating part of the un-support.
I could split the _BITS,_NUM handling out from
_NAMES(ie split drm.debug style patch); theres no user-demand for the_NAMESfeature ATM, and theres probably some legit API-bikeshedding to do.PATCHSET DESCRIPTION
This patchset adds 'typed' "class FOO" support to dynamic-debug, where 'typed' means either
DISJOINT_BITS, likedrm_dbg(DRM_UT_CORE,..), orLEVEL_NUM(like nouveau debug-levels). Use it in DRM modules: core, helpers, and in drivers i915, amdgpu, nouveau.If a module is using class'd prdbgs (
pr_debug_class,dev_dbg_class, or adapted drm_dbg_<category>) or similar in its code, it can "opt in" to allow dyndbg to manipulate those class'd prdebugs, by declaring in a c-file:DECLARE_DYNDBG_CLASSMAP(drm_debug_classes,
DD_CLASS_TYPE_DISJOINT_BITS, 0,"DRM_UT_CORE", "DRM_UT_DRIVER", "DRM_UT_KMS", "DRM_UT_PRIME", "DRM_UT_ATOMIC", "DRM_UT_VBL", "DRM_UT_STATE", "DRM_UT_LEASE", "DRM_UT_DP", "DRM_UT_DRMRES"); // how-to stringify __va_args inside the macro ?By doing this, a module tells dyndbg that it:
- is using class-ids [0..N] in prdbg callsites
( 0..N == DRM_UT_CORE..DRM_UT_DRMRES )- wants to refer to them by class-names [0..N]
- is mapping those names to those class-ids
- expects users to enable them via >control or >parameter/knobThen, a user can enable the prdbgs by their class:
:#> echo class
DRM_UT_KMS+p >/proc/dynamic_debug/controlAnd with another 3-line bitmap param decl/init, wrapping the
drm_debug_classesvar in a module-param-cb::#> echo 0x1 > /sys/module/drm/parameters/debugand optionally using classnames:
:#> echo +DRM_UT_CORE,-DRM_UT_KMS \ > /sys/module/drm/parameters/debug_cats
DYNAMIC_DEBUGgets:struct
_ddebuggets a new .class_id:5 field, big enough to representdrm_debug_category(after squeezing). It defaults to 31 for all existing prdbgs.class_idalso supports verbose uses.classmaps (as declared by macro above) are in their own linker section, are loaded by kernel/module, and handled by
add_module, which attaches classmaps to their module's ddebug table.
ddebug_change()handles a class FOO query by validating that FOO is known by each module in the loop. The query is skipped unless the module knows FOO, so no changes are possible w/o a good classname.Without class FOO in a query/command, only ids=31 can be changed by that query. This protects all class'd prdbgs from changes by legacy class-less user queries.
With this support, the module opt-in approach means that:
- modules declare classnames they like, meaningful names: DRM_UT_* these are numbered [0..N]
- modules callpr_debug_class(N, "fmt..",...)or drm_dbg(CAT, "fmt..",...) - same form.- class-id space, while limited:0-30, is private to each module
- "class FOO" is only way to select a class'd prdbg
- unrelated modules use 0..N separately, for different purposes.
- modules "share" classnames by separate decls (uses of macro) all drm modules reuse the above declaration.
then they respond together to a >control4
CLASS_TYPESare defined; they split behavior on 2 factors:1. independent bits vs related:(X<Y) bits [0-N]
2. input form: number/hex vs CSV-list: [+-]CLASS_NAMES
DD_CLASS_TYPE_DISJOINT_BITSindependent bits,0x1finput is clearest
DD_CLASS_TYPE_LEVEL_NUM(x<y), input is level, not bitvec
DD_CLASS_TYPE_DISJOINT_NAMEScsv-list of independent +-CLASS_NAMEs
DD_CLASS_TYPE_LEVEL_NAMEScsv-list of related +-CLASS_NAMEs, only 1 term neededSplitting up behavior this way is safe, and flexible:
- no bitmap-vs-level > sysknob ambiguity
as was case when both were accepted on same knob
- narrower interfaces
uint is uint
- can deferDISJOINT_NAMEShandling, but keep the enums. it has no users ...
- can later add 2 more ENUMS allowing both inputs
in separateLEVEL_NUM&DISJOINT_BITSchoices
then authors choice if they want to accept mixed input
- can enumerate "wierd" relations if needed DISJOINT_BITS|LEVEL_NUM should cover everything I can forsee but theres room forDD_CLASS_TYPE_STOCHASTIC(over the garage)DISJOINT & LEVEL cover the space; 1st is independent, 2nd is related. The relation could differ from (x<y), but atm I can't think of another that makes any sensible distinction from (x<y).
Quick review of debug logging:
DRM is biggest use-case: 23 macros, issuing 10 exclusive categories of messages, from ~5100 callsites, across core (drm, _*helpers), and 3+ drivers (Im working amdgpu, i915, more recently nouveau). These mostly flow to
drm_debug_enabled(category)for a print/no decision.nouveau has minimum direct use of the DRM.debug macros, but does use
pr_debug(in VMM iirc), anddrm_debug_enabled()in ~50 places via macros, and another ~50 iirc due to NOUVEAU_DEBUG_MMU=yWhat nouveau has most of is log-levels: there are ~800 uses of them;
nvkm_(fatal|error|warn|info|debug|trace|spam), they all flow thrunvkm_printk_. Even excluding some levels as "always-on" and not appropriate for dyndbg's extra resources and complexity, theres ~450 callsites.A reported smattering of raw/adhoc debug code. all but unknown to me.
Like any debug logging, they're mostly off, and should have close to 0-off-cost. This is what dyndbg (with/on jump-label) was made for.
Bottom line: in order to unify more potential (drm,etc) use-cases, dyndbg needs to support both debug classification schemes:
RELATED/LEVEL_NUM and INDEPENDENT/DISJOINT_BITS.This is rev3. rev2 is here:
https://lore.kernel.org/lkml/[email protected]/summary of diffs:
- rebased on 5.19-rc6 to pick up kernel/module changes
- tracfs bits now use__vstring,__vstr_assign, from S.Rostedt- 4 class-map-types - as outlined above
now supportsLEVEL_NUMsemantics, WIP nouveau integration. v2 became theDISJOINT_BITSuse case
Lots of API-ish surface area here *RFC*- class-maps now in
section("__dyndbg_classes")class FOO queries are available at earlyboot / module-load drop (un)?register_classes()- test-dynamic-debug module
tests the 4 CLASS-TYPES
good place to bikeshed / paintshop the API- nouveau - start poking - WIP
NV_PRINT->dev_dbg(creates 632 prdbgs, but not class'd)LEVEL_NUMclasses declared to see how they "fit", unused yet.Summary:
- plenty of new stuff here.
- plenty of new API surface area.
- exposes CLASSNAMES to user, via control, >symbolic-sysknobMore on
LEVEL_NUM:dyndbg's class scheme is names-based, so even for
LEVEL_NUMwith numeric input, there must be a "V0" name; a name with which to turn off "V1". And don't do 'pr_dbg_class(0,..)'.
LEVEL_NUMis an overlay onDISJOINT_BITS; the callback reads the input as a level, and computes and applies the bitmap to enforce it. Yes it wastes "V0" bit. That might matter if an author wanted many separate verbose-knobs with a few levels each, but that seems fairly unlikely.More importantly, it means that relative verbosity is not enforced at the >control input; IOW this is allowed:
:#> echo class V1 -p >
/proc/dynamic_debug/control:#> echo class V3 +p >/proc/dynamic_debug/control2nd line doesn't undo 1st, as it would if changed via sysfs-knob:
:#> echo 3 >
/sys/module/drm/parameters/debugISTM this is fine, the "relative" meaning is added at the interface, where it presents to a user. Doing otherwise means surgery to
ddebug_change, which seems unnecessary given an option.CLASS NAMESPACE and DRM
The class namespace is flat and wide, so "V1" is a poor choice, other than for demonstration (as in
test_dynamic_debugmodule). If every module had a "V1", turning them all on would issue lots of unrelated noise.Instead, class
DRM_UT_COREhas a name with a specific sub-system wide (ie multi-module) meaning, and can (and should) be responded to by all cooperating modules.For DRM, this means 4-5 duplicate uses of
DEFINE_DYNDBG_CLASSMAP, from multiple drivers' "*_{drm,dev,main}.c" files; all of them agreeing on the classnames, map-type and base. Though repetitive, and a bit fiddly when multiple classes share the module's id-space, it is simple, and consistent with the "static struct foo = {INIT_expr}" pattern used in the macro. Im open to simpler ways, initializing an extern sounded like a maze w/o cheese.For core,
drm_print.chas an additional task; it defines and initializes the bitmap sysknob that converts bits to a query:static struct ddebug_classes_bitmap_param drm_debug_bitmap = { .bits = &__drm_debug, .flags = "p", .map = &drm_debug_classes, }; module_param_cb(debug, ¶m_ops_dyndbg_classes, &drm_debug_bitmap, 0600);then the callback converts bit-toggles on input into something like:
:#> echo class
DRM_UT_KMS+p > controlwhich enables all
drm_dbg_kms()callsites in all modules that declared that classname as known.NB: classmaps and
classes_bitmap_paramsare different structs. this allows the former to be shared by 2 of latter, each toggling 'p' & 'T' flags, to control output to syslog or tracelog independently.NBB: while "V1" isnt a good classname, "EMERG" and and other KERN-LEVEL names have a legacy. That said, dyndbg shouldnt be involved in EMERG actions.
NOUVEAU and multiple
LEVEL_NUMknobs ?One thing nouveau has that I havent yet grokked is 2|3 independent verbose levels, in {,cli,sub}->debug (see
subdev.h). But Ive coded them as 2 more macro invocations; using bases 10, 15 to avoid/respect the 0-9 mapping of DRM.debug categories to those class-ids.With this, the drm subsystem uses 20/31 of its class-id range, perhaps 63 is better, despite the cumbersome 0x-64bit interface. Note that the sysfs-knobs do not expose the base/offset (its an inward-facing .class_id offset); each sysfs-knob gets its own 0..N bitmap, the base maps it to the 0..30 subrange allocated (manually, via the base arg to macro) for this class-map.
anyway, heres how
modprobe nouveaugoes with dynamic_debug.verbose=3[86512.693954] dyndbg: class[0]: module:nouveau base:15 len:5 ty:1 [86512.693958] dyndbg: 15: 0 NV_SUBDEV_DBG_OFF # aka V0 [86512.693959] dyndbg: 16: 1 NV_SUBDEV_DBG_INFO [86512.693960] dyndbg: 17: 2 NV_SUBDEV_DBG_DEBUG [86512.693960] dyndbg: 18: 3 NV_SUBDEV_DBG_TRACE [86512.693960] dyndbg: 19: 4 NV_SUBDEV_DBG_SPAM [86512.693961] dyndbg: class[1]: module:nouveau base:10 len:5 ty:1 [86512.693961] dyndbg: 10: 0 NV_CLI_DBG_OFF [86512.693962] dyndbg: 11: 1 NV_CLI_DBG_INFO [86512.693962] dyndbg: 12: 2 NV_CLI_DBG_DEBUG [86512.693963] dyndbg: 13: 3 NV_CLI_DBG_TRACE [86512.693963] dyndbg: 14: 4 NV_CLI_DBG_SPAM [86512.693963] dyndbg: class[2]: module:nouveau base:0 len:10 ty:0 [86512.693964] dyndbg: 0: 0 DRM_UT_CORE [86512.693964] dyndbg: 1: 1 DRM_UT_DRIVER [86512.693965] dyndbg: 2: 2 DRM_UT_KMS [86512.693965] dyndbg: 3: 3 DRM_UT_PRIME [86512.693965] dyndbg: 4: 4 DRM_UT_ATOMIC [86512.693966] dyndbg: 5: 5 DRM_UT_VBL [86512.693966] dyndbg: 6: 6 DRM_UT_STATE [86512.693966] dyndbg: 7: 7 DRM_UT_LEASE [86512.693967] dyndbg: 8: 8 DRM_UT_DP [86512.693967] dyndbg: 9: 9 DRM_UT_DRMRES [86512.693968] dyndbg: module:nouveau attached 3 classes [86512.693968] dyndbg: 632 debug prints in module nouveauThey are not yet wired by class; the nv-printks are using
dev_dbgfor now, so they can be enabled with standard selections (module, func, etc).DYNDBG API
I added
__pr_debug_clsto make things testable, I wanted to keep it private/un-api, because drm already has drm_dbg_<cat>(cat, fmt..), and that seemed a pretty good model to follow: enums with strong names forclass_idconstants, and same names for classes.ie: __pr_debug_cls(DRM_UT_KMS, "Whats the Matter with KMS: %s\n", reason);But now nouveau probably wants/needs it, perhaps others too.
pr_dbg_cls/dev_dbg_cls? class or debug spelled out ?MORE TESTING with DRM & TRACEFS
Most dev & testing has been on virtme, with test-dynamic-debug module doing an api-validation-demonstration. The test module proves multiple sysknobs, but cannot prove real multi-module sharing of the class-name space. The DRM.debug adaptation must (and does) do that.
Now Im running on real gpu/drm hw; on both an amdgpu desktop, and this amdgpu+nouveau laptop. Its stable enough to type on, browse, build more kernels, etc.
:#> uname -r
5.18.0-f2-00038-g61d300083196
:#> wc/proc/dynamic_debug/control
11554 95556 1442827/proc/dynamic_debug/control
:#> lsmod | grep drmdrm_buddy 20480 1 i915 drm_ttm_helper 16384 2 amdgpu,nouveau ttm 86016 4 amdgpu,drm_ttm_helper,i915,nouveau drm_dp_helper 184320 3 amdgpu,i915,nouveau drm_kms_helper 208896 6 drm_dp_helper,amdgpu,i915,nouveau drm 655360 16 gpu_sched,drm_dp_helper,drm_kms_helper,drm_buddy,amdgpu,drm_ttm_helper,i915,ttm,nouveau cec 49152 2 drm_dp_helper,i915I've never turned on DRM.debug in frustration (or curiousity until recently); I dunno what normal traffic looks like. So I wrote a script to toggle each category: on/off for 1 sec, so I could 'more' thru the output to see the partitioned streams.
Different runs (of '10' sec of active tracing) produce between 330-3500 lines of logging, depending upon mousing/screen activity. Heres a bit of a many-window-select run:
wc tracegives "size" of the category's stream.:#>
trc_classes
12/sys/kernel/tracing/trace
doing classDRM_UT_CORE+/- T 1394 13941 141614/sys/kernel/tracing/trace
doing classDRM_UT_DRIVER+/- T 1396 13959 141816/sys/kernel/tracing/trace
doing classDRM_UT_KMS+/- T 1482 14521 148246/sys/kernel/tracing/trace
doing classDRM_UT_PRIME+/- T 1484 14539 148446/sys/kernel/tracing/trace
doing classDRM_UT_ATOMIC+/- T 2984 31658 396064/sys/kernel/tracing/trace
doing classDRM_UT_VBL+/- T 3411 37321 449848/sys/kernel/tracing/trace
doing classDRM_UT_STATE+/- T 3413 37339 450048/sys/kernel/tracing/trace
doing classDRM_UT_LEASE+/- T 3415 37357 450248/sys/kernel/tracing/trace
doing classDRM_UT_DP+/- T 3417 37375 450442/sys/kernel/tracing/trace
doing classDRM_UT_DRMRES+/- T 3419 37393 450644/sys/kernel/tracing/traceand some mid-run output from a quiet run, with less repetition.
bash-96790 [006] ..... 410237.432255: tracing_mark_write: doing class DRM_UT_DRIVER +T bash-96790 [006] ..... 410238.610319: tracing_mark_write: doing class DRM_UT_DRIVER -T bash-96790 [006] ..... 410239.776285: tracing_mark_write: doing class DRM_UT_KMS +T gnome-shell-2101 [003] ..... 410239.923029: drm_debug: [FB:98] kworker/u32:10-367584 [010] ..... 410239.924627: drm_debug: Allow idle optimizations (MALL): 0 kworker/u32:0-364714 [008] ..... 410239.935126: drm_debug: Allow idle optimizations (MALL): 1 gnome-shell-2101 [003] ..... 410240.527186: drm_debug: [FB:100] kworker/u32:0-364714 [008] ..... 410240.528686: drm_debug: Allow idle optimizations (MALL): 0 kworker/u32:10-367584 [010] ..... 410240.539378: drm_debug: Allow idle optimizations (MALL): 1 bash-96790 [006] ..... 410240.957921: tracing_mark_write: doing class DRM_UT_KMS -T bash-96790 [006] ..... 410242.199120: tracing_mark_write: doing class DRM_UT_PRIME +T bash-96790 [006] ..... 410243.301988: tracing_mark_write: doing class DRM_UT_PRIME -T bash-96790 [006] ..... 410244.416400: tracing_mark_write: doing class DRM_UT_ATOMIC +T gnome-shell-2101 [003] ..... 410244.653372: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] Allocated atomic state 000000001f1e6cb6 gnome-shell-2101 [003] ..... 410244.653381: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] Added [PLANE:55:plane-3] 00000000785ae904 state to 000000001f1e6cb6 gnome-shell-2101 [003] ..... 410244.653384: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] Added [CRTC:67:crtc-0] 00000000b06ca618 state to 000000001f1e6cb6 gnome-shell-2101 [003] ..... 410244.653389: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] Set [FB:98] for [PLANE:55:plane-3] state 00000000785ae904 gnome-shell-2101 [003] ..... 410244.653392: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] checking 000000001f1e6cb6 gnome-shell-2101 [003] ..... 410244.653407: drm_devdbg: cat:4, (0xffff8f26c173de00:0000:06:00.0)[UNSAFE-MEMORY] committing 000000001f1e6cb6 nonblocking kworker/u32:0-364714 [010] ..... 410244.653729: drm_debug: amdgpu_crtc id:0 crtc_state_flags: enable:1, active:1, planes_changed:1, mode_changed:0,active_changed:0,connectors_changed:0 kworker/u32:0-364714 [010] ..... 410244.654642: drm_debug: plane: id=3 dcc_en=0a few things to note in the trace output:
. the event-name:
drm_(debug|devdbg)is not very informative.
drm_devdbgfmt has cat:%d, it could be the classname, but that should
replace event-name, not supplement it. this pertains todrm_debugtoo..
drm_devdbghas lots of (dev-info), that could be optional on a new flag(s)If anyone wants to repeat the above with the patchset, the .rc file follows:
events_3(){
local a=$1
local b=$2
local c=$3
echo $a >/sys/kernel/tracing/events/dyndbg/enable# avoid drm_vblank*, its noisy
echo $b >/sys/kernel/tracing/events/drm/drm_debug/enableecho $c >/sys/kernel/tracing/events/drm/drm_devdbg/enable
}flags_class() { local flgs=$1; local cls=$2; echo class $cls $flgs > /proc/dynamic_debug/control }# turn on each DRM_UT_* for 1 second each. # kinda shows relative traffic of each category # separated into blocks to get flavor of each
drm_classes(){
local flgs=$1
[ -z $flgs ] && flgs="p"#echo >
/sys/kernel/tracing/trace
#wc/sys/kernel/tracing/tracefor cls in
DRM_UT_COREDRM_UT_DRIVERDRM_UT_KMSDRM_UT_PRIMEDRM_UT_ATOMIC\
DRM_UT_VBLDRM_UT_STATEDRM_UT_LEASEDRM_UT_DP\
DRM_UT_DRMRES;
do
echo -n doing class $cls " "echo doing class $cls +$flgs
sleep .1
flags_class+$flgs $cls
sleep 1echo doing class $cls -$flgs
sleep .1
flags_class-$flgs $cls
sleep 1#wc
/sys/kernel/tracing/trace
done
}# like above but with T flag, and markers, trace/enable trc_classes() { local flgs=$1 [ -z $flgs ] && flgs="T"echo >
/sys/kernel/tracing/trace
wc -l/sys/kernel/tracing/trace
events_31 1 1
for cls inDRM_UT_COREDRM_UT_DRIVERDRM_UT_KMSDRM_UT_PRIME\
DRM_UT_ATOMIC\
DRM_UT_VBLDRM_UT_STATEDRM_UT_LEASEDRM_UT_DP\
DRM_UT_DRMRES;
do
echo -n doing class $cls +/- $flgs " "echo doing class $cls +$flgs >
/sys/kernel/tracing/trace_markersleep .1
flags_class+$flgs $cls
sleep 1echo doing class $cls -$flgs >
/sys/kernel/tracing/trace_markersleep .1
flags_class-$flgs $cls
sleep 1wc
/sys/kernel/tracing/tracedone
events_30 0 0
}Jim Cromie (33):
1st, a group of "cleanups"
dyndbg: fix
static_branchmanipulation
dyndbg: fix module.dyndbg handling
dyndbg: show both old and new in change-info
dyndbg: reverse module walk in cat control
dyndbg: reverse module.callsite walk in cat control
dyndbg: useESCAPE_SPACEfor cat control
dyndbg: let query-modname override actual module name
dyndbg: addtest_dynamic_debugmodule
dyndbg: drop EXPORTeddynamic_debug_exec_queries
dyndbg: cleanup local vars inddebug_init
dyndbg: create and use struct_ddebug_infoclass FOO support
dyndbg: add
class_idtopr_debugcallsites
dyndbg: add__pr_debug_clsfor testing
dyndbg: addDECLARE_DYNDBG_CLASSMAPmacro kernel/module: add__dyndbg_classessection
dyndbg: addddebug_attach_module_classes
dyndbg: validate class FOO by checking with module
doc-dyndbg: describe "classCLASS_NAME" query support
doc-dyndbg: edit dynamic-debug-howto for brevity, audienceadd dyndbg-class-param support
dyndbg: add drm.debug style (drm/parameters/debug) bitmap support
dyndbg: testDECLARE_DYNDBG_CLASSMAP, sysfs nodesdrm.debug adaptation
drm_print: condense enumdrm_debug_category
drm: POC drm on dyndbg - use in core, 2 helpers, 3 drivers.
drm_print: interpose drm_*dbg with forwarding macros
drm_print: wrap drm_*_dbg in dyndbg descriptor factory macrodrm-print.h: include dyndbg header
drm-print: adddrm_dbg_driverto improve namespace symmetry
drm_print: refinedrm_debug_enabledfor jump-label
drm_print: prefer bare printkKERN_DEBUGon generic fn
drm_print: add_ddebugdescriptor to drm_*dbg prototypesnouveau-LEVEL_NUM integration: WIP/exploratory.
nouveau: change nvkm_debug/trace to use
dev_dbgPOC
nouveau: adaptNV_DEBUG,NV_ATOMICto use DRM.debug
nouveau: WIP add 2LEVEL_NUMclassmaps for CLI, SUBDEV.../admin-guide/dynamic-debug-howto.rst | 246 +++++----- MAINTAINERS | 2 + drivers/gpu/drm/Kconfig | 12 + drivers/gpu/drm/Makefile | 2 + drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c | 14 + drivers/gpu/drm/display/drm_dp_helper.c | 13 + drivers/gpu/drm/drm_crtc_helper.c | 13 + drivers/gpu/drm/drm_print.c | 48 +- drivers/gpu/drm/i915/i915_params.c | 12 + .../gpu/drm/nouveau/include/nvkm/core/debug.h | 16 + .../drm/nouveau/include/nvkm/core/subdev.h | 17 +- drivers/gpu/drm/nouveau/nouveau_drm.c | 20 + drivers/gpu/drm/nouveau/nouveau_drv.h | 16 +- drivers/gpu/drm/nouveau/nvkm/core/subdev.c | 23 + include/asm-generic/vmlinux.lds.h | 3 + include/drm/drm_print.h | 85 +++- include/linux/dynamic_debug.h | 176 +++++-- kernel/module/internal.h | 4 +- kernel/module/main.c | 20 +- lib/Kconfig.debug | 10 + lib/Makefile | 1 + lib/dynamic_debug.c | 450 +++++++++++++++--- lib/test_dynamic_debug.c | 165 +++++++ 23 files changed, 1099 insertions(+), 269 deletions(-) create mode 100644 lib/test_dynamic_debug.cSignature · 1 line
2.37.1
Signature · 3 lines
Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch