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