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