DRM_USE_DYNAMIC_DEBUG regression
Subsystems (11)
Jim Cromie
maintainerv2 cover DRM_USE_DYNAMIC_DEBUG regression
Hi everyone,
DRM_USE_DYNAMIC_DEBUG=y has a regression enabling drm.debug in drivers
It is due to a chicken-egg problem loading modules; on modprobe i915, drm is loaded 1st, and drm/parameters/debug is set. When drm_debug_enabled() tested it at runtime, things just worked.
But with DRM_USE_DYNAMIC_DEBUG=y, the runtime test is replaced with a post-insmod enablement of drm_dbg/dyndbg callsites, via dyndbg's callback on __drm_debug. So with drm.ko loaded before the dependent modules, their debug callsites arent present to be enabled.
OVERVIEW
As Jani Nikula noted rather more gently, DECLARE_DYNDBG_CLASSMAP is error-prone enough to call broken: it relied upon identical classmap definitions in all modules using DRM_UT_*. IOW, it muddled the K&R distinction between a (single) definition, and multiple references.
So 4 patches here split it into:
DYNDBG_CLASSMAP_DEFINE used once per subsystem to define each classmap.DYNDBG_CLASSMAP_USE declare dependence on a DEFINEd classmap.
This makes the weird coordinated-changes-by-identical-classmaps "feature" unnecessary.
DYNDBG_CLASSMAP_DEFINE initializes the classmap, stores it into the (existing) __dyndbg_classes section, and exports the struct var (unlike DECLARE_DYNDBG_CLASSMAP).
DYNDBG_CLASSMAP_USE initializes a class-ref struct, containing the user-module-name, and a ref to the exported classmap var.
The distinction allows separate treatment of classmaps and classmap-refs, the latter getting additional behavior to propagate class'd prdbg settings to modules being loaded.
Consider i915.ko, a DYNDBG_CLASSMAP_USEr: due to dependencies, modprobe drm debug=$val is done 1st. For DRM_USE_DYNAMIC_DEBUG=y, drm.debug=$val invokes dyndbg's kparam callback, which applies "class DRM_UT_*" >controls as given by the bits. But i915.ko isn't modprobed yet, so misses those >controls. These must be 're-delivered' when i915 is modprobed.
Recapitulating ddebug_attach_module_classes(1) for (existing) classes; ddebug_attach_client_module_classes(2) does this for (new) class-refs, as they are found when modprobing drm-drivers.
2 calls ddebug_apply_parents_params(3) on each referred classmap defn.
3 scans kernel-params owned by the module DEFINEing the classmap, either builtin or loadable, calls ddebug_match_apply_kparam(4) on each.
4 finds those kparams wired to dyndbg's param-ops, which are therefore castable to struct ddebug_class_param, and have a ref to the classmap that they "control". So 4 finds classmap definitions whose owner matches the user-module being loaded, and applies the kparam's state (__drm_debug in this case) by calling ddebug_apply_class_bitmap().
test_dynamic_debug is extended to recreate DRM's multi-module regression, it builds both test_dynamic_debug.ko and _submod.ko, with an ifdef to _DEFINE in the main module, and _USE in the submod. This gives both modules identical set of prdbgs, which is helpful for humans comparing results.
STATUS
here it is, "working":
doing class DRM_UT_CORE -p
[ 9904.961750] dyndbg: read 21 bytes from userspace [ 9904.962286] dyndbg: query 0: "class DRM_UT_CORE -p" mod:* [ 9904.962848] dyndbg: split into words: "class" "DRM_UT_CORE" "-p" [ 9904.963444] dyndbg: op='-' flags=0x0 maskp=0xfffffffe [ 9904.963945] dyndbg: parsed: func="" file="" module="" format="" lineno=0-0 class=DRM_UT_CORE [ 9904.964781] dyndbg: good-class: drm.DRM_UT_CORE module:drm nd:302 nc:1 nu:0 [ 9904.966411] dyndbg: class-ref: drm_kms_helper.DRM_UT_CORE module:drm_kms_helper nd:95 nc:0 nu:1 [ 9904.967265] dyndbg: class-ref: drm_display_helper.DRM_UT_CORE module:drm_display_helper nd:150 nc:0 nu:1 [ 9904.968349] dyndbg: class-ref: i915.DRM_UT_CORE module:i915 nd:1659 nc:0 nu:1 [ 9904.969801] dyndbg: class-ref: amdgpu.DRM_UT_CORE module:amdgpu nd:4425 nc:0 nu:1 [ 9904.977079] dyndbg: class-ref: nouveau.DRM_UT_CORE module:nouveau nd:103 nc:0 nu:1 [ 9904.977830] dyndbg: processed 1 queries, with 507 matches, 0 errs doing class DRM_UT_DRIVER +p [ 9906.151761] dyndbg: read 23 bytes from userspace [ 9906.152241] dyndbg: query 0: "class DRM_UT_DRIVER +p" mod:* [ 9906.152793] dyndbg: split into words: "class" "DRM_UT_DRIVER" "+p" [ 9906.153388] dyndbg: op='+' flags=0x1 maskp=0xffffffff [ 9906.153896] dyndbg: parsed: func="" file="" module="" format="" lineno=0-0 class=DRM_UT_DRIVER [ 9906.154746] dyndbg: good-class: drm.DRM_UT_DRIVER module:drm nd:302 nc:1 nu:0 [ 9906.155433] dyndbg: class-ref: drm_kms_helper.DRM_UT_DRIVER module:drm_kms_helper nd:95 nc:0 nu:1 [ 9906.156267] dyndbg: class-ref: drm_display_helper.DRM_UT_DRIVER module:drm_display_helper nd:150 nc:0 nu:1 [ 9906.157365] dyndbg: class-ref: i915.DRM_UT_DRIVER module:i915 nd:1659 nc:0 nu:1 [ 9906.163848] dyndbg: class-ref: amdgpu.DRM_UT_DRIVER module:amdgpu nd:4425 nc:0 nu:1 [ 9906.178963] dyndbg: class-ref: nouveau.DRM_UT_DRIVER module:nouveau nd:103 nc:0 nu:1 [ 9906.179934] dyndbg: processed 1 queries, with 1286 matches, 0 errs
It is still WIP, but Daniel Vetter inquired, so I figured Id send what I got.
The series ends in an RFC patch; __jump_label_patch can "crash the box" when the jump-entry is in the wrong state. The code makes no distinction between a well-formed "toggled" state and "insane". This patch gets me past some mis-initialization problem Im still probing.
Things seem to be mostly working.
Heres the script that Ive been testing with:
(see submod_test at bottom)
#!/bin/bash
# shell funcs to test module load behavior of dynamic-debug, using # test_dynamic_debug module. Meant to be useful at shell command # line, after sourcing this.
PS1=":#> " # obvious clue we're in the "environment"
# grease for use/play alias ddcmd='echo $* > /proc/dynamic_debug/control'
# support modprobe foo dyndbg=$VAR testing export THML="class HI +p;class MID +p;class LOW +p;" export TLVLS="class L1 +p;class L2 +p;class L3 +p;class L4 -p;"
alias lmt='modprobe test_dynamic_debug dyndbg=+pmf' alias rmt='rmmod test_dynamic_debug'
alias look='grep test_dynamic_debug /proc/dynamic_debug/control'
alias mpd='modprobe $1 dyndbg="$2"'
alias mpt='modprobe test_dynamic_debug dyndbg="$*"'
alias skt='cd /sys/kernel/tracing'
alias smtddp='cd /sys/module/test_dynamic_debug/parameters'
alias cget='grep $1 /proc/dynamic_debug/control'
lookfor () {
grep $1 /proc/dynamic_debug/control
}
vx() {
echo $* > /sys/module/dynamic_debug/parameters/verbose
}
# amdgpu has ~2200 pr-debugs (before drm-debug-on-dyndbg), # use them to prove kernel has both DYNAMIC_DEBUG and a DRM module # and modprobe <mod> dyndbg=+p works
load_drm_mod_test() {
local mod=${1:-amdgpu}
rmmod $mod 2>/dev/null
modprobe $mod dyndbg=+pfm
let count=$(grep =pmf /proc/dynamic_debug/control | grep $mod | wc -l) rmmod $mod
if [ $count -gt 100 ] ; then
echo $mod has $count pr-dbgs
return 0
else
echo $mod: too few sites: $count, suspect bad config return -1
fi
}
SMTDDP=/sys/module/test_dynamic_debug/parameters
function doit() {
cat $SMTDDP/do_prints
}qry_cmd() { # like ddcmd, with feedback
echo "QCMD: $* to-control" >&2
echo $* > /proc/dynamic_debug/control
}
# exercise class FOO behavior of test_dynamic_debug module
ttest_module__() {
flg=$1
dmesg -C
modprobe test_dynamic_debug dyndbg=+pfm
doit for cls in L1 L2 L3; do
qry_cmd module test_dynamic_debug class $cls $flg doit
done
doit
for cls in LOW MID HI; do
qry_cmd module test_dynamic_debug class $cls $flg doit
done
doit
for cls in D2_CORE D2_KMS D2_DRIVER; do
qry_cmd module test_dynamic_debug class $cls $flg doit
done
doit
dmesg | grep class
}
ttest_module() {
ttest_module__ +p
ttest_module__ -p
#ttest_module__ +T
#ttest_module__ -T
}# use/test bitmaps # knob is a sysfs-node
tddm_is_knob_() {
knob=$1;
if [ -f $SMTDDP/$knob ]; then
return 0
else
echo missing sysfs node: $knob, skipping tests return 1
fi
}
tddm_set_knob_() {
knob=$1;
val=$2;
expect=$3;
[[ -z $knob || -z $val ]] && echo "expecting 2+args: knob val [result]" && return
echo "TDDM: $val >$knob" >&2 && sleep 0.1
echo $val > $SMTDDP/$knob
echo "? $?"
val=`cat $SMTDDP/$knob`
[[ -z $expect ]] && expect=$val
if [[ $val == $expect ]]; then
echo pass-ish $val
else
echo fail $val != $expect
fi
}tddm_knob_clname_() {
targ=$1
cls=$2
res=$3
tddm_is_knob_ $targ || continue;
tddm_set_knob_ $targ $cls $res
cat $SMTDDP/do_prints
}tddm_knob_classes_() {
targ=$1
shift
cls=$*
tddm_is_knob_ $targ || return;
for bitsym in $cls;
do
tddm_knob_clname_ $targ $bitsym
cat $SMTDDP/do_prints
done
}# round-trip-test - args: node val want explanation
rtt_nvwx() {
node=$1 # to this
val=$2 # write this
want=$3 # expect this on readback
[ -z $3 ] && echo "want args: node input result" && return shift 3;
echo "RTT: $val -> $node : $want :: DOING: $*" >&2 && sleep 0.1
echo $val > $SMTDDP/$node
rc=$(cat $SMTDDP/$node)
# echo rc $rc
# pretty literal test
[[ $rc != $want ]] && echo crap [[ $rc != $want ]] && return 1
}# test-round-trip, using above.
# test disjoint - disjoint interface
trx_disjoint_names() {
nm=$1
rtt_nvwx $nm -HI,-MID,-LOW 0x0 all-off
rtt_nvwx $nm HI 0x4 hi
rtt_nvwx $nm MID 0x6 mid,hi
rtt_nvwx $nm LOW 0x7 low,mid,hi
rtt_nvwx $nm -HI 0x3 -hi,low,mid
rtt_nvwx $nm -MID 0x1 -mid,low
rtt_nvwx $nm -LOW 0x0 -low # multi-bit update
rtt_nvwx $nm +LOW,MID,HI 0x7 3-on # same-bit, multi-toggle (for exersize)
rtt_nvwx $nm -LOW,+LOW,-LOW,LOW,-LOW,LOW 0x7 on-off-repeat
}trt_disjoint_names() {
trx_disjoint_names T_disjoint_names
}trp_disjoint_names() {
trx_disjoint_names p_disjoint_names
}
# traditional bitmap
trx_disjoint_bits() {
nm=$1
echo 0 > $SMTDDP/$nm
rtt_nvwx $nm 0x0 0x0 no change
rtt_nvwx $nm 0x1 0x1 disjoint_CORE
rtt_nvwx $nm 0x2 0x2 disjoint_DRIVER,
rtt_nvwx $nm 0x4 0x4 disjoint_KMS,
rtt_nvwx $nm 0x10 0x10 disjoint_PRIME,
rtt_nvwx $nm 0x20 0x20 disjoint_ATOMIC,
rtt_nvwx $nm 0x40 0x40 disjoint_VBL,
rtt_nvwx $nm 0x80 0x80 disjoint_STATE,
rtt_nvwx $nm 0x100 0x100 disjoint_LEASE,rtt_nvwx $nm 0x4f 0x4f disjoint_VBL and below }
trt_disjoint_bits() {
trx_disjoint_bits T_disjoint_bits
}trp_disjoint_bits() {
trx_disjoint_bits p_disjoint_bits
}
# traditional numeric verbose
trx_level_num() {
nm=$1
echo 0 > $SMTDDP/$nm
rtt_nvwx $nm 0 0 clear all
rtt_nvwx $nm 1 1 level 1
rtt_nvwx $nm 2 2 levels 2,1
rtt_nvwx $nm 3 3 levels 3,2,1
rtt_nvwx $nm 4 4 levels 4-1
rtt_nvwx $nm 5 5 levels 5-1
rtt_nvwx $nm 6 6 levels 6-1
rtt_nvwx $nm 7 7 levels 7-1
rtt_nvwx $nm 2 2 levels 2,1
}
trt_level_num() {
trx_level_num T_level_num
}
trp_level_num() {
trx_level_num p_level_num
}# levelstrx_level_names() {
nm=$1
rtt_nvwx $nm -L0 0 clear all
rtt_nvwx $nm L0 0 clear all
rtt_nvwx $nm L1 1 level 1
rtt_nvwx $nm L2 2 levels 2,1
rtt_nvwx $nm L3 3 levels 3-1
rtt_nvwx $nm L4 4 levels 4-1
rtt_nvwx $nm L5 5 levels 5-1
rtt_nvwx $nm L7 7 levels 7-1
}trt_level_names() {
trx_level_names T_level_names
}trp_level_names() {
trx_level_names p_level_names
}
# these are more like exersize #tddm_syslog_classes_1 #tddm_syslog_classes_2 #tddm_syslog_prio #tddm_syslog_verbose
trt_all() {
# 1st, cuz its got base = 0, simplest
trt_disjoint_bits
trt_disjoint_names
trt_level_names
trt_level_num
}trp_all() {
# 1st, cuz its got base = 0, simplest
trp_disjoint_bits
trp_disjoint_names
trp_level_names
trp_level_num
}
init () {
modprobe test_dynamic_debug
smtddp
echo 0 > p_disjoint_names
echo 0 > p_level_names
echo 0 > p_level_num
echo 0 > p_disjoint_bits
}init_ () {
echo 0 > T_disjoint_names
echo 0 > T_level_names
echo 0 > T_level_num
echo 0 > T_disjoint_bits
}
alias refresh="cd -; . test-funcs.rc; cd -"
# need tests for # p_disjoint_bits # p_disjoint_names # p_level_num
submod () {
# set dyndbg-params at load
echo mp test_dynamic_debug p_disjoint_bits=${1:-0} p_level_num=${2:-0}
modprobe test_dynamic_debug p_disjoint_bits=${1:-0} p_level_num=${2:-0} dyndbg=+p
modprobe test_dynamic_debug_submod dyndbg=+p
}
unmod () {
rmmod test_dynamic_debug_submod
rmmod test_dynamic_debug
}ddgrep () {
grep $1 /proc/dynamic_debug/control
}
# these dont use bitmap interface: # so no levels behavior is available here
VX="V0 V1 V2 V3 V4 V5 V6"
for_X () {
flag=$1
classes=$2
for C in $classes; do
ddc_grep class:$C
qry_cmd class $C $flag
ddc_grep class:$C
done
}for_Vn () {
flag=$1
for C in V0 V1 V2 V3 V4 V5 V6; do
ddgrep class:$C
qry_cmd class $C $flag
ddgrep class:$C
done
}
for_D2 () {
flag=$1
for C in D2_CORE D2_DRIVER D2_KMS D2_PRIME D2_ATOMIC D2_VBL D2_STATE D2_LEASE D2_DP D2_DRMRES; do
ddgrep class:$C
qry_cmd class $C $flag
ddgrep class:$C
done
}
toggle_D2 () {
for_D2 -p
for_D2 +p
}toggle_Vn () {
for_Vn +p
for_Vn -p
}
submod_test () {
vx 4
unmod
submod 0x3ff 3
ddgrep _submod
echo 1 > /sys/module/test_dynamic_debug/parameters/do_prints echo 1 > /sys/module/test_dynamic_debug_submod/parameters/do_prints
echo 0 > /sys/module/test_dynamic_debug/parameters/p_disjoint_bits echo 0x2ff > /sys/module/test_dynamic_debug/parameters/p_disjoint_bits
echo 1 > /sys/module/test_dynamic_debug/parameters/do_prints echo 1 > /sys/module/test_dynamic_debug_submod/parameters/do_prints
}
Jim Cromie (20):
test-dyndbg: fixup CLASSMAP usage error
test-dyndbg: show that DEBUG enables prdbgs at compiletime
dyndbg: replace classmap list with a vector
dyndbg: make ddebug_apply_class_bitmap more selective
dyndbg: split param_set_dyndbg_classes to inner/outer
dyndbg: drop NUM_TYPE_ARRAY
dyndbg: reduce verbose/debug clutter
dyndbg: tighten ddebug_class_name() 1st arg
dyndbg: constify ddebug_apply_class_bitmap args
dyndbg-API: split DECLARE_(DYNDBG_CLASSMAP) to $1(_DEFINE|_USE)
dyndbg-API: specialize DYNDBG_CLASSMAP_(DEFINE|USE)
dyndbg-API: DYNDBG_CLASSMAP_USE drop extra args
dyndbg-API: DYNDBG_CLASSMAP_DEFINE() improvements
drm_print: fix stale macro-name in comment
test-dyndbg: build test_dynamic_debug_submod
test-dyndbg: rename DD_SYS_WRAP to DYNDBG_CLASSMAP_PARAM
test-dyndbg: disable WIP dyndbg-trace params
test-dyndbg: tune sub-module behavior
dyndbg: unwrap __ddebug_add_module inner function NOTYET
jump_label: RFC - tolerate toggled state
arch/x86/kernel/jump_label.c | 26 ++- drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c | 14 +- drivers/gpu/drm/display/drm_dp_helper.c | 14 +- drivers/gpu/drm/drm_crtc_helper.c | 14 +- drivers/gpu/drm/drm_print.c | 22 +- drivers/gpu/drm/i915/i915_params.c | 14 +- drivers/gpu/drm/nouveau/nouveau_drm.c | 14 +- include/asm-generic/vmlinux.lds.h | 3 + include/drm/drm_print.h | 6 +- include/linux/dynamic_debug.h | 57 +++-- include/linux/map.h | 54 +++++ kernel/module/main.c | 2 + lib/Makefile | 3 +- lib/dynamic_debug.c | 268 +++++++++++++++++------- lib/test_dynamic_debug.c | 116 ++++++---- lib/test_dynamic_debug_submod.c | 10 + 16 files changed, 437 insertions(+), 200 deletions(-) create mode 100644 include/linux/map.h create mode 100644 lib/test_dynamic_debug_submod.c
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 1/20 test-dyndbg: fixup CLASSMAP usage error
more careful reading of test output reveals:
lib/test_dynamic_debug.c:103 [test_dynamic_debug]do_cats =pmf "doing categories\n" lib/test_dynamic_debug.c:105 [test_dynamic_debug]do_cats =p "LOW msg\n" class:MID lib/test_dynamic_debug.c:106 [test_dynamic_debug]do_cats =p "MID msg\n" class:HI lib/test_dynamic_debug.c:107 [test_dynamic_debug]do_cats =_ "HI msg\n" class unknown, _id:13
That last line is wrong, the HI class is declared.
But the enum's 1st val (explicitly initialized) was wrong; it must be _base, not _base+1 (a DECLARE_DYNDBG_CLASSMAP param). So the last enumeration exceeded the range of mapped class-id's, which triggered the "class unknown" report. Basically, I coded in an error, and forgot to verify it and remove it.
RFC:
This patch fixes a bad usage of DECLARE_DYNDBG_CLASSMAP([1]), showing that it is too error-prone. As noted in test-dynamic-debug.c comments:
* 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-62 class_id space !!
* (build-bug-on tips welcome)
Those shortcomings could largely be fixed with a __stringify_list (which doesn't exist) used in DEFINE_DYNAMIC_DEBUG_CLASSMAP(), on __VA_ARGS__ a 2nd time. Then, DRM would pass DRM_UT_* ; all the categories, in order, and not their stringifications, which created all the usage complications above.
[1] name changed later to DYNDBG_CLASSMAP_DEFINE
--- lib/test_dynamic_debug.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/test_dynamic_debug.c +1 -1
@@ -75,7 +75,7 @@ DD_SYS_WRAP(disjoint_bits, p);DD_SYS_WRAP (disjoint_bits,T );/* symbolic input, independent bits */ -enum cat_disjoint_names {LOW =11 ,MID ,HI }; +enum cat_disjoint_names {LOW =10 ,MID ,HI };DECLARE_DYNDBG_CLASSMAP (map_disjoint_names,DD_CLASS_TYPE_DISJOINT_NAMES ,10 ,"LOW" ,"MID" ,"HI" );DD_SYS_WRAP (disjoint_names, p);
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 2/20 test-dyndbg: show that DEBUG enables prdbgs at compiletime
In reply to Jim CromieDyndbg is required to enable prdbgs at compile-time if DEBUG is defined. Show this works; add the defn to test_dynamic_debug.c, and manually inspect/verify its effect at module load:
[ 15.292810] dyndbg: module:test_dynamic_debug attached 4 classes [ 15.293189] dyndbg: 32 debug prints in module test_dynamic_debug [ 15.293715] test_dd: init start [ 15.293716] test_dd: doing categories [ 15.293716] test_dd: LOW msg ... [ 15.293733] test_dd: L6 msg [ 15.293733] test_dd: L7 msg [ 15.293733] test_dd: init done
NOTES:
As is observable above, define DEBUG enables all prdbgs, including those in mod_init-fn, and more notably, the class'd ones (callsites with non-default class_ids).
This differs from the >control interface, which in order to properly protect a client's class'd prdbgs, requires a "class FOO" in queries to change them. If this sounds wrong, note that the DEBUG is in the module source file, and is thus privileged.
This yields an occaisional surprise; the following disables all the compile-time enabled plain prdbgs, but leaves the class'd ones enabled.
:#> modprobe test_dynamic_debug dyndbg==_
--- lib/test_dynamic_debug.c | 2 ++ 1 file changed, 2 insertions(+)
lib/test_dynamic_debug.c +2 -0
@@ -8,6 +8,8 @@#define pr_fmt (fmt) "test_dd: " fmt +#define DEBUG /* enable all prdbgs (plain & class'd) at compiletime */ +#include <linux/module.h> /* run tests by reading or writing sysfs node: do_prints */
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 3/20 dyndbg: replace classmap list with a vector
In reply to Jim CromieClassmaps are stored/linked in a section/array, but are each added to the module's ddebug_table.maps list-head.
This is unnecessary; even when ddebug_attach_classmap() is handling the builtin section (with classmaps for multiple builtin modules), its contents are ordered, so a module's possibly multiple classmaps will be consecutive in the section, and could be treated as a vector/block, since both start-addy and subrange length are in the ddebug_info arg.
So this changes:
struct ddebug_class_map drops list-head link.
struct ddebug_table drops the list-head maps, and gets: classes & num_classes for the start-addy and num_classes, placed to improve struct packing.
The loading: in ddebug_attach_module_classes(), replace the for-the-modname list-add loop, with a forloop that finds the module's subrange (start,length) of matching classmaps within the possibly builtin classmaps vector, and saves those to the ddebug_table.
The reading/using: change list-foreach loops in ddebug_class_name() & ddebug_find_valid_class() to walk the array from start to length.
Also:
Move #define __outvar up, above an added use in a fn-prototype. Simplify ddebug_attach_module_classes args, ref has both addy,len.
This isn't technically a bugfix, but IMO simplifies later fixes for the chicken-egg post-init enablement regression.
--- include/linux/dynamic_debug.h | 1 - lib/dynamic_debug.c | 61 ++++++++++++++++++----------------- 2 files changed, 32 insertions(+), 30 deletions(-)
include/linux/dynamic_debug.h +0 -1
@@ -81,7 +81,6 @@ enum class_map_type { };struct ddebug_class_map { -struct list_head link;struct module *mod;const char *mod_name;/* needed for builtins */ const char **class_names;
lib/dynamic_debug.c +32 -29
119 lines not on this page · raw message
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 4/20 dyndbg: make ddebug_apply_class_bitmap more selective
In reply to Jim Cromieddebug_apply_class_bitmap() currently applies the class settings to all modules, by calling ddebug_exec_queries(query, NULL), where NULL is wildcard ("*" does the same). Make it more selective, by adding query_module param, and passing it into ddebug_exec_queries, instead of the NULL.
This allows its more selective use later; for propagating drm.debug settings to dependent modules when/just-after they load. Doing this propagation with "*" is fine, but would match with all previously loaded modules, creating more dynamic_debug.verbose=3 logging activity, and obscuring the actual changes.
No functional change.
---
after modprobe i915, heres the module dependencies, though not all on drm.debug.
bash-5.2# lsmod
Module Size Used by i915 3133440 0 drm_buddy 20480 1 i915 ttm 90112 1 i915 i2c_algo_bit 16384 1 i915 video 61440 1 i915 wmi 32768 1 video drm_display_helper 200704 1 i915 drm_kms_helper 208896 2 drm_display_helper,i915 drm 606208 5 drm_kms_helper,drm_display_helper,drm_buddy,i915,ttm cec 57344 2 drm_display_helper,i915 --- lib/dynamic_debug.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-)
lib/dynamic_debug.c +12 -7
@@ -600,7 +600,8 @@ static int ddebug_exec_queries(char *query, const char *modname)/* apply a new bitmap to the sys-knob's current bit-state */ static int ddebug_apply_class_bitmap (const struct ddebug_class_param *dcp, -unsigned long *new_bits,unsigned long *old_bits) +unsigned long *new_bits,unsigned long *old_bits, +const char *query_modname) {#define QUERY_SIZE 128char query[QUERY_SIZE ];
@@ -608,7 +609,8 @@ static int ddebug_apply_class_bitmap(const struct ddebug_class_param *dcp,int matches =0 ;int bi, ct; -v2pr_info ("apply: 0x%lx to: 0x%lx\n" , *new_bits, *old_bits); +v2pr_info ("apply bitmap: 0x%lx to: 0x%lx for %s\n" , *new_bits, *old_bits, + query_modname ?:"" );for (bi =0 ; bi < map->length; bi++) {if (test_bit (bi, new_bits) ==test_bit (bi, old_bits))
@@ -617,12 +619,15 @@ static int ddebug_apply_class_bitmap(const struct ddebug_class_param *dcp,snprintf (query,QUERY_SIZE ,"class %s %c%s" , map->class_names[bi],test_bit (bi, new_bits) ?'+' :'-' , dcp->flags); - ct =ddebug_exec_queries (query,NULL ); + ct =ddebug_exec_queries (query, query_modname); matches += ct;v2pr_info ("bit_%d: %d matches on class: %s -> 0x%lx\n" , bi, ct, map->class_names[bi], *new_bits); } +v2pr_info ("applied bitmap: 0x%lx to: 0x%lx for %s\n" , *new_bits, *old_bits, + query_modname ?:"" ); +return matches; }
@@ -678,7 +683,7 @@ static int param_set_dyndbg_classnames(const char *instr, const struct kernel_pacontinue ; } curr_bits ^=BIT (cls_id); - totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, dcp->bits); + totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, dcp->bits,NULL ); *dcp->bits = curr_bits;v2pr_info ("%s: changed bit %d:%s\n" ,KP_NAME (kp), cls_id, map->class_names[cls_id]);
@@ -688,7 +693,7 @@ static int param_set_dyndbg_classnames(const char *instr, const struct kernel_pa old_bits =CLASSMAP_BITMASK (*dcp->lvl); curr_bits =CLASSMAP_BITMASK (cls_id + (wanted ?1 :0 )); - totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, &old_bits); + totct +=ddebug_apply_class_bitmap (dcp, &curr_bits, &old_bits,NULL ); *dcp->lvl = (cls_id + (wanted ?1 :0 ));v2pr_info ("%s: changed bit-%d: \"%s\" %lx->%lx\n" ,KP_NAME (kp), cls_id, map->class_names[cls_id], old_bits, curr_bits);
@@ -751,7 +756,7 @@ int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp) inrep &=CLASSMAP_BITMASK (map->length); }v2pr_info ("bits:%lx > %s\n" , inrep,KP_NAME (kp)); - totct +=ddebug_apply_class_bitmap (dcp, &inrep, dcp->bits); + totct +=ddebug_apply_class_bitmap (dcp, &inrep, dcp->bits,NULL ); *dcp->bits = inrep;break ;case DD_CLASS_TYPE_LEVEL_NUM :
@@ -764,7 +769,7 @@ int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp) old_bits =CLASSMAP_BITMASK (*dcp->lvl); new_bits =CLASSMAP_BITMASK (inrep);v2pr_info ("lvl:%ld bits:0x%lx > %s\n" , inrep, new_bits,KP_NAME (kp)); - totct +=ddebug_apply_class_bitmap (dcp, &new_bits, &old_bits); + totct +=ddebug_apply_class_bitmap (dcp, &new_bits, &old_bits,NULL ); *dcp->lvl = inrep;break ;default :
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 5/20 dyndbg: split param_set_dyndbg_classes to inner/outer
In reply to Jim CromieSplit param_set_dyndbg_classes() to interface-preserving wrapper & inner function with an additional param: mod_name, which is passed into ddebug_apply_class_bitmap() to allow adjusting a single module's prdbgs. Wrapper passes NULL, preserving current behavior for now.
no functional change.
--- lib/dynamic_debug.c | 36 +++++++++++++++++++++--------------- 1 file changed, 21 insertions(+), 15 deletions(-)
lib/dynamic_debug.c +21 -15
@@ -707,18 +707,9 @@ static int param_set_dyndbg_classnames(const char *instr, const struct kernel_pareturn 0 ; } -/** -* param_set_dyndbg_classes - class FOO >control -* @instr: string echo>d to sysfs, input depends on map_type -* @kp: kp->arg has state: bits/lvl, map, map_type -* -* Enable/disable prdbgs by their class, as given in the arguments to -* DECLARE_DYNDBG_CLASSMAP. For LEVEL map-types, enforce relative -* levels by bitpos. -* -* Returns: 0 or <0 if error. -*/ -int param_set_dyndbg_classes (const char *instr,const struct kernel_param *kp) +static int param_set_dyndbg_module_classes (const char *instr, +const struct kernel_param *kp, +const char *modnm) {const struct ddebug_class_param *dcp = kp->arg;const struct ddebug_class_map *map = dcp->map;
@@ -755,8 +746,8 @@ int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp) KP_NAME(kp), inrep, CLASSMAP_BITMASK(map->length)); inrep &=CLASSMAP_BITMASK (map->length); } -v2pr_info ("bits:%lx > %s\n" , inrep,KP_NAME (kp)); - totct +=ddebug_apply_class_bitmap (dcp, &inrep, dcp->bits,NULL ); +v2pr_info ("bits:0x%lx > %s.%s\n" , inrep, modnm ?:"*" ,KP_NAME (kp)); + totct +=ddebug_apply_class_bitmap (dcp, &inrep, dcp->bits, modnm); *dcp->bits = inrep;break ;case DD_CLASS_TYPE_LEVEL_NUM :
@@ -769,7 +760,7 @@ int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp) old_bits =CLASSMAP_BITMASK (*dcp->lvl); new_bits =CLASSMAP_BITMASK (inrep);v2pr_info ("lvl:%ld bits:0x%lx > %s\n" , inrep, new_bits,KP_NAME (kp)); - totct +=ddebug_apply_class_bitmap (dcp, &new_bits, &old_bits,NULL ); + totct +=ddebug_apply_class_bitmap (dcp, &new_bits, &old_bits, modnm); *dcp->lvl = inrep;break ;default :
@@ -778,6 +769,21 @@ int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp)vpr_info ("%s: total matches: %d\n" ,KP_NAME (kp), totct);return 0 ; } +/** +* param_set_dyndbg_classes - class FOO >control +* @instr: string echo>d to sysfs, input depends on map_type +* @kp: kp->arg has state: bits/lvl, map, map_type +* +* Enable/disable prdbgs by their class, as given in the arguments to +* DECLARE_DYNDBG_CLASSMAP. For LEVEL map-types, enforce relative +* levels by bitpos. +* +* Returns: 0 or <0 if error. +*/ +int param_set_dyndbg_classes (const char *instr,const struct kernel_param *kp) +{ +return param_set_dyndbg_module_classes (instr, kp,NULL ); +}EXPORT_SYMBOL (param_set_dyndbg_classes);/**
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 6/20 dyndbg: drop NUM_TYPE_ARRAY
In reply to Jim CromieARRAY_SIZE works here, since array decl is complete.
--- include/linux/dynamic_debug.h | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
include/linux/dynamic_debug.h +1 -3
@@ -104,11 +104,9 @@ struct ddebug_class_map { .mod_name = KBUILD_MODNAME, \ .base = _base, \ .map_type = _maptype, \ - .length = NUM_TYPE_ARGS(char*, __VA_ARGS__), \ + .length = ARRAY_SIZE(_var##_classnames), \ .class_names = _var##_classnames, \ } -#define NUM_TYPE_ARGS (eltype, ...) \ - (sizeof((eltype[]){__VA_ARGS__}) / sizeof(eltype))/* encapsulate linker provided built-in (or module) dyndbg data */ struct _ddebug_info {
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 7/20 dyndbg: reduce verbose/debug clutter
In reply to Jim Cromiecurrently, for verbose=3, this is logged:
dyndbg: query 0: "class DRM_UT_CORE +p" mod:*
dyndbg: split into words: "class" "DRM_UT_CORE" "+p"
dyndbg: op='+'
dyndbg: flags=0x1
dyndbg: *flagsp=0x1 *maskp=0xffffffff
dyndbg: parsed: func="" file="" module="" format="" lineno=0-0 class=DRM_UT_CORE
dyndbg: no matches for query
dyndbg: no-match: func="" file="" module="" format="" lineno=0-0 class=DRM_UT_CORE
dyndbg: processed 1 queries, with 0 matches, 0 errs
This patch:
shrinks 3 lines of 2nd stanza to single line
drops 2 middle lines of 3rd stanza
3 differs from 1 only by status
2 is just status, retold in 4, with more info.
--- lib/dynamic_debug.c | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-)
lib/dynamic_debug.c +3 -11
@@ -265,9 +265,6 @@ static int ddebug_change(const struct ddebug_query *query, }mutex_unlock (&ddebug_lock); -if (!nfound && verbose) -pr_info ("no matches for query\n" ); -return nfound; }
@@ -496,7 +493,6 @@ static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers)pr_err ("bad flag-op %c, at start of %s\n" , *str, str);return -EINVAL ; } -v3pr_info ("op='%c'\n" , op);for (; *str ; ++str) {for (i =ARRAY_SIZE (opt_array) -1 ; i >=0 ; i--) {
@@ -510,7 +506,6 @@ static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers)return -EINVAL ; } } -v3pr_info ("flags=0x%x\n" , modifiers->flags);/* calculate final flags, mask based upon op */ switch (op) {
@@ -526,7 +521,7 @@ static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers) modifiers->flags =0 ;break ; } -v3pr_info ("*flagsp=0x%x *maskp=0x%x\n" , modifiers->flags, modifiers->mask); +v3pr_info ("op='%c' flags=0x%x maskp=0x%x\n" , op, modifiers->flags, modifiers->mask);return 0 ; }
@@ -536,7 +531,7 @@ static int ddebug_exec_query(char *query_string, const char *modname)struct flag_settings modifiers = {};struct ddebug_query query = {};#define MAXWORDS 9 -int nwords, nfound; +int nwords;char *words[MAXWORDS ]; nwords =ddebug_tokenize (query_string, words,MAXWORDS );
@@ -554,10 +549,7 @@ static int ddebug_exec_query(char *query_string, const char *modname)return -EINVAL ; }/* actually go and implement the change */ - nfound =ddebug_change (&query, &modifiers); -vpr_info_dq (&query, nfound ?"applied" :"no-match" ); - -return nfound; +return ddebug_change (&query, &modifiers); }/* handle multiple queries in query string, continue on error, return
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 8/20 dyndbg: tighten ddebug_class_name() 1st arg
In reply to Jim CromieChange function's 1st arg-type, by derefing in the caller. The fn doesnt need any other fields in the old type.
no functional change.
--- lib/dynamic_debug.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
lib/dynamic_debug.c +5 -5
@@ -1110,12 +1110,12 @@ static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)#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) +static const char *ddebug_class_name (struct ddebug_table *dt,struct _ddebug *dp) { -struct ddebug_class_map *map = iter->table->classes; -int i, nc = iter->table->num_classes; +struct ddebug_class_map *map = dt->classes; +int i; -for (i =0 ; i < nc; i++, map++) +for (i =0 ; i < dt->num_classes; i++, map++)if (class_in_range (dp->class_id, map))return map->class_names[dp->class_id - map->base];
@@ -1149,7 +1149,7 @@ static int ddebug_proc_show(struct seq_file *m, void *p)seq_puts (m,"\"" );if (dp->class_id != _DPRINTK_CLASS_DFLT) { - class =ddebug_class_name (iter, dp); + class =ddebug_class_name (iter->table, dp);if (class)seq_printf (m," class:%s" , class);else
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 9/20 dyndbg: constify ddebug_apply_class_bitmap args
In reply to Jim Cromieddebug_apply_class_bitmap() does not alter its 2 bitmap args, make this guarantee in the interface.
NOTE: the bitmap is also available in the dcp arg, but the 2 vars serve a 2nd purpose; the CLASS_TYPE callers use them to translate levels into their underlying disjoint representation.
--- lib/dynamic_debug.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/dynamic_debug.c +1 -1
@@ -592,7 +592,7 @@ static int ddebug_exec_queries(char *query, const char *modname)/* apply a new bitmap to the sys-knob's current bit-state */ static int ddebug_apply_class_bitmap (const struct ddebug_class_param *dcp, -unsigned long *new_bits,unsigned long *old_bits, +const unsigned long *new_bits,const unsigned long *old_bits,const char *query_modname) {#define QUERY_SIZE 128
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 10/20 dyndbg-API: split DECLARE_(DYNDBG_CLASSMAP) to $1(_DEFINE|_USE)
In reply to Jim CromieDECLARE_DYNDBG_CLASSMAP's job was to allow modules to declare the debug classes/categories they want dyndbg to >control on their behalf. Its args give the class-names, their mapping to class_ids, and the sysfs interface style (usually a class-bitmap). Modules wanting a drm.debug style knob need to create the kparam, and call module_param_cb() to wire the sysfs node to the classmap. DRM does this is in drm_print.c
In DRM, multiple modules declare identical DRM_UT_* classmaps, so that the class'd prdbgs are modified across those modules in a coordinated way across the subsystem, by either explicit class DRM_UT_* queries to
Quoted 1 line
control, or by writes to
/sys/module/drm/parameters/debug(drm.debug)
This coordination-by-identical-declarations is weird, so this patch splits the macro into _DEFINE and _USE flavors. This distinction follows the definition vs declaration that K&R gave us, improving the api; _DEFINE is used once to specify the classmap, and multiple users _USE the single definition explicitly.
Currently the latter just reuses the former, and still needs all the same args, but that can be tuned later; the _DEFINE can initialize an (extern/global) struct classmap, and _USE can, well use/reference that struct.
Also wrap DYNDBG_CLASSMAP_USEs with ifdef DRM_USE_DYNAMIC_DEBUG to balance with the one around drm_print's use of DYNDBG_CLASSMAP_DEFINE.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c | 4 +++- drivers/gpu/drm/display/drm_dp_helper.c | 4 +++- drivers/gpu/drm/drm_crtc_helper.c | 4 +++- drivers/gpu/drm/drm_print.c | 2 +- drivers/gpu/drm/i915/i915_params.c | 4 +++- drivers/gpu/drm/nouveau/nouveau_drm.c | 4 +++- include/linux/dynamic_debug.h | 20 ++++++++++++---- lib/test_dynamic_debug.c | 32 ++++++++++++------------- 8 files changed, 48 insertions(+), 26 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +3 -1
@@ -188,7 +188,8 @@ 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, +#if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) +DYNDBG_CLASSMAP_USE(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0, "DRM_UT_CORE", "DRM_UT_DRIVER", "DRM_UT_KMS",
@@ -199,6 +200,7 @@ DECLARE_DYNDBG_CLASSMAP(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0,"DRM_UT_LEASE" ,"DRM_UT_DP" , "DRM_UT_DRMRES"); +#endif struct amdgpu_mgpu_info mgpu_info = { .mutex =__MUTEX_INITIALIZER (mgpu_info.mutex),
drivers/gpu/drm/display/drm_dp_helper.c +3 -1
@@ -41,7 +41,8 @@#include "drm_dp_helper_internal.h" -DECLARE_DYNDBG_CLASSMAP(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0, +#if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) +DYNDBG_CLASSMAP_USE(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0, "DRM_UT_CORE", "DRM_UT_DRIVER", "DRM_UT_KMS",
@@ -52,6 +53,7 @@ DECLARE_DYNDBG_CLASSMAP(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0,"DRM_UT_LEASE" ,"DRM_UT_DP" , "DRM_UT_DRMRES"); +#endif struct dp_aux_backlight {struct backlight_device *base;
drivers/gpu/drm/drm_crtc_helper.c +3 -1
@@ -51,7 +51,8 @@#include "drm_crtc_helper_internal.h" -DECLARE_DYNDBG_CLASSMAP(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0, +#if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) +DYNDBG_CLASSMAP_USE(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0, "DRM_UT_CORE", "DRM_UT_DRIVER", "DRM_UT_KMS",
@@ -62,6 +63,7 @@ DECLARE_DYNDBG_CLASSMAP(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0,"DRM_UT_LEASE" ,"DRM_UT_DP" , "DRM_UT_DRMRES"); +#endif /** * DOC: overview
drivers/gpu/drm/drm_print.c +1 -1
@@ -56,7 +56,7 @@ MODULE_PARM_DESC(debug, "Enable debug output, where each bit enables a debug catmodule_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, +DYNDBG_CLASSMAP_DEFINE(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0, "DRM_UT_CORE", "DRM_UT_DRIVER", "DRM_UT_KMS",
drivers/gpu/drm/i915/i915_params.c +3 -1
@@ -29,7 +29,8 @@#include "i915_params.h" #include "i915_drv.h" -DECLARE_DYNDBG_CLASSMAP(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0, +#if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) +DYNDBG_CLASSMAP_USE(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0, "DRM_UT_CORE", "DRM_UT_DRIVER", "DRM_UT_KMS",
@@ -40,6 +41,7 @@ DECLARE_DYNDBG_CLASSMAP(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0,"DRM_UT_LEASE" ,"DRM_UT_DP" , "DRM_UT_DRMRES"); +#endif #define i915_param_named (name,T , perm, desc) \ module_param_named(name, i915_modparams.name, T, perm); \
drivers/gpu/drm/nouveau/nouveau_drm.c +3 -1
@@ -71,7 +71,8 @@#include "nouveau_svm.h" #include "nouveau_dmem.h" -DECLARE_DYNDBG_CLASSMAP(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0, +#if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) +DYNDBG_CLASSMAP_USE(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0, "DRM_UT_CORE", "DRM_UT_DRIVER", "DRM_UT_KMS",
@@ -82,6 +83,7 @@ DECLARE_DYNDBG_CLASSMAP(drm_debug_classes, DD_CLASS_TYPE_DISJOINT_BITS, 0,"DRM_UT_LEASE" ,"DRM_UT_DP" , "DRM_UT_DRMRES"); +#endif MODULE_PARM_DESC (config,"option string to pass to driver core" );static char *nouveau_config;
include/linux/dynamic_debug.h +16 -4
@@ -56,7 +56,7 @@ struct _ddebug {#endif } __attribute__((aligned(8))); -enum class_map_type { +enum ddebug_class_map_type {DD_CLASS_TYPE_DISJOINT_BITS ,/** * DD_CLASS_TYPE_DISJOINT_BITS: classes are independent, one per bit.
@@ -86,17 +86,19 @@ struct ddebug_class_map {const char **class_names;const int length;const int base;/* index of 1st .class_id, allows split/shared space */ -enum class_map_type map_type; +enum ddebug_class_map_type map_type; };/** -* DECLARE_DYNDBG_CLASSMAP - declare classnames known by a module +* DYNDBG_CLASSMAP_DEFINE - define the class_map that names the +* debug classes used in this module. This tells dyndbg the authorized +* classnames it should manipulate. * @_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, ...) \ +#define DYNDBG_CLASSMAP_DEFINE (_var, _maptype, _base, ...) \ static const char *_var##_classnames[] = { __VA_ARGS__ }; \ static struct ddebug_class_map __aligned(8) __used \ __section("__dyndbg_classes") _var = { \
@@ -108,6 +110,16 @@ struct ddebug_class_map { .class_names = _var##_classnames, \ } +/* +* refer to the classmap instantiated once, by the macro above. This +* distinguishes the multiple users of drm.debug from the single +* definition, allowing them to specialize. ATM its a pass-thru, but +* it should help regularize the admittedly wierd sharing by identical +* definitions. +*/ +#define DYNDBG_CLASSMAP_USE (_var, _maptype, _base, ...) \ + DYNDBG_CLASSMAP_DEFINE(_var, _maptype, _base, __VA_ARGS__) +/* encapsulate linker provided built-in (or module) dyndbg data */ struct _ddebug_info {struct _ddebug *descs;
lib/test_dynamic_debug.c +16 -16
@@ -62,38 +62,38 @@ enum cat_disjoint_bits {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" ); +DYNDBG_CLASSMAP_DEFINE (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 =10 ,MID ,HI }; -DECLARE_DYNDBG_CLASSMAP (map_disjoint_names,DD_CLASS_TYPE_DISJOINT_NAMES ,10 , -"LOW" ,"MID" ,"HI" ); +DYNDBG_CLASSMAP_DEFINE (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 , +DYNDBG_CLASSMAP_DEFINE (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" ); +DYNDBG_CLASSMAP_DEFINE (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 );
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 11/20 dyndbg-API: specialize DYNDBG_CLASSMAP_(DEFINE|USE)
In reply to Jim CromieNow that the DECLARE_DYNDBG_CLASSMAP macro has been split into DYNDBG_CLASSMAP_DEFINE and DYNDBG_CLASSMAP_USE, lets differentiate them according to their separate jobs.
Dyndbg's existing __dyndbg_classes[] section does:
. catalogs the classmaps defined by the module (or builtin modules) . authorizes dyndbg to >control those class'd prdbgs for the module.
This patch adds __dyndbg_class_refs[] section:
. catalogs references/uses of the above classmap definitions. . authorizes dyndbg to >control those class'd prdbgs in ref'g module. . maps the client module to classmap definitions
drm-drivers and helpers are clients.
this allows dyndbg to apply drm.debug to the client module, when added.
The distinction of the 2 roles yields 2 gains:
It follows the define-once-declare-elsewhere pattern that K&R gave us, dumping the weird coordinated-changes-by-identical-classmaps API.
It should help solve the chicken-egg problem that DRM_USE_DYNAMIC_DEBUG has; the _USEr module must propagate the drm.debug setting once the using module has loaded.
The new DYNDBG_CLASSMAP_* macros add records to the sections:
DYNDBG_CLASSMAP_DEFINE:
invoked just once per sub-system.
for drm, its drm_print, where drm.debug is exposed. defines the classmap, names "DRM_UT_*", maps to class_id's authorizes dyndbg to exert >control
populates __dyndbg_classes[] "section", __used. exports the classmap.
DYNDBG_CLASSMAP_USE:
invoked by modules using classmaps defined & exported elsewhere populates __dyndbg_class_refs[] "section", __used. maps client-module name to the extern'd classmap.
has client-name, so dyndbg can recognize loading client modules.
also:
struct ddebug_info gets 2 new fields to encapsulate the new section:
class_refs, num_class_refs.
set by dynamic_debug_init() for builtins.
or by kernel/module/main:load_info() for loadable modules.
. struct ddebug_class_user
contains: user-module-name, ref to classmap-defn
dyndbg finds drm-driver's use of a classmap, gets/applies its settings
. vmlinux.lds.h additions: linker symbols, KEEP for new section
dynamic_debug.c: 2 sets of changes;
those "under" ddebug_add_module(), immediately below those "under" ddebug_change(), further below
ddebug_attach_module_classes():
as before:
called from ddebug_add_module
finds classmaps whose .mod_name matches module being added. attaches them to the module's ddebug_table.
ddebug_attach_client_module_classes():
new:
called from ddebug_add_module, after list-add to ddebug-tables. like above, but works class-refs, not classes.
foreach __dyndbg_class_refs: ddebug_param_load_dependent_class(classmap*)
s/ddebug_find_kparams/ddebug_apply_parents_params/.
ddebug_find_kparam(classmap*):
scans module's/builtin kernel-params, calls ddebug_match_attach_kparam for each to find the params/sysfs-nodes using a classmap.
ddebug_match_apply_kparam():
1st, it tests the kernel-param.ops is dyndbg's; this guarantees that the attached arg is a struct ddebug_class_param, which has a ref to the param's state.
Then compare the modname being loaded to the classmap.mod_name; if it matches, save the debug_class_param into the classmap.dc_parm. This lets users of the classmap (in particular a client) access the state.
ddebug_param_load_dependent_class():
Called from ddebug_attach_client_module_classes() on each class_refs[] entry. Each user refs a classmap which has already been seen by ddebug_find_kparam(), and whose .dc_parm has the state.
So this fn just copies the state to a local var, then calls ddebug_apply_class_bitmap() to apply it to the dependent module. ddebug_apply_class_bitmap() tests for bit changes before sending messages without making changes.
ddebug_find_valid_class():
This helps ddebug_change(), doing the search over classmaps, looking for the class given to >control. So now it searches over __dyndbg_class_refs[] after __dyndbg_classes[].
Thats the theory anyway. things are still broken (differently) for both builtins and loadables. For loadables, the >control is applied, but doesnt alter any callsites. For builtins, things break earlier.
[*] consider swapping struct ddebug_class_param's dc_parm for kparam. This gives access to kparam->name, helpful for current debugging. Attaching that kp via macro would simplify attach-*module-classes too.
dyndbg: rework ddebug_(|client_)_module_attach_classes
move ddebug_attach_module_classes() up.
name-refinements++:
s/ddebug_param_load_dependent_class/ddebug_apply_parents_params/
--- include/asm-generic/vmlinux.lds.h | 3 + include/linux/dynamic_debug.h | 39 ++++--- kernel/module/main.c | 2 + lib/dynamic_debug.c | 166 ++++++++++++++++++++++++++---- 4 files changed, 176 insertions(+), 34 deletions(-)
include/asm-generic/vmlinux.lds.h +3 -0
@@ -363,6 +363,9 @@ __start___dyndbg_classes = .; \ KEEP(*(__dyndbg_classes)) \ __stop___dyndbg_classes = .; \ + __start___dyndbg_class_refs = .; \ + KEEP(*(__dyndbg_class_refs)) \ + __stop___dyndbg_class_refs = .; \ __start___dyndbg = .; \ KEEP(*(__dyndbg)) \ __stop___dyndbg = .; \
include/linux/dynamic_debug.h +26 -13
@@ -81,8 +81,8 @@ enum ddebug_class_map_type { };struct ddebug_class_map { -struct module *mod; -const char *mod_name;/* needed for builtins */ +const struct module *mod;/* NULL for builtins */ +const char *mod_name;const char **class_names;const int length;const int base;/* index of 1st .class_id, allows split/shared space */
@@ -99,8 +99,8 @@ struct ddebug_class_map {* @classes: class-names used to control class'd prdbgs */ #define DYNDBG_CLASSMAP_DEFINE (_var, _maptype, _base, ...) \ - static const char *_var##_classnames[] = { __VA_ARGS__ }; \ - static struct ddebug_class_map __aligned(8) __used \ + const char *_var##_classnames[] = { __VA_ARGS__ }; \ + struct ddebug_class_map __aligned(8) __used \ __section("__dyndbg_classes") _var = { \ .mod = THIS_MODULE, \ .mod_name = KBUILD_MODNAME, \
@@ -108,24 +108,37 @@ struct ddebug_class_map { .map_type = _maptype, \ .length = ARRAY_SIZE(_var##_classnames), \ .class_names = _var##_classnames, \ - } + }; \ +EXPORT_SYMBOL (_var) -/* -* refer to the classmap instantiated once, by the macro above. This -* distinguishes the multiple users of drm.debug from the single -* definition, allowing them to specialize. ATM its a pass-thru, but -* it should help regularize the admittedly wierd sharing by identical -* definitions. +struct ddebug_class_user { +char *user_mod_name; +struct ddebug_class_map *map; +}; +/** +* DYNDBG_CLASSMAP_USE - Use a classmap DEFINEd in another module. +* This lets dyndbg initialize the dependent module's prdbgs from the +* other module's controlling sysfs node. */ -#define DYNDBG_CLASSMAP_USE (_var, _maptype, _base, ...) \ - DYNDBG_CLASSMAP_DEFINE(_var, _maptype, _base, __VA_ARGS__) +#define DYNDBG_CLASSMAP_USE (_var, ...) \ + DYNDBG_CLASSMAP_USE_(_var, __UNIQUE_ID(ddebug_class_user), \ + __VA_ARGS__) +#define DYNDBG_CLASSMAP_USE_ (_var, _uname, ...) \ + extern struct ddebug_class_map _var; \ + static struct ddebug_class_user __used \ + __section("__dyndbg_class_refs") _uname = { \ + .user_mod_name = KBUILD_MODNAME, \ + .map = &_var, \ + }/* encapsulate linker provided built-in (or module) dyndbg data */ struct _ddebug_info {struct _ddebug *descs;struct ddebug_class_map *classes; +struct ddebug_class_user *class_refs;unsigned int num_descs;unsigned int num_classes; +unsigned int num_class_refs; };struct ddebug_class_param {
kernel/module/main.c +2 -0
@@ -2111,6 +2111,8 @@ static int find_module_sections(struct module *mod, struct load_info *info) sizeof(*info->dyndbg.descs), &info->dyndbg.num_descs); info->dyndbg.classes =section_objs (info,"__dyndbg_classes" ,sizeof (*info->dyndbg.classes), &info->dyndbg.num_classes); + info->dyndbg.class_refs =section_objs (info,"__dyndbg_class_refs" , +sizeof (*info->dyndbg.class_refs), &info->dyndbg.num_class_refs);return 0 ; }
lib/dynamic_debug.c +145 -21
282 lines not on this page · raw message
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 12/20 dyndbg-API: DYNDBG_CLASSMAP_USE drop extra args
In reply to Jim CromieDrop macro args after _var. Since DYNDBG_CLASSMAP_USE no longer forwards to DYNDBG_CLASSMAP_DEFINE, it doesn't need those args to forward. Keep only the _var arg, which is the extern'd struct classmap with all the class info.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c | 12 +--------- drivers/gpu/drm/display/drm_dp_helper.c | 12 +--------- drivers/gpu/drm/drm_crtc_helper.c | 12 +--------- drivers/gpu/drm/i915/i915_params.c | 12 +--------- drivers/gpu/drm/nouveau/nouveau_drm.c | 12 +--------- include/linux/dynamic_debug.h | 30 ++++++++++++++----------- 6 files changed, 22 insertions(+), 68 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +1 -11
@@ -189,17 +189,7 @@ int amdgpu_vcnfw_log;static void amdgpu_drv_delayed_reset_work_handler (struct work_struct *work);#if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) -DYNDBG_CLASSMAP_USE (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" ); +DYNDBG_CLASSMAP_USE (drm_debug_classes);#endif struct amdgpu_mgpu_info mgpu_info = {
drivers/gpu/drm/display/drm_dp_helper.c +1 -11
@@ -42,17 +42,7 @@#include "drm_dp_helper_internal.h" #if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) -DYNDBG_CLASSMAP_USE (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" ); +DYNDBG_CLASSMAP_USE (drm_debug_classes);#endif struct dp_aux_backlight {
drivers/gpu/drm/drm_crtc_helper.c +1 -11
@@ -52,17 +52,7 @@#include "drm_crtc_helper_internal.h" #if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) -DYNDBG_CLASSMAP_USE (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" ); +DYNDBG_CLASSMAP_USE (drm_debug_classes);#endif /**
drivers/gpu/drm/i915/i915_params.c +1 -11
@@ -30,17 +30,7 @@#include "i915_drv.h" #if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) -DYNDBG_CLASSMAP_USE (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" ); +DYNDBG_CLASSMAP_USE (drm_debug_classes);#endif #define i915_param_named (name,T , perm, desc) \
drivers/gpu/drm/nouveau/nouveau_drm.c +1 -11
@@ -72,17 +72,7 @@#include "nouveau_dmem.h" #if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) -DYNDBG_CLASSMAP_USE (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" ); +DYNDBG_CLASSMAP_USE (drm_debug_classes);#endif MODULE_PARM_DESC (config,"option string to pass to driver core" );
include/linux/dynamic_debug.h +17 -13
@@ -90,13 +90,15 @@ struct ddebug_class_map { };/** -* DYNDBG_CLASSMAP_DEFINE - define the class_map that names the -* debug classes used in this module. This tells dyndbg the authorized -* classnames it should manipulate. -* @_var: a struct ddebug_class_map, passed to module_param_cb +* DYNDBG_CLASSMAP_DEFINE - define debug-classes used by a module. +* @_var: name of the classmap, exported for other modules coordinated use. * @_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 +* @classes: enum-map - symbol names are "classnames", vals are .class_ids +* +* @classes vals are _ddebug.class_ids used in the module, the symbol +* names are stringified; they authorize "class FOO" to >control. +* Connection to a kernel-param is done separately. */ #define DYNDBG_CLASSMAP_DEFINE (_var, _maptype, _base, ...) \ const char *_var##_classnames[] = { __VA_ARGS__ }; \
@@ -116,16 +118,18 @@ struct ddebug_class_user {struct ddebug_class_map *map; };/** -* DYNDBG_CLASSMAP_USE - Use a classmap DEFINEd in another module. -* This lets dyndbg initialize the dependent module's prdbgs from the -* other module's controlling sysfs node. +* DYNDBG_CLASSMAP_USE - refer to a classmap, DEFINEd elsewhere. +* @_var: name of the exported classmap +* +* This registers the module's use of another module's classmap defn, +* allowing dyndbg to find the controlling kparam, and propagate its +* settings to the dependent module being loaded. */ -#define DYNDBG_CLASSMAP_USE (_var, ...) \ - DYNDBG_CLASSMAP_USE_(_var, __UNIQUE_ID(ddebug_class_user), \ - __VA_ARGS__) -#define DYNDBG_CLASSMAP_USE_ (_var, _uname, ...) \ +#define DYNDBG_CLASSMAP_USE (_var) \ + DYNDBG_CLASSMAP_USE_(_var, __UNIQUE_ID(ddebug_class_user)) +#define DYNDBG_CLASSMAP_USE_ (_var, _uname) \ extern struct ddebug_class_map _var; \ - static struct ddebug_class_user __used \ + struct ddebug_class_user __used \ __section("__dyndbg_class_refs") _uname = { \ .user_mod_name = KBUILD_MODNAME, \ .map = &_var, \
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 13/20 dyndbg-API: DYNDBG_CLASSMAP_DEFINE() improvements
In reply to Jim Cromiepatch 1 in this series fixed a CLASSMAP usage error, this improves the api so that misuse is less likely.
changes here:
0- Add William Swanson's public domain map macro:
https://github.com/swansontec/map-macro/blob/master/map.h
this makes 1 possible.
1- classnames were formerly specified as strings: "DRM_UT_CORE"
now they are the actual enum const symbols: DRM_UT_CORE
direct use of symbols is tighter, more comprehensible by tools, grep
2- drop _base arg.
_base was the value of the 1st classname
that is now available due to 1, no need to require it 2x
So take _base out of the API/kdoc. Note that the macro impl keeps the _base arg so that it can be used to set classmap.base, but reuses it in the MAP-stringify _base, __VA_ARGS__ expression.
Also cleanup the API usage comment in test_dynamic_debug.c, and since comments in test-code might not be noticed, restate that here.
Using the CLASSMAP api:
- class-specifications are enum consts/symbols, like DRM_UT_CORE, DRM_UT_KMS, etc.
their values define bits in the sysfs-node (like drm.debug)
- they are stringified and accepted at >control
echo class DRM_UT_CORE +p >control
- multiple class-maps must share the per-module: 0-62 class_id space (by setting initial enum values to non-overlapping subranges)
todo: fixup the 'i' prefix, a quick/dirty avoidance of MAP.
NOTE: test_dynamic_debug.c also has this helper macro to wire a classmap to a drm.debug style parameter; its easier to just use it as a model/template as needed, rather than try to make it general enough to be an official API helper.
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)--- drivers/gpu/drm/drm_print.c | 22 +++++++------- include/drm/drm_print.h | 1 + include/linux/dynamic_debug.h | 17 ++++++----- include/linux/map.h | 54 +++++++++++++++++++++++++++++++++++ lib/test_dynamic_debug.c | 43 ++++++++++++++-------------- 5 files changed, 95 insertions(+), 42 deletions(-) create mode 100644 include/linux/map.h
drivers/gpu/drm/drm_print.c +11 -11
@@ -56,17 +56,17 @@ MODULE_PARM_DESC(debug, "Enable debug output, where each bit enables a debug catmodule_param_named (debug, __drm_debug, ulong,0600 );#else /* classnames must match vals of enum drm_debug_category */ -DYNDBG_CLASSMAP_DEFINE (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" ); +DYNDBG_CLASSMAP_DEFINE (drm_debug_classes,DD_CLASS_TYPE_DISJOINT_BITS , +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,
include/drm/drm_print.h +1 -0
@@ -333,6 +333,7 @@ static inline bool drm_debug_enabled_raw(enum drm_debug_category category) })#if defined(CONFIG_DRM_USE_DYNAMIC_DEBUG ) +//extern struct ddebug_class_map drm_debug_classes[]; /* * the drm.debug API uses dyndbg, so each drm_*dbg macro/callsite gets * a descriptor, and only enabled callsites are reachable. They use
include/linux/dynamic_debug.h +8 -9
@@ -7,6 +7,7 @@#endif #include <linux/build_bug.h> +#include <linux/map.h> /* * An instance of this structure is created in a special
@@ -90,18 +91,16 @@ struct ddebug_class_map { };/** -* DYNDBG_CLASSMAP_DEFINE - define debug-classes used by a module. -* @_var: name of the classmap, exported for other modules coordinated use. -* @_type: enum class_map_type, chooses bits/verbose, numeric/symbolic -* @_base: offset of 1st class-name. splits .class_id space -* @classes: enum-map - symbol names are "classnames", vals are .class_ids +* DYNDBG_CLASSMAP_DEFINE - define the debug classes used in this module. +* This tells dyndbg what debug classes it should control for the client. * -* @classes vals are _ddebug.class_ids used in the module, the symbol -* names are stringified; they authorize "class FOO" to >control. -* Connection to a kernel-param is done separately. +* @_var: struct ddebug_class_map, as passed to module_param_cb +* @_type: enum ddebug_class_map_type, chooses bits/verbose, numeric/symbolic +* @classes: enum class values used in module, such as: DRM_UT_* */ #define DYNDBG_CLASSMAP_DEFINE (_var, _maptype, _base, ...) \ - const char *_var##_classnames[] = { __VA_ARGS__ }; \ + const char *_var##_classnames[] = { \ + iMAP_LIST(__stringify, _base, __VA_ARGS__) }; \ struct ddebug_class_map __aligned(8) __used \ __section("__dyndbg_classes") _var = { \ .mod = THIS_MODULE, \
include/linux/map.h new file +54 -0
54 lines not on this page · raw message
lib/test_dynamic_debug.c +21 -22
70 lines not on this page · raw message
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 14/20 drm_print: fix stale macro-name in comment
In reply to Jim CromieCited commit uses stale macro name, fix this, and explain better.
When DRM_USE_DYNAMIC_DEBUG=y, DYNDBG_CLASSMAP_DEFINE() maps DRM_UT_* onto BITs in drm.debug. This still uses enum drm_debug_category, but it is somewhat indirect, with the ordered set of DRM_UT_* enum-vals. This requires that the macro args: DRM_UT_* list must be kept in sync and in order.
---
. emphasize ABI non-change despite enum val change - Jani Nikula . reorder to back of patchset to follow API name changes.
--- include/drm/drm_print.h | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
include/drm/drm_print.h +4 -1
@@ -276,7 +276,10 @@ static inline struct drm_printer drm_err_printer(const char *prefix)* */ enum drm_debug_category { -/* These names must match those in DYNAMIC_DEBUG_CLASSBITS */ +/* +* Keep DYNDBG_CLASSMAP_DEFINE args in sync with changes here, +* the enum-values define BIT()s in drm.debug, so are ABI. +*/ /** * @DRM_UT_CORE: Used in the generic drm code: drm_ioctl.c, drm_mm.c, * drm_memory.c, ...
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 15/20 test-dyndbg: build test_dynamic_debug_submod
In reply to Jim CromieCONFIG_DRM_USE_DYNAMIC_DEBUG=y has a regression; drm subsystem modules, which depend upon drm.ko and use the drm.debug API, do not get enabled when __drm_debug is set by modprobe drm debug=0x1f.
With =N, __drm_debug is checked before logging the msg, so the end-of-modprobe debug=$init affected all later checks. But with =y, each run-time check is replaced by a static-key that is set at end-of-modprobe.
This creates a chicken-egg dependency; i915 must be modprobed before its drm.debugs are enabled, but drm.ko (and __drm_debug=$init) must be done before modprobe i915, so its callsites arent there yet to be enabled.
The WIP-fix is to split DECLARE_DYNDBG_CLASSMAP to:
DYNDBG_CLASSMAP_DEFINE - invoked in 'parent' DYNDBG_CLASSMAP_USE - invoked in dependent, to USE the exported definition
To prove the fix w/o involving DRM, we need 2 modules, one dependent on the other. Add test_dynamic_debug_submod.ko, which _USEs the classmaps _exported by test_dynamic_debug.ko
To keep code to a minimum, test_dynamic_debug.c ifdefs on TEST_DYNAMIC_DEBUG_SUBMOD to build either parent or dependent, with either DYNDBG_CLASSMAP_DEFINE or DYNDBG_CLASSMAP_USE blocks.
So test_dynamic_debug_submod.c is just 2 lines: include parent after defining SUBMOD. This also gives the 2 modules identical logging behavior as a baseline.
--- lib/Makefile | 3 +- lib/test_dynamic_debug.c | 50 ++++++++++++++++++++++++++++----- lib/test_dynamic_debug_submod.c | 10 +++++++ 3 files changed, 55 insertions(+), 8 deletions(-) create mode 100644 lib/test_dynamic_debug_submod.c
lib/Makefile +2 -1
@@ -78,7 +78,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_DYNAMIC_DEBUG) += test_dynamic_debug.o test_dynamic_debug_submod.o obj-$(CONFIG_TEST_PRINTF) += test_printf.o obj-$(CONFIG_TEST_SCANF) += test_scanf.o obj-$(CONFIG_TEST_BITMAP) += test_bitmap.o
@@ -100,6 +100,7 @@ obj-$(CONFIG_KPROBES_SANITY_TEST) += test_kprobes.o obj-$(CONFIG_TEST_REF_TRACKER) += test_ref_tracker.o CFLAGS_test_fprobe.o += $(CC_FLAGS_FTRACE) obj-$(CONFIG_FPROBE_SANITY_TEST) += test_fprobe.o + # # CFLAGS for compiling floating point code inside the kernel. x86/Makefile turns # off the generation of FPU/SSE* instructions for kernel proper but FPU_FLAGS
lib/test_dynamic_debug.c +43 -7
90 lines not on this page · raw message
lib/test_dynamic_debug_submod.c new file +10 -0
@@ -0,0 +1,10 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Kernel module for testing dynamic_debug +* +* Authors: +* Jim Cromie <[email protected]> +*/ + +#define TEST_DYNAMIC_DEBUG_SUBMOD +#include "test_dynamic_debug.c"
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 16/20 test-dyndbg: rename DD_SYS_WRAP to DYNDBG_CLASSMAP_PARAM
In reply to Jim CromieOriginal name was a punt; but the macro is maybe general enough to put in the API later. Rename and improve the macro towards that end.
Also tweak internal name constructed in the macro, to add a '_' between the name components. This changes the .i file only.
no functional change.
--- lib/test_dynamic_debug.c | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-)
lib/test_dynamic_debug.c +12 -11
@@ -44,14 +44,15 @@ module_param_cb(do_prints, ¶m_ops_do_prints, NULL, 0600);* Additionally, here: * - tie together sysname, mapname, bitsname, flagsname */ -#define DD_SYS_WRAP (_model, _flags) \ +#define DYNDBG_CLASSMAP_PARAM (_model, _flags) \ static unsigned long bits_##_model; \ - static struct ddebug_class_param _flags##_model = { \ + static struct ddebug_class_param _flags##_##_model = { \ .bits = &bits_##_model, \ .flags = #_flags, \ .map = &map_##_model, \ }; \ - module_param_cb(_flags##_##_model, ¶m_ops_dyndbg_classes, &_flags##_model, 0600) + module_param_cb(_flags##_##_model, ¶m_ops_dyndbg_classes, \ + &_flags##_##_model, 0600)/* * dynamic-debug imitates drm.debug model's use of enums (DRM_UT_CORE
@@ -112,23 +113,23 @@ DYNDBG_CLASSMAP_DEFINE(map_disjoint_bits, DD_CLASS_TYPE_DISJOINT_BITS,D2_LEASE ,D2_DP , D2_DRMRES); -DD_SYS_WRAP (disjoint_bits, p); -DD_SYS_WRAP (disjoint_bits,T ); +DYNDBG_CLASSMAP_PARAM (disjoint_bits, p); +DYNDBG_CLASSMAP_PARAM (disjoint_bits,T );DYNDBG_CLASSMAP_DEFINE (map_disjoint_names,DD_CLASS_TYPE_DISJOINT_NAMES ,LOW ,MID ,HI ); -DD_SYS_WRAP (disjoint_names, p); -DD_SYS_WRAP (disjoint_names,T ); +DYNDBG_CLASSMAP_PARAM (disjoint_names, p); +DYNDBG_CLASSMAP_PARAM (disjoint_names,T );DYNDBG_CLASSMAP_DEFINE (map_level_num,DD_CLASS_TYPE_LEVEL_NUM ,V0 ,V1 ,V2 ,V3 ,V4 ,V5 ,V6 ,V7 ); -DD_SYS_WRAP (level_num, p); -DD_SYS_WRAP (level_num,T ); +DYNDBG_CLASSMAP_PARAM (level_num, p); +DYNDBG_CLASSMAP_PARAM (level_num,T );DYNDBG_CLASSMAP_DEFINE (map_level_names,DD_CLASS_TYPE_LEVEL_NAMES ,L0 ,L1 ,L2 ,L3 ,L4 ,L5 ,L6 ,L7 ); -DD_SYS_WRAP (level_names, p); -DD_SYS_WRAP (level_names,T ); +DYNDBG_CLASSMAP_PARAM (level_names, p); +DYNDBG_CLASSMAP_PARAM (level_names,T );#endif /* TEST_DYNAMIC_DEBUG_SUBMOD */
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 17/20 test-dyndbg: disable WIP dyndbg-trace params
In reply to Jim CromieThe dyndbg-to-trace feature is WIP, and not in mainline, so the presence of the interface to use/test it is unhelpful/confusing.
So define DYNDBG_CLASSMAP_PARAM_T() as DYNDBG_CLASSMAP_PARAM() or blank, depending upon ifdef DYDBG_TRACE, and update 4 params controlling the T-flag to use it.
--- lib/test_dynamic_debug.c | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-)
lib/test_dynamic_debug.c +12 -4
@@ -54,6 +54,14 @@ module_param_cb(do_prints, ¶m_ops_do_prints, NULL, 0600); module_param_cb(_flags##_##_model, ¶m_ops_dyndbg_classes, \ &_flags##_##_model, 0600) +/* TBD */ +#ifdef DYNDBG_TRACE +#define DYNDBG_CLASSMAP_PARAM_T (_model, _flags) \ + DYNDBG_CLASSMAP_PARAM(_model, _flags) +#else +#define DYNDBG_CLASSMAP_PARAM_T (_model, _flags) +#endif +/* * dynamic-debug imitates drm.debug model's use of enums (DRM_UT_CORE * etc) to define it's classes/categories. dyndbg allows class-id's
@@ -114,22 +122,22 @@ DYNDBG_CLASSMAP_DEFINE(map_disjoint_bits, DD_CLASS_TYPE_DISJOINT_BITS,D2_DP , D2_DRMRES);DYNDBG_CLASSMAP_PARAM (disjoint_bits, p); -DYNDBG_CLASSMAP_PARAM (disjoint_bits,T ); +DYNDBG_CLASSMAP_PARAM_T (disjoint_bits,T );DYNDBG_CLASSMAP_DEFINE (map_disjoint_names,DD_CLASS_TYPE_DISJOINT_NAMES ,LOW ,MID ,HI );DYNDBG_CLASSMAP_PARAM (disjoint_names, p); -DYNDBG_CLASSMAP_PARAM (disjoint_names,T ); +DYNDBG_CLASSMAP_PARAM_T (disjoint_names,T );DYNDBG_CLASSMAP_DEFINE (map_level_num,DD_CLASS_TYPE_LEVEL_NUM ,V0 ,V1 ,V2 ,V3 ,V4 ,V5 ,V6 ,V7 );DYNDBG_CLASSMAP_PARAM (level_num, p); -DYNDBG_CLASSMAP_PARAM (level_num,T ); +DYNDBG_CLASSMAP_PARAM_T (level_num,T );DYNDBG_CLASSMAP_DEFINE (map_level_names,DD_CLASS_TYPE_LEVEL_NAMES ,L0 ,L1 ,L2 ,L3 ,L4 ,L5 ,L6 ,L7 );DYNDBG_CLASSMAP_PARAM (level_names, p); -DYNDBG_CLASSMAP_PARAM (level_names,T ); +DYNDBG_CLASSMAP_PARAM_T (level_names,T );#endif /* TEST_DYNAMIC_DEBUG_SUBMOD */
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 18/20 test-dyndbg: tune sub-module behavior
In reply to Jim Cromielib/test_dynamic_debug.c is used to build 2 modules:
test_dynamic_debug.ko and test_dynamic_debug_submod.ko
Define DEBUG only in the main module, not in the submod. Its purpose is to insure that prdbgs are enabled by default, so that a modprobe without params actually logs something, showing that compile-time enablement works. This doesn't need to be repeated in the submodule.
Rather, the submodule's purpose is to prove that classmaps defined and exported from a parent module are propagated to submodules, setting their class'd debugs accordingly.
--- lib/test_dynamic_debug.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
lib/test_dynamic_debug.c +4 -4
@@ -6,13 +6,13 @@* Jim Cromie <[email protected]> */ -#if defined(TEST_DYNAMIC_DEBUG_SUBMOD ) -#define pr_fmt (fmt) "test_dd_submod: " fmt -#else +#if !defined(TEST_DYNAMIC_DEBUG_SUBMOD )#define pr_fmt (fmt) "test_dd: " fmt +#define DEBUG /* enable all prdbgs (plain & class'd) at compiletime */ +#else +#define pr_fmt (fmt) "test_dd_submod: " fmt#endif -#define DEBUG /* enable all prdbgs (plain & class'd) at compiletime */ #include <linux/module.h>
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 19/20 dyndbg: unwrap __ddebug_add_module inner function NOTYET
In reply to Jim CromieThe inner func has a base arg which is unused in the body, so theres no point in having the inner fn.
Its one-time purpose was to expose a wider interface to the internal
caller: dynamic_debug_init(), to allow communicating each module's offset in the builtin _ddebug[] table.
That purpose was obsoleted by cited commit, when ddebug_add_module() was converted to pass a *ddebug_info, which is used as a cursor by the caller.
TODO: the cited commit gives another reason for base, to provide an index in support of de-duplicating column data. Refresh that patchset to see if its still true.
--- lib/dynamic_debug.c | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-)
lib/dynamic_debug.c +3 -9
@@ -1348,8 +1348,7 @@ static void ddebug_attach_client_module_classes(struct ddebug_table *dt, const s* Allocate a new ddebug_table for the given module * and add it to the global list. */ -static int __ddebug_add_module (struct _ddebug_info *di,unsigned int base, -const char *modname) +int ddebug_add_module (struct _ddebug_info *di,const char *modname) {struct ddebug_table *dt;
@@ -1391,11 +1390,6 @@ static int __ddebug_add_module(struct _ddebug_info *di, unsigned int base,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)
@@ -1538,7 +1532,7 @@ static int __init dynamic_debug_init(void) mod_ct++; di.num_descs = mod_sites; di.descs = iter_mod_start; - ret =__ddebug_add_module (&di, i - mod_sites, modname); + ret =ddebug_add_module (&di, modname);if (ret) goto out_err;
@@ -1549,7 +1543,7 @@ static int __init dynamic_debug_init(void) } di.num_descs = mod_sites; di.descs = iter_mod_start; - ret =__ddebug_add_module (&di, i - mod_sites, modname); + ret =ddebug_add_module (&di, modname);if (ret) goto out_err;
Signature · 1 line
2.39.0
Jim Cromie
maintainerPATCH v2 20/20 jump_label: RFC - tolerate toggled state
In reply to Jim Cromie__jump_label_patch currently will "crash the box" if it finds a jump_entry not as expected. ISTM this overly harsh; it doesn't distinguish between "alternate/opposite" state, and truly "insane/corrupted".
The "opposite" (but well-formed) state is a milder mis-initialization problem, and some less severe mitigation seems practical. ATM this just warns about it; a range/enum of outcomes: warn, crash, silence, ok, fixup-continue, etc, are possible on a case-by-case basis.
Ive managed to create this mis-initialization condition with test_dynamic_debug.ko & _submod.ko. These replicate DRM's regression on DRM_USE_DYNAMIC_DEBUG=y; drm.debug callsites in drivers/helpers (dependent modules) are not enabled along with those in drm.ko itself.
Heres that "opposite" state, occurring:
:#> echo 1 > /sys/module/test_dynamic_debug/parameters/p_disjoint_bits
[ 235.258452] dyndbg: bits:0x1 > *.p_disjoint_bits [ 235.258908] dyndbg: apply bitmap: 0x1 to: 0x4f for '*' [ 235.259351] dyndbg: query 0: "class D2_DRIVER -p" mod:* [ 235.259799] dyndbg: split into words: "class" "D2_DRIVER" "-p" [ 235.260290] dyndbg: op='-' flags=0x0 maskp=0xfffffffe [ 235.260720] dyndbg: parsed: func="" file="" module="" format="" lineno=0-0 class=D2_DRIVER [ 235.261418] dyndbg: good-class: test_dynamic_debug.D2_DRIVER module: test_dynamic_debug nd: 32 nc: 4 nu: 0 [ 235.262276] dyndbg: class-ref: test_dynamic_debug_submod.D2_DRIVER module: test_dynamic_debug_submod nd: 32 nc: 0 nu: 4 [ 235.263178] jump_label: found alternate op at do_cats+0x16/0x180 [test_dynamic_debug_submod] [00000000ba944cc2] (0f 1f 44 00 00 != e9 e1 00 00 00)) size:5 type:0 [ 235.264431] dyndbg: processed 1 queries, with 2 matches, 0 errs [ 235.264951] dyndbg: bit_1: 2 matches on class: D2_DRIVER -> 0x1 [ 235.265444] dyndbg: query 0: "class D2_KMS -p" mod:* [ 235.265869] dyndbg: split into words: "class" "D2_KMS" "-p" [ 235.266337] dyndbg: op='-' flags=0x0 maskp=0xfffffffe [ 235.266767] dyndbg: parsed: func="" file="" module="" format="" lineno=0-0 class=D2_KMS [ 235.267432] dyndbg: good-class: test_dynamic_debug.D2_KMS module: test_dynamic_debug nd: 32 nc: 4 nu: 0 [ 235.268264] dyndbg: class-ref: test_dynamic_debug_submod.D2_KMS module: test_dynamic_debug_submod nd: 32 nc: 0 nu: 4 [ 235.269142] jump_label: found alternate op at do_cats+0x1b/0x180 [test_dynamic_debug_submod] [00000000e8d6c160] (0f 1f 44 00 00 != e9 c4 00 00 00)) size:5 type:0 [ 235.270384] dyndbg: processed 1 queries, with 2 matches, 0 errs
RFC:
Ive hit this case a few times, but havent been able to isolate the when and why.
warn-only is something of a punt, and I'm still left with remaining bugs which are likely related; I'm able to toggle the p-flag on callsites in the submod, but their enablement still doesn't yield logging activity.
---
heres the Fatal kernel bug: (its on a -dirty kernel)
[ 2831.639643] dyndbg: good-class: test_dynamic_debug.D2_CORE module: test_dynamic_debug nd: 32 nc: 4 nu: 0 [ 2831.641316] dyndbg: class-ref: test_dynamic_debug_submod.D2_CORE module: test_dynamic_debug_submod nd: 32 nc: 0 nu: 4 [ 2831.642048] jump_label: Fatal kernel bug, unexpected op at do_cats+0x11/0x180 [test_dynamic_debug_submod] [00000000fa724232] (0f 1f 44 00 00 != e9 fe 00 00 00)) size:5 type:0 [ 2831.643077] ------------[ cut here ]------------ [ 2831.643537] kernel BUG at arch/x86/kernel/jump_label.c:73! [ 2831.643902] invalid opcode: 0000 [#1] PREEMPT SMP KASAN [ 2831.644248] CPU: 1 PID: 425 Comm: bash Tainted: G E 6.1.0-tf2-00021-gbe37efe8728f-dirty #696 [ 2831.644862] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.1-2.fc37 04/01/2014 [ 2831.645431] RIP: 0010:__jump_label_patch.cold+0x24/0x26 [ 2831.645773] Code: 83 e9 ef 00 ac fe 48 c7 c3 20 4c 5c 85 41 56 45 89 f9 49 89 d8 4c 89 e9 4c 89 ea 4c 89 ee 48 c7 c7 00 70 c5 82 e8 d7 1a 01 00 <0f> 0b 41 54 45 31 e4 55 48 89 fd 53 bb 00 00 00 80 48 81 c3 00 20 [ 2831.646896] RSP: 0018:ffffc9000101f738 EFLAGS: 00010282 [ 2831.647242] RAX: 00000000000000a2 RBX: ffffffff855c4c20 RCX: 0000000000000000 [ 2831.647702] RDX: 00000000000000a2 RSI: ffffffff81294fc4 RDI: fffff52000203ede [ 2831.648155] RBP: ffffc9000101f778 R08: 0000000000000003 R09: ffffc9000101f4ff [ 2831.648626] R10: fffff52000203e9f R11: 78656e75202c756a R12: ffffffff855c4c20 [ 2831.649096] R13: ffffffffc0250011 R14: 0000000000000000 R15: 0000000000000005 [ 2831.649498] FS: 00007fe4014aa740(0000) GS:ffff88805ae00000(0000) knlGS:0000000000000000 [ 2831.649894] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 2831.650175] CR2: 00007f9c326e6c08 CR3: 000000000ff59000 CR4: 0000000000750ee0 [ 2831.650520] PKRU: 55555554 [ 2831.650667] Call Trace: [ 2831.650793] <TASK> [ 2831.650903] ? do_cats+0x11/0x180 [test_dynamic_debug_submod] [ 2831.651195] arch_jump_label_transform_queue+0x43/0xa0 [ 2831.651450] __jump_label_update+0x9b/0x1b0 [ 2831.651670] static_key_disable_cpuslocked+0x9f/0xd0 [ 2831.651917] static_key_disable+0x16/0x20 [ 2831.652117] ddebug_change+0x45d/0x5c0 --- arch/x86/kernel/jump_label.c | 26 +++++++++++++++++--------- 1 file changed, 17 insertions(+), 9 deletions(-)
arch/x86/kernel/jump_label.c +17 -9
@@ -35,7 +35,7 @@ struct jump_label_patch {static struct jump_label_patch __jump_label_patch (struct jump_entry *entry,enum jump_label_type type) { -const void *expect, *code, *nop; +const void *expect, *code, *nop, *alt;const void *addr, *dest;int size;
@@ -57,20 +57,28 @@ __jump_label_patch(struct jump_entry *entry, enum jump_label_type type)default :BUG (); } -if (type ==JUMP_LABEL_JMP ) +if (type ==JUMP_LABEL_JMP ) { expect = nop; -else + alt = code; + }else { expect = code; - + alt = nop; + }if (memcmp (addr, expect, size)) {/* -* The location is not an op that we were expecting. -* Something went wrong. Crash the box, as something could be -* corrupting the kernel. +* The location is not the op that we were expecting. +* If its the alternate/toggled op, then warn, otherwise +* something went more wrong. Crash the box, as +* something could be corrupting the kernel. */ -pr_crit ("jump_label: Fatal kernel bug, unexpected op at %pS [%p] (%5ph != %5ph)) size:%d type:%d\n" , +if (memcmp (addr, alt, size)) { +pr_crit ("jump_label: Fatal kernel bug, unexpected op at %pS [%p] (%5ph != %5ph)) size:%d type:%d\n" , + addr, addr, addr, expect, size, type); +BUG (); + }else { +pr_warn ("jump_label: found alternate op at %pS [%p] (%5ph != %5ph)) size:%d type:%d\n" , addr, addr, addr, expect, size, type); -BUG (); + } }if (type ==JUMP_LABEL_NOP )
Signature · 1 line
2.39.0
Peter Zijlstra
maintainerRe: [PATCH v2 20/20] jump_label: RFC - tolerate toggled state
Quoted 16 lines · Jim Cromie
__jump_label_patchcurrently will "crash the box" if it finds ajump_entrynot as expected. ISTM this overly harsh; it doesn't distinguish between "alternate/opposite" state, and truly "insane/corrupted".The "opposite" (but well-formed) state is a milder mis-initialization problem, and some less severe mitigation seems practical. ATM this just warns about it; a range/enum of outcomes: warn, crash, silence, ok, fixup-continue, etc, are possible on a case-by-case basis.
Ive managed to create this mis-initialization condition with test_dynamic_debug.ko & _submod.ko. These replicate DRM's regression on DRM_USE_DYNAMIC_DEBUG=y; drm.debug callsites in
drivers/helpers(dependent modules) are not enabled along with those in drm.ko itself.
Quoted 7 lines
Ive hit this case a few times, but havent been able to isolate the when and why.
warn-only is something of a punt, and I'm still left with remaining bugs which are likely related; I'm able to toggle the p-flag on callsites in the submod, but their enablement still doesn't yield logging activity.
Right; having been in this is state is bad since it will generate inconsistent code-flow. Full on panic *might* not be warranted (as it does for corrupted text) but it is still a fairly bad situation -- so I'm not convinced we want to warn and carry on.
It would be really good to figure out why the site was skipped over and got out of skew.
Given it's all module stuff, the 'obvious' case would be something like a race between adding the new sites and flipping it, but I'm not seeing how -- things are rather crudely serialized by jump_label_mutex.
The only other option I can come up with is that somehow the update condition in jump_label_add_module() is somehow wrong.
Jason Baron
maintainerRe: [PATCH v2 20/20] jump_label: RFC - tolerate toggled state
Quoted 30 lines · Peter Zijlstra
Quoted 16 lines · Jim Cromie
__jump_label_patchcurrently will "crash the box" if it finds ajump_entrynot as expected. ISTM this overly harsh; it doesn't distinguish between "alternate/opposite" state, and truly "insane/corrupted".The "opposite" (but well-formed) state is a milder mis-initialization problem, and some less severe mitigation seems practical. ATM this just warns about it; a range/enum of outcomes: warn, crash, silence, ok, fixup-continue, etc, are possible on a case-by-case basis.
Ive managed to create this mis-initialization condition with test_dynamic_debug.ko & _submod.ko. These replicate DRM's regression on DRM_USE_DYNAMIC_DEBUG=y; drm.debug callsites in
drivers/helpers(dependent modules) are not enabled along with those in drm.ko itself.Quoted 7 lines
Ive hit this case a few times, but havent been able to isolate the when and why.
warn-only is something of a punt, and I'm still left with remaining bugs which are likely related; I'm able to toggle the p-flag on callsites in the submod, but their enablement still doesn't yield logging activity.
Right; having been in this is state is bad since it will generate inconsistent code-flow. Full on panic *might* not be warranted (as it does for corrupted text) but it is still a fairly bad situation -- so I'm not convinced we want to warn and carry on.
Quoted 6 lines
It would be really good to figure out why the site was skipped over and got out of skew.
Given it's all module stuff, the 'obvious' case would be something like a race between adding the new sites and flipping it, but I'm not seeing how -- things are rather crudely serialized by
jump_label_mutex.
Indeed, looks like dynamic debug introduces a new path in this series to that tries to toggle the jump label sites before they have been initialized, which ends up with the jump label key enabled but only some of the sites in the correct state. Then when the key is subsequently disabled it finds some in the wrong state. I just posted a patch for dynamic debug to use the module callback notifiers so it's ordered properly against jump label.
Note this isn't an issue in the current tree b/c there is no path to toggle the sites currently before they are initialized, but Jim's series here adds such a path.
Thanks,
-Jason
Quoted 4 lines
The only other option I can come up with is that somehow the update condition in
jump_label_add_module()is somehow wrong.
Patchwork
CI[Intel-gfx] ✗ Fi.CI.BUILD: failure for DRM_USE_DYNAMIC_DEBUG regression (rev2)
In reply to Jim Cromie== Series Details ==
== Series Details ==
Series: DRM_USE_DYNAMIC_DEBUG regression (rev2)
URL : https://patchwork.freedesktop.org/series/111651/
State : failure
== Summary ==
Error: patch https://patchwork.freedesktop.org/api/1.0/series/111651/revisions/2/mbox/ not applied
Applying: test-dyndbg: fixup CLASSMAP usage error
Applying: test-dyndbg: show that DEBUG enables prdbgs at compiletime
Applying: dyndbg: replace classmap list with a vector
Applying: dyndbg: make ddebug_apply_class_bitmap more selective
Applying: dyndbg: split param_set_dyndbg_classes to inner/outer
Applying: dyndbg: drop NUM_TYPE_ARRAY
Applying: dyndbg: reduce verbose/debug clutter
Applying: dyndbg: tighten ddebug_class_name() 1st arg
Applying: dyndbg: constify ddebug_apply_class_bitmap args
Applying: dyndbg-API: split DECLARE_(DYNDBG_CLASSMAP) to $1(_DEFINE|_USE)
Applying: dyndbg-API: specialize DYNDBG_CLASSMAP_(DEFINE|USE)
Using index info to reconstruct a base tree...
M include/asm-generic/vmlinux.lds.h
M kernel/module/main.c
Falling back to patching base and 3-way merge...
Auto-merging kernel/module/main.c
Auto-merging include/asm-generic/vmlinux.lds.h
CONFLICT (content): Merge conflict in include/asm-generic/vmlinux.lds.h
error: Failed to merge in the changes.
hint: Use 'git am --show-current-patch=diff' to see the failed patch
Patch failed at 0011 dyndbg-API: specialize DYNDBG_CLASSMAP_(DEFINE|USE)
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".