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