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