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