@@ -56,6 +56,34 @@ struct _ddebug {
#endif
} __attribute__((aligned(8)));
+struct ddebug_known_classes_map {
+ struct list_head link;
+ struct module *mod;
+ const char *mod_name; /* needed for builtins */
+ const int base; /* index of 1st .class_id, allows split/shared space */
+ const int length;
+ const char *classes[]; /* index maps .class_id */
+};
+
+#define NUM_TYPE_ARGS(eltype, ...) \
+ (sizeof((eltype[]) {__VA_ARGS__}) / sizeof(eltype))
+/**
+ * DYNAMIC_DEBUG_CLASSES - declare classnames known by a module
+ * @_var: passed to dynamic_debug_register_classes(_var)
+ * @_base: offset of 1st class-name. splits .class_id space
+ * @classes: class-names known/used by of .class_ids[_base.._base+length]
+ *
+ * @classes specifies names for the classids used by a module; dyndbg
+ * accepts "class <name>" commands if <name> is known and registered.
+ */
+#define DYNAMIC_DEBUG_CLASSES(_var, _base, ...) \
+ static __maybe_unused struct ddebug_known_classes_map _var = { \
+ .mod = THIS_MODULE, \
+ .mod_name = KBUILD_MODNAME, \
+ .base = _base, \
+ .length = NUM_TYPE_ARGS(char*, __VA_ARGS__), \
+ .classes = { __VA_ARGS__ } \
+ }
#if defined(CONFIG_DYNAMIC_DEBUG_CORE)
@@ -206,6 +234,9 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
KERN_DEBUG, prefix_str, prefix_type, \
rowsize, groupsize, buf, len, ascii)
+int dynamic_debug_register_classes(struct ddebug_known_classes_map *map);
+void dynamic_debug_unregister_classes(struct ddebug_known_classes_map *map);
+
#else /* !CONFIG_DYNAMIC_DEBUG_CORE */
#include <linux/string.h>
@@ -247,6 +278,11 @@ static inline int ddebug_dyndbg_module_param_cb(char *param, char *val,
} while (0)
+static inline int dynamic_debug_register_classes(const struct ddebug_known_classes_map *map)
+{ return 0; }
+static inline void dynamic_debug_unregister_classes(struct ddebug_known_classes_map *map)
+{}
+
#endif /* !CONFIG_DYNAMIC_DEBUG_CORE */
#endif
@@ -45,6 +45,8 @@ extern struct _ddebug __stop___dyndbg[];
struct ddebug_table {
struct list_head link;
const char *mod_name;
+ /* a module can have multiple class-sets eventually, but not yet */
+ struct ddebug_known_classes_map const *map;
unsigned int num_ddebugs;
struct _ddebug *ddebugs;
};
@@ -916,6 +918,57 @@ static const struct proc_ops proc_fops = {
.proc_write = ddebug_proc_write
};
+/**
+ * dynamic_debug_register_classes - register a module's known classes
+ * @map: &struct ddebug_known_classes_map
+ *
+ * modules using non-default pr_debug.class_id's should call this to
+ * inform dyndbg which classes they use (0..N), and what their
+ * classnames are. They are then usable in ```echo $cmd >control```
+ */
+int dynamic_debug_register_classes(struct ddebug_known_classes_map *map)
+{
+ struct ddebug_table *dt;
+ int rc = -ENOENT;
+
+ mutex_lock(&ddebug_lock);
+#ifdef CONFIG_MODULES
+ if (map->mod) {
+ /* loadable module */
+ list_for_each_entry(dt, &ddebug_tables, link) {
+ if (dt->mod_name == map->mod->name) {
+ rc = 0;
+ dt->map = map;
+ break;
+ }
+ }
+ }
+#endif
+ if (!map->mod) {
+ /* builtin module */
+ list_for_each_entry(dt, &ddebug_tables, link) {
+ if (!strcmp(dt->mod_name, map->mod_name)) {
+ rc = 0;
+ dt->map = map;
+ break;
+ }
+ }
+ }
+ mutex_unlock(&ddebug_lock);
+ if (rc)
+ pr_warn("register_classes: module %s not found\n", map->mod_name);
+ else
+ vpr_info("register_classes: %s\n", map->mod_name);
+
+ return rc;
+}
+EXPORT_SYMBOL(dynamic_debug_register_classes);
+
+void dynamic_debug_unregister_classes(struct ddebug_known_classes_map *map)
+{
+ vpr_info("unregister_classes: %s\n", map->mod_name);
+}
+
/*
* Allocate a new ddebug_table for the given module
* and add it to the global list.
Add dynamic_debug_register_classes() to API, allowing user modules (builtin and loadable) to register class_names for the .class_id's they are using. Knowing classes is 1st step to validating with them. Add dynamic_debug_unregister_classes() also. Add struct ddebug_known_classes_map: maps known class_name strings to .class_id[0..N], where N<31. .base allows sharing of that range. A wrapper macro: DYNAMIC_DEBUG_CLASSES(_var, _modmatch, _base, classes) defines and initializes that struct var, _maybe_unused is added so the decl doesn't draw warnings when dyndbg is not enabled; a small list of classnames is tolerable wasted space. _var: user passes this into dynamic_debug_register_classes(var). _base: usually 0, it allows splitting 31 classes into subranges, so that multiple sysfs-nodes can share the module's class-id space. classes: list of strings with classnames, mapped to class-id=idx(+_base) mod_name: KBUILD_MODNAME, available for builtins, loadables mod: ref to loadable module. allows ==, distinguishing loadables. When modules register known classnames, they opt-in to permit dyndbg to allow "class <name>" queries to manipulate their class'd pr_debugs (if any), default class_id pr_debugs are still controllable as before. dynamic_debug_register_classes(&map) finds the module's ddebug_table record, and attaches the map to it. This makes it available to ddebug_change(), which will use it to validate class'd commands. Sharing class-names across multiple modules is how those modules coordinate; all drm* and drivers would respond to: #> echo class DRM_UT_CORE +p > /proc/dynamic_debug/control Therefore no class-name uniqueness check is useful. TODO: Eventually we need a list of registered classes, not just the zero-or-one implemented here. This will support multiple sysfs-nodes, one each for print-to-syslog, print-to-tracefs, or subranges using _base. Signed-off-by: Jim Cromie <jim.cromie@gmail.com> --- . fix register_classes() for !CONFIG_MODULES . add maybe-unused to var decl in DYNAMIC_DEBUG_CLASSES . kdoc for DYNAMIC_DEBUG_CLASSES . add dynamic_debug_unregister_classes --- include/linux/dynamic_debug.h | 36 ++++++++++++++++++++++++ lib/dynamic_debug.c | 53 +++++++++++++++++++++++++++++++++++ 2 files changed, 89 insertions(+)