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