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