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