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 */
12
13 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
14
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/moduleparam.h>
18 #include <linux/kallsyms.h>
19 #include <linux/types.h>
20 #include <linux/mutex.h>
21 #include <linux/proc_fs.h>
22 #include <linux/seq_file.h>
23 #include <linux/list.h>
24 #include <linux/sysctl.h>
25 #include <linux/ctype.h>
26 #include <linux/string.h>
27 #include <linux/uaccess.h>
28 #include <linux/dynamic_debug.h>
29 #include <linux/debugfs.h>
30 #include <linux/slab.h>
31 #include <linux/jump_label.h>
32 #include <linux/hardirq.h>
33 #include <linux/sched.h>
34 #include <linux/device.h>
35 #include <linux/netdevice.h>
36
37 extern struct _ddebug __start___verbose[];
38 extern struct _ddebug __stop___verbose[];
39
40 struct ddebug_table {
41 struct list_head link;
42 char *mod_name;
43 unsigned int num_ddebugs;
44 struct _ddebug *ddebugs;
45 };
46
47 struct ddebug_query {
48 const char *filename;
49 const char *module;
50 const char *function;
51 const char *format;
52 unsigned int first_lineno, last_lineno;
53 };
54
55 struct ddebug_iter {
56 struct ddebug_table *table;
57 unsigned int idx;
58 };
59
60 static DEFINE_MUTEX(ddebug_lock);
61 static LIST_HEAD(ddebug_tables);
62 static int verbose = 0;
63 module_param(verbose, int, 0644);
64
65 /* Return the last part of a pathname */
basename(const char * path)66 static inline const char *basename(const char *path)
67 {
68 const char *tail = strrchr(path, '/');
69 return tail ? tail+1 : path;
70 }
71
72 /* Return the path relative to source root */
trim_prefix(const char * path)73 static inline const char *trim_prefix(const char *path)
74 {
75 int skip = strlen(__FILE__) - strlen("lib/dynamic_debug.c");
76
77 if (strncmp(path, __FILE__, skip))
78 skip = 0; /* prefix mismatch, don't skip */
79
80 return path + skip;
81 }
82
83 static struct { unsigned flag:8; char opt_char; } opt_array[] = {
84 { _DPRINTK_FLAGS_PRINT, 'p' },
85 { _DPRINTK_FLAGS_INCL_MODNAME, 'm' },
86 { _DPRINTK_FLAGS_INCL_FUNCNAME, 'f' },
87 { _DPRINTK_FLAGS_INCL_LINENO, 'l' },
88 { _DPRINTK_FLAGS_INCL_TID, 't' },
89 { _DPRINTK_FLAGS_NONE, '_' },
90 };
91
92 /* format a string into buf[] which describes the _ddebug's flags */
ddebug_describe_flags(struct _ddebug * dp,char * buf,size_t maxlen)93 static char *ddebug_describe_flags(struct _ddebug *dp, char *buf,
94 size_t maxlen)
95 {
96 char *p = buf;
97 int i;
98
99 BUG_ON(maxlen < 6);
100 for (i = 0; i < ARRAY_SIZE(opt_array); ++i)
101 if (dp->flags & opt_array[i].flag)
102 *p++ = opt_array[i].opt_char;
103 if (p == buf)
104 *p++ = '_';
105 *p = '\0';
106
107 return buf;
108 }
109
110 #define vpr_info_dq(q, msg) \
111 do { \
112 if (verbose) \
113 /* trim last char off format print */ \
114 pr_info("%s: func=\"%s\" file=\"%s\" " \
115 "module=\"%s\" format=\"%.*s\" " \
116 "lineno=%u-%u", \
117 msg, \
118 q->function ? q->function : "", \
119 q->filename ? q->filename : "", \
120 q->module ? q->module : "", \
121 (int)(q->format ? strlen(q->format) - 1 : 0), \
122 q->format ? q->format : "", \
123 q->first_lineno, q->last_lineno); \
124 } while (0)
125
126 /*
127 * Search the tables for _ddebug's which match the given `query' and
128 * apply the `flags' and `mask' to them. Returns number of matching
129 * callsites, normally the same as number of changes. If verbose,
130 * logs the changes. Takes ddebug_lock.
131 */
ddebug_change(const struct ddebug_query * query,unsigned int flags,unsigned int mask)132 static int ddebug_change(const struct ddebug_query *query,
133 unsigned int flags, unsigned int mask)
134 {
135 int i;
136 struct ddebug_table *dt;
137 unsigned int newflags;
138 unsigned int nfound = 0;
139 char flagbuf[10];
140
141 /* search for matching ddebugs */
142 mutex_lock(&ddebug_lock);
143 list_for_each_entry(dt, &ddebug_tables, link) {
144
145 /* match against the module name */
146 if (query->module && strcmp(query->module, dt->mod_name))
147 continue;
148
149 for (i = 0 ; i < dt->num_ddebugs ; i++) {
150 struct _ddebug *dp = &dt->ddebugs[i];
151
152 /* match against the source filename */
153 if (query->filename &&
154 strcmp(query->filename, dp->filename) &&
155 strcmp(query->filename, basename(dp->filename)) &&
156 strcmp(query->filename, trim_prefix(dp->filename)))
157 continue;
158
159 /* match against the function */
160 if (query->function &&
161 strcmp(query->function, dp->function))
162 continue;
163
164 /* match against the format */
165 if (query->format &&
166 !strstr(dp->format, query->format))
167 continue;
168
169 /* match against the line number range */
170 if (query->first_lineno &&
171 dp->lineno < query->first_lineno)
172 continue;
173 if (query->last_lineno &&
174 dp->lineno > query->last_lineno)
175 continue;
176
177 nfound++;
178
179 newflags = (dp->flags & mask) | flags;
180 if (newflags == dp->flags)
181 continue;
182 dp->flags = newflags;
183 if (verbose)
184 pr_info("changed %s:%d [%s]%s =%s\n",
185 trim_prefix(dp->filename), dp->lineno,
186 dt->mod_name, dp->function,
187 ddebug_describe_flags(dp, flagbuf,
188 sizeof(flagbuf)));
189 }
190 }
191 mutex_unlock(&ddebug_lock);
192
193 if (!nfound && verbose)
194 pr_info("no matches for query\n");
195
196 return nfound;
197 }
198
199 /*
200 * Split the buffer `buf' into space-separated words.
201 * Handles simple " and ' quoting, i.e. without nested,
202 * embedded or escaped \". Return the number of words
203 * or <0 on error.
204 */
ddebug_tokenize(char * buf,char * words[],int maxwords)205 static int ddebug_tokenize(char *buf, char *words[], int maxwords)
206 {
207 int nwords = 0;
208
209 while (*buf) {
210 char *end;
211
212 /* Skip leading whitespace */
213 buf = skip_spaces(buf);
214 if (!*buf)
215 break; /* oh, it was trailing whitespace */
216 if (*buf == '#')
217 break; /* token starts comment, skip rest of line */
218
219 /* find `end' of word, whitespace separated or quoted */
220 if (*buf == '"' || *buf == '\'') {
221 int quote = *buf++;
222 for (end = buf ; *end && *end != quote ; end++)
223 ;
224 if (!*end)
225 return -EINVAL; /* unclosed quote */
226 } else {
227 for (end = buf ; *end && !isspace(*end) ; end++)
228 ;
229 BUG_ON(end == buf);
230 }
231
232 /* `buf' is start of word, `end' is one past its end */
233 if (nwords == maxwords)
234 return -EINVAL; /* ran out of words[] before bytes */
235 if (*end)
236 *end++ = '\0'; /* terminate the word */
237 words[nwords++] = buf;
238 buf = end;
239 }
240
241 if (verbose) {
242 int i;
243 pr_info("split into words:");
244 for (i = 0 ; i < nwords ; i++)
245 pr_cont(" \"%s\"", words[i]);
246 pr_cont("\n");
247 }
248
249 return nwords;
250 }
251
252 /*
253 * Parse a single line number. Note that the empty string ""
254 * is treated as a special case and converted to zero, which
255 * is later treated as a "don't care" value.
256 */
parse_lineno(const char * str,unsigned int * val)257 static inline int parse_lineno(const char *str, unsigned int *val)
258 {
259 char *end = NULL;
260 BUG_ON(str == NULL);
261 if (*str == '\0') {
262 *val = 0;
263 return 0;
264 }
265 *val = simple_strtoul(str, &end, 10);
266 return end == NULL || end == str || *end != '\0' ? -EINVAL : 0;
267 }
268
269 /*
270 * Undo octal escaping in a string, inplace. This is useful to
271 * allow the user to express a query which matches a format
272 * containing embedded spaces.
273 */
274 #define isodigit(c) ((c) >= '0' && (c) <= '7')
unescape(char * str)275 static char *unescape(char *str)
276 {
277 char *in = str;
278 char *out = str;
279
280 while (*in) {
281 if (*in == '\\') {
282 if (in[1] == '\\') {
283 *out++ = '\\';
284 in += 2;
285 continue;
286 } else if (in[1] == 't') {
287 *out++ = '\t';
288 in += 2;
289 continue;
290 } else if (in[1] == 'n') {
291 *out++ = '\n';
292 in += 2;
293 continue;
294 } else if (isodigit(in[1]) &&
295 isodigit(in[2]) &&
296 isodigit(in[3])) {
297 *out++ = ((in[1] - '0')<<6) |
298 ((in[2] - '0')<<3) |
299 (in[3] - '0');
300 in += 4;
301 continue;
302 }
303 }
304 *out++ = *in++;
305 }
306 *out = '\0';
307
308 return str;
309 }
310
check_set(const char ** dest,char * src,char * name)311 static int check_set(const char **dest, char *src, char *name)
312 {
313 int rc = 0;
314
315 if (*dest) {
316 rc = -EINVAL;
317 pr_err("match-spec:%s val:%s overridden by %s",
318 name, *dest, src);
319 }
320 *dest = src;
321 return rc;
322 }
323
324 /*
325 * Parse words[] as a ddebug query specification, which is a series
326 * of (keyword, value) pairs chosen from these possibilities:
327 *
328 * func <function-name>
329 * file <full-pathname>
330 * file <base-filename>
331 * module <module-name>
332 * format <escaped-string-to-find-in-format>
333 * line <lineno>
334 * line <first-lineno>-<last-lineno> // where either may be empty
335 *
336 * Only 1 of each type is allowed.
337 * Returns 0 on success, <0 on error.
338 */
ddebug_parse_query(char * words[],int nwords,struct ddebug_query * query)339 static int ddebug_parse_query(char *words[], int nwords,
340 struct ddebug_query *query)
341 {
342 unsigned int i;
343 int rc;
344
345 /* check we have an even number of words */
346 if (nwords % 2 != 0)
347 return -EINVAL;
348 memset(query, 0, sizeof(*query));
349
350 for (i = 0 ; i < nwords ; i += 2) {
351 if (!strcmp(words[i], "func"))
352 rc = check_set(&query->function, words[i+1], "func");
353 else if (!strcmp(words[i], "file"))
354 rc = check_set(&query->filename, words[i+1], "file");
355 else if (!strcmp(words[i], "module"))
356 rc = check_set(&query->module, words[i+1], "module");
357 else if (!strcmp(words[i], "format"))
358 rc = check_set(&query->format, unescape(words[i+1]),
359 "format");
360 else if (!strcmp(words[i], "line")) {
361 char *first = words[i+1];
362 char *last = strchr(first, '-');
363 if (query->first_lineno || query->last_lineno) {
364 pr_err("match-spec:line given 2 times\n");
365 return -EINVAL;
366 }
367 if (last)
368 *last++ = '\0';
369 if (parse_lineno(first, &query->first_lineno) < 0)
370 return -EINVAL;
371 if (last) {
372 /* range <first>-<last> */
373 if (parse_lineno(last, &query->last_lineno)
374 < query->first_lineno) {
375 pr_err("last-line < 1st-line\n");
376 return -EINVAL;
377 }
378 } else {
379 query->last_lineno = query->first_lineno;
380 }
381 } else {
382 pr_err("unknown keyword \"%s\"\n", words[i]);
383 return -EINVAL;
384 }
385 if (rc)
386 return rc;
387 }
388 vpr_info_dq(query, "parsed");
389 return 0;
390 }
391
392 /*
393 * Parse `str' as a flags specification, format [-+=][p]+.
394 * Sets up *maskp and *flagsp to be used when changing the
395 * flags fields of matched _ddebug's. Returns 0 on success
396 * or <0 on error.
397 */
ddebug_parse_flags(const char * str,unsigned int * flagsp,unsigned int * maskp)398 static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
399 unsigned int *maskp)
400 {
401 unsigned flags = 0;
402 int op = '=', i;
403
404 switch (*str) {
405 case '+':
406 case '-':
407 case '=':
408 op = *str++;
409 break;
410 default:
411 return -EINVAL;
412 }
413 if (verbose)
414 pr_info("op='%c'\n", op);
415
416 for ( ; *str ; ++str) {
417 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
418 if (*str == opt_array[i].opt_char) {
419 flags |= opt_array[i].flag;
420 break;
421 }
422 }
423 if (i < 0)
424 return -EINVAL;
425 }
426 if (verbose)
427 pr_info("flags=0x%x\n", flags);
428
429 /* calculate final *flagsp, *maskp according to mask and op */
430 switch (op) {
431 case '=':
432 *maskp = 0;
433 *flagsp = flags;
434 break;
435 case '+':
436 *maskp = ~0U;
437 *flagsp = flags;
438 break;
439 case '-':
440 *maskp = ~flags;
441 *flagsp = 0;
442 break;
443 }
444 if (verbose)
445 pr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
446 return 0;
447 }
448
ddebug_exec_query(char * query_string)449 static int ddebug_exec_query(char *query_string)
450 {
451 unsigned int flags = 0, mask = 0;
452 struct ddebug_query query;
453 #define MAXWORDS 9
454 int nwords, nfound;
455 char *words[MAXWORDS];
456
457 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
458 if (nwords <= 0)
459 return -EINVAL;
460 if (ddebug_parse_query(words, nwords-1, &query))
461 return -EINVAL;
462 if (ddebug_parse_flags(words[nwords-1], &flags, &mask))
463 return -EINVAL;
464
465 /* actually go and implement the change */
466 nfound = ddebug_change(&query, flags, mask);
467 vpr_info_dq((&query), (nfound) ? "applied" : "no-match");
468
469 return nfound;
470 }
471
472 /* handle multiple queries in query string, continue on error, return
473 last error or number of matching callsites. Module name is either
474 in param (for boot arg) or perhaps in query string.
475 */
ddebug_exec_queries(char * query)476 static int ddebug_exec_queries(char *query)
477 {
478 char *split;
479 int i, errs = 0, exitcode = 0, rc, nfound = 0;
480
481 for (i = 0; query; query = split) {
482 split = strpbrk(query, ";\n");
483 if (split)
484 *split++ = '\0';
485
486 query = skip_spaces(query);
487 if (!query || !*query || *query == '#')
488 continue;
489
490 if (verbose)
491 pr_info("query %d: \"%s\"\n", i, query);
492
493 rc = ddebug_exec_query(query);
494 if (rc < 0) {
495 errs++;
496 exitcode = rc;
497 } else
498 nfound += rc;
499 i++;
500 }
501 pr_info("processed %d queries, with %d matches, %d errs\n",
502 i, nfound, errs);
503
504 if (exitcode)
505 return exitcode;
506 return nfound;
507 }
508
509 #define PREFIX_SIZE 64
510
remaining(int wrote)511 static int remaining(int wrote)
512 {
513 if (PREFIX_SIZE - wrote > 0)
514 return PREFIX_SIZE - wrote;
515 return 0;
516 }
517
dynamic_emit_prefix(const struct _ddebug * desc,char * buf)518 static char *dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
519 {
520 int pos_after_tid;
521 int pos = 0;
522
523 pos += snprintf(buf + pos, remaining(pos), "%s", KERN_DEBUG);
524 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
525 if (in_interrupt())
526 pos += snprintf(buf + pos, remaining(pos), "%s ",
527 "<intr>");
528 else
529 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
530 task_pid_vnr(current));
531 }
532 pos_after_tid = pos;
533 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
534 pos += snprintf(buf + pos, remaining(pos), "%s:",
535 desc->modname);
536 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
537 pos += snprintf(buf + pos, remaining(pos), "%s:",
538 desc->function);
539 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
540 pos += snprintf(buf + pos, remaining(pos), "%d:",
541 desc->lineno);
542 if (pos - pos_after_tid)
543 pos += snprintf(buf + pos, remaining(pos), " ");
544 if (pos >= PREFIX_SIZE)
545 buf[PREFIX_SIZE - 1] = '\0';
546
547 return buf;
548 }
549
__dynamic_pr_debug(struct _ddebug * descriptor,const char * fmt,...)550 int __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
551 {
552 va_list args;
553 int res;
554 struct va_format vaf;
555 char buf[PREFIX_SIZE];
556
557 BUG_ON(!descriptor);
558 BUG_ON(!fmt);
559
560 va_start(args, fmt);
561 vaf.fmt = fmt;
562 vaf.va = &args;
563 res = printk("%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
564 va_end(args);
565
566 return res;
567 }
568 EXPORT_SYMBOL(__dynamic_pr_debug);
569
__dynamic_dev_dbg(struct _ddebug * descriptor,const struct device * dev,const char * fmt,...)570 int __dynamic_dev_dbg(struct _ddebug *descriptor,
571 const struct device *dev, const char *fmt, ...)
572 {
573 struct va_format vaf;
574 va_list args;
575 int res;
576 char buf[PREFIX_SIZE];
577
578 BUG_ON(!descriptor);
579 BUG_ON(!fmt);
580
581 va_start(args, fmt);
582 vaf.fmt = fmt;
583 vaf.va = &args;
584 res = __dev_printk(dynamic_emit_prefix(descriptor, buf), dev, &vaf);
585 va_end(args);
586
587 return res;
588 }
589 EXPORT_SYMBOL(__dynamic_dev_dbg);
590
591 #ifdef CONFIG_NET
592
__dynamic_netdev_dbg(struct _ddebug * descriptor,const struct net_device * dev,const char * fmt,...)593 int __dynamic_netdev_dbg(struct _ddebug *descriptor,
594 const struct net_device *dev, const char *fmt, ...)
595 {
596 struct va_format vaf;
597 va_list args;
598 int res;
599 char buf[PREFIX_SIZE];
600
601 BUG_ON(!descriptor);
602 BUG_ON(!fmt);
603
604 va_start(args, fmt);
605 vaf.fmt = fmt;
606 vaf.va = &args;
607 res = __netdev_printk(dynamic_emit_prefix(descriptor, buf), dev, &vaf);
608 va_end(args);
609
610 return res;
611 }
612 EXPORT_SYMBOL(__dynamic_netdev_dbg);
613
614 #endif
615
616 #define DDEBUG_STRING_SIZE 1024
617 static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
618
ddebug_setup_query(char * str)619 static __init int ddebug_setup_query(char *str)
620 {
621 if (strlen(str) >= DDEBUG_STRING_SIZE) {
622 pr_warn("ddebug boot param string too large\n");
623 return 0;
624 }
625 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
626 return 1;
627 }
628
629 __setup("ddebug_query=", ddebug_setup_query);
630
631 /*
632 * File_ops->write method for <debugfs>/dynamic_debug/conrol. Gathers the
633 * command text from userspace, parses and executes it.
634 */
635 #define USER_BUF_PAGE 4096
ddebug_proc_write(struct file * file,const char __user * ubuf,size_t len,loff_t * offp)636 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
637 size_t len, loff_t *offp)
638 {
639 char *tmpbuf;
640 int ret;
641
642 if (len == 0)
643 return 0;
644 if (len > USER_BUF_PAGE - 1) {
645 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
646 return -E2BIG;
647 }
648 tmpbuf = kmalloc(len + 1, GFP_KERNEL);
649 if (!tmpbuf)
650 return -ENOMEM;
651 if (copy_from_user(tmpbuf, ubuf, len)) {
652 kfree(tmpbuf);
653 return -EFAULT;
654 }
655 tmpbuf[len] = '\0';
656 if (verbose)
657 pr_info("read %d bytes from userspace\n", (int)len);
658
659 ret = ddebug_exec_queries(tmpbuf);
660 kfree(tmpbuf);
661 if (ret < 0)
662 return ret;
663
664 *offp += len;
665 return len;
666 }
667
668 /*
669 * Set the iterator to point to the first _ddebug object
670 * and return a pointer to that first object. Returns
671 * NULL if there are no _ddebugs at all.
672 */
ddebug_iter_first(struct ddebug_iter * iter)673 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
674 {
675 if (list_empty(&ddebug_tables)) {
676 iter->table = NULL;
677 iter->idx = 0;
678 return NULL;
679 }
680 iter->table = list_entry(ddebug_tables.next,
681 struct ddebug_table, link);
682 iter->idx = 0;
683 return &iter->table->ddebugs[iter->idx];
684 }
685
686 /*
687 * Advance the iterator to point to the next _ddebug
688 * object from the one the iterator currently points at,
689 * and returns a pointer to the new _ddebug. Returns
690 * NULL if the iterator has seen all the _ddebugs.
691 */
ddebug_iter_next(struct ddebug_iter * iter)692 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
693 {
694 if (iter->table == NULL)
695 return NULL;
696 if (++iter->idx == iter->table->num_ddebugs) {
697 /* iterate to next table */
698 iter->idx = 0;
699 if (list_is_last(&iter->table->link, &ddebug_tables)) {
700 iter->table = NULL;
701 return NULL;
702 }
703 iter->table = list_entry(iter->table->link.next,
704 struct ddebug_table, link);
705 }
706 return &iter->table->ddebugs[iter->idx];
707 }
708
709 /*
710 * Seq_ops start method. Called at the start of every
711 * read() call from userspace. Takes the ddebug_lock and
712 * seeks the seq_file's iterator to the given position.
713 */
ddebug_proc_start(struct seq_file * m,loff_t * pos)714 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
715 {
716 struct ddebug_iter *iter = m->private;
717 struct _ddebug *dp;
718 int n = *pos;
719
720 if (verbose)
721 pr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
722
723 mutex_lock(&ddebug_lock);
724
725 if (!n)
726 return SEQ_START_TOKEN;
727 if (n < 0)
728 return NULL;
729 dp = ddebug_iter_first(iter);
730 while (dp != NULL && --n > 0)
731 dp = ddebug_iter_next(iter);
732 return dp;
733 }
734
735 /*
736 * Seq_ops next method. Called several times within a read()
737 * call from userspace, with ddebug_lock held. Walks to the
738 * next _ddebug object with a special case for the header line.
739 */
ddebug_proc_next(struct seq_file * m,void * p,loff_t * pos)740 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
741 {
742 struct ddebug_iter *iter = m->private;
743 struct _ddebug *dp;
744
745 if (verbose)
746 pr_info("called m=%p p=%p *pos=%lld\n",
747 m, p, (unsigned long long)*pos);
748
749 if (p == SEQ_START_TOKEN)
750 dp = ddebug_iter_first(iter);
751 else
752 dp = ddebug_iter_next(iter);
753 ++*pos;
754 return dp;
755 }
756
757 /*
758 * Seq_ops show method. Called several times within a read()
759 * call from userspace, with ddebug_lock held. Formats the
760 * current _ddebug as a single human-readable line, with a
761 * special case for the header line.
762 */
ddebug_proc_show(struct seq_file * m,void * p)763 static int ddebug_proc_show(struct seq_file *m, void *p)
764 {
765 struct ddebug_iter *iter = m->private;
766 struct _ddebug *dp = p;
767 char flagsbuf[10];
768
769 if (verbose)
770 pr_info("called m=%p p=%p\n", m, p);
771
772 if (p == SEQ_START_TOKEN) {
773 seq_puts(m,
774 "# filename:lineno [module]function flags format\n");
775 return 0;
776 }
777
778 seq_printf(m, "%s:%u [%s]%s =%s \"",
779 trim_prefix(dp->filename), dp->lineno,
780 iter->table->mod_name, dp->function,
781 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
782 seq_escape(m, dp->format, "\t\r\n\"");
783 seq_puts(m, "\"\n");
784
785 return 0;
786 }
787
788 /*
789 * Seq_ops stop method. Called at the end of each read()
790 * call from userspace. Drops ddebug_lock.
791 */
ddebug_proc_stop(struct seq_file * m,void * p)792 static void ddebug_proc_stop(struct seq_file *m, void *p)
793 {
794 if (verbose)
795 pr_info("called m=%p p=%p\n", m, p);
796 mutex_unlock(&ddebug_lock);
797 }
798
799 static const struct seq_operations ddebug_proc_seqops = {
800 .start = ddebug_proc_start,
801 .next = ddebug_proc_next,
802 .show = ddebug_proc_show,
803 .stop = ddebug_proc_stop
804 };
805
806 /*
807 * File_ops->open method for <debugfs>/dynamic_debug/control. Does
808 * the seq_file setup dance, and also creates an iterator to walk the
809 * _ddebugs. Note that we create a seq_file always, even for O_WRONLY
810 * files where it's not needed, as doing so simplifies the ->release
811 * method.
812 */
ddebug_proc_open(struct inode * inode,struct file * file)813 static int ddebug_proc_open(struct inode *inode, struct file *file)
814 {
815 struct ddebug_iter *iter;
816 int err;
817
818 if (verbose)
819 pr_info("called\n");
820
821 iter = kzalloc(sizeof(*iter), GFP_KERNEL);
822 if (iter == NULL)
823 return -ENOMEM;
824
825 err = seq_open(file, &ddebug_proc_seqops);
826 if (err) {
827 kfree(iter);
828 return err;
829 }
830 ((struct seq_file *) file->private_data)->private = iter;
831 return 0;
832 }
833
834 static const struct file_operations ddebug_proc_fops = {
835 .owner = THIS_MODULE,
836 .open = ddebug_proc_open,
837 .read = seq_read,
838 .llseek = seq_lseek,
839 .release = seq_release_private,
840 .write = ddebug_proc_write
841 };
842
843 /*
844 * Allocate a new ddebug_table for the given module
845 * and add it to the global list.
846 */
ddebug_add_module(struct _ddebug * tab,unsigned int n,const char * name)847 int ddebug_add_module(struct _ddebug *tab, unsigned int n,
848 const char *name)
849 {
850 struct ddebug_table *dt;
851 char *new_name;
852
853 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
854 if (dt == NULL)
855 return -ENOMEM;
856 new_name = kstrdup(name, GFP_KERNEL);
857 if (new_name == NULL) {
858 kfree(dt);
859 return -ENOMEM;
860 }
861 dt->mod_name = new_name;
862 dt->num_ddebugs = n;
863 dt->ddebugs = tab;
864
865 mutex_lock(&ddebug_lock);
866 list_add_tail(&dt->link, &ddebug_tables);
867 mutex_unlock(&ddebug_lock);
868
869 if (verbose)
870 pr_info("%u debug prints in module %s\n", n, dt->mod_name);
871 return 0;
872 }
873 EXPORT_SYMBOL_GPL(ddebug_add_module);
874
ddebug_table_free(struct ddebug_table * dt)875 static void ddebug_table_free(struct ddebug_table *dt)
876 {
877 list_del_init(&dt->link);
878 kfree(dt->mod_name);
879 kfree(dt);
880 }
881
882 /*
883 * Called in response to a module being unloaded. Removes
884 * any ddebug_table's which point at the module.
885 */
ddebug_remove_module(const char * mod_name)886 int ddebug_remove_module(const char *mod_name)
887 {
888 struct ddebug_table *dt, *nextdt;
889 int ret = -ENOENT;
890
891 if (verbose)
892 pr_info("removing module \"%s\"\n", mod_name);
893
894 mutex_lock(&ddebug_lock);
895 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
896 if (!strcmp(dt->mod_name, mod_name)) {
897 ddebug_table_free(dt);
898 ret = 0;
899 }
900 }
901 mutex_unlock(&ddebug_lock);
902 return ret;
903 }
904 EXPORT_SYMBOL_GPL(ddebug_remove_module);
905
ddebug_remove_all_tables(void)906 static void ddebug_remove_all_tables(void)
907 {
908 mutex_lock(&ddebug_lock);
909 while (!list_empty(&ddebug_tables)) {
910 struct ddebug_table *dt = list_entry(ddebug_tables.next,
911 struct ddebug_table,
912 link);
913 ddebug_table_free(dt);
914 }
915 mutex_unlock(&ddebug_lock);
916 }
917
918 static __initdata int ddebug_init_success;
919
dynamic_debug_init_debugfs(void)920 static int __init dynamic_debug_init_debugfs(void)
921 {
922 struct dentry *dir, *file;
923
924 if (!ddebug_init_success)
925 return -ENODEV;
926
927 dir = debugfs_create_dir("dynamic_debug", NULL);
928 if (!dir)
929 return -ENOMEM;
930 file = debugfs_create_file("control", 0644, dir, NULL,
931 &ddebug_proc_fops);
932 if (!file) {
933 debugfs_remove(dir);
934 return -ENOMEM;
935 }
936 return 0;
937 }
938
dynamic_debug_init(void)939 static int __init dynamic_debug_init(void)
940 {
941 struct _ddebug *iter, *iter_start;
942 const char *modname = NULL;
943 int ret = 0;
944 int n = 0;
945
946 if (__start___verbose == __stop___verbose) {
947 pr_warn("_ddebug table is empty in a "
948 "CONFIG_DYNAMIC_DEBUG build");
949 return 1;
950 }
951 iter = __start___verbose;
952 modname = iter->modname;
953 iter_start = iter;
954 for (; iter < __stop___verbose; iter++) {
955 if (strcmp(modname, iter->modname)) {
956 ret = ddebug_add_module(iter_start, n, modname);
957 if (ret)
958 goto out_free;
959 n = 0;
960 modname = iter->modname;
961 iter_start = iter;
962 }
963 n++;
964 }
965 ret = ddebug_add_module(iter_start, n, modname);
966 if (ret)
967 goto out_free;
968
969 /* ddebug_query boot param got passed -> set it up */
970 if (ddebug_setup_string[0] != '\0') {
971 ret = ddebug_exec_queries(ddebug_setup_string);
972 if (ret < 0)
973 pr_warn("Invalid ddebug boot param %s",
974 ddebug_setup_string);
975 else
976 pr_info("%d changes by ddebug_query\n", ret);
977
978 /* keep tables even on ddebug_query parse error */
979 ret = 0;
980 }
981
982 out_free:
983 if (ret)
984 ddebug_remove_all_tables();
985 else
986 ddebug_init_success = 1;
987 return 0;
988 }
989 /* Allow early initialization for boot messages via boot param */
990 arch_initcall(dynamic_debug_init);
991 /* Debugfs setup must be done later */
992 module_init(dynamic_debug_init_debugfs);
993