Commit 6ea3bf46 authored by Jim Cromie's avatar Jim Cromie Committed by Greg Kroah-Hartman
Browse files

dyndbg: test DECLARE_DYNDBG_CLASSMAP, sysfs nodes 



Demonstrate use of DECLARE_DYNDBG_CLASSMAP macro, and expose them as
sysfs-nodes for testing.

For each of the 4 class-map-types:

  - declare a class-map of that type,
  - declare the enum corresponding to those class-names
  - share _base across 0..30 range
  - add a __pr_debug_cls() call for each class-name
  - declare 2 sysnodes for each class-map
    for 'p' flag, and future 'T' flag

These declarations create the following sysfs parameter interface:

  :#> pwd
  /sys/module/test_dynamic_debug/parameters
  :#> ls
  T_disjoint_bits  T_disjoint_names  T_level_names  T_level_num  do_prints
  p_disjoint_bits  p_disjoint_names  p_level_names  p_level_num

NOTES:

The local wrapper macro is an api candidate, but there are already too
many parameters.  OTOH, maybe related enum should be in there too,
since it has _base inter-dependencies.

The T_* params control the (future) T flag on the same class'd
pr_debug callsites as their p* counterparts.  Using them will fail,
until the dyndbg-trace patches are added in.

:#> echo 1 > T_disjoint
[   28.792489] dyndbg: disjoint: 0x1 > test_dynamic_debug.T_D2
[   28.793848] dyndbg: query 0: "class D2_CORE +T" mod:*
[   28.795086] dyndbg: split into words: "class" "D2_CORE" "+T"
[   28.796467] dyndbg: op='+'
[   28.797148] dyndbg: unknown flag 'T'
[   28.798021] dyndbg: flags parse failed
[   28.798947] dyndbg: processed 1 queries, with 0 matches, 1 errs
[   28.800378] dyndbg: bit_0: -22 matches on class: D2_CORE -> 0x1
[   28.801959] dyndbg: test_dynamic_debug.T_D2: updated 0x0 -> 0x1
[   28.803974] dyndbg: total matches: -22

Signed-off-by: default avatarJim Cromie <jim.cromie@gmail.com>
Link: https://lore.kernel.org/r/20220904214134.408619-22-jim.cromie@gmail.com


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent b9400852

lib/test_dynamic_debug.c

+110 −15
Original line number Diff line number Diff line
@@ -10,57 +10,152 @@ 


#include <linux/module.h>



static void do_prints(void); /* device under test */



/* run tests by reading or writing sysfs node */

/* run tests by reading or writing sysfs node: do_prints */



static void do_prints(void); /* device under test */

static int param_set_do_prints(const char *instr, const struct kernel_param *kp)

{

	do_prints();

	return 0;

}



static int param_get_do_prints(char *buffer, const struct kernel_param *kp)

{

	do_prints();

	return scnprintf(buffer, PAGE_SIZE, "did do_prints\n");

}



static const struct kernel_param_ops param_ops_do_prints = {

	.set = param_set_do_prints,

	.get = param_get_do_prints,

};



module_param_cb(do_prints, &param_ops_do_prints, NULL, 0600);



static void do_alpha(void)

/*

 * Using the CLASSMAP api:

 * - classmaps must have corresponding enum

 * - enum symbols must match/correlate with class-name strings in the map.

 * - base must equal enum's 1st value

 * - multiple maps must set their base to share the 0-30 class_id space !!

 *   (build-bug-on tips welcome)

 * Additionally, here:

 * - tie together sysname, mapname, bitsname, flagsname

 */

#define DD_SYS_WRAP(_model, _flags)					\

	static unsigned long bits_##_model;				\

	static struct ddebug_class_param _flags##_model = {		\

		.bits = &bits_##_model,					\

		.flags = #_flags,					\

		.map = &map_##_model,					\

	};								\

	module_param_cb(_flags##_##_model, &param_ops_dyndbg_classes, &_flags##_model, 0600)



/* numeric input, independent bits */

enum cat_disjoint_bits {

	D2_CORE = 0,

	D2_DRIVER,

	D2_KMS,

	D2_PRIME,

	D2_ATOMIC,

	D2_VBL,

	D2_STATE,

	D2_LEASE,

	D2_DP,

	D2_DRMRES };

DECLARE_DYNDBG_CLASSMAP(map_disjoint_bits, DD_CLASS_TYPE_DISJOINT_BITS, 0,

			"D2_CORE",

			"D2_DRIVER",

			"D2_KMS",

			"D2_PRIME",

			"D2_ATOMIC",

			"D2_VBL",

			"D2_STATE",

			"D2_LEASE",

			"D2_DP",

			"D2_DRMRES");

DD_SYS_WRAP(disjoint_bits, p);

DD_SYS_WRAP(disjoint_bits, T);



/* symbolic input, independent bits */

enum cat_disjoint_names { LOW = 11, MID, HI };

DECLARE_DYNDBG_CLASSMAP(map_disjoint_names, DD_CLASS_TYPE_DISJOINT_NAMES, 10,

			"LOW", "MID", "HI");

DD_SYS_WRAP(disjoint_names, p);

DD_SYS_WRAP(disjoint_names, T);



/* numeric verbosity, V2 > V1 related */

enum cat_level_num { V0 = 14, V1, V2, V3, V4, V5, V6, V7 };

DECLARE_DYNDBG_CLASSMAP(map_level_num, DD_CLASS_TYPE_LEVEL_NUM, 14,

		       "V0", "V1", "V2", "V3", "V4", "V5", "V6", "V7");

DD_SYS_WRAP(level_num, p);

DD_SYS_WRAP(level_num, T);



/* symbolic verbosity */

enum cat_level_names { L0 = 22, L1, L2, L3, L4, L5, L6, L7 };

DECLARE_DYNDBG_CLASSMAP(map_level_names, DD_CLASS_TYPE_LEVEL_NAMES, 22,

			"L0", "L1", "L2", "L3", "L4", "L5", "L6", "L7");

DD_SYS_WRAP(level_names, p);

DD_SYS_WRAP(level_names, T);



/* stand-in for all pr_debug etc */

#define prdbg(SYM) __pr_debug_cls(SYM, #SYM " msg\n")



static void do_cats(void)

{

	pr_debug("do alpha\n");

	pr_debug("doing categories\n");



	prdbg(LOW);

	prdbg(MID);

	prdbg(HI);



	prdbg(D2_CORE);

	prdbg(D2_DRIVER);

	prdbg(D2_KMS);

	prdbg(D2_PRIME);

	prdbg(D2_ATOMIC);

	prdbg(D2_VBL);

	prdbg(D2_STATE);

	prdbg(D2_LEASE);

	prdbg(D2_DP);

	prdbg(D2_DRMRES);

}

static void do_beta(void)



static void do_levels(void)

{

	pr_debug("do beta\n");

	pr_debug("doing levels\n");



	prdbg(V1);

	prdbg(V2);

	prdbg(V3);

	prdbg(V4);

	prdbg(V5);

	prdbg(V6);

	prdbg(V7);



	prdbg(L1);

	prdbg(L2);

	prdbg(L3);

	prdbg(L4);

	prdbg(L5);

	prdbg(L6);

	prdbg(L7);

}



static void do_prints(void)

{

	do_alpha();

	do_beta();

	do_cats();

	do_levels();

}



static int __init test_dynamic_debug_init(void)

{

	pr_debug("init start\n");



	do_prints();



	pr_debug("init done\n");

	return 0;

}



static void __exit test_dynamic_debug_exit(void)

{

	pr_debug("exiting\n");

	pr_debug("exited\n");

}



module_init(test_dynamic_debug_init);