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