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