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[];
44extern struct ddebug_class_map __start___dyndbg_classes[];
45extern struct ddebug_class_map __stop___dyndbg_classes[];
46
47struct ddebug_table {
48 struct list_head link, maps;
49 const char *mod_name;
50 unsigned int num_ddebugs;
51 struct _ddebug *ddebugs;
52};
53
54struct ddebug_query {
55 const char *filename;
56 const char *module;
57 const char *function;
58 const char *format;
59 const char *class_string;
60 unsigned int first_lineno, last_lineno;
61};
62
63struct ddebug_iter {
64 struct ddebug_table *table;
65 int idx;
66};
67
68struct flag_settings {
69 unsigned int flags;
70 unsigned int mask;
71};
72
73static DEFINE_MUTEX(ddebug_lock);
74static LIST_HEAD(ddebug_tables);
75static int verbose;
76module_param(verbose, int, 0644);
77MODULE_PARM_DESC(verbose, " dynamic_debug/control processing "
78 "( 0 = off (default), 1 = module add/rm, 2 = >control summary, 3 = parsing, 4 = per-site changes)");
79
80/* Return the path relative to source root */
81static inline const char *trim_prefix(const char *path)
82{
83 int skip = strlen(__FILE__) - strlen("lib/dynamic_debug.c");
84
85 if (strncmp(path, __FILE__, skip))
86 skip = 0; /* prefix mismatch, don't skip */
87
88 return path + skip;
89}
90
91static const struct { unsigned flag:8; char opt_char; } opt_array[] = {
92 { _DPRINTK_FLAGS_PRINT, 'p' },
93 { _DPRINTK_FLAGS_INCL_MODNAME, 'm' },
94 { _DPRINTK_FLAGS_INCL_FUNCNAME, 'f' },
95 { _DPRINTK_FLAGS_INCL_SOURCENAME, 's' },
96 { _DPRINTK_FLAGS_INCL_LINENO, 'l' },
97 { _DPRINTK_FLAGS_INCL_TID, 't' },
98 { _DPRINTK_FLAGS_NONE, '_' },
99};
100
101struct flagsbuf { char buf[ARRAY_SIZE(opt_array)+1]; };
102
103/* format a string into buf[] which describes the _ddebug's flags */
104static char *ddebug_describe_flags(unsigned int flags, struct flagsbuf *fb)
105{
106 char *p = fb->buf;
107 int i;
108
109 for (i = 0; i < ARRAY_SIZE(opt_array); ++i)
110 if (flags & opt_array[i].flag)
111 *p++ = opt_array[i].opt_char;
112 if (p == fb->buf)
113 *p++ = '_';
114 *p = '\0';
115
116 return fb->buf;
117}
118
119#define vnpr_info(lvl, fmt, ...) \
120do { \
121 if (verbose >= lvl) \
122 pr_info(fmt, ##__VA_ARGS__); \
123} while (0)
124
125#define vpr_info(fmt, ...) vnpr_info(1, fmt, ##__VA_ARGS__)
126#define v2pr_info(fmt, ...) vnpr_info(2, fmt, ##__VA_ARGS__)
127#define v3pr_info(fmt, ...) vnpr_info(3, fmt, ##__VA_ARGS__)
128#define v4pr_info(fmt, ...) vnpr_info(4, fmt, ##__VA_ARGS__)
129
130static void vpr_info_dq(const struct ddebug_query *query, const char *msg)
131{
132 /* trim any trailing newlines */
133 int fmtlen = 0;
134
135 if (query->format) {
136 fmtlen = strlen(query->format);
137 while (fmtlen && query->format[fmtlen - 1] == '\n')
138 fmtlen--;
139 }
140
141 v3pr_info("%s: func=\"%s\" file=\"%s\" module=\"%s\" format=\"%.*s\" lineno=%u-%u class=%s\n",
142 msg,
143 query->function ?: "",
144 query->filename ?: "",
145 query->module ?: "",
146 fmtlen, query->format ?: "",
147 query->first_lineno, query->last_lineno, query->class_string);
148}
149
150static struct ddebug_class_map *ddebug_find_valid_class(struct ddebug_table const *dt,
151 const char *class_string, int *class_id)
152{
153 struct ddebug_class_map *map;
154 int idx;
155
156 list_for_each_entry(map, &dt->maps, link) {
157 idx = match_string(map->class_names, map->length, class_string);
158 if (idx >= 0) {
159 *class_id = idx + map->base;
160 return map;
161 }
162 }
163 *class_id = -ENOENT;
164 return NULL;
165}
166
167#define __outvar /* filled by callee */
168/*
169 * Search the tables for _ddebug's which match the given `query' and
170 * apply the `flags' and `mask' to them. Returns number of matching
171 * callsites, normally the same as number of changes. If verbose,
172 * logs the changes. Takes ddebug_lock.
173 */
174static int ddebug_change(const struct ddebug_query *query,
175 struct flag_settings *modifiers)
176{
177 int i;
178 struct ddebug_table *dt;
179 unsigned int newflags;
180 unsigned int nfound = 0;
181 struct flagsbuf fbuf, nbuf;
182 struct ddebug_class_map *map = NULL;
183 int __outvar valid_class;
184
185 /* search for matching ddebugs */
186 mutex_lock(&ddebug_lock);
187 list_for_each_entry(dt, &ddebug_tables, link) {
188
189 /* match against the module name */
190 if (query->module &&
191 !match_wildcard(query->module, dt->mod_name))
192 continue;
193
194 if (query->class_string) {
195 map = ddebug_find_valid_class(dt, query->class_string, &valid_class);
196 if (!map)
197 continue;
198 } else {
199 /* constrain query, do not touch class'd callsites */
200 valid_class = _DPRINTK_CLASS_DFLT;
201 }
202
203 for (i = 0; i < dt->num_ddebugs; i++) {
204 struct _ddebug *dp = &dt->ddebugs[i];
205
206 /* match site against query-class */
207 if (dp->class_id != valid_class)
208 continue;
209
210 /* match against the source filename */
211 if (query->filename &&
212 !match_wildcard(query->filename, dp->filename) &&
213 !match_wildcard(query->filename,
214 kbasename(dp->filename)) &&
215 !match_wildcard(query->filename,
216 trim_prefix(dp->filename)))
217 continue;
218
219 /* match against the function */
220 if (query->function &&
221 !match_wildcard(query->function, dp->function))
222 continue;
223
224 /* match against the format */
225 if (query->format) {
226 if (*query->format == '^') {
227 char *p;
228 /* anchored search. match must be at beginning */
229 p = strstr(dp->format, query->format+1);
230 if (p != dp->format)
231 continue;
232 } else if (!strstr(dp->format, query->format))
233 continue;
234 }
235
236 /* match against the line number range */
237 if (query->first_lineno &&
238 dp->lineno < query->first_lineno)
239 continue;
240 if (query->last_lineno &&
241 dp->lineno > query->last_lineno)
242 continue;
243
244 nfound++;
245
246 newflags = (dp->flags & modifiers->mask) | modifiers->flags;
247 if (newflags == dp->flags)
248 continue;
249#ifdef CONFIG_JUMP_LABEL
250 if (dp->flags & _DPRINTK_FLAGS_PRINT) {
251 if (!(newflags & _DPRINTK_FLAGS_PRINT))
252 static_branch_disable(&dp->key.dd_key_true);
253 } else if (newflags & _DPRINTK_FLAGS_PRINT) {
254 static_branch_enable(&dp->key.dd_key_true);
255 }
256#endif
257 v4pr_info("changed %s:%d [%s]%s %s => %s\n",
258 trim_prefix(dp->filename), dp->lineno,
259 dt->mod_name, dp->function,
260 ddebug_describe_flags(dp->flags, &fbuf),
261 ddebug_describe_flags(newflags, &nbuf));
262 dp->flags = newflags;
263 }
264 }
265 mutex_unlock(&ddebug_lock);
266
267 if (!nfound && verbose)
268 pr_info("no matches for query\n");
269
270 return nfound;
271}
272
273/*
274 * Split the buffer `buf' into space-separated words.
275 * Handles simple " and ' quoting, i.e. without nested,
276 * embedded or escaped \". Return the number of words
277 * or <0 on error.
278 */
279static int ddebug_tokenize(char *buf, char *words[], int maxwords)
280{
281 int nwords = 0;
282
283 while (*buf) {
284 char *end;
285
286 /* Skip leading whitespace */
287 buf = skip_spaces(buf);
288 if (!*buf)
289 break; /* oh, it was trailing whitespace */
290 if (*buf == '#')
291 break; /* token starts comment, skip rest of line */
292
293 /* find `end' of word, whitespace separated or quoted */
294 if (*buf == '"' || *buf == '\'') {
295 int quote = *buf++;
296 for (end = buf; *end && *end != quote; end++)
297 ;
298 if (!*end) {
299 pr_err("unclosed quote: %s\n", buf);
300 return -EINVAL; /* unclosed quote */
301 }
302 } else {
303 for (end = buf; *end && !isspace(*end); end++)
304 ;
305 BUG_ON(end == buf);
306 }
307
308 /* `buf' is start of word, `end' is one past its end */
309 if (nwords == maxwords) {
310 pr_err("too many words, legal max <=%d\n", maxwords);
311 return -EINVAL; /* ran out of words[] before bytes */
312 }
313 if (*end)
314 *end++ = '\0'; /* terminate the word */
315 words[nwords++] = buf;
316 buf = end;
317 }
318
319 if (verbose >= 3) {
320 int i;
321 pr_info("split into words:");
322 for (i = 0; i < nwords; i++)
323 pr_cont(" \"%s\"", words[i]);
324 pr_cont("\n");
325 }
326
327 return nwords;
328}
329
330/*
331 * Parse a single line number. Note that the empty string ""
332 * is treated as a special case and converted to zero, which
333 * is later treated as a "don't care" value.
334 */
335static inline int parse_lineno(const char *str, unsigned int *val)
336{
337 BUG_ON(str == NULL);
338 if (*str == '\0') {
339 *val = 0;
340 return 0;
341 }
342 if (kstrtouint(str, 10, val) < 0) {
343 pr_err("bad line-number: %s\n", str);
344 return -EINVAL;
345 }
346 return 0;
347}
348
349static int parse_linerange(struct ddebug_query *query, const char *first)
350{
351 char *last = strchr(first, '-');
352
353 if (query->first_lineno || query->last_lineno) {
354 pr_err("match-spec: line used 2x\n");
355 return -EINVAL;
356 }
357 if (last)
358 *last++ = '\0';
359 if (parse_lineno(first, &query->first_lineno) < 0)
360 return -EINVAL;
361 if (last) {
362 /* range <first>-<last> */
363 if (parse_lineno(last, &query->last_lineno) < 0)
364 return -EINVAL;
365
366 /* special case for last lineno not specified */
367 if (query->last_lineno == 0)
368 query->last_lineno = UINT_MAX;
369
370 if (query->last_lineno < query->first_lineno) {
371 pr_err("last-line:%d < 1st-line:%d\n",
372 query->last_lineno,
373 query->first_lineno);
374 return -EINVAL;
375 }
376 } else {
377 query->last_lineno = query->first_lineno;
378 }
379 v3pr_info("parsed line %d-%d\n", query->first_lineno,
380 query->last_lineno);
381 return 0;
382}
383
384static int check_set(const char **dest, char *src, char *name)
385{
386 int rc = 0;
387
388 if (*dest) {
389 rc = -EINVAL;
390 pr_err("match-spec:%s val:%s overridden by %s\n",
391 name, *dest, src);
392 }
393 *dest = src;
394 return rc;
395}
396
397/*
398 * Parse words[] as a ddebug query specification, which is a series
399 * of (keyword, value) pairs chosen from these possibilities:
400 *
401 * func <function-name>
402 * file <full-pathname>
403 * file <base-filename>
404 * module <module-name>
405 * format <escaped-string-to-find-in-format>
406 * line <lineno>
407 * line <first-lineno>-<last-lineno> // where either may be empty
408 *
409 * Only 1 of each type is allowed.
410 * Returns 0 on success, <0 on error.
411 */
412static int ddebug_parse_query(char *words[], int nwords,
413 struct ddebug_query *query, const char *modname)
414{
415 unsigned int i;
416 int rc = 0;
417 char *fline;
418
419 /* check we have an even number of words */
420 if (nwords % 2 != 0) {
421 pr_err("expecting pairs of match-spec <value>\n");
422 return -EINVAL;
423 }
424
425 for (i = 0; i < nwords; i += 2) {
426 char *keyword = words[i];
427 char *arg = words[i+1];
428
429 if (!strcmp(keyword, "func")) {
430 rc = check_set(&query->function, arg, "func");
431 } else if (!strcmp(keyword, "file")) {
432 if (check_set(&query->filename, arg, "file"))
433 return -EINVAL;
434
435 /* tail :$info is function or line-range */
436 fline = strchr(query->filename, ':');
437 if (!fline)
438 continue;
439 *fline++ = '\0';
440 if (isalpha(*fline) || *fline == '*' || *fline == '?') {
441 /* take as function name */
442 if (check_set(&query->function, fline, "func"))
443 return -EINVAL;
444 } else {
445 if (parse_linerange(query, fline))
446 return -EINVAL;
447 }
448 } else if (!strcmp(keyword, "module")) {
449 rc = check_set(&query->module, arg, "module");
450 } else if (!strcmp(keyword, "format")) {
451 string_unescape_inplace(arg, UNESCAPE_SPACE |
452 UNESCAPE_OCTAL |
453 UNESCAPE_SPECIAL);
454 rc = check_set(&query->format, arg, "format");
455 } else if (!strcmp(keyword, "line")) {
456 if (parse_linerange(query, arg))
457 return -EINVAL;
458 } else if (!strcmp(keyword, "class")) {
459 rc = check_set(&query->class_string, arg, "class");
460 } else {
461 pr_err("unknown keyword \"%s\"\n", keyword);
462 return -EINVAL;
463 }
464 if (rc)
465 return rc;
466 }
467 if (!query->module && modname)
468 /*
469 * support $modname.dyndbg=<multiple queries>, when
470 * not given in the query itself
471 */
472 query->module = modname;
473
474 vpr_info_dq(query, "parsed");
475 return 0;
476}
477
478/*
479 * Parse `str' as a flags specification, format [-+=][p]+.
480 * Sets up *maskp and *flagsp to be used when changing the
481 * flags fields of matched _ddebug's. Returns 0 on success
482 * or <0 on error.
483 */
484static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers)
485{
486 int op, i;
487
488 switch (*str) {
489 case '+':
490 case '-':
491 case '=':
492 op = *str++;
493 break;
494 default:
495 pr_err("bad flag-op %c, at start of %s\n", *str, str);
496 return -EINVAL;
497 }
498 v3pr_info("op='%c'\n", op);
499
500 for (; *str ; ++str) {
501 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
502 if (*str == opt_array[i].opt_char) {
503 modifiers->flags |= opt_array[i].flag;
504 break;
505 }
506 }
507 if (i < 0) {
508 pr_err("unknown flag '%c'\n", *str);
509 return -EINVAL;
510 }
511 }
512 v3pr_info("flags=0x%x\n", modifiers->flags);
513
514 /* calculate final flags, mask based upon op */
515 switch (op) {
516 case '=':
517 /* modifiers->flags already set */
518 modifiers->mask = 0;
519 break;
520 case '+':
521 modifiers->mask = ~0U;
522 break;
523 case '-':
524 modifiers->mask = ~modifiers->flags;
525 modifiers->flags = 0;
526 break;
527 }
528 v3pr_info("*flagsp=0x%x *maskp=0x%x\n", modifiers->flags, modifiers->mask);
529
530 return 0;
531}
532
533static int ddebug_exec_query(char *query_string, const char *modname)
534{
535 struct flag_settings modifiers = {};
536 struct ddebug_query query = {};
537#define MAXWORDS 9
538 int nwords, nfound;
539 char *words[MAXWORDS];
540
541 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
542 if (nwords <= 0) {
543 pr_err("tokenize failed\n");
544 return -EINVAL;
545 }
546 /* check flags 1st (last arg) so query is pairs of spec,val */
547 if (ddebug_parse_flags(words[nwords-1], &modifiers)) {
548 pr_err("flags parse failed\n");
549 return -EINVAL;
550 }
551 if (ddebug_parse_query(words, nwords-1, &query, modname)) {
552 pr_err("query parse failed\n");
553 return -EINVAL;
554 }
555 /* actually go and implement the change */
556 nfound = ddebug_change(&query, &modifiers);
557 vpr_info_dq(&query, nfound ? "applied" : "no-match");
558
559 return nfound;
560}
561
562/* handle multiple queries in query string, continue on error, return
563 last error or number of matching callsites. Module name is either
564 in param (for boot arg) or perhaps in query string.
565*/
566static int ddebug_exec_queries(char *query, const char *modname)
567{
568 char *split;
569 int i, errs = 0, exitcode = 0, rc, nfound = 0;
570
571 for (i = 0; query; query = split) {
572 split = strpbrk(query, ";\n");
573 if (split)
574 *split++ = '\0';
575
576 query = skip_spaces(query);
577 if (!query || !*query || *query == '#')
578 continue;
579
580 vpr_info("query %d: \"%s\" mod:%s\n", i, query, modname ?: "*");
581
582 rc = ddebug_exec_query(query, modname);
583 if (rc < 0) {
584 errs++;
585 exitcode = rc;
586 } else {
587 nfound += rc;
588 }
589 i++;
590 }
591 if (i)
592 v2pr_info("processed %d queries, with %d matches, %d errs\n",
593 i, nfound, errs);
594
595 if (exitcode)
596 return exitcode;
597 return nfound;
598}
599
600/* apply a new bitmap to the sys-knob's current bit-state */
601static int ddebug_apply_class_bitmap(const struct ddebug_class_param *dcp,
602 unsigned long *new_bits, unsigned long *old_bits)
603{
604#define QUERY_SIZE 128
605 char query[QUERY_SIZE];
606 const struct ddebug_class_map *map = dcp->map;
607 int matches = 0;
608 int bi, ct;
609
610 v2pr_info("apply: 0x%lx to: 0x%lx\n", *new_bits, *old_bits);
611
612 for (bi = 0; bi < map->length; bi++) {
613 if (test_bit(bi, new_bits) == test_bit(bi, old_bits))
614 continue;
615
616 snprintf(query, QUERY_SIZE, "class %s %c%s", map->class_names[bi],
617 test_bit(bi, new_bits) ? '+' : '-', dcp->flags);
618
619 ct = ddebug_exec_queries(query, NULL);
620 matches += ct;
621
622 v2pr_info("bit_%d: %d matches on class: %s -> 0x%lx\n", bi,
623 ct, map->class_names[bi], *new_bits);
624 }
625 return matches;
626}
627
628/* stub to later conditionally add "$module." prefix where not already done */
629#define KP_NAME(kp) kp->name
630
631#define CLASSMAP_BITMASK(width) ((1UL << (width)) - 1)
632
633/* accept comma-separated-list of [+-] classnames */
634static int param_set_dyndbg_classnames(const char *instr, const struct kernel_param *kp)
635{
636 const struct ddebug_class_param *dcp = kp->arg;
637 const struct ddebug_class_map *map = dcp->map;
638 unsigned long curr_bits, old_bits;
639 char *cl_str, *p, *tmp;
640 int cls_id, totct = 0;
641 bool wanted;
642
643 cl_str = tmp = kstrdup(instr, GFP_KERNEL);
644 p = strchr(cl_str, '\n');
645 if (p)
646 *p = '\0';
647
648 /* start with previously set state-bits, then modify */
649 curr_bits = old_bits = *dcp->bits;
650 vpr_info("\"%s\" > %s:0x%lx\n", cl_str, KP_NAME(kp), curr_bits);
651
652 for (; cl_str; cl_str = p) {
653 p = strchr(cl_str, ',');
654 if (p)
655 *p++ = '\0';
656
657 if (*cl_str == '-') {
658 wanted = false;
659 cl_str++;
660 } else {
661 wanted = true;
662 if (*cl_str == '+')
663 cl_str++;
664 }
665 cls_id = match_string(map->class_names, map->length, cl_str);
666 if (cls_id < 0) {
667 pr_err("%s unknown to %s\n", cl_str, KP_NAME(kp));
668 continue;
669 }
670
671 /* have one or more valid class_ids of one *_NAMES type */
672 switch (map->map_type) {
673 case DD_CLASS_TYPE_DISJOINT_NAMES:
674 /* the +/- pertains to a single bit */
675 if (test_bit(cls_id, &curr_bits) == wanted) {
676 v3pr_info("no change on %s\n", cl_str);
677 continue;
678 }
679 curr_bits ^= BIT(cls_id);
680 totct += ddebug_apply_class_bitmap(dcp, &curr_bits, dcp->bits);
681 *dcp->bits = curr_bits;
682 v2pr_info("%s: changed bit %d:%s\n", KP_NAME(kp), cls_id,
683 map->class_names[cls_id]);
684 break;
685 case DD_CLASS_TYPE_LEVEL_NAMES:
686 /* cls_id = N in 0..max. wanted +/- determines N or N-1 */
687 old_bits = CLASSMAP_BITMASK(*dcp->lvl);
688 curr_bits = CLASSMAP_BITMASK(cls_id + (wanted ? 1 : 0 ));
689
690 totct += ddebug_apply_class_bitmap(dcp, &curr_bits, &old_bits);
691 *dcp->lvl = (cls_id + (wanted ? 1 : 0));
692 v2pr_info("%s: changed bit-%d: \"%s\" %lx->%lx\n", KP_NAME(kp), cls_id,
693 map->class_names[cls_id], old_bits, curr_bits);
694 break;
695 default:
696 pr_err("illegal map-type value %d\n", map->map_type);
697 }
698 }
699 kfree(tmp);
700 vpr_info("total matches: %d\n", totct);
701 return 0;
702}
703
704/**
705 * param_set_dyndbg_classes - class FOO >control
706 * @instr: string echo>d to sysfs, input depends on map_type
707 * @kp: kp->arg has state: bits/lvl, map, map_type
708 *
709 * Enable/disable prdbgs by their class, as given in the arguments to
710 * DECLARE_DYNDBG_CLASSMAP. For LEVEL map-types, enforce relative
711 * levels by bitpos.
712 *
713 * Returns: 0 or <0 if error.
714 */
715int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp)
716{
717 const struct ddebug_class_param *dcp = kp->arg;
718 const struct ddebug_class_map *map = dcp->map;
719 unsigned long inrep, new_bits, old_bits;
720 int rc, totct = 0;
721
722 switch (map->map_type) {
723
724 case DD_CLASS_TYPE_DISJOINT_NAMES:
725 case DD_CLASS_TYPE_LEVEL_NAMES:
726 /* handle [+-]classnames list separately, we are done here */
727 return param_set_dyndbg_classnames(instr, kp);
728
729 case DD_CLASS_TYPE_DISJOINT_BITS:
730 case DD_CLASS_TYPE_LEVEL_NUM:
731 /* numeric input, accept and fall-thru */
732 rc = kstrtoul(instr, 0, &inrep);
733 if (rc) {
734 pr_err("expecting numeric input: %s > %s\n", instr, KP_NAME(kp));
735 return -EINVAL;
736 }
737 break;
738 default:
739 pr_err("%s: bad map type: %d\n", KP_NAME(kp), map->map_type);
740 return -EINVAL;
741 }
742
743 /* only _BITS,_NUM (numeric) map-types get here */
744 switch (map->map_type) {
745 case DD_CLASS_TYPE_DISJOINT_BITS:
746 /* expect bits. mask and warn if too many */
747 if (inrep & ~CLASSMAP_BITMASK(map->length)) {
748 pr_warn("%s: input: 0x%lx exceeds mask: 0x%lx, masking\n",
749 KP_NAME(kp), inrep, CLASSMAP_BITMASK(map->length));
750 inrep &= CLASSMAP_BITMASK(map->length);
751 }
752 v2pr_info("bits:%lx > %s\n", inrep, KP_NAME(kp));
753 totct += ddebug_apply_class_bitmap(dcp, &inrep, dcp->bits);
754 *dcp->bits = inrep;
755 break;
756 case DD_CLASS_TYPE_LEVEL_NUM:
757 /* input is bitpos, of highest verbosity to be enabled */
758 if (inrep > map->length) {
759 pr_warn("%s: level:%ld exceeds max:%d, clamping\n",
760 KP_NAME(kp), inrep, map->length);
761 inrep = map->length;
762 }
763 old_bits = CLASSMAP_BITMASK(*dcp->lvl);
764 new_bits = CLASSMAP_BITMASK(inrep);
765 v2pr_info("lvl:%ld bits:0x%lx > %s\n", inrep, new_bits, KP_NAME(kp));
766 totct += ddebug_apply_class_bitmap(dcp, &new_bits, &old_bits);
767 *dcp->lvl = inrep;
768 break;
769 default:
770 pr_warn("%s: bad map type: %d\n", KP_NAME(kp), map->map_type);
771 }
772 vpr_info("%s: total matches: %d\n", KP_NAME(kp), totct);
773 return 0;
774}
775EXPORT_SYMBOL(param_set_dyndbg_classes);
776
777/**
778 * param_get_dyndbg_classes - classes reader
779 * @buffer: string description of controlled bits -> classes
780 * @kp: kp->arg has state: bits, map
781 *
782 * Reads last written state, underlying prdbg state may have been
783 * altered by direct >control. Displays 0x for DISJOINT, 0-N for
784 * LEVEL Returns: #chars written or <0 on error
785 */
786int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp)
787{
788 const struct ddebug_class_param *dcp = kp->arg;
789 const struct ddebug_class_map *map = dcp->map;
790
791 switch (map->map_type) {
792
793 case DD_CLASS_TYPE_DISJOINT_NAMES:
794 case DD_CLASS_TYPE_DISJOINT_BITS:
795 return scnprintf(buffer, PAGE_SIZE, "0x%lx\n", *dcp->bits);
796
797 case DD_CLASS_TYPE_LEVEL_NAMES:
798 case DD_CLASS_TYPE_LEVEL_NUM:
799 return scnprintf(buffer, PAGE_SIZE, "%d\n", *dcp->lvl);
800 default:
801 return -1;
802 }
803}
804EXPORT_SYMBOL(param_get_dyndbg_classes);
805
806const struct kernel_param_ops param_ops_dyndbg_classes = {
807 .set = param_set_dyndbg_classes,
808 .get = param_get_dyndbg_classes,
809};
810EXPORT_SYMBOL(param_ops_dyndbg_classes);
811
812#define PREFIX_SIZE 128
813
814static int remaining(int wrote)
815{
816 if (PREFIX_SIZE - wrote > 0)
817 return PREFIX_SIZE - wrote;
818 return 0;
819}
820
821static char *__dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
822{
823 int pos_after_tid;
824 int pos = 0;
825
826 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
827 if (in_interrupt())
828 pos += snprintf(buf + pos, remaining(pos), "<intr> ");
829 else
830 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
831 task_pid_vnr(current));
832 }
833 pos_after_tid = pos;
834 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
835 pos += snprintf(buf + pos, remaining(pos), "%s:",
836 desc->modname);
837 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
838 pos += snprintf(buf + pos, remaining(pos), "%s:",
839 desc->function);
840 if (desc->flags & _DPRINTK_FLAGS_INCL_SOURCENAME)
841 pos += snprintf(buf + pos, remaining(pos), "%s:",
842 trim_prefix(desc->filename));
843 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
844 pos += snprintf(buf + pos, remaining(pos), "%d:",
845 desc->lineno);
846 if (pos - pos_after_tid)
847 pos += snprintf(buf + pos, remaining(pos), " ");
848 if (pos >= PREFIX_SIZE)
849 buf[PREFIX_SIZE - 1] = '\0';
850
851 return buf;
852}
853
854static inline char *dynamic_emit_prefix(struct _ddebug *desc, char *buf)
855{
856 if (unlikely(desc->flags & _DPRINTK_FLAGS_INCL_ANY))
857 return __dynamic_emit_prefix(desc, buf);
858 return buf;
859}
860
861void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
862{
863 va_list args;
864 struct va_format vaf;
865 char buf[PREFIX_SIZE] = "";
866
867 BUG_ON(!descriptor);
868 BUG_ON(!fmt);
869
870 va_start(args, fmt);
871
872 vaf.fmt = fmt;
873 vaf.va = &args;
874
875 printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
876
877 va_end(args);
878}
879EXPORT_SYMBOL(__dynamic_pr_debug);
880
881void __dynamic_dev_dbg(struct _ddebug *descriptor,
882 const struct device *dev, const char *fmt, ...)
883{
884 struct va_format vaf;
885 va_list args;
886
887 BUG_ON(!descriptor);
888 BUG_ON(!fmt);
889
890 va_start(args, fmt);
891
892 vaf.fmt = fmt;
893 vaf.va = &args;
894
895 if (!dev) {
896 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
897 } else {
898 char buf[PREFIX_SIZE] = "";
899
900 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
901 dynamic_emit_prefix(descriptor, buf),
902 dev_driver_string(dev), dev_name(dev),
903 &vaf);
904 }
905
906 va_end(args);
907}
908EXPORT_SYMBOL(__dynamic_dev_dbg);
909
910#ifdef CONFIG_NET
911
912void __dynamic_netdev_dbg(struct _ddebug *descriptor,
913 const struct net_device *dev, const char *fmt, ...)
914{
915 struct va_format vaf;
916 va_list args;
917
918 BUG_ON(!descriptor);
919 BUG_ON(!fmt);
920
921 va_start(args, fmt);
922
923 vaf.fmt = fmt;
924 vaf.va = &args;
925
926 if (dev && dev->dev.parent) {
927 char buf[PREFIX_SIZE] = "";
928
929 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
930 "%s%s %s %s%s: %pV",
931 dynamic_emit_prefix(descriptor, buf),
932 dev_driver_string(dev->dev.parent),
933 dev_name(dev->dev.parent),
934 netdev_name(dev), netdev_reg_state(dev),
935 &vaf);
936 } else if (dev) {
937 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
938 netdev_reg_state(dev), &vaf);
939 } else {
940 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
941 }
942
943 va_end(args);
944}
945EXPORT_SYMBOL(__dynamic_netdev_dbg);
946
947#endif
948
949#if IS_ENABLED(CONFIG_INFINIBAND)
950
951void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
952 const struct ib_device *ibdev, const char *fmt, ...)
953{
954 struct va_format vaf;
955 va_list args;
956
957 va_start(args, fmt);
958
959 vaf.fmt = fmt;
960 vaf.va = &args;
961
962 if (ibdev && ibdev->dev.parent) {
963 char buf[PREFIX_SIZE] = "";
964
965 dev_printk_emit(LOGLEVEL_DEBUG, ibdev->dev.parent,
966 "%s%s %s %s: %pV",
967 dynamic_emit_prefix(descriptor, buf),
968 dev_driver_string(ibdev->dev.parent),
969 dev_name(ibdev->dev.parent),
970 dev_name(&ibdev->dev),
971 &vaf);
972 } else if (ibdev) {
973 printk(KERN_DEBUG "%s: %pV", dev_name(&ibdev->dev), &vaf);
974 } else {
975 printk(KERN_DEBUG "(NULL ib_device): %pV", &vaf);
976 }
977
978 va_end(args);
979}
980EXPORT_SYMBOL(__dynamic_ibdev_dbg);
981
982#endif
983
984/*
985 * Install a noop handler to make dyndbg look like a normal kernel cli param.
986 * This avoids warnings about dyndbg being an unknown cli param when supplied
987 * by a user.
988 */
989static __init int dyndbg_setup(char *str)
990{
991 return 1;
992}
993
994__setup("dyndbg=", dyndbg_setup);
995
996/*
997 * File_ops->write method for <debugfs>/dynamic_debug/control. Gathers the
998 * command text from userspace, parses and executes it.
999 */
1000#define USER_BUF_PAGE 4096
1001static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
1002 size_t len, loff_t *offp)
1003{
1004 char *tmpbuf;
1005 int ret;
1006
1007 if (len == 0)
1008 return 0;
1009 if (len > USER_BUF_PAGE - 1) {
1010 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
1011 return -E2BIG;
1012 }
1013 tmpbuf = memdup_user_nul(ubuf, len);
1014 if (IS_ERR(tmpbuf))
1015 return PTR_ERR(tmpbuf);
1016 v2pr_info("read %zu bytes from userspace\n", len);
1017
1018 ret = ddebug_exec_queries(tmpbuf, NULL);
1019 kfree(tmpbuf);
1020 if (ret < 0)
1021 return ret;
1022
1023 *offp += len;
1024 return len;
1025}
1026
1027/*
1028 * Set the iterator to point to the first _ddebug object
1029 * and return a pointer to that first object. Returns
1030 * NULL if there are no _ddebugs at all.
1031 */
1032static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
1033{
1034 if (list_empty(&ddebug_tables)) {
1035 iter->table = NULL;
1036 return NULL;
1037 }
1038 iter->table = list_entry(ddebug_tables.next,
1039 struct ddebug_table, link);
1040 iter->idx = iter->table->num_ddebugs;
1041 return &iter->table->ddebugs[--iter->idx];
1042}
1043
1044/*
1045 * Advance the iterator to point to the next _ddebug
1046 * object from the one the iterator currently points at,
1047 * and returns a pointer to the new _ddebug. Returns
1048 * NULL if the iterator has seen all the _ddebugs.
1049 */
1050static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
1051{
1052 if (iter->table == NULL)
1053 return NULL;
1054 if (--iter->idx < 0) {
1055 /* iterate to next table */
1056 if (list_is_last(&iter->table->link, &ddebug_tables)) {
1057 iter->table = NULL;
1058 return NULL;
1059 }
1060 iter->table = list_entry(iter->table->link.next,
1061 struct ddebug_table, link);
1062 iter->idx = iter->table->num_ddebugs;
1063 --iter->idx;
1064 }
1065 return &iter->table->ddebugs[iter->idx];
1066}
1067
1068/*
1069 * Seq_ops start method. Called at the start of every
1070 * read() call from userspace. Takes the ddebug_lock and
1071 * seeks the seq_file's iterator to the given position.
1072 */
1073static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
1074{
1075 struct ddebug_iter *iter = m->private;
1076 struct _ddebug *dp;
1077 int n = *pos;
1078
1079 mutex_lock(&ddebug_lock);
1080
1081 if (!n)
1082 return SEQ_START_TOKEN;
1083 if (n < 0)
1084 return NULL;
1085 dp = ddebug_iter_first(iter);
1086 while (dp != NULL && --n > 0)
1087 dp = ddebug_iter_next(iter);
1088 return dp;
1089}
1090
1091/*
1092 * Seq_ops next method. Called several times within a read()
1093 * call from userspace, with ddebug_lock held. Walks to the
1094 * next _ddebug object with a special case for the header line.
1095 */
1096static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
1097{
1098 struct ddebug_iter *iter = m->private;
1099 struct _ddebug *dp;
1100
1101 if (p == SEQ_START_TOKEN)
1102 dp = ddebug_iter_first(iter);
1103 else
1104 dp = ddebug_iter_next(iter);
1105 ++*pos;
1106 return dp;
1107}
1108
1109#define class_in_range(class_id, map) \
1110 (class_id >= map->base && class_id < map->base + map->length)
1111
1112static const char *ddebug_class_name(struct ddebug_iter *iter, struct _ddebug *dp)
1113{
1114 struct ddebug_class_map *map;
1115
1116 list_for_each_entry(map, &iter->table->maps, link)
1117 if (class_in_range(dp->class_id, map))
1118 return map->class_names[dp->class_id - map->base];
1119
1120 return NULL;
1121}
1122
1123/*
1124 * Seq_ops show method. Called several times within a read()
1125 * call from userspace, with ddebug_lock held. Formats the
1126 * current _ddebug as a single human-readable line, with a
1127 * special case for the header line.
1128 */
1129static int ddebug_proc_show(struct seq_file *m, void *p)
1130{
1131 struct ddebug_iter *iter = m->private;
1132 struct _ddebug *dp = p;
1133 struct flagsbuf flags;
1134 char const *class;
1135
1136 if (p == SEQ_START_TOKEN) {
1137 seq_puts(m,
1138 "# filename:lineno [module]function flags format\n");
1139 return 0;
1140 }
1141
1142 seq_printf(m, "%s:%u [%s]%s =%s \"",
1143 trim_prefix(dp->filename), dp->lineno,
1144 iter->table->mod_name, dp->function,
1145 ddebug_describe_flags(dp->flags, &flags));
1146 seq_escape_str(m, dp->format, ESCAPE_SPACE, "\t\r\n\"");
1147 seq_puts(m, "\"");
1148
1149 if (dp->class_id != _DPRINTK_CLASS_DFLT) {
1150 class = ddebug_class_name(iter, dp);
1151 if (class)
1152 seq_printf(m, " class:%s", class);
1153 else
1154 seq_printf(m, " class unknown, _id:%d", dp->class_id);
1155 }
1156 seq_puts(m, "\n");
1157
1158 return 0;
1159}
1160
1161/*
1162 * Seq_ops stop method. Called at the end of each read()
1163 * call from userspace. Drops ddebug_lock.
1164 */
1165static void ddebug_proc_stop(struct seq_file *m, void *p)
1166{
1167 mutex_unlock(&ddebug_lock);
1168}
1169
1170static const struct seq_operations ddebug_proc_seqops = {
1171 .start = ddebug_proc_start,
1172 .next = ddebug_proc_next,
1173 .show = ddebug_proc_show,
1174 .stop = ddebug_proc_stop
1175};
1176
1177static int ddebug_proc_open(struct inode *inode, struct file *file)
1178{
1179 return seq_open_private(file, &ddebug_proc_seqops,
1180 sizeof(struct ddebug_iter));
1181}
1182
1183static const struct file_operations ddebug_proc_fops = {
1184 .owner = THIS_MODULE,
1185 .open = ddebug_proc_open,
1186 .read = seq_read,
1187 .llseek = seq_lseek,
1188 .release = seq_release_private,
1189 .write = ddebug_proc_write
1190};
1191
1192static const struct proc_ops proc_fops = {
1193 .proc_open = ddebug_proc_open,
1194 .proc_read = seq_read,
1195 .proc_lseek = seq_lseek,
1196 .proc_release = seq_release_private,
1197 .proc_write = ddebug_proc_write
1198};
1199
1200static void ddebug_attach_module_classes(struct ddebug_table *dt,
1201 struct ddebug_class_map *classes,
1202 int num_classes)
1203{
1204 struct ddebug_class_map *cm;
1205 int i, j, ct = 0;
1206
1207 for (cm = classes, i = 0; i < num_classes; i++, cm++) {
1208
1209 if (!strcmp(cm->mod_name, dt->mod_name)) {
1210
1211 v2pr_info("class[%d]: module:%s base:%d len:%d ty:%d\n", i,
1212 cm->mod_name, cm->base, cm->length, cm->map_type);
1213
1214 for (j = 0; j < cm->length; j++)
1215 v3pr_info(" %d: %d %s\n", j + cm->base, j,
1216 cm->class_names[j]);
1217
1218 list_add(&cm->link, &dt->maps);
1219 ct++;
1220 }
1221 }
1222 if (ct)
1223 vpr_info("module:%s attached %d classes\n", dt->mod_name, ct);
1224}
1225
1226/*
1227 * Allocate a new ddebug_table for the given module
1228 * and add it to the global list.
1229 */
1230static int ddebug_add_module(struct _ddebug_info *di, const char *modname)
1231{
1232 struct ddebug_table *dt;
1233
1234 v3pr_info("add-module: %s.%d sites\n", modname, di->num_descs);
1235 if (!di->num_descs) {
1236 v3pr_info(" skip %s\n", modname);
1237 return 0;
1238 }
1239
1240 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
1241 if (dt == NULL) {
1242 pr_err("error adding module: %s\n", modname);
1243 return -ENOMEM;
1244 }
1245 /*
1246 * For built-in modules, name lives in .rodata and is
1247 * immortal. For loaded modules, name points at the name[]
1248 * member of struct module, which lives at least as long as
1249 * this struct ddebug_table.
1250 */
1251 dt->mod_name = modname;
1252 dt->ddebugs = di->descs;
1253 dt->num_ddebugs = di->num_descs;
1254
1255 INIT_LIST_HEAD(&dt->link);
1256 INIT_LIST_HEAD(&dt->maps);
1257
1258 if (di->classes && di->num_classes)
1259 ddebug_attach_module_classes(dt, di->classes, di->num_classes);
1260
1261 mutex_lock(&ddebug_lock);
1262 list_add_tail(&dt->link, &ddebug_tables);
1263 mutex_unlock(&ddebug_lock);
1264
1265 vpr_info("%3u debug prints in module %s\n", di->num_descs, modname);
1266 return 0;
1267}
1268
1269/* helper for ddebug_dyndbg_(boot|module)_param_cb */
1270static int ddebug_dyndbg_param_cb(char *param, char *val,
1271 const char *modname, int on_err)
1272{
1273 char *sep;
1274
1275 sep = strchr(param, '.');
1276 if (sep) {
1277 /* needed only for ddebug_dyndbg_boot_param_cb */
1278 *sep = '\0';
1279 modname = param;
1280 param = sep + 1;
1281 }
1282 if (strcmp(param, "dyndbg"))
1283 return on_err; /* determined by caller */
1284
1285 ddebug_exec_queries((val ? val : "+p"), modname);
1286
1287 return 0; /* query failure shouldn't stop module load */
1288}
1289
1290/* handle both dyndbg and $module.dyndbg params at boot */
1291static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
1292 const char *unused, void *arg)
1293{
1294 vpr_info("%s=\"%s\"\n", param, val);
1295 return ddebug_dyndbg_param_cb(param, val, NULL, 0);
1296}
1297
1298/*
1299 * modprobe foo finds foo.params in boot-args, strips "foo.", and
1300 * passes them to load_module(). This callback gets unknown params,
1301 * processes dyndbg params, rejects others.
1302 */
1303int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
1304{
1305 vpr_info("module: %s %s=\"%s\"\n", module, param, val);
1306 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
1307}
1308
1309static void ddebug_table_free(struct ddebug_table *dt)
1310{
1311 list_del_init(&dt->link);
1312 kfree(dt);
1313}
1314
1315#ifdef CONFIG_MODULES
1316
1317/*
1318 * Called in response to a module being unloaded. Removes
1319 * any ddebug_table's which point at the module.
1320 */
1321static int ddebug_remove_module(const char *mod_name)
1322{
1323 struct ddebug_table *dt, *nextdt;
1324 int ret = -ENOENT;
1325
1326 mutex_lock(&ddebug_lock);
1327 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
1328 if (dt->mod_name == mod_name) {
1329 ddebug_table_free(dt);
1330 ret = 0;
1331 break;
1332 }
1333 }
1334 mutex_unlock(&ddebug_lock);
1335 if (!ret)
1336 v2pr_info("removed module \"%s\"\n", mod_name);
1337 return ret;
1338}
1339
1340static int ddebug_module_notify(struct notifier_block *self, unsigned long val,
1341 void *data)
1342{
1343 struct module *mod = data;
1344 int ret = 0;
1345
1346 switch (val) {
1347 case MODULE_STATE_COMING:
1348 ret = ddebug_add_module(&mod->dyndbg_info, mod->name);
1349 if (ret)
1350 WARN(1, "Failed to allocate memory: dyndbg may not work properly.\n");
1351 break;
1352 case MODULE_STATE_GOING:
1353 ddebug_remove_module(mod->name);
1354 break;
1355 }
1356
1357 return notifier_from_errno(ret);
1358}
1359
1360static struct notifier_block ddebug_module_nb = {
1361 .notifier_call = ddebug_module_notify,
1362 .priority = 0, /* dynamic debug depends on jump label */
1363};
1364
1365#endif /* CONFIG_MODULES */
1366
1367static void ddebug_remove_all_tables(void)
1368{
1369 mutex_lock(&ddebug_lock);
1370 while (!list_empty(&ddebug_tables)) {
1371 struct ddebug_table *dt = list_entry(ddebug_tables.next,
1372 struct ddebug_table,
1373 link);
1374 ddebug_table_free(dt);
1375 }
1376 mutex_unlock(&ddebug_lock);
1377}
1378
1379static __initdata int ddebug_init_success;
1380
1381static int __init dynamic_debug_init_control(void)
1382{
1383 struct proc_dir_entry *procfs_dir;
1384 struct dentry *debugfs_dir;
1385
1386 if (!ddebug_init_success)
1387 return -ENODEV;
1388
1389 /* Create the control file in debugfs if it is enabled */
1390 if (debugfs_initialized()) {
1391 debugfs_dir = debugfs_create_dir("dynamic_debug", NULL);
1392 debugfs_create_file("control", 0644, debugfs_dir, NULL,
1393 &ddebug_proc_fops);
1394 }
1395
1396 /* Also create the control file in procfs */
1397 procfs_dir = proc_mkdir("dynamic_debug", NULL);
1398 if (procfs_dir)
1399 proc_create("control", 0644, procfs_dir, &proc_fops);
1400
1401 return 0;
1402}
1403
1404static int __init dynamic_debug_init(void)
1405{
1406 struct _ddebug *iter, *iter_mod_start;
1407 int ret, i, mod_sites, mod_ct;
1408 const char *modname;
1409 char *cmdline;
1410
1411 struct _ddebug_info di = {
1412 .descs = __start___dyndbg,
1413 .classes = __start___dyndbg_classes,
1414 .num_descs = __stop___dyndbg - __start___dyndbg,
1415 .num_classes = __stop___dyndbg_classes - __start___dyndbg_classes,
1416 };
1417
1418#ifdef CONFIG_MODULES
1419 ret = register_module_notifier(&ddebug_module_nb);
1420 if (ret) {
1421 pr_warn("Failed to register dynamic debug module notifier\n");
1422 return ret;
1423 }
1424#endif /* CONFIG_MODULES */
1425
1426 if (&__start___dyndbg == &__stop___dyndbg) {
1427 if (IS_ENABLED(CONFIG_DYNAMIC_DEBUG)) {
1428 pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
1429 return 1;
1430 }
1431 pr_info("Ignore empty _ddebug table in a CONFIG_DYNAMIC_DEBUG_CORE build\n");
1432 ddebug_init_success = 1;
1433 return 0;
1434 }
1435
1436 iter = iter_mod_start = __start___dyndbg;
1437 modname = iter->modname;
1438 i = mod_sites = mod_ct = 0;
1439
1440 for (; iter < __stop___dyndbg; iter++, i++, mod_sites++) {
1441
1442 if (strcmp(modname, iter->modname)) {
1443 mod_ct++;
1444 di.num_descs = mod_sites;
1445 di.descs = iter_mod_start;
1446 ret = ddebug_add_module(&di, modname);
1447 if (ret)
1448 goto out_err;
1449
1450 mod_sites = 0;
1451 modname = iter->modname;
1452 iter_mod_start = iter;
1453 }
1454 }
1455 di.num_descs = mod_sites;
1456 di.descs = iter_mod_start;
1457 ret = ddebug_add_module(&di, modname);
1458 if (ret)
1459 goto out_err;
1460
1461 ddebug_init_success = 1;
1462 vpr_info("%d prdebugs in %d modules, %d KiB in ddebug tables, %d kiB in __dyndbg section\n",
1463 i, mod_ct, (int)((mod_ct * sizeof(struct ddebug_table)) >> 10),
1464 (int)((i * sizeof(struct _ddebug)) >> 10));
1465
1466 if (di.num_classes)
1467 v2pr_info(" %d builtin ddebug class-maps\n", di.num_classes);
1468
1469 /* now that ddebug tables are loaded, process all boot args
1470 * again to find and activate queries given in dyndbg params.
1471 * While this has already been done for known boot params, it
1472 * ignored the unknown ones (dyndbg in particular). Reusing
1473 * parse_args avoids ad-hoc parsing. This will also attempt
1474 * to activate queries for not-yet-loaded modules, which is
1475 * slightly noisy if verbose, but harmless.
1476 */
1477 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1478 parse_args("dyndbg params", cmdline, NULL,
1479 0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
1480 kfree(cmdline);
1481 return 0;
1482
1483out_err:
1484 ddebug_remove_all_tables();
1485 return 0;
1486}
1487/* Allow early initialization for boot messages via boot param */
1488early_initcall(dynamic_debug_init);
1489
1490/* Debugfs setup must be done later */
1491fs_initcall(dynamic_debug_init_control);