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