xref: /openbmc/linux/lib/dynamic_debug.c (revision 7cffcade)
1 /*
2  * lib/dynamic_debug.c
3  *
4  * make pr_debug()/dev_dbg() calls runtime configurable based upon their
5  * source module.
6  *
7  * Copyright (C) 2008 Jason Baron <jbaron@redhat.com>
8  * By Greg Banks <gnb@melbourne.sgi.com>
9  * Copyright (c) 2008 Silicon Graphics Inc.  All Rights Reserved.
10  * Copyright (C) 2011 Bart Van Assche.  All Rights Reserved.
11  * Copyright (C) 2013 Du, Changbin <changbin.du@gmail.com>
12  */
13 
14 #define pr_fmt(fmt) "dyndbg: " fmt
15 
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/moduleparam.h>
19 #include <linux/kallsyms.h>
20 #include <linux/types.h>
21 #include <linux/mutex.h>
22 #include <linux/proc_fs.h>
23 #include <linux/seq_file.h>
24 #include <linux/list.h>
25 #include <linux/sysctl.h>
26 #include <linux/ctype.h>
27 #include <linux/string.h>
28 #include <linux/parser.h>
29 #include <linux/string_helpers.h>
30 #include <linux/uaccess.h>
31 #include <linux/dynamic_debug.h>
32 #include <linux/debugfs.h>
33 #include <linux/slab.h>
34 #include <linux/jump_label.h>
35 #include <linux/hardirq.h>
36 #include <linux/sched.h>
37 #include <linux/device.h>
38 #include <linux/netdevice.h>
39 
40 #include <rdma/ib_verbs.h>
41 
42 extern struct _ddebug __start___dyndbg[];
43 extern struct _ddebug __stop___dyndbg[];
44 extern struct ddebug_class_map __start___dyndbg_classes[];
45 extern struct ddebug_class_map __stop___dyndbg_classes[];
46 
47 struct ddebug_table {
48 	struct list_head link, maps;
49 	const char *mod_name;
50 	unsigned int num_ddebugs;
51 	struct _ddebug *ddebugs;
52 };
53 
54 struct ddebug_query {
55 	const char *filename;
56 	const char *module;
57 	const char *function;
58 	const char *format;
59 	const char *class_string;
60 	unsigned int first_lineno, last_lineno;
61 };
62 
63 struct ddebug_iter {
64 	struct ddebug_table *table;
65 	int idx;
66 };
67 
68 struct flag_settings {
69 	unsigned int flags;
70 	unsigned int mask;
71 };
72 
73 static DEFINE_MUTEX(ddebug_lock);
74 static LIST_HEAD(ddebug_tables);
75 static int verbose;
76 module_param(verbose, int, 0644);
77 MODULE_PARM_DESC(verbose, " dynamic_debug/control processing "
78 		 "( 0 = off (default), 1 = module add/rm, 2 = >control summary, 3 = parsing, 4 = per-site changes)");
79 
80 /* Return the path relative to source root */
81 static inline const char *trim_prefix(const char *path)
82 {
83 	int skip = strlen(__FILE__) - strlen("lib/dynamic_debug.c");
84 
85 	if (strncmp(path, __FILE__, skip))
86 		skip = 0; /* prefix mismatch, don't skip */
87 
88 	return path + skip;
89 }
90 
91 static struct { unsigned flag:8; char opt_char; } opt_array[] = {
92 	{ _DPRINTK_FLAGS_PRINT, 'p' },
93 	{ _DPRINTK_FLAGS_INCL_MODNAME, 'm' },
94 	{ _DPRINTK_FLAGS_INCL_FUNCNAME, 'f' },
95 	{ _DPRINTK_FLAGS_INCL_LINENO, 'l' },
96 	{ _DPRINTK_FLAGS_INCL_TID, 't' },
97 	{ _DPRINTK_FLAGS_NONE, '_' },
98 };
99 
100 struct flagsbuf { char buf[ARRAY_SIZE(opt_array)+1]; };
101 
102 /* format a string into buf[] which describes the _ddebug's flags */
103 static char *ddebug_describe_flags(unsigned int flags, struct flagsbuf *fb)
104 {
105 	char *p = fb->buf;
106 	int i;
107 
108 	for (i = 0; i < ARRAY_SIZE(opt_array); ++i)
109 		if (flags & opt_array[i].flag)
110 			*p++ = opt_array[i].opt_char;
111 	if (p == fb->buf)
112 		*p++ = '_';
113 	*p = '\0';
114 
115 	return fb->buf;
116 }
117 
118 #define vnpr_info(lvl, fmt, ...)				\
119 do {								\
120 	if (verbose >= lvl)					\
121 		pr_info(fmt, ##__VA_ARGS__);			\
122 } while (0)
123 
124 #define vpr_info(fmt, ...)	vnpr_info(1, fmt, ##__VA_ARGS__)
125 #define v2pr_info(fmt, ...)	vnpr_info(2, fmt, ##__VA_ARGS__)
126 #define v3pr_info(fmt, ...)	vnpr_info(3, fmt, ##__VA_ARGS__)
127 #define v4pr_info(fmt, ...)	vnpr_info(4, fmt, ##__VA_ARGS__)
128 
129 static void vpr_info_dq(const struct ddebug_query *query, const char *msg)
130 {
131 	/* trim any trailing newlines */
132 	int fmtlen = 0;
133 
134 	if (query->format) {
135 		fmtlen = strlen(query->format);
136 		while (fmtlen && query->format[fmtlen - 1] == '\n')
137 			fmtlen--;
138 	}
139 
140 	v3pr_info("%s: func=\"%s\" file=\"%s\" module=\"%s\" format=\"%.*s\" lineno=%u-%u class=%s\n",
141 		  msg,
142 		  query->function ?: "",
143 		  query->filename ?: "",
144 		  query->module ?: "",
145 		  fmtlen, query->format ?: "",
146 		  query->first_lineno, query->last_lineno, query->class_string);
147 }
148 
149 static struct ddebug_class_map *ddebug_find_valid_class(struct ddebug_table const *dt,
150 							  const char *class_string, int *class_id)
151 {
152 	struct ddebug_class_map *map;
153 	int idx;
154 
155 	list_for_each_entry(map, &dt->maps, link) {
156 		idx = match_string(map->class_names, map->length, class_string);
157 		if (idx >= 0) {
158 			*class_id = idx + map->base;
159 			return map;
160 		}
161 	}
162 	*class_id = -ENOENT;
163 	return NULL;
164 }
165 
166 #define __outvar /* filled by callee */
167 /*
168  * Search the tables for _ddebug's which match the given `query' and
169  * apply the `flags' and `mask' to them.  Returns number of matching
170  * callsites, normally the same as number of changes.  If verbose,
171  * logs the changes.  Takes ddebug_lock.
172  */
173 static int ddebug_change(const struct ddebug_query *query,
174 			 struct flag_settings *modifiers)
175 {
176 	int i;
177 	struct ddebug_table *dt;
178 	unsigned int newflags;
179 	unsigned int nfound = 0;
180 	struct flagsbuf fbuf, nbuf;
181 	struct ddebug_class_map *map = NULL;
182 	int __outvar valid_class;
183 
184 	/* search for matching ddebugs */
185 	mutex_lock(&ddebug_lock);
186 	list_for_each_entry(dt, &ddebug_tables, link) {
187 
188 		/* match against the module name */
189 		if (query->module &&
190 		    !match_wildcard(query->module, dt->mod_name))
191 			continue;
192 
193 		if (query->class_string) {
194 			map = ddebug_find_valid_class(dt, query->class_string, &valid_class);
195 			if (!map)
196 				continue;
197 		} else {
198 			/* constrain query, do not touch class'd callsites */
199 			valid_class = _DPRINTK_CLASS_DFLT;
200 		}
201 
202 		for (i = 0; i < dt->num_ddebugs; i++) {
203 			struct _ddebug *dp = &dt->ddebugs[i];
204 
205 			/* match site against query-class */
206 			if (dp->class_id != valid_class)
207 				continue;
208 
209 			/* match against the source filename */
210 			if (query->filename &&
211 			    !match_wildcard(query->filename, dp->filename) &&
212 			    !match_wildcard(query->filename,
213 					   kbasename(dp->filename)) &&
214 			    !match_wildcard(query->filename,
215 					   trim_prefix(dp->filename)))
216 				continue;
217 
218 			/* match against the function */
219 			if (query->function &&
220 			    !match_wildcard(query->function, dp->function))
221 				continue;
222 
223 			/* match against the format */
224 			if (query->format) {
225 				if (*query->format == '^') {
226 					char *p;
227 					/* anchored search. match must be at beginning */
228 					p = strstr(dp->format, query->format+1);
229 					if (p != dp->format)
230 						continue;
231 				} else if (!strstr(dp->format, query->format))
232 					continue;
233 			}
234 
235 			/* match against the line number range */
236 			if (query->first_lineno &&
237 			    dp->lineno < query->first_lineno)
238 				continue;
239 			if (query->last_lineno &&
240 			    dp->lineno > query->last_lineno)
241 				continue;
242 
243 			nfound++;
244 
245 			newflags = (dp->flags & modifiers->mask) | modifiers->flags;
246 			if (newflags == dp->flags)
247 				continue;
248 #ifdef CONFIG_JUMP_LABEL
249 			if (dp->flags & _DPRINTK_FLAGS_PRINT) {
250 				if (!(newflags & _DPRINTK_FLAGS_PRINT))
251 					static_branch_disable(&dp->key.dd_key_true);
252 			} else if (newflags & _DPRINTK_FLAGS_PRINT) {
253 				static_branch_enable(&dp->key.dd_key_true);
254 			}
255 #endif
256 			v4pr_info("changed %s:%d [%s]%s %s => %s\n",
257 				  trim_prefix(dp->filename), dp->lineno,
258 				  dt->mod_name, dp->function,
259 				  ddebug_describe_flags(dp->flags, &fbuf),
260 				  ddebug_describe_flags(newflags, &nbuf));
261 			dp->flags = newflags;
262 		}
263 	}
264 	mutex_unlock(&ddebug_lock);
265 
266 	if (!nfound && verbose)
267 		pr_info("no matches for query\n");
268 
269 	return nfound;
270 }
271 
272 /*
273  * Split the buffer `buf' into space-separated words.
274  * Handles simple " and ' quoting, i.e. without nested,
275  * embedded or escaped \".  Return the number of words
276  * or <0 on error.
277  */
278 static int ddebug_tokenize(char *buf, char *words[], int maxwords)
279 {
280 	int nwords = 0;
281 
282 	while (*buf) {
283 		char *end;
284 
285 		/* Skip leading whitespace */
286 		buf = skip_spaces(buf);
287 		if (!*buf)
288 			break;	/* oh, it was trailing whitespace */
289 		if (*buf == '#')
290 			break;	/* token starts comment, skip rest of line */
291 
292 		/* find `end' of word, whitespace separated or quoted */
293 		if (*buf == '"' || *buf == '\'') {
294 			int quote = *buf++;
295 			for (end = buf; *end && *end != quote; end++)
296 				;
297 			if (!*end) {
298 				pr_err("unclosed quote: %s\n", buf);
299 				return -EINVAL;	/* unclosed quote */
300 			}
301 		} else {
302 			for (end = buf; *end && !isspace(*end); end++)
303 				;
304 			BUG_ON(end == buf);
305 		}
306 
307 		/* `buf' is start of word, `end' is one past its end */
308 		if (nwords == maxwords) {
309 			pr_err("too many words, legal max <=%d\n", maxwords);
310 			return -EINVAL;	/* ran out of words[] before bytes */
311 		}
312 		if (*end)
313 			*end++ = '\0';	/* terminate the word */
314 		words[nwords++] = buf;
315 		buf = end;
316 	}
317 
318 	if (verbose >= 3) {
319 		int i;
320 		pr_info("split into words:");
321 		for (i = 0; i < nwords; i++)
322 			pr_cont(" \"%s\"", words[i]);
323 		pr_cont("\n");
324 	}
325 
326 	return nwords;
327 }
328 
329 /*
330  * Parse a single line number.  Note that the empty string ""
331  * is treated as a special case and converted to zero, which
332  * is later treated as a "don't care" value.
333  */
334 static inline int parse_lineno(const char *str, unsigned int *val)
335 {
336 	BUG_ON(str == NULL);
337 	if (*str == '\0') {
338 		*val = 0;
339 		return 0;
340 	}
341 	if (kstrtouint(str, 10, val) < 0) {
342 		pr_err("bad line-number: %s\n", str);
343 		return -EINVAL;
344 	}
345 	return 0;
346 }
347 
348 static int parse_linerange(struct ddebug_query *query, const char *first)
349 {
350 	char *last = strchr(first, '-');
351 
352 	if (query->first_lineno || query->last_lineno) {
353 		pr_err("match-spec: line used 2x\n");
354 		return -EINVAL;
355 	}
356 	if (last)
357 		*last++ = '\0';
358 	if (parse_lineno(first, &query->first_lineno) < 0)
359 		return -EINVAL;
360 	if (last) {
361 		/* range <first>-<last> */
362 		if (parse_lineno(last, &query->last_lineno) < 0)
363 			return -EINVAL;
364 
365 		/* special case for last lineno not specified */
366 		if (query->last_lineno == 0)
367 			query->last_lineno = UINT_MAX;
368 
369 		if (query->last_lineno < query->first_lineno) {
370 			pr_err("last-line:%d < 1st-line:%d\n",
371 			       query->last_lineno,
372 			       query->first_lineno);
373 			return -EINVAL;
374 		}
375 	} else {
376 		query->last_lineno = query->first_lineno;
377 	}
378 	v3pr_info("parsed line %d-%d\n", query->first_lineno,
379 		 query->last_lineno);
380 	return 0;
381 }
382 
383 static int check_set(const char **dest, char *src, char *name)
384 {
385 	int rc = 0;
386 
387 	if (*dest) {
388 		rc = -EINVAL;
389 		pr_err("match-spec:%s val:%s overridden by %s\n",
390 		       name, *dest, src);
391 	}
392 	*dest = src;
393 	return rc;
394 }
395 
396 /*
397  * Parse words[] as a ddebug query specification, which is a series
398  * of (keyword, value) pairs chosen from these possibilities:
399  *
400  * func <function-name>
401  * file <full-pathname>
402  * file <base-filename>
403  * module <module-name>
404  * format <escaped-string-to-find-in-format>
405  * line <lineno>
406  * line <first-lineno>-<last-lineno> // where either may be empty
407  *
408  * Only 1 of each type is allowed.
409  * Returns 0 on success, <0 on error.
410  */
411 static int ddebug_parse_query(char *words[], int nwords,
412 			struct ddebug_query *query, const char *modname)
413 {
414 	unsigned int i;
415 	int rc = 0;
416 	char *fline;
417 
418 	/* check we have an even number of words */
419 	if (nwords % 2 != 0) {
420 		pr_err("expecting pairs of match-spec <value>\n");
421 		return -EINVAL;
422 	}
423 
424 	for (i = 0; i < nwords; i += 2) {
425 		char *keyword = words[i];
426 		char *arg = words[i+1];
427 
428 		if (!strcmp(keyword, "func")) {
429 			rc = check_set(&query->function, arg, "func");
430 		} else if (!strcmp(keyword, "file")) {
431 			if (check_set(&query->filename, arg, "file"))
432 				return -EINVAL;
433 
434 			/* tail :$info is function or line-range */
435 			fline = strchr(query->filename, ':');
436 			if (!fline)
437 				continue;
438 			*fline++ = '\0';
439 			if (isalpha(*fline) || *fline == '*' || *fline == '?') {
440 				/* take as function name */
441 				if (check_set(&query->function, fline, "func"))
442 					return -EINVAL;
443 			} else {
444 				if (parse_linerange(query, fline))
445 					return -EINVAL;
446 			}
447 		} else if (!strcmp(keyword, "module")) {
448 			rc = check_set(&query->module, arg, "module");
449 		} else if (!strcmp(keyword, "format")) {
450 			string_unescape_inplace(arg, UNESCAPE_SPACE |
451 							    UNESCAPE_OCTAL |
452 							    UNESCAPE_SPECIAL);
453 			rc = check_set(&query->format, arg, "format");
454 		} else if (!strcmp(keyword, "line")) {
455 			if (parse_linerange(query, arg))
456 				return -EINVAL;
457 		} else if (!strcmp(keyword, "class")) {
458 			rc = check_set(&query->class_string, arg, "class");
459 		} else {
460 			pr_err("unknown keyword \"%s\"\n", keyword);
461 			return -EINVAL;
462 		}
463 		if (rc)
464 			return rc;
465 	}
466 	if (!query->module && modname)
467 		/*
468 		 * support $modname.dyndbg=<multiple queries>, when
469 		 * not given in the query itself
470 		 */
471 		query->module = modname;
472 
473 	vpr_info_dq(query, "parsed");
474 	return 0;
475 }
476 
477 /*
478  * Parse `str' as a flags specification, format [-+=][p]+.
479  * Sets up *maskp and *flagsp to be used when changing the
480  * flags fields of matched _ddebug's.  Returns 0 on success
481  * or <0 on error.
482  */
483 static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers)
484 {
485 	int op, i;
486 
487 	switch (*str) {
488 	case '+':
489 	case '-':
490 	case '=':
491 		op = *str++;
492 		break;
493 	default:
494 		pr_err("bad flag-op %c, at start of %s\n", *str, str);
495 		return -EINVAL;
496 	}
497 	v3pr_info("op='%c'\n", op);
498 
499 	for (; *str ; ++str) {
500 		for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
501 			if (*str == opt_array[i].opt_char) {
502 				modifiers->flags |= opt_array[i].flag;
503 				break;
504 			}
505 		}
506 		if (i < 0) {
507 			pr_err("unknown flag '%c'\n", *str);
508 			return -EINVAL;
509 		}
510 	}
511 	v3pr_info("flags=0x%x\n", modifiers->flags);
512 
513 	/* calculate final flags, mask based upon op */
514 	switch (op) {
515 	case '=':
516 		/* modifiers->flags already set */
517 		modifiers->mask = 0;
518 		break;
519 	case '+':
520 		modifiers->mask = ~0U;
521 		break;
522 	case '-':
523 		modifiers->mask = ~modifiers->flags;
524 		modifiers->flags = 0;
525 		break;
526 	}
527 	v3pr_info("*flagsp=0x%x *maskp=0x%x\n", modifiers->flags, modifiers->mask);
528 
529 	return 0;
530 }
531 
532 static int ddebug_exec_query(char *query_string, const char *modname)
533 {
534 	struct flag_settings modifiers = {};
535 	struct ddebug_query query = {};
536 #define MAXWORDS 9
537 	int nwords, nfound;
538 	char *words[MAXWORDS];
539 
540 	nwords = ddebug_tokenize(query_string, words, MAXWORDS);
541 	if (nwords <= 0) {
542 		pr_err("tokenize failed\n");
543 		return -EINVAL;
544 	}
545 	/* check flags 1st (last arg) so query is pairs of spec,val */
546 	if (ddebug_parse_flags(words[nwords-1], &modifiers)) {
547 		pr_err("flags parse failed\n");
548 		return -EINVAL;
549 	}
550 	if (ddebug_parse_query(words, nwords-1, &query, modname)) {
551 		pr_err("query parse failed\n");
552 		return -EINVAL;
553 	}
554 	/* actually go and implement the change */
555 	nfound = ddebug_change(&query, &modifiers);
556 	vpr_info_dq(&query, nfound ? "applied" : "no-match");
557 
558 	return nfound;
559 }
560 
561 /* handle multiple queries in query string, continue on error, return
562    last error or number of matching callsites.  Module name is either
563    in param (for boot arg) or perhaps in query string.
564 */
565 static int ddebug_exec_queries(char *query, const char *modname)
566 {
567 	char *split;
568 	int i, errs = 0, exitcode = 0, rc, nfound = 0;
569 
570 	for (i = 0; query; query = split) {
571 		split = strpbrk(query, ";\n");
572 		if (split)
573 			*split++ = '\0';
574 
575 		query = skip_spaces(query);
576 		if (!query || !*query || *query == '#')
577 			continue;
578 
579 		vpr_info("query %d: \"%s\" mod:%s\n", i, query, modname ?: "*");
580 
581 		rc = ddebug_exec_query(query, modname);
582 		if (rc < 0) {
583 			errs++;
584 			exitcode = rc;
585 		} else {
586 			nfound += rc;
587 		}
588 		i++;
589 	}
590 	if (i)
591 		v2pr_info("processed %d queries, with %d matches, %d errs\n",
592 			 i, nfound, errs);
593 
594 	if (exitcode)
595 		return exitcode;
596 	return nfound;
597 }
598 
599 /* apply a new bitmap to the sys-knob's current bit-state */
600 static int ddebug_apply_class_bitmap(const struct ddebug_class_param *dcp,
601 				     unsigned long *new_bits, unsigned long *old_bits)
602 {
603 #define QUERY_SIZE 128
604 	char query[QUERY_SIZE];
605 	const struct ddebug_class_map *map = dcp->map;
606 	int matches = 0;
607 	int bi, ct;
608 
609 	v2pr_info("apply: 0x%lx to: 0x%lx\n", *new_bits, *old_bits);
610 
611 	for (bi = 0; bi < map->length; bi++) {
612 		if (test_bit(bi, new_bits) == test_bit(bi, old_bits))
613 			continue;
614 
615 		snprintf(query, QUERY_SIZE, "class %s %c%s", map->class_names[bi],
616 			 test_bit(bi, new_bits) ? '+' : '-', dcp->flags);
617 
618 		ct = ddebug_exec_queries(query, NULL);
619 		matches += ct;
620 
621 		v2pr_info("bit_%d: %d matches on class: %s -> 0x%lx\n", bi,
622 			  ct, map->class_names[bi], *new_bits);
623 	}
624 	return matches;
625 }
626 
627 /* stub to later conditionally add "$module." prefix where not already done */
628 #define KP_NAME(kp)	kp->name
629 
630 #define CLASSMAP_BITMASK(width) ((1UL << (width)) - 1)
631 
632 /* accept comma-separated-list of [+-] classnames */
633 static int param_set_dyndbg_classnames(const char *instr, const struct kernel_param *kp)
634 {
635 	const struct ddebug_class_param *dcp = kp->arg;
636 	const struct ddebug_class_map *map = dcp->map;
637 	unsigned long curr_bits, old_bits;
638 	char *cl_str, *p, *tmp;
639 	int cls_id, totct = 0;
640 	bool wanted;
641 
642 	cl_str = tmp = kstrdup(instr, GFP_KERNEL);
643 	p = strchr(cl_str, '\n');
644 	if (p)
645 		*p = '\0';
646 
647 	/* start with previously set state-bits, then modify */
648 	curr_bits = old_bits = *dcp->bits;
649 	vpr_info("\"%s\" > %s:0x%lx\n", cl_str, KP_NAME(kp), curr_bits);
650 
651 	for (; cl_str; cl_str = p) {
652 		p = strchr(cl_str, ',');
653 		if (p)
654 			*p++ = '\0';
655 
656 		if (*cl_str == '-') {
657 			wanted = false;
658 			cl_str++;
659 		} else {
660 			wanted = true;
661 			if (*cl_str == '+')
662 				cl_str++;
663 		}
664 		cls_id = match_string(map->class_names, map->length, cl_str);
665 		if (cls_id < 0) {
666 			pr_err("%s unknown to %s\n", cl_str, KP_NAME(kp));
667 			continue;
668 		}
669 
670 		/* have one or more valid class_ids of one *_NAMES type */
671 		switch (map->map_type) {
672 		case DD_CLASS_TYPE_DISJOINT_NAMES:
673 			/* the +/- pertains to a single bit */
674 			if (test_bit(cls_id, &curr_bits) == wanted) {
675 				v3pr_info("no change on %s\n", cl_str);
676 				continue;
677 			}
678 			curr_bits ^= BIT(cls_id);
679 			totct += ddebug_apply_class_bitmap(dcp, &curr_bits, dcp->bits);
680 			*dcp->bits = curr_bits;
681 			v2pr_info("%s: changed bit %d:%s\n", KP_NAME(kp), cls_id,
682 				  map->class_names[cls_id]);
683 			break;
684 		case DD_CLASS_TYPE_LEVEL_NAMES:
685 			/* cls_id = N in 0..max. wanted +/- determines N or N-1 */
686 			old_bits = CLASSMAP_BITMASK(*dcp->lvl);
687 			curr_bits = CLASSMAP_BITMASK(cls_id + (wanted ? 1 : 0 ));
688 
689 			totct += ddebug_apply_class_bitmap(dcp, &curr_bits, &old_bits);
690 			*dcp->lvl = (cls_id + (wanted ? 1 : 0));
691 			v2pr_info("%s: changed bit-%d: \"%s\" %lx->%lx\n", KP_NAME(kp), cls_id,
692 				  map->class_names[cls_id], old_bits, curr_bits);
693 			break;
694 		default:
695 			pr_err("illegal map-type value %d\n", map->map_type);
696 		}
697 	}
698 	kfree(tmp);
699 	vpr_info("total matches: %d\n", totct);
700 	return 0;
701 }
702 
703 /**
704  * param_set_dyndbg_classes - class FOO >control
705  * @instr: string echo>d to sysfs, input depends on map_type
706  * @kp:    kp->arg has state: bits/lvl, map, map_type
707  *
708  * Enable/disable prdbgs by their class, as given in the arguments to
709  * DECLARE_DYNDBG_CLASSMAP.  For LEVEL map-types, enforce relative
710  * levels by bitpos.
711  *
712  * Returns: 0 or <0 if error.
713  */
714 int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp)
715 {
716 	const struct ddebug_class_param *dcp = kp->arg;
717 	const struct ddebug_class_map *map = dcp->map;
718 	unsigned long inrep, new_bits, old_bits;
719 	int rc, totct = 0;
720 
721 	switch (map->map_type) {
722 
723 	case DD_CLASS_TYPE_DISJOINT_NAMES:
724 	case DD_CLASS_TYPE_LEVEL_NAMES:
725 		/* handle [+-]classnames list separately, we are done here */
726 		return param_set_dyndbg_classnames(instr, kp);
727 
728 	case DD_CLASS_TYPE_DISJOINT_BITS:
729 	case DD_CLASS_TYPE_LEVEL_NUM:
730 		/* numeric input, accept and fall-thru */
731 		rc = kstrtoul(instr, 0, &inrep);
732 		if (rc) {
733 			pr_err("expecting numeric input: %s > %s\n", instr, KP_NAME(kp));
734 			return -EINVAL;
735 		}
736 		break;
737 	default:
738 		pr_err("%s: bad map type: %d\n", KP_NAME(kp), map->map_type);
739 		return -EINVAL;
740 	}
741 
742 	/* only _BITS,_NUM (numeric) map-types get here */
743 	switch (map->map_type) {
744 	case DD_CLASS_TYPE_DISJOINT_BITS:
745 		/* expect bits. mask and warn if too many */
746 		if (inrep & ~CLASSMAP_BITMASK(map->length)) {
747 			pr_warn("%s: input: 0x%lx exceeds mask: 0x%lx, masking\n",
748 				KP_NAME(kp), inrep, CLASSMAP_BITMASK(map->length));
749 			inrep &= CLASSMAP_BITMASK(map->length);
750 		}
751 		v2pr_info("bits:%lx > %s\n", inrep, KP_NAME(kp));
752 		totct += ddebug_apply_class_bitmap(dcp, &inrep, dcp->bits);
753 		*dcp->bits = inrep;
754 		break;
755 	case DD_CLASS_TYPE_LEVEL_NUM:
756 		/* input is bitpos, of highest verbosity to be enabled */
757 		if (inrep > map->length) {
758 			pr_warn("%s: level:%ld exceeds max:%d, clamping\n",
759 				KP_NAME(kp), inrep, map->length);
760 			inrep = map->length;
761 		}
762 		old_bits = CLASSMAP_BITMASK(*dcp->lvl);
763 		new_bits = CLASSMAP_BITMASK(inrep);
764 		v2pr_info("lvl:%ld bits:0x%lx > %s\n", inrep, new_bits, KP_NAME(kp));
765 		totct += ddebug_apply_class_bitmap(dcp, &new_bits, &old_bits);
766 		*dcp->lvl = inrep;
767 		break;
768 	default:
769 		pr_warn("%s: bad map type: %d\n", KP_NAME(kp), map->map_type);
770 	}
771 	vpr_info("%s: total matches: %d\n", KP_NAME(kp), totct);
772 	return 0;
773 }
774 EXPORT_SYMBOL(param_set_dyndbg_classes);
775 
776 /**
777  * param_get_dyndbg_classes - classes reader
778  * @buffer: string description of controlled bits -> classes
779  * @kp:     kp->arg has state: bits, map
780  *
781  * Reads last written state, underlying prdbg state may have been
782  * altered by direct >control.  Displays 0x for DISJOINT, 0-N for
783  * LEVEL Returns: #chars written or <0 on error
784  */
785 int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp)
786 {
787 	const struct ddebug_class_param *dcp = kp->arg;
788 	const struct ddebug_class_map *map = dcp->map;
789 
790 	switch (map->map_type) {
791 
792 	case DD_CLASS_TYPE_DISJOINT_NAMES:
793 	case DD_CLASS_TYPE_DISJOINT_BITS:
794 		return scnprintf(buffer, PAGE_SIZE, "0x%lx\n", *dcp->bits);
795 
796 	case DD_CLASS_TYPE_LEVEL_NAMES:
797 	case DD_CLASS_TYPE_LEVEL_NUM:
798 		return scnprintf(buffer, PAGE_SIZE, "%d\n", *dcp->lvl);
799 	default:
800 		return -1;
801 	}
802 }
803 EXPORT_SYMBOL(param_get_dyndbg_classes);
804 
805 const struct kernel_param_ops param_ops_dyndbg_classes = {
806 	.set = param_set_dyndbg_classes,
807 	.get = param_get_dyndbg_classes,
808 };
809 EXPORT_SYMBOL(param_ops_dyndbg_classes);
810 
811 #define PREFIX_SIZE 64
812 
813 static int remaining(int wrote)
814 {
815 	if (PREFIX_SIZE - wrote > 0)
816 		return PREFIX_SIZE - wrote;
817 	return 0;
818 }
819 
820 static char *__dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
821 {
822 	int pos_after_tid;
823 	int pos = 0;
824 
825 	if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
826 		if (in_interrupt())
827 			pos += snprintf(buf + pos, remaining(pos), "<intr> ");
828 		else
829 			pos += snprintf(buf + pos, remaining(pos), "[%d] ",
830 					task_pid_vnr(current));
831 	}
832 	pos_after_tid = pos;
833 	if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
834 		pos += snprintf(buf + pos, remaining(pos), "%s:",
835 				desc->modname);
836 	if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
837 		pos += snprintf(buf + pos, remaining(pos), "%s:",
838 				desc->function);
839 	if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
840 		pos += snprintf(buf + pos, remaining(pos), "%d:",
841 				desc->lineno);
842 	if (pos - pos_after_tid)
843 		pos += snprintf(buf + pos, remaining(pos), " ");
844 	if (pos >= PREFIX_SIZE)
845 		buf[PREFIX_SIZE - 1] = '\0';
846 
847 	return buf;
848 }
849 
850 static inline char *dynamic_emit_prefix(struct _ddebug *desc, char *buf)
851 {
852 	if (unlikely(desc->flags & _DPRINTK_FLAGS_INCL_ANY))
853 		return __dynamic_emit_prefix(desc, buf);
854 	return buf;
855 }
856 
857 void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
858 {
859 	va_list args;
860 	struct va_format vaf;
861 	char buf[PREFIX_SIZE] = "";
862 
863 	BUG_ON(!descriptor);
864 	BUG_ON(!fmt);
865 
866 	va_start(args, fmt);
867 
868 	vaf.fmt = fmt;
869 	vaf.va = &args;
870 
871 	printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
872 
873 	va_end(args);
874 }
875 EXPORT_SYMBOL(__dynamic_pr_debug);
876 
877 void __dynamic_dev_dbg(struct _ddebug *descriptor,
878 		      const struct device *dev, const char *fmt, ...)
879 {
880 	struct va_format vaf;
881 	va_list args;
882 
883 	BUG_ON(!descriptor);
884 	BUG_ON(!fmt);
885 
886 	va_start(args, fmt);
887 
888 	vaf.fmt = fmt;
889 	vaf.va = &args;
890 
891 	if (!dev) {
892 		printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
893 	} else {
894 		char buf[PREFIX_SIZE] = "";
895 
896 		dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
897 				dynamic_emit_prefix(descriptor, buf),
898 				dev_driver_string(dev), dev_name(dev),
899 				&vaf);
900 	}
901 
902 	va_end(args);
903 }
904 EXPORT_SYMBOL(__dynamic_dev_dbg);
905 
906 #ifdef CONFIG_NET
907 
908 void __dynamic_netdev_dbg(struct _ddebug *descriptor,
909 			  const struct net_device *dev, const char *fmt, ...)
910 {
911 	struct va_format vaf;
912 	va_list args;
913 
914 	BUG_ON(!descriptor);
915 	BUG_ON(!fmt);
916 
917 	va_start(args, fmt);
918 
919 	vaf.fmt = fmt;
920 	vaf.va = &args;
921 
922 	if (dev && dev->dev.parent) {
923 		char buf[PREFIX_SIZE] = "";
924 
925 		dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
926 				"%s%s %s %s%s: %pV",
927 				dynamic_emit_prefix(descriptor, buf),
928 				dev_driver_string(dev->dev.parent),
929 				dev_name(dev->dev.parent),
930 				netdev_name(dev), netdev_reg_state(dev),
931 				&vaf);
932 	} else if (dev) {
933 		printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
934 		       netdev_reg_state(dev), &vaf);
935 	} else {
936 		printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
937 	}
938 
939 	va_end(args);
940 }
941 EXPORT_SYMBOL(__dynamic_netdev_dbg);
942 
943 #endif
944 
945 #if IS_ENABLED(CONFIG_INFINIBAND)
946 
947 void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
948 			 const struct ib_device *ibdev, const char *fmt, ...)
949 {
950 	struct va_format vaf;
951 	va_list args;
952 
953 	va_start(args, fmt);
954 
955 	vaf.fmt = fmt;
956 	vaf.va = &args;
957 
958 	if (ibdev && ibdev->dev.parent) {
959 		char buf[PREFIX_SIZE] = "";
960 
961 		dev_printk_emit(LOGLEVEL_DEBUG, ibdev->dev.parent,
962 				"%s%s %s %s: %pV",
963 				dynamic_emit_prefix(descriptor, buf),
964 				dev_driver_string(ibdev->dev.parent),
965 				dev_name(ibdev->dev.parent),
966 				dev_name(&ibdev->dev),
967 				&vaf);
968 	} else if (ibdev) {
969 		printk(KERN_DEBUG "%s: %pV", dev_name(&ibdev->dev), &vaf);
970 	} else {
971 		printk(KERN_DEBUG "(NULL ib_device): %pV", &vaf);
972 	}
973 
974 	va_end(args);
975 }
976 EXPORT_SYMBOL(__dynamic_ibdev_dbg);
977 
978 #endif
979 
980 /*
981  * Install a noop handler to make dyndbg look like a normal kernel cli param.
982  * This avoids warnings about dyndbg being an unknown cli param when supplied
983  * by a user.
984  */
985 static __init int dyndbg_setup(char *str)
986 {
987 	return 1;
988 }
989 
990 __setup("dyndbg=", dyndbg_setup);
991 
992 /*
993  * File_ops->write method for <debugfs>/dynamic_debug/control.  Gathers the
994  * command text from userspace, parses and executes it.
995  */
996 #define USER_BUF_PAGE 4096
997 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
998 				  size_t len, loff_t *offp)
999 {
1000 	char *tmpbuf;
1001 	int ret;
1002 
1003 	if (len == 0)
1004 		return 0;
1005 	if (len > USER_BUF_PAGE - 1) {
1006 		pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
1007 		return -E2BIG;
1008 	}
1009 	tmpbuf = memdup_user_nul(ubuf, len);
1010 	if (IS_ERR(tmpbuf))
1011 		return PTR_ERR(tmpbuf);
1012 	v2pr_info("read %zu bytes from userspace\n", len);
1013 
1014 	ret = ddebug_exec_queries(tmpbuf, NULL);
1015 	kfree(tmpbuf);
1016 	if (ret < 0)
1017 		return ret;
1018 
1019 	*offp += len;
1020 	return len;
1021 }
1022 
1023 /*
1024  * Set the iterator to point to the first _ddebug object
1025  * and return a pointer to that first object.  Returns
1026  * NULL if there are no _ddebugs at all.
1027  */
1028 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
1029 {
1030 	if (list_empty(&ddebug_tables)) {
1031 		iter->table = NULL;
1032 		return NULL;
1033 	}
1034 	iter->table = list_entry(ddebug_tables.next,
1035 				 struct ddebug_table, link);
1036 	iter->idx = iter->table->num_ddebugs;
1037 	return &iter->table->ddebugs[--iter->idx];
1038 }
1039 
1040 /*
1041  * Advance the iterator to point to the next _ddebug
1042  * object from the one the iterator currently points at,
1043  * and returns a pointer to the new _ddebug.  Returns
1044  * NULL if the iterator has seen all the _ddebugs.
1045  */
1046 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
1047 {
1048 	if (iter->table == NULL)
1049 		return NULL;
1050 	if (--iter->idx < 0) {
1051 		/* iterate to next table */
1052 		if (list_is_last(&iter->table->link, &ddebug_tables)) {
1053 			iter->table = NULL;
1054 			return NULL;
1055 		}
1056 		iter->table = list_entry(iter->table->link.next,
1057 					 struct ddebug_table, link);
1058 		iter->idx = iter->table->num_ddebugs;
1059 		--iter->idx;
1060 	}
1061 	return &iter->table->ddebugs[iter->idx];
1062 }
1063 
1064 /*
1065  * Seq_ops start method.  Called at the start of every
1066  * read() call from userspace.  Takes the ddebug_lock and
1067  * seeks the seq_file's iterator to the given position.
1068  */
1069 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
1070 {
1071 	struct ddebug_iter *iter = m->private;
1072 	struct _ddebug *dp;
1073 	int n = *pos;
1074 
1075 	mutex_lock(&ddebug_lock);
1076 
1077 	if (!n)
1078 		return SEQ_START_TOKEN;
1079 	if (n < 0)
1080 		return NULL;
1081 	dp = ddebug_iter_first(iter);
1082 	while (dp != NULL && --n > 0)
1083 		dp = ddebug_iter_next(iter);
1084 	return dp;
1085 }
1086 
1087 /*
1088  * Seq_ops next method.  Called several times within a read()
1089  * call from userspace, with ddebug_lock held.  Walks to the
1090  * next _ddebug object with a special case for the header line.
1091  */
1092 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
1093 {
1094 	struct ddebug_iter *iter = m->private;
1095 	struct _ddebug *dp;
1096 
1097 	if (p == SEQ_START_TOKEN)
1098 		dp = ddebug_iter_first(iter);
1099 	else
1100 		dp = ddebug_iter_next(iter);
1101 	++*pos;
1102 	return dp;
1103 }
1104 
1105 #define class_in_range(class_id, map)					\
1106 	(class_id >= map->base && class_id < map->base + map->length)
1107 
1108 static const char *ddebug_class_name(struct ddebug_iter *iter, struct _ddebug *dp)
1109 {
1110 	struct ddebug_class_map *map;
1111 
1112 	list_for_each_entry(map, &iter->table->maps, link)
1113 		if (class_in_range(dp->class_id, map))
1114 			return map->class_names[dp->class_id - map->base];
1115 
1116 	return NULL;
1117 }
1118 
1119 /*
1120  * Seq_ops show method.  Called several times within a read()
1121  * call from userspace, with ddebug_lock held.  Formats the
1122  * current _ddebug as a single human-readable line, with a
1123  * special case for the header line.
1124  */
1125 static int ddebug_proc_show(struct seq_file *m, void *p)
1126 {
1127 	struct ddebug_iter *iter = m->private;
1128 	struct _ddebug *dp = p;
1129 	struct flagsbuf flags;
1130 	char const *class;
1131 
1132 	if (p == SEQ_START_TOKEN) {
1133 		seq_puts(m,
1134 			 "# filename:lineno [module]function flags format\n");
1135 		return 0;
1136 	}
1137 
1138 	seq_printf(m, "%s:%u [%s]%s =%s \"",
1139 		   trim_prefix(dp->filename), dp->lineno,
1140 		   iter->table->mod_name, dp->function,
1141 		   ddebug_describe_flags(dp->flags, &flags));
1142 	seq_escape_str(m, dp->format, ESCAPE_SPACE, "\t\r\n\"");
1143 	seq_puts(m, "\"");
1144 
1145 	if (dp->class_id != _DPRINTK_CLASS_DFLT) {
1146 		class = ddebug_class_name(iter, dp);
1147 		if (class)
1148 			seq_printf(m, " class:%s", class);
1149 		else
1150 			seq_printf(m, " class unknown, _id:%d", dp->class_id);
1151 	}
1152 	seq_puts(m, "\n");
1153 
1154 	return 0;
1155 }
1156 
1157 /*
1158  * Seq_ops stop method.  Called at the end of each read()
1159  * call from userspace.  Drops ddebug_lock.
1160  */
1161 static void ddebug_proc_stop(struct seq_file *m, void *p)
1162 {
1163 	mutex_unlock(&ddebug_lock);
1164 }
1165 
1166 static const struct seq_operations ddebug_proc_seqops = {
1167 	.start = ddebug_proc_start,
1168 	.next = ddebug_proc_next,
1169 	.show = ddebug_proc_show,
1170 	.stop = ddebug_proc_stop
1171 };
1172 
1173 static int ddebug_proc_open(struct inode *inode, struct file *file)
1174 {
1175 	return seq_open_private(file, &ddebug_proc_seqops,
1176 				sizeof(struct ddebug_iter));
1177 }
1178 
1179 static const struct file_operations ddebug_proc_fops = {
1180 	.owner = THIS_MODULE,
1181 	.open = ddebug_proc_open,
1182 	.read = seq_read,
1183 	.llseek = seq_lseek,
1184 	.release = seq_release_private,
1185 	.write = ddebug_proc_write
1186 };
1187 
1188 static const struct proc_ops proc_fops = {
1189 	.proc_open = ddebug_proc_open,
1190 	.proc_read = seq_read,
1191 	.proc_lseek = seq_lseek,
1192 	.proc_release = seq_release_private,
1193 	.proc_write = ddebug_proc_write
1194 };
1195 
1196 static void ddebug_attach_module_classes(struct ddebug_table *dt,
1197 					 struct ddebug_class_map *classes,
1198 					 int num_classes)
1199 {
1200 	struct ddebug_class_map *cm;
1201 	int i, j, ct = 0;
1202 
1203 	for (cm = classes, i = 0; i < num_classes; i++, cm++) {
1204 
1205 		if (!strcmp(cm->mod_name, dt->mod_name)) {
1206 
1207 			v2pr_info("class[%d]: module:%s base:%d len:%d ty:%d\n", i,
1208 				  cm->mod_name, cm->base, cm->length, cm->map_type);
1209 
1210 			for (j = 0; j < cm->length; j++)
1211 				v3pr_info(" %d: %d %s\n", j + cm->base, j,
1212 					  cm->class_names[j]);
1213 
1214 			list_add(&cm->link, &dt->maps);
1215 			ct++;
1216 		}
1217 	}
1218 	if (ct)
1219 		vpr_info("module:%s attached %d classes\n", dt->mod_name, ct);
1220 }
1221 
1222 /*
1223  * Allocate a new ddebug_table for the given module
1224  * and add it to the global list.
1225  */
1226 static int __ddebug_add_module(struct _ddebug_info *di, unsigned int base,
1227 			       const char *modname)
1228 {
1229 	struct ddebug_table *dt;
1230 
1231 	v3pr_info("add-module: %s.%d sites\n", modname, di->num_descs);
1232 	if (!di->num_descs) {
1233 		v3pr_info(" skip %s\n", modname);
1234 		return 0;
1235 	}
1236 
1237 	dt = kzalloc(sizeof(*dt), GFP_KERNEL);
1238 	if (dt == NULL) {
1239 		pr_err("error adding module: %s\n", modname);
1240 		return -ENOMEM;
1241 	}
1242 	/*
1243 	 * For built-in modules, name lives in .rodata and is
1244 	 * immortal. For loaded modules, name points at the name[]
1245 	 * member of struct module, which lives at least as long as
1246 	 * this struct ddebug_table.
1247 	 */
1248 	dt->mod_name = modname;
1249 	dt->ddebugs = di->descs;
1250 	dt->num_ddebugs = di->num_descs;
1251 
1252 	INIT_LIST_HEAD(&dt->link);
1253 	INIT_LIST_HEAD(&dt->maps);
1254 
1255 	if (di->classes && di->num_classes)
1256 		ddebug_attach_module_classes(dt, di->classes, di->num_classes);
1257 
1258 	mutex_lock(&ddebug_lock);
1259 	list_add_tail(&dt->link, &ddebug_tables);
1260 	mutex_unlock(&ddebug_lock);
1261 
1262 	vpr_info("%3u debug prints in module %s\n", di->num_descs, modname);
1263 	return 0;
1264 }
1265 
1266 int ddebug_add_module(struct _ddebug_info *di, const char *modname)
1267 {
1268 	return __ddebug_add_module(di, 0, modname);
1269 }
1270 
1271 /* helper for ddebug_dyndbg_(boot|module)_param_cb */
1272 static int ddebug_dyndbg_param_cb(char *param, char *val,
1273 				const char *modname, int on_err)
1274 {
1275 	char *sep;
1276 
1277 	sep = strchr(param, '.');
1278 	if (sep) {
1279 		/* needed only for ddebug_dyndbg_boot_param_cb */
1280 		*sep = '\0';
1281 		modname = param;
1282 		param = sep + 1;
1283 	}
1284 	if (strcmp(param, "dyndbg"))
1285 		return on_err; /* determined by caller */
1286 
1287 	ddebug_exec_queries((val ? val : "+p"), modname);
1288 
1289 	return 0; /* query failure shouldn't stop module load */
1290 }
1291 
1292 /* handle both dyndbg and $module.dyndbg params at boot */
1293 static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
1294 				const char *unused, void *arg)
1295 {
1296 	vpr_info("%s=\"%s\"\n", param, val);
1297 	return ddebug_dyndbg_param_cb(param, val, NULL, 0);
1298 }
1299 
1300 /*
1301  * modprobe foo finds foo.params in boot-args, strips "foo.", and
1302  * passes them to load_module().  This callback gets unknown params,
1303  * processes dyndbg params, rejects others.
1304  */
1305 int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
1306 {
1307 	vpr_info("module: %s %s=\"%s\"\n", module, param, val);
1308 	return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
1309 }
1310 
1311 static void ddebug_table_free(struct ddebug_table *dt)
1312 {
1313 	list_del_init(&dt->link);
1314 	kfree(dt);
1315 }
1316 
1317 /*
1318  * Called in response to a module being unloaded.  Removes
1319  * any ddebug_table's which point at the module.
1320  */
1321 int ddebug_remove_module(const char *mod_name)
1322 {
1323 	struct ddebug_table *dt, *nextdt;
1324 	int ret = -ENOENT;
1325 
1326 	mutex_lock(&ddebug_lock);
1327 	list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
1328 		if (dt->mod_name == mod_name) {
1329 			ddebug_table_free(dt);
1330 			ret = 0;
1331 			break;
1332 		}
1333 	}
1334 	mutex_unlock(&ddebug_lock);
1335 	if (!ret)
1336 		v2pr_info("removed module \"%s\"\n", mod_name);
1337 	return ret;
1338 }
1339 
1340 static void ddebug_remove_all_tables(void)
1341 {
1342 	mutex_lock(&ddebug_lock);
1343 	while (!list_empty(&ddebug_tables)) {
1344 		struct ddebug_table *dt = list_entry(ddebug_tables.next,
1345 						      struct ddebug_table,
1346 						      link);
1347 		ddebug_table_free(dt);
1348 	}
1349 	mutex_unlock(&ddebug_lock);
1350 }
1351 
1352 static __initdata int ddebug_init_success;
1353 
1354 static int __init dynamic_debug_init_control(void)
1355 {
1356 	struct proc_dir_entry *procfs_dir;
1357 	struct dentry *debugfs_dir;
1358 
1359 	if (!ddebug_init_success)
1360 		return -ENODEV;
1361 
1362 	/* Create the control file in debugfs if it is enabled */
1363 	if (debugfs_initialized()) {
1364 		debugfs_dir = debugfs_create_dir("dynamic_debug", NULL);
1365 		debugfs_create_file("control", 0644, debugfs_dir, NULL,
1366 				    &ddebug_proc_fops);
1367 	}
1368 
1369 	/* Also create the control file in procfs */
1370 	procfs_dir = proc_mkdir("dynamic_debug", NULL);
1371 	if (procfs_dir)
1372 		proc_create("control", 0644, procfs_dir, &proc_fops);
1373 
1374 	return 0;
1375 }
1376 
1377 static int __init dynamic_debug_init(void)
1378 {
1379 	struct _ddebug *iter, *iter_mod_start;
1380 	int ret, i, mod_sites, mod_ct;
1381 	const char *modname;
1382 	char *cmdline;
1383 
1384 	struct _ddebug_info di = {
1385 		.descs = __start___dyndbg,
1386 		.classes = __start___dyndbg_classes,
1387 		.num_descs = __stop___dyndbg - __start___dyndbg,
1388 		.num_classes = __stop___dyndbg_classes - __start___dyndbg_classes,
1389 	};
1390 
1391 	if (&__start___dyndbg == &__stop___dyndbg) {
1392 		if (IS_ENABLED(CONFIG_DYNAMIC_DEBUG)) {
1393 			pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
1394 			return 1;
1395 		}
1396 		pr_info("Ignore empty _ddebug table in a CONFIG_DYNAMIC_DEBUG_CORE build\n");
1397 		ddebug_init_success = 1;
1398 		return 0;
1399 	}
1400 
1401 	iter = iter_mod_start = __start___dyndbg;
1402 	modname = iter->modname;
1403 	i = mod_sites = mod_ct = 0;
1404 
1405 	for (; iter < __stop___dyndbg; iter++, i++, mod_sites++) {
1406 
1407 		if (strcmp(modname, iter->modname)) {
1408 			mod_ct++;
1409 			di.num_descs = mod_sites;
1410 			di.descs = iter_mod_start;
1411 			ret = __ddebug_add_module(&di, i - mod_sites, modname);
1412 			if (ret)
1413 				goto out_err;
1414 
1415 			mod_sites = 0;
1416 			modname = iter->modname;
1417 			iter_mod_start = iter;
1418 		}
1419 	}
1420 	di.num_descs = mod_sites;
1421 	di.descs = iter_mod_start;
1422 	ret = __ddebug_add_module(&di, i - mod_sites, modname);
1423 	if (ret)
1424 		goto out_err;
1425 
1426 	ddebug_init_success = 1;
1427 	vpr_info("%d prdebugs in %d modules, %d KiB in ddebug tables, %d kiB in __dyndbg section\n",
1428 		 i, mod_ct, (int)((mod_ct * sizeof(struct ddebug_table)) >> 10),
1429 		 (int)((i * sizeof(struct _ddebug)) >> 10));
1430 
1431 	if (di.num_classes)
1432 		v2pr_info("  %d builtin ddebug class-maps\n", di.num_classes);
1433 
1434 	/* now that ddebug tables are loaded, process all boot args
1435 	 * again to find and activate queries given in dyndbg params.
1436 	 * While this has already been done for known boot params, it
1437 	 * ignored the unknown ones (dyndbg in particular).  Reusing
1438 	 * parse_args avoids ad-hoc parsing.  This will also attempt
1439 	 * to activate queries for not-yet-loaded modules, which is
1440 	 * slightly noisy if verbose, but harmless.
1441 	 */
1442 	cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1443 	parse_args("dyndbg params", cmdline, NULL,
1444 		   0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
1445 	kfree(cmdline);
1446 	return 0;
1447 
1448 out_err:
1449 	ddebug_remove_all_tables();
1450 	return 0;
1451 }
1452 /* Allow early initialization for boot messages via boot param */
1453 early_initcall(dynamic_debug_init);
1454 
1455 /* Debugfs setup must be done later */
1456 fs_initcall(dynamic_debug_init_control);
1457