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