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