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) "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 char *keyword = words[i];
388 char *arg = words[i+1];
389
390 if (!strcmp(keyword, "func")) {
391 rc = check_set(&query->function, arg, "func");
392 } else if (!strcmp(keyword, "file")) {
393 if (check_set(&query->filename, arg, "file"))
394 return -EINVAL;
395
396 /* tail :$info is function or line-range */
397 fline = strchr(query->filename, ':');
398 if (!fline)
399 continue;
400 *fline++ = '\0';
401 if (isalpha(*fline) || *fline == '*' || *fline == '?') {
402 /* take as function name */
403 if (check_set(&query->function, fline, "func"))
404 return -EINVAL;
405 } else {
406 if (parse_linerange(query, fline))
407 return -EINVAL;
408 }
409 } else if (!strcmp(keyword, "module")) {
410 rc = check_set(&query->module, arg, "module");
411 } else if (!strcmp(keyword, "format")) {
412 string_unescape_inplace(arg, UNESCAPE_SPACE |
413 UNESCAPE_OCTAL |
414 UNESCAPE_SPECIAL);
415 rc = check_set(&query->format, arg, "format");
416 } else if (!strcmp(keyword, "line")) {
417 if (parse_linerange(query, arg))
418 return -EINVAL;
419 } else {
420 pr_err("unknown keyword \"%s\"\n", keyword);
421 return -EINVAL;
422 }
423 if (rc)
424 return rc;
425 }
426 vpr_info_dq(query, "parsed");
427 return 0;
428}
429
430/*
431 * Parse `str' as a flags specification, format [-+=][p]+.
432 * Sets up *maskp and *flagsp to be used when changing the
433 * flags fields of matched _ddebug's. Returns 0 on success
434 * or <0 on error.
435 */
436static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers)
437{
438 int op, i;
439
440 switch (*str) {
441 case '+':
442 case '-':
443 case '=':
444 op = *str++;
445 break;
446 default:
447 pr_err("bad flag-op %c, at start of %s\n", *str, str);
448 return -EINVAL;
449 }
450 vpr_info("op='%c'\n", op);
451
452 for (; *str ; ++str) {
453 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
454 if (*str == opt_array[i].opt_char) {
455 modifiers->flags |= opt_array[i].flag;
456 break;
457 }
458 }
459 if (i < 0) {
460 pr_err("unknown flag '%c'\n", *str);
461 return -EINVAL;
462 }
463 }
464 vpr_info("flags=0x%x\n", modifiers->flags);
465
466 /* calculate final flags, mask based upon op */
467 switch (op) {
468 case '=':
469 /* modifiers->flags already set */
470 modifiers->mask = 0;
471 break;
472 case '+':
473 modifiers->mask = ~0U;
474 break;
475 case '-':
476 modifiers->mask = ~modifiers->flags;
477 modifiers->flags = 0;
478 break;
479 }
480 vpr_info("*flagsp=0x%x *maskp=0x%x\n", modifiers->flags, modifiers->mask);
481
482 return 0;
483}
484
485static int ddebug_exec_query(char *query_string, const char *modname)
486{
487 struct flag_settings modifiers = {};
488 struct ddebug_query query = {};
489#define MAXWORDS 9
490 int nwords, nfound;
491 char *words[MAXWORDS];
492
493 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
494 if (nwords <= 0) {
495 pr_err("tokenize failed\n");
496 return -EINVAL;
497 }
498 /* check flags 1st (last arg) so query is pairs of spec,val */
499 if (ddebug_parse_flags(words[nwords-1], &modifiers)) {
500 pr_err("flags parse failed\n");
501 return -EINVAL;
502 }
503 if (ddebug_parse_query(words, nwords-1, &query, modname)) {
504 pr_err("query parse failed\n");
505 return -EINVAL;
506 }
507 /* actually go and implement the change */
508 nfound = ddebug_change(&query, &modifiers);
509 vpr_info_dq(&query, nfound ? "applied" : "no-match");
510
511 return nfound;
512}
513
514/* handle multiple queries in query string, continue on error, return
515 last error or number of matching callsites. Module name is either
516 in param (for boot arg) or perhaps in query string.
517*/
518static int ddebug_exec_queries(char *query, const char *modname)
519{
520 char *split;
521 int i, errs = 0, exitcode = 0, rc, nfound = 0;
522
523 for (i = 0; query; query = split) {
524 split = strpbrk(query, ";\n");
525 if (split)
526 *split++ = '\0';
527
528 query = skip_spaces(query);
529 if (!query || !*query || *query == '#')
530 continue;
531
532 vpr_info("query %d: \"%s\"\n", i, query);
533
534 rc = ddebug_exec_query(query, modname);
535 if (rc < 0) {
536 errs++;
537 exitcode = rc;
538 } else {
539 nfound += rc;
540 }
541 i++;
542 }
543 vpr_info("processed %d queries, with %d matches, %d errs\n",
544 i, nfound, errs);
545
546 if (exitcode)
547 return exitcode;
548 return nfound;
549}
550
551/**
552 * dynamic_debug_exec_queries - select and change dynamic-debug prints
553 * @query: query-string described in admin-guide/dynamic-debug-howto
554 * @modname: string containing module name, usually &module.mod_name
555 *
556 * This uses the >/proc/dynamic_debug/control reader, allowing module
557 * authors to modify their dynamic-debug callsites. The modname is
558 * canonically struct module.mod_name, but can also be null or a
559 * module-wildcard, for example: "drm*".
560 */
561int dynamic_debug_exec_queries(const char *query, const char *modname)
562{
563 int rc;
564 char *qry; /* writable copy of query */
565
566 if (!query) {
567 pr_err("non-null query/command string expected\n");
568 return -EINVAL;
569 }
570 qry = kstrndup(query, PAGE_SIZE, GFP_KERNEL);
571 if (!qry)
572 return -ENOMEM;
573
574 rc = ddebug_exec_queries(qry, modname);
575 kfree(qry);
576 return rc;
577}
578EXPORT_SYMBOL_GPL(dynamic_debug_exec_queries);
579
580#define PREFIX_SIZE 64
581
582static int remaining(int wrote)
583{
584 if (PREFIX_SIZE - wrote > 0)
585 return PREFIX_SIZE - wrote;
586 return 0;
587}
588
589static char *__dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
590{
591 int pos_after_tid;
592 int pos = 0;
593
594 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
595 if (in_interrupt())
596 pos += snprintf(buf + pos, remaining(pos), "<intr> ");
597 else
598 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
599 task_pid_vnr(current));
600 }
601 pos_after_tid = pos;
602 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
603 pos += snprintf(buf + pos, remaining(pos), "%s:",
604 desc->modname);
605 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
606 pos += snprintf(buf + pos, remaining(pos), "%s:",
607 desc->function);
608 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
609 pos += snprintf(buf + pos, remaining(pos), "%d:",
610 desc->lineno);
611 if (pos - pos_after_tid)
612 pos += snprintf(buf + pos, remaining(pos), " ");
613 if (pos >= PREFIX_SIZE)
614 buf[PREFIX_SIZE - 1] = '\0';
615
616 return buf;
617}
618
619static inline char *dynamic_emit_prefix(struct _ddebug *desc, char *buf)
620{
621 if (unlikely(desc->flags & _DPRINTK_FLAGS_INCL_ANY))
622 return __dynamic_emit_prefix(desc, buf);
623 return buf;
624}
625
626void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
627{
628 va_list args;
629 struct va_format vaf;
630 char buf[PREFIX_SIZE] = "";
631
632 BUG_ON(!descriptor);
633 BUG_ON(!fmt);
634
635 va_start(args, fmt);
636
637 vaf.fmt = fmt;
638 vaf.va = &args;
639
640 printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
641
642 va_end(args);
643}
644EXPORT_SYMBOL(__dynamic_pr_debug);
645
646void __dynamic_dev_dbg(struct _ddebug *descriptor,
647 const struct device *dev, const char *fmt, ...)
648{
649 struct va_format vaf;
650 va_list args;
651
652 BUG_ON(!descriptor);
653 BUG_ON(!fmt);
654
655 va_start(args, fmt);
656
657 vaf.fmt = fmt;
658 vaf.va = &args;
659
660 if (!dev) {
661 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
662 } else {
663 char buf[PREFIX_SIZE] = "";
664
665 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
666 dynamic_emit_prefix(descriptor, buf),
667 dev_driver_string(dev), dev_name(dev),
668 &vaf);
669 }
670
671 va_end(args);
672}
673EXPORT_SYMBOL(__dynamic_dev_dbg);
674
675#ifdef CONFIG_NET
676
677void __dynamic_netdev_dbg(struct _ddebug *descriptor,
678 const struct net_device *dev, const char *fmt, ...)
679{
680 struct va_format vaf;
681 va_list args;
682
683 BUG_ON(!descriptor);
684 BUG_ON(!fmt);
685
686 va_start(args, fmt);
687
688 vaf.fmt = fmt;
689 vaf.va = &args;
690
691 if (dev && dev->dev.parent) {
692 char buf[PREFIX_SIZE] = "";
693
694 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
695 "%s%s %s %s%s: %pV",
696 dynamic_emit_prefix(descriptor, buf),
697 dev_driver_string(dev->dev.parent),
698 dev_name(dev->dev.parent),
699 netdev_name(dev), netdev_reg_state(dev),
700 &vaf);
701 } else if (dev) {
702 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
703 netdev_reg_state(dev), &vaf);
704 } else {
705 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
706 }
707
708 va_end(args);
709}
710EXPORT_SYMBOL(__dynamic_netdev_dbg);
711
712#endif
713
714#if IS_ENABLED(CONFIG_INFINIBAND)
715
716void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
717 const struct ib_device *ibdev, const char *fmt, ...)
718{
719 struct va_format vaf;
720 va_list args;
721
722 va_start(args, fmt);
723
724 vaf.fmt = fmt;
725 vaf.va = &args;
726
727 if (ibdev && ibdev->dev.parent) {
728 char buf[PREFIX_SIZE] = "";
729
730 dev_printk_emit(LOGLEVEL_DEBUG, ibdev->dev.parent,
731 "%s%s %s %s: %pV",
732 dynamic_emit_prefix(descriptor, buf),
733 dev_driver_string(ibdev->dev.parent),
734 dev_name(ibdev->dev.parent),
735 dev_name(&ibdev->dev),
736 &vaf);
737 } else if (ibdev) {
738 printk(KERN_DEBUG "%s: %pV", dev_name(&ibdev->dev), &vaf);
739 } else {
740 printk(KERN_DEBUG "(NULL ib_device): %pV", &vaf);
741 }
742
743 va_end(args);
744}
745EXPORT_SYMBOL(__dynamic_ibdev_dbg);
746
747#endif
748
749#define DDEBUG_STRING_SIZE 1024
750static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
751
752static __init int ddebug_setup_query(char *str)
753{
754 if (strlen(str) >= DDEBUG_STRING_SIZE) {
755 pr_warn("ddebug boot param string too large\n");
756 return 0;
757 }
758 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
759 return 1;
760}
761
762__setup("ddebug_query=", ddebug_setup_query);
763
764/*
765 * File_ops->write method for <debugfs>/dynamic_debug/control. Gathers the
766 * command text from userspace, parses and executes it.
767 */
768#define USER_BUF_PAGE 4096
769static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
770 size_t len, loff_t *offp)
771{
772 char *tmpbuf;
773 int ret;
774
775 if (len == 0)
776 return 0;
777 if (len > USER_BUF_PAGE - 1) {
778 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
779 return -E2BIG;
780 }
781 tmpbuf = memdup_user_nul(ubuf, len);
782 if (IS_ERR(tmpbuf))
783 return PTR_ERR(tmpbuf);
784 vpr_info("read %d bytes from userspace\n", (int)len);
785
786 ret = ddebug_exec_queries(tmpbuf, NULL);
787 kfree(tmpbuf);
788 if (ret < 0)
789 return ret;
790
791 *offp += len;
792 return len;
793}
794
795/*
796 * Set the iterator to point to the first _ddebug object
797 * and return a pointer to that first object. Returns
798 * NULL if there are no _ddebugs at all.
799 */
800static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
801{
802 if (list_empty(&ddebug_tables)) {
803 iter->table = NULL;
804 iter->idx = 0;
805 return NULL;
806 }
807 iter->table = list_entry(ddebug_tables.next,
808 struct ddebug_table, link);
809 iter->idx = 0;
810 return &iter->table->ddebugs[iter->idx];
811}
812
813/*
814 * Advance the iterator to point to the next _ddebug
815 * object from the one the iterator currently points at,
816 * and returns a pointer to the new _ddebug. Returns
817 * NULL if the iterator has seen all the _ddebugs.
818 */
819static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
820{
821 if (iter->table == NULL)
822 return NULL;
823 if (++iter->idx == iter->table->num_ddebugs) {
824 /* iterate to next table */
825 iter->idx = 0;
826 if (list_is_last(&iter->table->link, &ddebug_tables)) {
827 iter->table = NULL;
828 return NULL;
829 }
830 iter->table = list_entry(iter->table->link.next,
831 struct ddebug_table, link);
832 }
833 return &iter->table->ddebugs[iter->idx];
834}
835
836/*
837 * Seq_ops start method. Called at the start of every
838 * read() call from userspace. Takes the ddebug_lock and
839 * seeks the seq_file's iterator to the given position.
840 */
841static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
842{
843 struct ddebug_iter *iter = m->private;
844 struct _ddebug *dp;
845 int n = *pos;
846
847 mutex_lock(&ddebug_lock);
848
849 if (!n)
850 return SEQ_START_TOKEN;
851 if (n < 0)
852 return NULL;
853 dp = ddebug_iter_first(iter);
854 while (dp != NULL && --n > 0)
855 dp = ddebug_iter_next(iter);
856 return dp;
857}
858
859/*
860 * Seq_ops next method. Called several times within a read()
861 * call from userspace, with ddebug_lock held. Walks to the
862 * next _ddebug object with a special case for the header line.
863 */
864static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
865{
866 struct ddebug_iter *iter = m->private;
867 struct _ddebug *dp;
868
869 if (p == SEQ_START_TOKEN)
870 dp = ddebug_iter_first(iter);
871 else
872 dp = ddebug_iter_next(iter);
873 ++*pos;
874 return dp;
875}
876
877/*
878 * Seq_ops show method. Called several times within a read()
879 * call from userspace, with ddebug_lock held. Formats the
880 * current _ddebug as a single human-readable line, with a
881 * special case for the header line.
882 */
883static int ddebug_proc_show(struct seq_file *m, void *p)
884{
885 struct ddebug_iter *iter = m->private;
886 struct _ddebug *dp = p;
887 struct flagsbuf flags;
888
889 if (p == SEQ_START_TOKEN) {
890 seq_puts(m,
891 "# filename:lineno [module]function flags format\n");
892 return 0;
893 }
894
895 seq_printf(m, "%s:%u [%s]%s =%s \"",
896 trim_prefix(dp->filename), dp->lineno,
897 iter->table->mod_name, dp->function,
898 ddebug_describe_flags(dp->flags, &flags));
899 seq_escape(m, dp->format, "\t\r\n\"");
900 seq_puts(m, "\"\n");
901
902 return 0;
903}
904
905/*
906 * Seq_ops stop method. Called at the end of each read()
907 * call from userspace. Drops ddebug_lock.
908 */
909static void ddebug_proc_stop(struct seq_file *m, void *p)
910{
911 mutex_unlock(&ddebug_lock);
912}
913
914static const struct seq_operations ddebug_proc_seqops = {
915 .start = ddebug_proc_start,
916 .next = ddebug_proc_next,
917 .show = ddebug_proc_show,
918 .stop = ddebug_proc_stop
919};
920
921static int ddebug_proc_open(struct inode *inode, struct file *file)
922{
923 return seq_open_private(file, &ddebug_proc_seqops,
924 sizeof(struct ddebug_iter));
925}
926
927static const struct file_operations ddebug_proc_fops = {
928 .owner = THIS_MODULE,
929 .open = ddebug_proc_open,
930 .read = seq_read,
931 .llseek = seq_lseek,
932 .release = seq_release_private,
933 .write = ddebug_proc_write
934};
935
936static const struct proc_ops proc_fops = {
937 .proc_open = ddebug_proc_open,
938 .proc_read = seq_read,
939 .proc_lseek = seq_lseek,
940 .proc_release = seq_release_private,
941 .proc_write = ddebug_proc_write
942};
943
944/*
945 * Allocate a new ddebug_table for the given module
946 * and add it to the global list.
947 */
948int ddebug_add_module(struct _ddebug *tab, unsigned int n,
949 const char *name)
950{
951 struct ddebug_table *dt;
952
953 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
954 if (dt == NULL) {
955 pr_err("error adding module: %s\n", name);
956 return -ENOMEM;
957 }
958 /*
959 * For built-in modules, name lives in .rodata and is
960 * immortal. For loaded modules, name points at the name[]
961 * member of struct module, which lives at least as long as
962 * this struct ddebug_table.
963 */
964 dt->mod_name = name;
965 dt->num_ddebugs = n;
966 dt->ddebugs = tab;
967
968 mutex_lock(&ddebug_lock);
969 list_add(&dt->link, &ddebug_tables);
970 mutex_unlock(&ddebug_lock);
971
972 v2pr_info("%3u debug prints in module %s\n", n, dt->mod_name);
973 return 0;
974}
975
976/* helper for ddebug_dyndbg_(boot|module)_param_cb */
977static int ddebug_dyndbg_param_cb(char *param, char *val,
978 const char *modname, int on_err)
979{
980 char *sep;
981
982 sep = strchr(param, '.');
983 if (sep) {
984 /* needed only for ddebug_dyndbg_boot_param_cb */
985 *sep = '\0';
986 modname = param;
987 param = sep + 1;
988 }
989 if (strcmp(param, "dyndbg"))
990 return on_err; /* determined by caller */
991
992 ddebug_exec_queries((val ? val : "+p"), modname);
993
994 return 0; /* query failure shouldn't stop module load */
995}
996
997/* handle both dyndbg and $module.dyndbg params at boot */
998static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
999 const char *unused, void *arg)
1000{
1001 vpr_info("%s=\"%s\"\n", param, val);
1002 return ddebug_dyndbg_param_cb(param, val, NULL, 0);
1003}
1004
1005/*
1006 * modprobe foo finds foo.params in boot-args, strips "foo.", and
1007 * passes them to load_module(). This callback gets unknown params,
1008 * processes dyndbg params, rejects others.
1009 */
1010int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
1011{
1012 vpr_info("module: %s %s=\"%s\"\n", module, param, val);
1013 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
1014}
1015
1016static void ddebug_table_free(struct ddebug_table *dt)
1017{
1018 list_del_init(&dt->link);
1019 kfree(dt);
1020}
1021
1022/*
1023 * Called in response to a module being unloaded. Removes
1024 * any ddebug_table's which point at the module.
1025 */
1026int ddebug_remove_module(const char *mod_name)
1027{
1028 struct ddebug_table *dt, *nextdt;
1029 int ret = -ENOENT;
1030
1031 v2pr_info("removing module \"%s\"\n", mod_name);
1032
1033 mutex_lock(&ddebug_lock);
1034 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
1035 if (dt->mod_name == mod_name) {
1036 ddebug_table_free(dt);
1037 ret = 0;
1038 break;
1039 }
1040 }
1041 mutex_unlock(&ddebug_lock);
1042 return ret;
1043}
1044
1045static void ddebug_remove_all_tables(void)
1046{
1047 mutex_lock(&ddebug_lock);
1048 while (!list_empty(&ddebug_tables)) {
1049 struct ddebug_table *dt = list_entry(ddebug_tables.next,
1050 struct ddebug_table,
1051 link);
1052 ddebug_table_free(dt);
1053 }
1054 mutex_unlock(&ddebug_lock);
1055}
1056
1057static __initdata int ddebug_init_success;
1058
1059static int __init dynamic_debug_init_control(void)
1060{
1061 struct proc_dir_entry *procfs_dir;
1062 struct dentry *debugfs_dir;
1063
1064 if (!ddebug_init_success)
1065 return -ENODEV;
1066
1067 /* Create the control file in debugfs if it is enabled */
1068 if (debugfs_initialized()) {
1069 debugfs_dir = debugfs_create_dir("dynamic_debug", NULL);
1070 debugfs_create_file("control", 0644, debugfs_dir, NULL,
1071 &ddebug_proc_fops);
1072 }
1073
1074 /* Also create the control file in procfs */
1075 procfs_dir = proc_mkdir("dynamic_debug", NULL);
1076 if (procfs_dir)
1077 proc_create("control", 0644, procfs_dir, &proc_fops);
1078
1079 return 0;
1080}
1081
1082static int __init dynamic_debug_init(void)
1083{
1084 struct _ddebug *iter, *iter_start;
1085 const char *modname = NULL;
1086 char *cmdline;
1087 int ret = 0;
1088 int n = 0, entries = 0, modct = 0;
1089
1090 if (&__start___dyndbg == &__stop___dyndbg) {
1091 if (IS_ENABLED(CONFIG_DYNAMIC_DEBUG)) {
1092 pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
1093 return 1;
1094 }
1095 pr_info("Ignore empty _ddebug table in a CONFIG_DYNAMIC_DEBUG_CORE build\n");
1096 ddebug_init_success = 1;
1097 return 0;
1098 }
1099 iter = __start___dyndbg;
1100 modname = iter->modname;
1101 iter_start = iter;
1102 for (; iter < __stop___dyndbg; iter++) {
1103 entries++;
1104 if (strcmp(modname, iter->modname)) {
1105 modct++;
1106 ret = ddebug_add_module(iter_start, n, modname);
1107 if (ret)
1108 goto out_err;
1109 n = 0;
1110 modname = iter->modname;
1111 iter_start = iter;
1112 }
1113 n++;
1114 }
1115 ret = ddebug_add_module(iter_start, n, modname);
1116 if (ret)
1117 goto out_err;
1118
1119 ddebug_init_success = 1;
1120 vpr_info("%d prdebugs in %d modules, %d KiB in ddebug tables, %d kiB in __dyndbg section\n",
1121 entries, modct, (int)((modct * sizeof(struct ddebug_table)) >> 10),
1122 (int)((entries * sizeof(struct _ddebug)) >> 10));
1123
1124 /* apply ddebug_query boot param, dont unload tables on err */
1125 if (ddebug_setup_string[0] != '\0') {
1126 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
1127 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
1128 if (ret < 0)
1129 pr_warn("Invalid ddebug boot param %s\n",
1130 ddebug_setup_string);
1131 else
1132 pr_info("%d changes by ddebug_query\n", ret);
1133 }
1134 /* now that ddebug tables are loaded, process all boot args
1135 * again to find and activate queries given in dyndbg params.
1136 * While this has already been done for known boot params, it
1137 * ignored the unknown ones (dyndbg in particular). Reusing
1138 * parse_args avoids ad-hoc parsing. This will also attempt
1139 * to activate queries for not-yet-loaded modules, which is
1140 * slightly noisy if verbose, but harmless.
1141 */
1142 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1143 parse_args("dyndbg params", cmdline, NULL,
1144 0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
1145 kfree(cmdline);
1146 return 0;
1147
1148out_err:
1149 ddebug_remove_all_tables();
1150 return 0;
1151}
1152/* Allow early initialization for boot messages via boot param */
1153early_initcall(dynamic_debug_init);
1154
1155/* Debugfs setup must be done later */
1156fs_initcall(dynamic_debug_init_control);
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 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
540void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
541{
542 va_list args;
543 struct va_format vaf;
544 char buf[PREFIX_SIZE];
545
546 BUG_ON(!descriptor);
547 BUG_ON(!fmt);
548
549 va_start(args, fmt);
550
551 vaf.fmt = fmt;
552 vaf.va = &args;
553
554 printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
555
556 va_end(args);
557}
558EXPORT_SYMBOL(__dynamic_pr_debug);
559
560void __dynamic_dev_dbg(struct _ddebug *descriptor,
561 const struct device *dev, const char *fmt, ...)
562{
563 struct va_format vaf;
564 va_list args;
565
566 BUG_ON(!descriptor);
567 BUG_ON(!fmt);
568
569 va_start(args, fmt);
570
571 vaf.fmt = fmt;
572 vaf.va = &args;
573
574 if (!dev) {
575 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
576 } else {
577 char buf[PREFIX_SIZE];
578
579 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
580 dynamic_emit_prefix(descriptor, buf),
581 dev_driver_string(dev), dev_name(dev),
582 &vaf);
583 }
584
585 va_end(args);
586}
587EXPORT_SYMBOL(__dynamic_dev_dbg);
588
589#ifdef CONFIG_NET
590
591void __dynamic_netdev_dbg(struct _ddebug *descriptor,
592 const struct net_device *dev, const char *fmt, ...)
593{
594 struct va_format vaf;
595 va_list args;
596
597 BUG_ON(!descriptor);
598 BUG_ON(!fmt);
599
600 va_start(args, fmt);
601
602 vaf.fmt = fmt;
603 vaf.va = &args;
604
605 if (dev && dev->dev.parent) {
606 char buf[PREFIX_SIZE];
607
608 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
609 "%s%s %s %s%s: %pV",
610 dynamic_emit_prefix(descriptor, buf),
611 dev_driver_string(dev->dev.parent),
612 dev_name(dev->dev.parent),
613 netdev_name(dev), netdev_reg_state(dev),
614 &vaf);
615 } else if (dev) {
616 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
617 netdev_reg_state(dev), &vaf);
618 } else {
619 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
620 }
621
622 va_end(args);
623}
624EXPORT_SYMBOL(__dynamic_netdev_dbg);
625
626#endif
627
628#define DDEBUG_STRING_SIZE 1024
629static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
630
631static __init int ddebug_setup_query(char *str)
632{
633 if (strlen(str) >= DDEBUG_STRING_SIZE) {
634 pr_warn("ddebug boot param string too large\n");
635 return 0;
636 }
637 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
638 return 1;
639}
640
641__setup("ddebug_query=", ddebug_setup_query);
642
643/*
644 * File_ops->write method for <debugfs>/dynamic_debug/control. Gathers the
645 * command text from userspace, parses and executes it.
646 */
647#define USER_BUF_PAGE 4096
648static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
649 size_t len, loff_t *offp)
650{
651 char *tmpbuf;
652 int ret;
653
654 if (len == 0)
655 return 0;
656 if (len > USER_BUF_PAGE - 1) {
657 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
658 return -E2BIG;
659 }
660 tmpbuf = memdup_user_nul(ubuf, len);
661 if (IS_ERR(tmpbuf))
662 return PTR_ERR(tmpbuf);
663 vpr_info("read %d bytes from userspace\n", (int)len);
664
665 ret = ddebug_exec_queries(tmpbuf, NULL);
666 kfree(tmpbuf);
667 if (ret < 0)
668 return ret;
669
670 *offp += len;
671 return len;
672}
673
674/*
675 * Set the iterator to point to the first _ddebug object
676 * and return a pointer to that first object. Returns
677 * NULL if there are no _ddebugs at all.
678 */
679static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
680{
681 if (list_empty(&ddebug_tables)) {
682 iter->table = NULL;
683 iter->idx = 0;
684 return NULL;
685 }
686 iter->table = list_entry(ddebug_tables.next,
687 struct ddebug_table, link);
688 iter->idx = 0;
689 return &iter->table->ddebugs[iter->idx];
690}
691
692/*
693 * Advance the iterator to point to the next _ddebug
694 * object from the one the iterator currently points at,
695 * and returns a pointer to the new _ddebug. Returns
696 * NULL if the iterator has seen all the _ddebugs.
697 */
698static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
699{
700 if (iter->table == NULL)
701 return NULL;
702 if (++iter->idx == iter->table->num_ddebugs) {
703 /* iterate to next table */
704 iter->idx = 0;
705 if (list_is_last(&iter->table->link, &ddebug_tables)) {
706 iter->table = NULL;
707 return NULL;
708 }
709 iter->table = list_entry(iter->table->link.next,
710 struct ddebug_table, link);
711 }
712 return &iter->table->ddebugs[iter->idx];
713}
714
715/*
716 * Seq_ops start method. Called at the start of every
717 * read() call from userspace. Takes the ddebug_lock and
718 * seeks the seq_file's iterator to the given position.
719 */
720static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
721{
722 struct ddebug_iter *iter = m->private;
723 struct _ddebug *dp;
724 int n = *pos;
725
726 vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
727
728 mutex_lock(&ddebug_lock);
729
730 if (!n)
731 return SEQ_START_TOKEN;
732 if (n < 0)
733 return NULL;
734 dp = ddebug_iter_first(iter);
735 while (dp != NULL && --n > 0)
736 dp = ddebug_iter_next(iter);
737 return dp;
738}
739
740/*
741 * Seq_ops next method. Called several times within a read()
742 * call from userspace, with ddebug_lock held. Walks to the
743 * next _ddebug object with a special case for the header line.
744 */
745static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
746{
747 struct ddebug_iter *iter = m->private;
748 struct _ddebug *dp;
749
750 vpr_info("called m=%p p=%p *pos=%lld\n",
751 m, p, (unsigned long long)*pos);
752
753 if (p == SEQ_START_TOKEN)
754 dp = ddebug_iter_first(iter);
755 else
756 dp = ddebug_iter_next(iter);
757 ++*pos;
758 return dp;
759}
760
761/*
762 * Seq_ops show method. Called several times within a read()
763 * call from userspace, with ddebug_lock held. Formats the
764 * current _ddebug as a single human-readable line, with a
765 * special case for the header line.
766 */
767static int ddebug_proc_show(struct seq_file *m, void *p)
768{
769 struct ddebug_iter *iter = m->private;
770 struct _ddebug *dp = p;
771 char flagsbuf[10];
772
773 vpr_info("called m=%p p=%p\n", m, p);
774
775 if (p == SEQ_START_TOKEN) {
776 seq_puts(m,
777 "# filename:lineno [module]function flags format\n");
778 return 0;
779 }
780
781 seq_printf(m, "%s:%u [%s]%s =%s \"",
782 trim_prefix(dp->filename), dp->lineno,
783 iter->table->mod_name, dp->function,
784 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
785 seq_escape(m, dp->format, "\t\r\n\"");
786 seq_puts(m, "\"\n");
787
788 return 0;
789}
790
791/*
792 * Seq_ops stop method. Called at the end of each read()
793 * call from userspace. Drops ddebug_lock.
794 */
795static void ddebug_proc_stop(struct seq_file *m, void *p)
796{
797 vpr_info("called m=%p p=%p\n", m, p);
798 mutex_unlock(&ddebug_lock);
799}
800
801static const struct seq_operations ddebug_proc_seqops = {
802 .start = ddebug_proc_start,
803 .next = ddebug_proc_next,
804 .show = ddebug_proc_show,
805 .stop = ddebug_proc_stop
806};
807
808/*
809 * File_ops->open method for <debugfs>/dynamic_debug/control. Does
810 * the seq_file setup dance, and also creates an iterator to walk the
811 * _ddebugs. Note that we create a seq_file always, even for O_WRONLY
812 * files where it's not needed, as doing so simplifies the ->release
813 * method.
814 */
815static int ddebug_proc_open(struct inode *inode, struct file *file)
816{
817 vpr_info("called\n");
818 return seq_open_private(file, &ddebug_proc_seqops,
819 sizeof(struct ddebug_iter));
820}
821
822static const struct file_operations ddebug_proc_fops = {
823 .owner = THIS_MODULE,
824 .open = ddebug_proc_open,
825 .read = seq_read,
826 .llseek = seq_lseek,
827 .release = seq_release_private,
828 .write = ddebug_proc_write
829};
830
831/*
832 * Allocate a new ddebug_table for the given module
833 * and add it to the global list.
834 */
835int ddebug_add_module(struct _ddebug *tab, unsigned int n,
836 const char *name)
837{
838 struct ddebug_table *dt;
839 const char *new_name;
840
841 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
842 if (dt == NULL)
843 return -ENOMEM;
844 new_name = kstrdup_const(name, GFP_KERNEL);
845 if (new_name == NULL) {
846 kfree(dt);
847 return -ENOMEM;
848 }
849 dt->mod_name = new_name;
850 dt->num_ddebugs = n;
851 dt->ddebugs = tab;
852
853 mutex_lock(&ddebug_lock);
854 list_add_tail(&dt->link, &ddebug_tables);
855 mutex_unlock(&ddebug_lock);
856
857 vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
858 return 0;
859}
860EXPORT_SYMBOL_GPL(ddebug_add_module);
861
862/* helper for ddebug_dyndbg_(boot|module)_param_cb */
863static int ddebug_dyndbg_param_cb(char *param, char *val,
864 const char *modname, int on_err)
865{
866 char *sep;
867
868 sep = strchr(param, '.');
869 if (sep) {
870 /* needed only for ddebug_dyndbg_boot_param_cb */
871 *sep = '\0';
872 modname = param;
873 param = sep + 1;
874 }
875 if (strcmp(param, "dyndbg"))
876 return on_err; /* determined by caller */
877
878 ddebug_exec_queries((val ? val : "+p"), modname);
879
880 return 0; /* query failure shouldnt stop module load */
881}
882
883/* handle both dyndbg and $module.dyndbg params at boot */
884static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
885 const char *unused, void *arg)
886{
887 vpr_info("%s=\"%s\"\n", param, val);
888 return ddebug_dyndbg_param_cb(param, val, NULL, 0);
889}
890
891/*
892 * modprobe foo finds foo.params in boot-args, strips "foo.", and
893 * passes them to load_module(). This callback gets unknown params,
894 * processes dyndbg params, rejects others.
895 */
896int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
897{
898 vpr_info("module: %s %s=\"%s\"\n", module, param, val);
899 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
900}
901
902static void ddebug_table_free(struct ddebug_table *dt)
903{
904 list_del_init(&dt->link);
905 kfree_const(dt->mod_name);
906 kfree(dt);
907}
908
909/*
910 * Called in response to a module being unloaded. Removes
911 * any ddebug_table's which point at the module.
912 */
913int ddebug_remove_module(const char *mod_name)
914{
915 struct ddebug_table *dt, *nextdt;
916 int ret = -ENOENT;
917
918 vpr_info("removing module \"%s\"\n", mod_name);
919
920 mutex_lock(&ddebug_lock);
921 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
922 if (!strcmp(dt->mod_name, mod_name)) {
923 ddebug_table_free(dt);
924 ret = 0;
925 }
926 }
927 mutex_unlock(&ddebug_lock);
928 return ret;
929}
930EXPORT_SYMBOL_GPL(ddebug_remove_module);
931
932static void ddebug_remove_all_tables(void)
933{
934 mutex_lock(&ddebug_lock);
935 while (!list_empty(&ddebug_tables)) {
936 struct ddebug_table *dt = list_entry(ddebug_tables.next,
937 struct ddebug_table,
938 link);
939 ddebug_table_free(dt);
940 }
941 mutex_unlock(&ddebug_lock);
942}
943
944static __initdata int ddebug_init_success;
945
946static int __init dynamic_debug_init_debugfs(void)
947{
948 struct dentry *dir, *file;
949
950 if (!ddebug_init_success)
951 return -ENODEV;
952
953 dir = debugfs_create_dir("dynamic_debug", NULL);
954 if (!dir)
955 return -ENOMEM;
956 file = debugfs_create_file("control", 0644, dir, NULL,
957 &ddebug_proc_fops);
958 if (!file) {
959 debugfs_remove(dir);
960 return -ENOMEM;
961 }
962 return 0;
963}
964
965static int __init dynamic_debug_init(void)
966{
967 struct _ddebug *iter, *iter_start;
968 const char *modname = NULL;
969 char *cmdline;
970 int ret = 0;
971 int n = 0, entries = 0, modct = 0;
972 int verbose_bytes = 0;
973
974 if (__start___verbose == __stop___verbose) {
975 pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
976 return 1;
977 }
978 iter = __start___verbose;
979 modname = iter->modname;
980 iter_start = iter;
981 for (; iter < __stop___verbose; iter++) {
982 entries++;
983 verbose_bytes += strlen(iter->modname) + strlen(iter->function)
984 + strlen(iter->filename) + strlen(iter->format);
985
986 if (strcmp(modname, iter->modname)) {
987 modct++;
988 ret = ddebug_add_module(iter_start, n, modname);
989 if (ret)
990 goto out_err;
991 n = 0;
992 modname = iter->modname;
993 iter_start = iter;
994 }
995 n++;
996 }
997 ret = ddebug_add_module(iter_start, n, modname);
998 if (ret)
999 goto out_err;
1000
1001 ddebug_init_success = 1;
1002 vpr_info("%d modules, %d entries and %d bytes in ddebug tables, %d bytes in (readonly) verbose section\n",
1003 modct, entries, (int)(modct * sizeof(struct ddebug_table)),
1004 verbose_bytes + (int)(__stop___verbose - __start___verbose));
1005
1006 /* apply ddebug_query boot param, dont unload tables on err */
1007 if (ddebug_setup_string[0] != '\0') {
1008 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
1009 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
1010 if (ret < 0)
1011 pr_warn("Invalid ddebug boot param %s\n",
1012 ddebug_setup_string);
1013 else
1014 pr_info("%d changes by ddebug_query\n", ret);
1015 }
1016 /* now that ddebug tables are loaded, process all boot args
1017 * again to find and activate queries given in dyndbg params.
1018 * While this has already been done for known boot params, it
1019 * ignored the unknown ones (dyndbg in particular). Reusing
1020 * parse_args avoids ad-hoc parsing. This will also attempt
1021 * to activate queries for not-yet-loaded modules, which is
1022 * slightly noisy if verbose, but harmless.
1023 */
1024 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1025 parse_args("dyndbg params", cmdline, NULL,
1026 0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
1027 kfree(cmdline);
1028 return 0;
1029
1030out_err:
1031 ddebug_remove_all_tables();
1032 return 0;
1033}
1034/* Allow early initialization for boot messages via boot param */
1035early_initcall(dynamic_debug_init);
1036
1037/* Debugfs setup must be done later */
1038fs_initcall(dynamic_debug_init_debugfs);