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