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