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
45 struct ddebug_table {
46 struct list_head link;
47 const char *mod_name;
48 unsigned int num_ddebugs;
49 struct _ddebug *ddebugs;
50 };
51
52 struct ddebug_query {
53 const char *filename;
54 const char *module;
55 const char *function;
56 const char *format;
57 unsigned int first_lineno, last_lineno;
58 };
59
60 struct ddebug_iter {
61 struct ddebug_table *table;
62 unsigned int idx;
63 };
64
65 struct flag_settings {
66 unsigned int flags;
67 unsigned int mask;
68 };
69
70 static DEFINE_MUTEX(ddebug_lock);
71 static LIST_HEAD(ddebug_tables);
72 static int verbose;
73 module_param(verbose, int, 0644);
74
75 /* Return the path relative to source root */
trim_prefix(const char * path)76 static inline const char *trim_prefix(const char *path)
77 {
78 int skip = strlen(__FILE__) - strlen("lib/dynamic_debug.c");
79
80 if (strncmp(path, __FILE__, skip))
81 skip = 0; /* prefix mismatch, don't skip */
82
83 return path + skip;
84 }
85
86 static struct { unsigned flag:8; char opt_char; } opt_array[] = {
87 { _DPRINTK_FLAGS_PRINT, 'p' },
88 { _DPRINTK_FLAGS_INCL_MODNAME, 'm' },
89 { _DPRINTK_FLAGS_INCL_FUNCNAME, 'f' },
90 { _DPRINTK_FLAGS_INCL_LINENO, 'l' },
91 { _DPRINTK_FLAGS_INCL_TID, 't' },
92 { _DPRINTK_FLAGS_NONE, '_' },
93 };
94
95 struct flagsbuf { char buf[ARRAY_SIZE(opt_array)+1]; };
96
97 /* format a string into buf[] which describes the _ddebug's flags */
ddebug_describe_flags(unsigned int flags,struct flagsbuf * fb)98 static char *ddebug_describe_flags(unsigned int flags, struct flagsbuf *fb)
99 {
100 char *p = fb->buf;
101 int i;
102
103 for (i = 0; i < ARRAY_SIZE(opt_array); ++i)
104 if (flags & opt_array[i].flag)
105 *p++ = opt_array[i].opt_char;
106 if (p == fb->buf)
107 *p++ = '_';
108 *p = '\0';
109
110 return fb->buf;
111 }
112
113 #define vnpr_info(lvl, fmt, ...) \
114 do { \
115 if (verbose >= lvl) \
116 pr_info(fmt, ##__VA_ARGS__); \
117 } while (0)
118
119 #define vpr_info(fmt, ...) vnpr_info(1, fmt, ##__VA_ARGS__)
120 #define v2pr_info(fmt, ...) vnpr_info(2, fmt, ##__VA_ARGS__)
121
vpr_info_dq(const struct ddebug_query * query,const char * msg)122 static void vpr_info_dq(const struct ddebug_query *query, const char *msg)
123 {
124 /* trim any trailing newlines */
125 int fmtlen = 0;
126
127 if (query->format) {
128 fmtlen = strlen(query->format);
129 while (fmtlen && query->format[fmtlen - 1] == '\n')
130 fmtlen--;
131 }
132
133 vpr_info("%s: func=\"%s\" file=\"%s\" module=\"%s\" format=\"%.*s\" lineno=%u-%u\n",
134 msg,
135 query->function ?: "",
136 query->filename ?: "",
137 query->module ?: "",
138 fmtlen, query->format ?: "",
139 query->first_lineno, query->last_lineno);
140 }
141
142 /*
143 * Search the tables for _ddebug's which match the given `query' and
144 * apply the `flags' and `mask' to them. Returns number of matching
145 * callsites, normally the same as number of changes. If verbose,
146 * logs the changes. Takes ddebug_lock.
147 */
ddebug_change(const struct ddebug_query * query,struct flag_settings * modifiers)148 static int ddebug_change(const struct ddebug_query *query,
149 struct flag_settings *modifiers)
150 {
151 int i;
152 struct ddebug_table *dt;
153 unsigned int newflags;
154 unsigned int nfound = 0;
155 struct flagsbuf fbuf;
156
157 /* search for matching ddebugs */
158 mutex_lock(&ddebug_lock);
159 list_for_each_entry(dt, &ddebug_tables, link) {
160
161 /* match against the module name */
162 if (query->module &&
163 !match_wildcard(query->module, dt->mod_name))
164 continue;
165
166 for (i = 0; i < dt->num_ddebugs; i++) {
167 struct _ddebug *dp = &dt->ddebugs[i];
168
169 /* match against the source filename */
170 if (query->filename &&
171 !match_wildcard(query->filename, dp->filename) &&
172 !match_wildcard(query->filename,
173 kbasename(dp->filename)) &&
174 !match_wildcard(query->filename,
175 trim_prefix(dp->filename)))
176 continue;
177
178 /* match against the function */
179 if (query->function &&
180 !match_wildcard(query->function, dp->function))
181 continue;
182
183 /* match against the format */
184 if (query->format) {
185 if (*query->format == '^') {
186 char *p;
187 /* anchored search. match must be at beginning */
188 p = strstr(dp->format, query->format+1);
189 if (p != dp->format)
190 continue;
191 } else if (!strstr(dp->format, query->format))
192 continue;
193 }
194
195 /* match against the line number range */
196 if (query->first_lineno &&
197 dp->lineno < query->first_lineno)
198 continue;
199 if (query->last_lineno &&
200 dp->lineno > query->last_lineno)
201 continue;
202
203 nfound++;
204
205 newflags = (dp->flags & modifiers->mask) | modifiers->flags;
206 if (newflags == dp->flags)
207 continue;
208 #ifdef CONFIG_JUMP_LABEL
209 if (dp->flags & _DPRINTK_FLAGS_PRINT) {
210 if (!(newflags & _DPRINTK_FLAGS_PRINT))
211 static_branch_disable(&dp->key.dd_key_true);
212 } else if (newflags & _DPRINTK_FLAGS_PRINT) {
213 static_branch_enable(&dp->key.dd_key_true);
214 }
215 #endif
216 dp->flags = newflags;
217 v2pr_info("changed %s:%d [%s]%s =%s\n",
218 trim_prefix(dp->filename), dp->lineno,
219 dt->mod_name, dp->function,
220 ddebug_describe_flags(dp->flags, &fbuf));
221 }
222 }
223 mutex_unlock(&ddebug_lock);
224
225 if (!nfound && verbose)
226 pr_info("no matches for query\n");
227
228 return nfound;
229 }
230
231 /*
232 * Split the buffer `buf' into space-separated words.
233 * Handles simple " and ' quoting, i.e. without nested,
234 * embedded or escaped \". Return the number of words
235 * or <0 on error.
236 */
ddebug_tokenize(char * buf,char * words[],int maxwords)237 static int ddebug_tokenize(char *buf, char *words[], int maxwords)
238 {
239 int nwords = 0;
240
241 while (*buf) {
242 char *end;
243
244 /* Skip leading whitespace */
245 buf = skip_spaces(buf);
246 if (!*buf)
247 break; /* oh, it was trailing whitespace */
248 if (*buf == '#')
249 break; /* token starts comment, skip rest of line */
250
251 /* find `end' of word, whitespace separated or quoted */
252 if (*buf == '"' || *buf == '\'') {
253 int quote = *buf++;
254 for (end = buf; *end && *end != quote; end++)
255 ;
256 if (!*end) {
257 pr_err("unclosed quote: %s\n", buf);
258 return -EINVAL; /* unclosed quote */
259 }
260 } else {
261 for (end = buf; *end && !isspace(*end); end++)
262 ;
263 BUG_ON(end == buf);
264 }
265
266 /* `buf' is start of word, `end' is one past its end */
267 if (nwords == maxwords) {
268 pr_err("too many words, legal max <=%d\n", maxwords);
269 return -EINVAL; /* ran out of words[] before bytes */
270 }
271 if (*end)
272 *end++ = '\0'; /* terminate the word */
273 words[nwords++] = buf;
274 buf = end;
275 }
276
277 if (verbose) {
278 int i;
279 pr_info("split into words:");
280 for (i = 0; i < nwords; i++)
281 pr_cont(" \"%s\"", words[i]);
282 pr_cont("\n");
283 }
284
285 return nwords;
286 }
287
288 /*
289 * Parse a single line number. Note that the empty string ""
290 * is treated as a special case and converted to zero, which
291 * is later treated as a "don't care" value.
292 */
parse_lineno(const char * str,unsigned int * val)293 static inline int parse_lineno(const char *str, unsigned int *val)
294 {
295 BUG_ON(str == NULL);
296 if (*str == '\0') {
297 *val = 0;
298 return 0;
299 }
300 if (kstrtouint(str, 10, val) < 0) {
301 pr_err("bad line-number: %s\n", str);
302 return -EINVAL;
303 }
304 return 0;
305 }
306
parse_linerange(struct ddebug_query * query,const char * first)307 static int parse_linerange(struct ddebug_query *query, const char *first)
308 {
309 char *last = strchr(first, '-');
310
311 if (query->first_lineno || query->last_lineno) {
312 pr_err("match-spec: line used 2x\n");
313 return -EINVAL;
314 }
315 if (last)
316 *last++ = '\0';
317 if (parse_lineno(first, &query->first_lineno) < 0)
318 return -EINVAL;
319 if (last) {
320 /* range <first>-<last> */
321 if (parse_lineno(last, &query->last_lineno) < 0)
322 return -EINVAL;
323
324 /* special case for last lineno not specified */
325 if (query->last_lineno == 0)
326 query->last_lineno = UINT_MAX;
327
328 if (query->last_lineno < query->first_lineno) {
329 pr_err("last-line:%d < 1st-line:%d\n",
330 query->last_lineno,
331 query->first_lineno);
332 return -EINVAL;
333 }
334 } else {
335 query->last_lineno = query->first_lineno;
336 }
337 vpr_info("parsed line %d-%d\n", query->first_lineno,
338 query->last_lineno);
339 return 0;
340 }
341
check_set(const char ** dest,char * src,char * name)342 static int check_set(const char **dest, char *src, char *name)
343 {
344 int rc = 0;
345
346 if (*dest) {
347 rc = -EINVAL;
348 pr_err("match-spec:%s val:%s overridden by %s\n",
349 name, *dest, src);
350 }
351 *dest = src;
352 return rc;
353 }
354
355 /*
356 * Parse words[] as a ddebug query specification, which is a series
357 * of (keyword, value) pairs chosen from these possibilities:
358 *
359 * func <function-name>
360 * file <full-pathname>
361 * file <base-filename>
362 * module <module-name>
363 * format <escaped-string-to-find-in-format>
364 * line <lineno>
365 * line <first-lineno>-<last-lineno> // where either may be empty
366 *
367 * Only 1 of each type is allowed.
368 * Returns 0 on success, <0 on error.
369 */
ddebug_parse_query(char * words[],int nwords,struct ddebug_query * query,const char * modname)370 static int ddebug_parse_query(char *words[], int nwords,
371 struct ddebug_query *query, const char *modname)
372 {
373 unsigned int i;
374 int rc = 0;
375 char *fline;
376
377 /* check we have an even number of words */
378 if (nwords % 2 != 0) {
379 pr_err("expecting pairs of match-spec <value>\n");
380 return -EINVAL;
381 }
382
383 for (i = 0; i < nwords; i += 2) {
384 char *keyword = words[i];
385 char *arg = words[i+1];
386
387 if (!strcmp(keyword, "func")) {
388 rc = check_set(&query->function, arg, "func");
389 } else if (!strcmp(keyword, "file")) {
390 if (check_set(&query->filename, arg, "file"))
391 return -EINVAL;
392
393 /* tail :$info is function or line-range */
394 fline = strchr(query->filename, ':');
395 if (!fline)
396 continue;
397 *fline++ = '\0';
398 if (isalpha(*fline) || *fline == '*' || *fline == '?') {
399 /* take as function name */
400 if (check_set(&query->function, fline, "func"))
401 return -EINVAL;
402 } else {
403 if (parse_linerange(query, fline))
404 return -EINVAL;
405 }
406 } else if (!strcmp(keyword, "module")) {
407 rc = check_set(&query->module, arg, "module");
408 } else if (!strcmp(keyword, "format")) {
409 string_unescape_inplace(arg, UNESCAPE_SPACE |
410 UNESCAPE_OCTAL |
411 UNESCAPE_SPECIAL);
412 rc = check_set(&query->format, arg, "format");
413 } else if (!strcmp(keyword, "line")) {
414 if (parse_linerange(query, arg))
415 return -EINVAL;
416 } else {
417 pr_err("unknown keyword \"%s\"\n", keyword);
418 return -EINVAL;
419 }
420 if (rc)
421 return rc;
422 }
423 if (!query->module && modname)
424 /*
425 * support $modname.dyndbg=<multiple queries>, when
426 * not given in the query itself
427 */
428 query->module = modname;
429
430 vpr_info_dq(query, "parsed");
431 return 0;
432 }
433
434 /*
435 * Parse `str' as a flags specification, format [-+=][p]+.
436 * Sets up *maskp and *flagsp to be used when changing the
437 * flags fields of matched _ddebug's. Returns 0 on success
438 * or <0 on error.
439 */
ddebug_parse_flags(const char * str,struct flag_settings * modifiers)440 static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers)
441 {
442 int op, i;
443
444 switch (*str) {
445 case '+':
446 case '-':
447 case '=':
448 op = *str++;
449 break;
450 default:
451 pr_err("bad flag-op %c, at start of %s\n", *str, str);
452 return -EINVAL;
453 }
454 vpr_info("op='%c'\n", op);
455
456 for (; *str ; ++str) {
457 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
458 if (*str == opt_array[i].opt_char) {
459 modifiers->flags |= opt_array[i].flag;
460 break;
461 }
462 }
463 if (i < 0) {
464 pr_err("unknown flag '%c'\n", *str);
465 return -EINVAL;
466 }
467 }
468 vpr_info("flags=0x%x\n", modifiers->flags);
469
470 /* calculate final flags, mask based upon op */
471 switch (op) {
472 case '=':
473 /* modifiers->flags already set */
474 modifiers->mask = 0;
475 break;
476 case '+':
477 modifiers->mask = ~0U;
478 break;
479 case '-':
480 modifiers->mask = ~modifiers->flags;
481 modifiers->flags = 0;
482 break;
483 }
484 vpr_info("*flagsp=0x%x *maskp=0x%x\n", modifiers->flags, modifiers->mask);
485
486 return 0;
487 }
488
ddebug_exec_query(char * query_string,const char * modname)489 static int ddebug_exec_query(char *query_string, const char *modname)
490 {
491 struct flag_settings modifiers = {};
492 struct ddebug_query query = {};
493 #define MAXWORDS 9
494 int nwords, nfound;
495 char *words[MAXWORDS];
496
497 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
498 if (nwords <= 0) {
499 pr_err("tokenize failed\n");
500 return -EINVAL;
501 }
502 /* check flags 1st (last arg) so query is pairs of spec,val */
503 if (ddebug_parse_flags(words[nwords-1], &modifiers)) {
504 pr_err("flags parse failed\n");
505 return -EINVAL;
506 }
507 if (ddebug_parse_query(words, nwords-1, &query, modname)) {
508 pr_err("query parse failed\n");
509 return -EINVAL;
510 }
511 /* actually go and implement the change */
512 nfound = ddebug_change(&query, &modifiers);
513 vpr_info_dq(&query, nfound ? "applied" : "no-match");
514
515 return nfound;
516 }
517
518 /* handle multiple queries in query string, continue on error, return
519 last error or number of matching callsites. Module name is either
520 in param (for boot arg) or perhaps in query string.
521 */
ddebug_exec_queries(char * query,const char * modname)522 static int ddebug_exec_queries(char *query, const char *modname)
523 {
524 char *split;
525 int i, errs = 0, exitcode = 0, rc, nfound = 0;
526
527 for (i = 0; query; query = split) {
528 split = strpbrk(query, ";\n");
529 if (split)
530 *split++ = '\0';
531
532 query = skip_spaces(query);
533 if (!query || !*query || *query == '#')
534 continue;
535
536 vpr_info("query %d: \"%s\"\n", i, query);
537
538 rc = ddebug_exec_query(query, modname);
539 if (rc < 0) {
540 errs++;
541 exitcode = rc;
542 } else {
543 nfound += rc;
544 }
545 i++;
546 }
547 vpr_info("processed %d queries, with %d matches, %d errs\n",
548 i, nfound, errs);
549
550 if (exitcode)
551 return exitcode;
552 return nfound;
553 }
554
555 #define PREFIX_SIZE 64
556
remaining(int wrote)557 static int remaining(int wrote)
558 {
559 if (PREFIX_SIZE - wrote > 0)
560 return PREFIX_SIZE - wrote;
561 return 0;
562 }
563
__dynamic_emit_prefix(const struct _ddebug * desc,char * buf)564 static char *__dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
565 {
566 int pos_after_tid;
567 int pos = 0;
568
569 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
570 if (in_interrupt())
571 pos += snprintf(buf + pos, remaining(pos), "<intr> ");
572 else
573 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
574 task_pid_vnr(current));
575 }
576 pos_after_tid = pos;
577 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
578 pos += snprintf(buf + pos, remaining(pos), "%s:",
579 desc->modname);
580 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
581 pos += snprintf(buf + pos, remaining(pos), "%s:",
582 desc->function);
583 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
584 pos += snprintf(buf + pos, remaining(pos), "%d:",
585 desc->lineno);
586 if (pos - pos_after_tid)
587 pos += snprintf(buf + pos, remaining(pos), " ");
588 if (pos >= PREFIX_SIZE)
589 buf[PREFIX_SIZE - 1] = '\0';
590
591 return buf;
592 }
593
dynamic_emit_prefix(struct _ddebug * desc,char * buf)594 static inline char *dynamic_emit_prefix(struct _ddebug *desc, char *buf)
595 {
596 if (unlikely(desc->flags & _DPRINTK_FLAGS_INCL_ANY))
597 return __dynamic_emit_prefix(desc, buf);
598 return buf;
599 }
600
__dynamic_pr_debug(struct _ddebug * descriptor,const char * fmt,...)601 void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
602 {
603 va_list args;
604 struct va_format vaf;
605 char buf[PREFIX_SIZE] = "";
606
607 BUG_ON(!descriptor);
608 BUG_ON(!fmt);
609
610 va_start(args, fmt);
611
612 vaf.fmt = fmt;
613 vaf.va = &args;
614
615 printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
616
617 va_end(args);
618 }
619 EXPORT_SYMBOL(__dynamic_pr_debug);
620
__dynamic_dev_dbg(struct _ddebug * descriptor,const struct device * dev,const char * fmt,...)621 void __dynamic_dev_dbg(struct _ddebug *descriptor,
622 const struct device *dev, const char *fmt, ...)
623 {
624 struct va_format vaf;
625 va_list args;
626
627 BUG_ON(!descriptor);
628 BUG_ON(!fmt);
629
630 va_start(args, fmt);
631
632 vaf.fmt = fmt;
633 vaf.va = &args;
634
635 if (!dev) {
636 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
637 } else {
638 char buf[PREFIX_SIZE] = "";
639
640 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
641 dynamic_emit_prefix(descriptor, buf),
642 dev_driver_string(dev), dev_name(dev),
643 &vaf);
644 }
645
646 va_end(args);
647 }
648 EXPORT_SYMBOL(__dynamic_dev_dbg);
649
650 #ifdef CONFIG_NET
651
__dynamic_netdev_dbg(struct _ddebug * descriptor,const struct net_device * dev,const char * fmt,...)652 void __dynamic_netdev_dbg(struct _ddebug *descriptor,
653 const struct net_device *dev, const char *fmt, ...)
654 {
655 struct va_format vaf;
656 va_list args;
657
658 BUG_ON(!descriptor);
659 BUG_ON(!fmt);
660
661 va_start(args, fmt);
662
663 vaf.fmt = fmt;
664 vaf.va = &args;
665
666 if (dev && dev->dev.parent) {
667 char buf[PREFIX_SIZE] = "";
668
669 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
670 "%s%s %s %s%s: %pV",
671 dynamic_emit_prefix(descriptor, buf),
672 dev_driver_string(dev->dev.parent),
673 dev_name(dev->dev.parent),
674 netdev_name(dev), netdev_reg_state(dev),
675 &vaf);
676 } else if (dev) {
677 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
678 netdev_reg_state(dev), &vaf);
679 } else {
680 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
681 }
682
683 va_end(args);
684 }
685 EXPORT_SYMBOL(__dynamic_netdev_dbg);
686
687 #endif
688
689 #if IS_ENABLED(CONFIG_INFINIBAND)
690
__dynamic_ibdev_dbg(struct _ddebug * descriptor,const struct ib_device * ibdev,const char * fmt,...)691 void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
692 const struct ib_device *ibdev, const char *fmt, ...)
693 {
694 struct va_format vaf;
695 va_list args;
696
697 va_start(args, fmt);
698
699 vaf.fmt = fmt;
700 vaf.va = &args;
701
702 if (ibdev && ibdev->dev.parent) {
703 char buf[PREFIX_SIZE] = "";
704
705 dev_printk_emit(LOGLEVEL_DEBUG, ibdev->dev.parent,
706 "%s%s %s %s: %pV",
707 dynamic_emit_prefix(descriptor, buf),
708 dev_driver_string(ibdev->dev.parent),
709 dev_name(ibdev->dev.parent),
710 dev_name(&ibdev->dev),
711 &vaf);
712 } else if (ibdev) {
713 printk(KERN_DEBUG "%s: %pV", dev_name(&ibdev->dev), &vaf);
714 } else {
715 printk(KERN_DEBUG "(NULL ib_device): %pV", &vaf);
716 }
717
718 va_end(args);
719 }
720 EXPORT_SYMBOL(__dynamic_ibdev_dbg);
721
722 #endif
723
724 #define DDEBUG_STRING_SIZE 1024
725 static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
726
ddebug_setup_query(char * str)727 static __init int ddebug_setup_query(char *str)
728 {
729 if (strlen(str) >= DDEBUG_STRING_SIZE) {
730 pr_warn("ddebug boot param string too large\n");
731 return 0;
732 }
733 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
734 return 1;
735 }
736
737 __setup("ddebug_query=", ddebug_setup_query);
738
739 /*
740 * Install a noop handler to make dyndbg look like a normal kernel cli param.
741 * This avoids warnings about dyndbg being an unknown cli param when supplied
742 * by a user.
743 */
dyndbg_setup(char * str)744 static __init int dyndbg_setup(char *str)
745 {
746 return 1;
747 }
748
749 __setup("dyndbg=", dyndbg_setup);
750
751 /*
752 * File_ops->write method for <debugfs>/dynamic_debug/control. Gathers the
753 * command text from userspace, parses and executes it.
754 */
755 #define USER_BUF_PAGE 4096
ddebug_proc_write(struct file * file,const char __user * ubuf,size_t len,loff_t * offp)756 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
757 size_t len, loff_t *offp)
758 {
759 char *tmpbuf;
760 int ret;
761
762 if (len == 0)
763 return 0;
764 if (len > USER_BUF_PAGE - 1) {
765 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
766 return -E2BIG;
767 }
768 tmpbuf = memdup_user_nul(ubuf, len);
769 if (IS_ERR(tmpbuf))
770 return PTR_ERR(tmpbuf);
771 vpr_info("read %d bytes from userspace\n", (int)len);
772
773 ret = ddebug_exec_queries(tmpbuf, NULL);
774 kfree(tmpbuf);
775 if (ret < 0)
776 return ret;
777
778 *offp += len;
779 return len;
780 }
781
782 /*
783 * Set the iterator to point to the first _ddebug object
784 * and return a pointer to that first object. Returns
785 * NULL if there are no _ddebugs at all.
786 */
ddebug_iter_first(struct ddebug_iter * iter)787 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
788 {
789 if (list_empty(&ddebug_tables)) {
790 iter->table = NULL;
791 iter->idx = 0;
792 return NULL;
793 }
794 iter->table = list_entry(ddebug_tables.next,
795 struct ddebug_table, link);
796 iter->idx = 0;
797 return &iter->table->ddebugs[iter->idx];
798 }
799
800 /*
801 * Advance the iterator to point to the next _ddebug
802 * object from the one the iterator currently points at,
803 * and returns a pointer to the new _ddebug. Returns
804 * NULL if the iterator has seen all the _ddebugs.
805 */
ddebug_iter_next(struct ddebug_iter * iter)806 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
807 {
808 if (iter->table == NULL)
809 return NULL;
810 if (++iter->idx == iter->table->num_ddebugs) {
811 /* iterate to next table */
812 iter->idx = 0;
813 if (list_is_last(&iter->table->link, &ddebug_tables)) {
814 iter->table = NULL;
815 return NULL;
816 }
817 iter->table = list_entry(iter->table->link.next,
818 struct ddebug_table, link);
819 }
820 return &iter->table->ddebugs[iter->idx];
821 }
822
823 /*
824 * Seq_ops start method. Called at the start of every
825 * read() call from userspace. Takes the ddebug_lock and
826 * seeks the seq_file's iterator to the given position.
827 */
ddebug_proc_start(struct seq_file * m,loff_t * pos)828 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
829 {
830 struct ddebug_iter *iter = m->private;
831 struct _ddebug *dp;
832 int n = *pos;
833
834 mutex_lock(&ddebug_lock);
835
836 if (!n)
837 return SEQ_START_TOKEN;
838 if (n < 0)
839 return NULL;
840 dp = ddebug_iter_first(iter);
841 while (dp != NULL && --n > 0)
842 dp = ddebug_iter_next(iter);
843 return dp;
844 }
845
846 /*
847 * Seq_ops next method. Called several times within a read()
848 * call from userspace, with ddebug_lock held. Walks to the
849 * next _ddebug object with a special case for the header line.
850 */
ddebug_proc_next(struct seq_file * m,void * p,loff_t * pos)851 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
852 {
853 struct ddebug_iter *iter = m->private;
854 struct _ddebug *dp;
855
856 if (p == SEQ_START_TOKEN)
857 dp = ddebug_iter_first(iter);
858 else
859 dp = ddebug_iter_next(iter);
860 ++*pos;
861 return dp;
862 }
863
864 /*
865 * Seq_ops show method. Called several times within a read()
866 * call from userspace, with ddebug_lock held. Formats the
867 * current _ddebug as a single human-readable line, with a
868 * special case for the header line.
869 */
ddebug_proc_show(struct seq_file * m,void * p)870 static int ddebug_proc_show(struct seq_file *m, void *p)
871 {
872 struct ddebug_iter *iter = m->private;
873 struct _ddebug *dp = p;
874 struct flagsbuf flags;
875
876 if (p == SEQ_START_TOKEN) {
877 seq_puts(m,
878 "# filename:lineno [module]function flags format\n");
879 return 0;
880 }
881
882 seq_printf(m, "%s:%u [%s]%s =%s \"",
883 trim_prefix(dp->filename), dp->lineno,
884 iter->table->mod_name, dp->function,
885 ddebug_describe_flags(dp->flags, &flags));
886 seq_escape(m, dp->format, "\t\r\n\"");
887 seq_puts(m, "\"\n");
888
889 return 0;
890 }
891
892 /*
893 * Seq_ops stop method. Called at the end of each read()
894 * call from userspace. Drops ddebug_lock.
895 */
ddebug_proc_stop(struct seq_file * m,void * p)896 static void ddebug_proc_stop(struct seq_file *m, void *p)
897 {
898 mutex_unlock(&ddebug_lock);
899 }
900
901 static const struct seq_operations ddebug_proc_seqops = {
902 .start = ddebug_proc_start,
903 .next = ddebug_proc_next,
904 .show = ddebug_proc_show,
905 .stop = ddebug_proc_stop
906 };
907
ddebug_proc_open(struct inode * inode,struct file * file)908 static int ddebug_proc_open(struct inode *inode, struct file *file)
909 {
910 return seq_open_private(file, &ddebug_proc_seqops,
911 sizeof(struct ddebug_iter));
912 }
913
914 static const struct file_operations ddebug_proc_fops = {
915 .owner = THIS_MODULE,
916 .open = ddebug_proc_open,
917 .read = seq_read,
918 .llseek = seq_lseek,
919 .release = seq_release_private,
920 .write = ddebug_proc_write
921 };
922
923 static const struct proc_ops proc_fops = {
924 .proc_open = ddebug_proc_open,
925 .proc_read = seq_read,
926 .proc_lseek = seq_lseek,
927 .proc_release = seq_release_private,
928 .proc_write = ddebug_proc_write
929 };
930
931 /*
932 * Allocate a new ddebug_table for the given module
933 * and add it to the global list.
934 */
ddebug_add_module(struct _ddebug * tab,unsigned int n,const char * name)935 int ddebug_add_module(struct _ddebug *tab, unsigned int n,
936 const char *name)
937 {
938 struct ddebug_table *dt;
939
940 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
941 if (dt == NULL) {
942 pr_err("error adding module: %s\n", name);
943 return -ENOMEM;
944 }
945 /*
946 * For built-in modules, name lives in .rodata and is
947 * immortal. For loaded modules, name points at the name[]
948 * member of struct module, which lives at least as long as
949 * this struct ddebug_table.
950 */
951 dt->mod_name = name;
952 dt->num_ddebugs = n;
953 dt->ddebugs = tab;
954
955 mutex_lock(&ddebug_lock);
956 list_add(&dt->link, &ddebug_tables);
957 mutex_unlock(&ddebug_lock);
958
959 v2pr_info("%3u debug prints in module %s\n", n, dt->mod_name);
960 return 0;
961 }
962
963 /* helper for ddebug_dyndbg_(boot|module)_param_cb */
ddebug_dyndbg_param_cb(char * param,char * val,const char * modname,int on_err)964 static int ddebug_dyndbg_param_cb(char *param, char *val,
965 const char *modname, int on_err)
966 {
967 char *sep;
968
969 sep = strchr(param, '.');
970 if (sep) {
971 /* needed only for ddebug_dyndbg_boot_param_cb */
972 *sep = '\0';
973 modname = param;
974 param = sep + 1;
975 }
976 if (strcmp(param, "dyndbg"))
977 return on_err; /* determined by caller */
978
979 ddebug_exec_queries((val ? val : "+p"), modname);
980
981 return 0; /* query failure shouldn't stop module load */
982 }
983
984 /* handle both dyndbg and $module.dyndbg params at boot */
ddebug_dyndbg_boot_param_cb(char * param,char * val,const char * unused,void * arg)985 static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
986 const char *unused, void *arg)
987 {
988 vpr_info("%s=\"%s\"\n", param, val);
989 return ddebug_dyndbg_param_cb(param, val, NULL, 0);
990 }
991
992 /*
993 * modprobe foo finds foo.params in boot-args, strips "foo.", and
994 * passes them to load_module(). This callback gets unknown params,
995 * processes dyndbg params, rejects others.
996 */
ddebug_dyndbg_module_param_cb(char * param,char * val,const char * module)997 int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
998 {
999 vpr_info("module: %s %s=\"%s\"\n", module, param, val);
1000 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
1001 }
1002
ddebug_table_free(struct ddebug_table * dt)1003 static void ddebug_table_free(struct ddebug_table *dt)
1004 {
1005 list_del_init(&dt->link);
1006 kfree(dt);
1007 }
1008
1009 /*
1010 * Called in response to a module being unloaded. Removes
1011 * any ddebug_table's which point at the module.
1012 */
ddebug_remove_module(const char * mod_name)1013 int ddebug_remove_module(const char *mod_name)
1014 {
1015 struct ddebug_table *dt, *nextdt;
1016 int ret = -ENOENT;
1017
1018 v2pr_info("removing module \"%s\"\n", mod_name);
1019
1020 mutex_lock(&ddebug_lock);
1021 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
1022 if (dt->mod_name == mod_name) {
1023 ddebug_table_free(dt);
1024 ret = 0;
1025 break;
1026 }
1027 }
1028 mutex_unlock(&ddebug_lock);
1029 return ret;
1030 }
1031
ddebug_remove_all_tables(void)1032 static void ddebug_remove_all_tables(void)
1033 {
1034 mutex_lock(&ddebug_lock);
1035 while (!list_empty(&ddebug_tables)) {
1036 struct ddebug_table *dt = list_entry(ddebug_tables.next,
1037 struct ddebug_table,
1038 link);
1039 ddebug_table_free(dt);
1040 }
1041 mutex_unlock(&ddebug_lock);
1042 }
1043
1044 static __initdata int ddebug_init_success;
1045
dynamic_debug_init_control(void)1046 static int __init dynamic_debug_init_control(void)
1047 {
1048 struct proc_dir_entry *procfs_dir;
1049 struct dentry *debugfs_dir;
1050
1051 if (!ddebug_init_success)
1052 return -ENODEV;
1053
1054 /* Create the control file in debugfs if it is enabled */
1055 if (debugfs_initialized()) {
1056 debugfs_dir = debugfs_create_dir("dynamic_debug", NULL);
1057 debugfs_create_file("control", 0644, debugfs_dir, NULL,
1058 &ddebug_proc_fops);
1059 }
1060
1061 /* Also create the control file in procfs */
1062 procfs_dir = proc_mkdir("dynamic_debug", NULL);
1063 if (procfs_dir)
1064 proc_create("control", 0644, procfs_dir, &proc_fops);
1065
1066 return 0;
1067 }
1068
dynamic_debug_init(void)1069 static int __init dynamic_debug_init(void)
1070 {
1071 struct _ddebug *iter, *iter_start;
1072 const char *modname = NULL;
1073 char *cmdline;
1074 int ret = 0;
1075 int n = 0, entries = 0, modct = 0;
1076
1077 if (&__start___dyndbg == &__stop___dyndbg) {
1078 if (IS_ENABLED(CONFIG_DYNAMIC_DEBUG)) {
1079 pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
1080 return 1;
1081 }
1082 pr_info("Ignore empty _ddebug table in a CONFIG_DYNAMIC_DEBUG_CORE build\n");
1083 ddebug_init_success = 1;
1084 return 0;
1085 }
1086 iter = __start___dyndbg;
1087 modname = iter->modname;
1088 iter_start = iter;
1089 for (; iter < __stop___dyndbg; iter++) {
1090 entries++;
1091 if (strcmp(modname, iter->modname)) {
1092 modct++;
1093 ret = ddebug_add_module(iter_start, n, modname);
1094 if (ret)
1095 goto out_err;
1096 n = 0;
1097 modname = iter->modname;
1098 iter_start = iter;
1099 }
1100 n++;
1101 }
1102 ret = ddebug_add_module(iter_start, n, modname);
1103 if (ret)
1104 goto out_err;
1105
1106 ddebug_init_success = 1;
1107 vpr_info("%d prdebugs in %d modules, %d KiB in ddebug tables, %d kiB in __dyndbg section\n",
1108 entries, modct, (int)((modct * sizeof(struct ddebug_table)) >> 10),
1109 (int)((entries * sizeof(struct _ddebug)) >> 10));
1110
1111 /* apply ddebug_query boot param, dont unload tables on err */
1112 if (ddebug_setup_string[0] != '\0') {
1113 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
1114 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
1115 if (ret < 0)
1116 pr_warn("Invalid ddebug boot param %s\n",
1117 ddebug_setup_string);
1118 else
1119 pr_info("%d changes by ddebug_query\n", ret);
1120 }
1121 /* now that ddebug tables are loaded, process all boot args
1122 * again to find and activate queries given in dyndbg params.
1123 * While this has already been done for known boot params, it
1124 * ignored the unknown ones (dyndbg in particular). Reusing
1125 * parse_args avoids ad-hoc parsing. This will also attempt
1126 * to activate queries for not-yet-loaded modules, which is
1127 * slightly noisy if verbose, but harmless.
1128 */
1129 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1130 parse_args("dyndbg params", cmdline, NULL,
1131 0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
1132 kfree(cmdline);
1133 return 0;
1134
1135 out_err:
1136 ddebug_remove_all_tables();
1137 return 0;
1138 }
1139 /* Allow early initialization for boot messages via boot param */
1140 early_initcall(dynamic_debug_init);
1141
1142 /* Debugfs setup must be done later */
1143 fs_initcall(dynamic_debug_init_control);
1144