[PATCH v5 17/18] dyndbg: hoist classmap-filter-by-modname up to ddebug_add_module
From: Jim Cromie <jim.cromie@gmail.com>
Date: 2026-07-02 16:41:40
Also in:
dri-devel, linux-arch, linux-doc, lkml
Subsystem:
dynamic debug, library code, the rest · Maintainers:
Jason Baron, Jim Cromie, Andrew Morton, Linus Torvalds
The body of ddebug_attach_module_classes() is just a code-block that finds the contiguous subrange of classmaps matching on modname, and saves it into the ddebug_table's info record. Implement this block in a macro to accommodate different component vectors in the "box" (as named in the for_subvec macro). We will reuse this macro shortly. And hoist its invocation out of ddebug_attach_module_classes() up into ddebug_add_module(). This moves the filtering step up closer to dynamic_debug_init(), which already segments the builtin pr_debug descriptors on their mod_name boundaries. Signed-off-by: Jim Cromie <jim.cromie@gmail.com> Reviewed-by: Louis Chauvet <louis.chauvet@bootlin.com> --- v3: expand block-comment in ddebug_add_module v2: move RvB after SoB finish hoist - drop old fn - ddebug_attach_module_classes the v1 rev left the old ddebug_attach_module_classes in place, but it is completely redundant now, since it already lost the list-linking job it was doing. It was being cut out later in the patchset (in the unsent API adaptation phase), but for cleaner review, lets excise it now. OLD all-in-1-series (pre split into reviewable chunks) v10?- reordered params to match kdoc v12- refactor/rename: s/dd_mark_vector_subrange/dd_set_module_subrange/ 1. Renamed the macro from dd_mark_vector_subrange to dd_set_module_subrange to better reflect its purpose of narrowing a vector to a module-specific subrange. 2. Simplified the arguments by removing the redundant _dst, as the _di pointer already provides access to the target _ddebug_info struct. 3. Refactored for Clarity: Instead of overwriting the struct's start pointer while the for_subvec loop is using it to iterate, I introduced a temporary __start variable. This avoids the "subtle" side effect and makes the logic easier to follow. 4. Updated Documentation: Improved the comment block to explicitly state that the macro scans for the first match and counts contiguous elements. fiuxp --- lib/dynamic_debug.c | 80 ++++++++++++++++++++++++++++------------------------- 1 file changed, 43 insertions(+), 37 deletions(-)
diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c
index a9965ec1807a..1d5b9f68791a 100644
--- a/lib/dynamic_debug.c
+++ b/lib/dynamic_debug.c@@ -1175,34 +1175,34 @@ static const struct proc_ops proc_fops = { .proc_write = ddebug_proc_write }; -static void ddebug_attach_module_classes(struct ddebug_table *dt, struct _ddebug_info *di) -{ - struct ddebug_class_map *cm; - int i, nc = 0; - - /* - * Find this module's classmaps in a subrange/wholerange of - * the builtin/modular classmap vector/section. Save the start - * and length of the subrange at its edges. - */ - for_subvec(i, cm, di, maps) { - if (!strcmp(cm->mod_name, dt->info.mod_name)) { - if (!nc) { - v2pr_info("start subrange, class[%d]: module:%s base:%d len:%d ty:%d\n", - i, cm->mod_name, cm->base, cm->length, cm->map_type); - dt->info.maps.start = cm; - } - nc++; - } else if (nc) { - /* end of matching classmaps */ - break; - } - } - if (nc) { - dt->info.maps.len = nc; - vpr_info("module:%s attached %d classes\n", dt->info.mod_name, nc); - } -} +/* + * dd_set_module_subrange - find matching subrange of classmaps + * @_i: caller-provided index var + * @_sp: cursor into @_vec + * @_di: pointer to the struct _ddebug_info to be narrowed + * @_vec: name of the vector member (must have .start and .len) + * + * Narrow a _ddebug_info's vector (@_vec) of classmaps to the + * contiguous subrange of elements where ->mod_name matches + * @__di->mod_name. This is primarily for builtins, loadable modules + * have only their classmaps, and dont need this sub-selection. + */ +#define dd_set_module_subrange(_i, _sp, _di, _vec) ({ \ + struct _ddebug_info *__di = (_di); \ + typeof(__di->_vec.start) __start = NULL; \ + int __nc = 0; \ + for_subvec(_i, _sp, __di, _vec) { \ + if (!strcmp((_sp)->mod_name, __di->mod_name)) { \ + if (!__nc++) \ + __start = (_sp); \ + } else if (__nc) { \ + break; /* end of consecutive matches */ \ + } \ + } \ + if (__nc) \ + __di->_vec.start = __start; \ + __di->_vec.len = __nc; \ +}) /* * Allocate a new ddebug_table for the given module
@@ -1211,6 +1211,8 @@ static void ddebug_attach_module_classes(struct ddebug_table *dt, struct _ddebug static int ddebug_add_module(struct _ddebug_info *di) { struct ddebug_table *dt; + struct ddebug_class_map *cm; + int i; if (!di->descs.len) return 0;
@@ -1223,17 +1225,21 @@ static int ddebug_add_module(struct _ddebug_info *di) return -ENOMEM; } /* - * For built-in modules, name (as supplied in di by its - * callers) lives in .rodata and is immortal. For loaded - * modules, name points at the name[] member of struct module, - * which lives at least as long as this struct ddebug_table. + * For built-in modules, di is a partial cursor into the + * builtin dyndbg data; the descriptors are the subrange + * matching the modname, but the classmaps are the full set. + * We find and set the relevant subrange of classmaps here. + * + * The modname string is in .rodata, the descriptors and + * classmaps are in writable .data. All are immortal. + * + * For loaded modules, mod_name points at the name[] member + * of struct module, and the descriptors and classmaps point + * at the module's ELF sections; all have lifetimes matching + * the module's presence. */ dt->info = *di; - - INIT_LIST_HEAD(&dt->link); - - if (di->maps.len) - ddebug_attach_module_classes(dt, di); + dd_set_module_subrange(i, cm, &dt->info, maps); mutex_lock(&ddebug_lock); list_add_tail(&dt->link, &ddebug_tables);
--
2.54.0