Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6
[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  */
11
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/kallsyms.h>
16 #include <linux/version.h>
17 #include <linux/types.h>
18 #include <linux/mutex.h>
19 #include <linux/proc_fs.h>
20 #include <linux/seq_file.h>
21 #include <linux/list.h>
22 #include <linux/sysctl.h>
23 #include <linux/ctype.h>
24 #include <linux/string.h>
25 #include <linux/uaccess.h>
26 #include <linux/dynamic_debug.h>
27 #include <linux/debugfs.h>
28 #include <linux/slab.h>
29 #include <linux/jump_label.h>
30
31 extern struct _ddebug __start___verbose[];
32 extern struct _ddebug __stop___verbose[];
33
34 struct ddebug_table {
35         struct list_head link;
36         char *mod_name;
37         unsigned int num_ddebugs;
38         unsigned int num_enabled;
39         struct _ddebug *ddebugs;
40 };
41
42 struct ddebug_query {
43         const char *filename;
44         const char *module;
45         const char *function;
46         const char *format;
47         unsigned int first_lineno, last_lineno;
48 };
49
50 struct ddebug_iter {
51         struct ddebug_table *table;
52         unsigned int idx;
53 };
54
55 static DEFINE_MUTEX(ddebug_lock);
56 static LIST_HEAD(ddebug_tables);
57 static int verbose = 0;
58
59 /* Return the last part of a pathname */
60 static inline const char *basename(const char *path)
61 {
62         const char *tail = strrchr(path, '/');
63         return tail ? tail+1 : path;
64 }
65
66 /* format a string into buf[] which describes the _ddebug's flags */
67 static char *ddebug_describe_flags(struct _ddebug *dp, char *buf,
68                                     size_t maxlen)
69 {
70         char *p = buf;
71
72         BUG_ON(maxlen < 4);
73         if (dp->flags & _DPRINTK_FLAGS_PRINT)
74                 *p++ = 'p';
75         if (p == buf)
76                 *p++ = '-';
77         *p = '\0';
78
79         return buf;
80 }
81
82 /*
83  * Search the tables for _ddebug's which match the given
84  * `query' and apply the `flags' and `mask' to them.  Tells
85  * the user which ddebug's were changed, or whether none
86  * were matched.
87  */
88 static void ddebug_change(const struct ddebug_query *query,
89                            unsigned int flags, unsigned int mask)
90 {
91         int i;
92         struct ddebug_table *dt;
93         unsigned int newflags;
94         unsigned int nfound = 0;
95         char flagbuf[8];
96
97         /* search for matching ddebugs */
98         mutex_lock(&ddebug_lock);
99         list_for_each_entry(dt, &ddebug_tables, link) {
100
101                 /* match against the module name */
102                 if (query->module != NULL &&
103                     strcmp(query->module, dt->mod_name))
104                         continue;
105
106                 for (i = 0 ; i < dt->num_ddebugs ; i++) {
107                         struct _ddebug *dp = &dt->ddebugs[i];
108
109                         /* match against the source filename */
110                         if (query->filename != NULL &&
111                             strcmp(query->filename, dp->filename) &&
112                             strcmp(query->filename, basename(dp->filename)))
113                                 continue;
114
115                         /* match against the function */
116                         if (query->function != NULL &&
117                             strcmp(query->function, dp->function))
118                                 continue;
119
120                         /* match against the format */
121                         if (query->format != NULL &&
122                             strstr(dp->format, query->format) == NULL)
123                                 continue;
124
125                         /* match against the line number range */
126                         if (query->first_lineno &&
127                             dp->lineno < query->first_lineno)
128                                 continue;
129                         if (query->last_lineno &&
130                             dp->lineno > query->last_lineno)
131                                 continue;
132
133                         nfound++;
134
135                         newflags = (dp->flags & mask) | flags;
136                         if (newflags == dp->flags)
137                                 continue;
138
139                         if (!newflags)
140                                 dt->num_enabled--;
141                         else if (!dp->flags)
142                                 dt->num_enabled++;
143                         dp->flags = newflags;
144                         if (newflags) {
145                                 jump_label_enable(&dp->enabled);
146                         } else {
147                                 jump_label_disable(&dp->enabled);
148                         }
149                         if (verbose)
150                                 printk(KERN_INFO
151                                         "ddebug: changed %s:%d [%s]%s %s\n",
152                                         dp->filename, dp->lineno,
153                                         dt->mod_name, dp->function,
154                                         ddebug_describe_flags(dp, flagbuf,
155                                                         sizeof(flagbuf)));
156                 }
157         }
158         mutex_unlock(&ddebug_lock);
159
160         if (!nfound && verbose)
161                 printk(KERN_INFO "ddebug: no matches for query\n");
162 }
163
164 /*
165  * Split the buffer `buf' into space-separated words.
166  * Handles simple " and ' quoting, i.e. without nested,
167  * embedded or escaped \".  Return the number of words
168  * or <0 on error.
169  */
170 static int ddebug_tokenize(char *buf, char *words[], int maxwords)
171 {
172         int nwords = 0;
173
174         while (*buf) {
175                 char *end;
176
177                 /* Skip leading whitespace */
178                 buf = skip_spaces(buf);
179                 if (!*buf)
180                         break;  /* oh, it was trailing whitespace */
181
182                 /* Run `end' over a word, either whitespace separated or quoted */
183                 if (*buf == '"' || *buf == '\'') {
184                         int quote = *buf++;
185                         for (end = buf ; *end && *end != quote ; end++)
186                                 ;
187                         if (!*end)
188                                 return -EINVAL; /* unclosed quote */
189                 } else {
190                         for (end = buf ; *end && !isspace(*end) ; end++)
191                                 ;
192                         BUG_ON(end == buf);
193                 }
194                 /* Here `buf' is the start of the word, `end' is one past the end */
195
196                 if (nwords == maxwords)
197                         return -EINVAL; /* ran out of words[] before bytes */
198                 if (*end)
199                         *end++ = '\0';  /* terminate the word */
200                 words[nwords++] = buf;
201                 buf = end;
202         }
203
204         if (verbose) {
205                 int i;
206                 printk(KERN_INFO "%s: split into words:", __func__);
207                 for (i = 0 ; i < nwords ; i++)
208                         printk(" \"%s\"", words[i]);
209                 printk("\n");
210         }
211
212         return nwords;
213 }
214
215 /*
216  * Parse a single line number.  Note that the empty string ""
217  * is treated as a special case and converted to zero, which
218  * is later treated as a "don't care" value.
219  */
220 static inline int parse_lineno(const char *str, unsigned int *val)
221 {
222         char *end = NULL;
223         BUG_ON(str == NULL);
224         if (*str == '\0') {
225                 *val = 0;
226                 return 0;
227         }
228         *val = simple_strtoul(str, &end, 10);
229         return end == NULL || end == str || *end != '\0' ? -EINVAL : 0;
230 }
231
232 /*
233  * Undo octal escaping in a string, inplace.  This is useful to
234  * allow the user to express a query which matches a format
235  * containing embedded spaces.
236  */
237 #define isodigit(c)             ((c) >= '0' && (c) <= '7')
238 static char *unescape(char *str)
239 {
240         char *in = str;
241         char *out = str;
242
243         while (*in) {
244                 if (*in == '\\') {
245                         if (in[1] == '\\') {
246                                 *out++ = '\\';
247                                 in += 2;
248                                 continue;
249                         } else if (in[1] == 't') {
250                                 *out++ = '\t';
251                                 in += 2;
252                                 continue;
253                         } else if (in[1] == 'n') {
254                                 *out++ = '\n';
255                                 in += 2;
256                                 continue;
257                         } else if (isodigit(in[1]) &&
258                                  isodigit(in[2]) &&
259                                  isodigit(in[3])) {
260                                 *out++ = ((in[1] - '0')<<6) |
261                                           ((in[2] - '0')<<3) |
262                                           (in[3] - '0');
263                                 in += 4;
264                                 continue;
265                         }
266                 }
267                 *out++ = *in++;
268         }
269         *out = '\0';
270
271         return str;
272 }
273
274 /*
275  * Parse words[] as a ddebug query specification, which is a series
276  * of (keyword, value) pairs chosen from these possibilities:
277  *
278  * func <function-name>
279  * file <full-pathname>
280  * file <base-filename>
281  * module <module-name>
282  * format <escaped-string-to-find-in-format>
283  * line <lineno>
284  * line <first-lineno>-<last-lineno> // where either may be empty
285  */
286 static int ddebug_parse_query(char *words[], int nwords,
287                                struct ddebug_query *query)
288 {
289         unsigned int i;
290
291         /* check we have an even number of words */
292         if (nwords % 2 != 0)
293                 return -EINVAL;
294         memset(query, 0, sizeof(*query));
295
296         for (i = 0 ; i < nwords ; i += 2) {
297                 if (!strcmp(words[i], "func"))
298                         query->function = words[i+1];
299                 else if (!strcmp(words[i], "file"))
300                         query->filename = words[i+1];
301                 else if (!strcmp(words[i], "module"))
302                         query->module = words[i+1];
303                 else if (!strcmp(words[i], "format"))
304                         query->format = unescape(words[i+1]);
305                 else if (!strcmp(words[i], "line")) {
306                         char *first = words[i+1];
307                         char *last = strchr(first, '-');
308                         if (last)
309                                 *last++ = '\0';
310                         if (parse_lineno(first, &query->first_lineno) < 0)
311                                 return -EINVAL;
312                         if (last != NULL) {
313                                 /* range <first>-<last> */
314                                 if (parse_lineno(last, &query->last_lineno) < 0)
315                                         return -EINVAL;
316                         } else {
317                                 query->last_lineno = query->first_lineno;
318                         }
319                 } else {
320                         if (verbose)
321                                 printk(KERN_ERR "%s: unknown keyword \"%s\"\n",
322                                         __func__, words[i]);
323                         return -EINVAL;
324                 }
325         }
326
327         if (verbose)
328                 printk(KERN_INFO "%s: q->function=\"%s\" q->filename=\"%s\" "
329                        "q->module=\"%s\" q->format=\"%s\" q->lineno=%u-%u\n",
330                         __func__, query->function, query->filename,
331                         query->module, query->format, query->first_lineno,
332                         query->last_lineno);
333
334         return 0;
335 }
336
337 /*
338  * Parse `str' as a flags specification, format [-+=][p]+.
339  * Sets up *maskp and *flagsp to be used when changing the
340  * flags fields of matched _ddebug's.  Returns 0 on success
341  * or <0 on error.
342  */
343 static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
344                                unsigned int *maskp)
345 {
346         unsigned flags = 0;
347         int op = '=';
348
349         switch (*str) {
350         case '+':
351         case '-':
352         case '=':
353                 op = *str++;
354                 break;
355         default:
356                 return -EINVAL;
357         }
358         if (verbose)
359                 printk(KERN_INFO "%s: op='%c'\n", __func__, op);
360
361         for ( ; *str ; ++str) {
362                 switch (*str) {
363                 case 'p':
364                         flags |= _DPRINTK_FLAGS_PRINT;
365                         break;
366                 default:
367                         return -EINVAL;
368                 }
369         }
370         if (flags == 0)
371                 return -EINVAL;
372         if (verbose)
373                 printk(KERN_INFO "%s: flags=0x%x\n", __func__, flags);
374
375         /* calculate final *flagsp, *maskp according to mask and op */
376         switch (op) {
377         case '=':
378                 *maskp = 0;
379                 *flagsp = flags;
380                 break;
381         case '+':
382                 *maskp = ~0U;
383                 *flagsp = flags;
384                 break;
385         case '-':
386                 *maskp = ~flags;
387                 *flagsp = 0;
388                 break;
389         }
390         if (verbose)
391                 printk(KERN_INFO "%s: *flagsp=0x%x *maskp=0x%x\n",
392                         __func__, *flagsp, *maskp);
393         return 0;
394 }
395
396 static int ddebug_exec_query(char *query_string)
397 {
398         unsigned int flags = 0, mask = 0;
399         struct ddebug_query query;
400 #define MAXWORDS 9
401         int nwords;
402         char *words[MAXWORDS];
403
404         nwords = ddebug_tokenize(query_string, words, MAXWORDS);
405         if (nwords <= 0)
406                 return -EINVAL;
407         if (ddebug_parse_query(words, nwords-1, &query))
408                 return -EINVAL;
409         if (ddebug_parse_flags(words[nwords-1], &flags, &mask))
410                 return -EINVAL;
411
412         /* actually go and implement the change */
413         ddebug_change(&query, flags, mask);
414         return 0;
415 }
416
417 static __initdata char ddebug_setup_string[1024];
418 static __init int ddebug_setup_query(char *str)
419 {
420         if (strlen(str) >= 1024) {
421                 pr_warning("ddebug boot param string too large\n");
422                 return 0;
423         }
424         strcpy(ddebug_setup_string, str);
425         return 1;
426 }
427
428 __setup("ddebug_query=", ddebug_setup_query);
429
430 /*
431  * File_ops->write method for <debugfs>/dynamic_debug/conrol.  Gathers the
432  * command text from userspace, parses and executes it.
433  */
434 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
435                                   size_t len, loff_t *offp)
436 {
437         char tmpbuf[256];
438         int ret;
439
440         if (len == 0)
441                 return 0;
442         /* we don't check *offp -- multiple writes() are allowed */
443         if (len > sizeof(tmpbuf)-1)
444                 return -E2BIG;
445         if (copy_from_user(tmpbuf, ubuf, len))
446                 return -EFAULT;
447         tmpbuf[len] = '\0';
448         if (verbose)
449                 printk(KERN_INFO "%s: read %d bytes from userspace\n",
450                         __func__, (int)len);
451
452         ret = ddebug_exec_query(tmpbuf);
453         if (ret)
454                 return ret;
455
456         *offp += len;
457         return len;
458 }
459
460 /*
461  * Set the iterator to point to the first _ddebug object
462  * and return a pointer to that first object.  Returns
463  * NULL if there are no _ddebugs at all.
464  */
465 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
466 {
467         if (list_empty(&ddebug_tables)) {
468                 iter->table = NULL;
469                 iter->idx = 0;
470                 return NULL;
471         }
472         iter->table = list_entry(ddebug_tables.next,
473                                  struct ddebug_table, link);
474         iter->idx = 0;
475         return &iter->table->ddebugs[iter->idx];
476 }
477
478 /*
479  * Advance the iterator to point to the next _ddebug
480  * object from the one the iterator currently points at,
481  * and returns a pointer to the new _ddebug.  Returns
482  * NULL if the iterator has seen all the _ddebugs.
483  */
484 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
485 {
486         if (iter->table == NULL)
487                 return NULL;
488         if (++iter->idx == iter->table->num_ddebugs) {
489                 /* iterate to next table */
490                 iter->idx = 0;
491                 if (list_is_last(&iter->table->link, &ddebug_tables)) {
492                         iter->table = NULL;
493                         return NULL;
494                 }
495                 iter->table = list_entry(iter->table->link.next,
496                                          struct ddebug_table, link);
497         }
498         return &iter->table->ddebugs[iter->idx];
499 }
500
501 /*
502  * Seq_ops start method.  Called at the start of every
503  * read() call from userspace.  Takes the ddebug_lock and
504  * seeks the seq_file's iterator to the given position.
505  */
506 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
507 {
508         struct ddebug_iter *iter = m->private;
509         struct _ddebug *dp;
510         int n = *pos;
511
512         if (verbose)
513                 printk(KERN_INFO "%s: called m=%p *pos=%lld\n",
514                         __func__, m, (unsigned long long)*pos);
515
516         mutex_lock(&ddebug_lock);
517
518         if (!n)
519                 return SEQ_START_TOKEN;
520         if (n < 0)
521                 return NULL;
522         dp = ddebug_iter_first(iter);
523         while (dp != NULL && --n > 0)
524                 dp = ddebug_iter_next(iter);
525         return dp;
526 }
527
528 /*
529  * Seq_ops next method.  Called several times within a read()
530  * call from userspace, with ddebug_lock held.  Walks to the
531  * next _ddebug object with a special case for the header line.
532  */
533 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
534 {
535         struct ddebug_iter *iter = m->private;
536         struct _ddebug *dp;
537
538         if (verbose)
539                 printk(KERN_INFO "%s: called m=%p p=%p *pos=%lld\n",
540                         __func__, m, p, (unsigned long long)*pos);
541
542         if (p == SEQ_START_TOKEN)
543                 dp = ddebug_iter_first(iter);
544         else
545                 dp = ddebug_iter_next(iter);
546         ++*pos;
547         return dp;
548 }
549
550 /*
551  * Seq_ops show method.  Called several times within a read()
552  * call from userspace, with ddebug_lock held.  Formats the
553  * current _ddebug as a single human-readable line, with a
554  * special case for the header line.
555  */
556 static int ddebug_proc_show(struct seq_file *m, void *p)
557 {
558         struct ddebug_iter *iter = m->private;
559         struct _ddebug *dp = p;
560         char flagsbuf[8];
561
562         if (verbose)
563                 printk(KERN_INFO "%s: called m=%p p=%p\n",
564                         __func__, m, p);
565
566         if (p == SEQ_START_TOKEN) {
567                 seq_puts(m,
568                         "# filename:lineno [module]function flags format\n");
569                 return 0;
570         }
571
572         seq_printf(m, "%s:%u [%s]%s %s \"",
573                    dp->filename, dp->lineno,
574                    iter->table->mod_name, dp->function,
575                    ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
576         seq_escape(m, dp->format, "\t\r\n\"");
577         seq_puts(m, "\"\n");
578
579         return 0;
580 }
581
582 /*
583  * Seq_ops stop method.  Called at the end of each read()
584  * call from userspace.  Drops ddebug_lock.
585  */
586 static void ddebug_proc_stop(struct seq_file *m, void *p)
587 {
588         if (verbose)
589                 printk(KERN_INFO "%s: called m=%p p=%p\n",
590                         __func__, m, p);
591         mutex_unlock(&ddebug_lock);
592 }
593
594 static const struct seq_operations ddebug_proc_seqops = {
595         .start = ddebug_proc_start,
596         .next = ddebug_proc_next,
597         .show = ddebug_proc_show,
598         .stop = ddebug_proc_stop
599 };
600
601 /*
602  * File_ops->open method for <debugfs>/dynamic_debug/control.  Does the seq_file
603  * setup dance, and also creates an iterator to walk the _ddebugs.
604  * Note that we create a seq_file always, even for O_WRONLY files
605  * where it's not needed, as doing so simplifies the ->release method.
606  */
607 static int ddebug_proc_open(struct inode *inode, struct file *file)
608 {
609         struct ddebug_iter *iter;
610         int err;
611
612         if (verbose)
613                 printk(KERN_INFO "%s: called\n", __func__);
614
615         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
616         if (iter == NULL)
617                 return -ENOMEM;
618
619         err = seq_open(file, &ddebug_proc_seqops);
620         if (err) {
621                 kfree(iter);
622                 return err;
623         }
624         ((struct seq_file *) file->private_data)->private = iter;
625         return 0;
626 }
627
628 static const struct file_operations ddebug_proc_fops = {
629         .owner = THIS_MODULE,
630         .open = ddebug_proc_open,
631         .read = seq_read,
632         .llseek = seq_lseek,
633         .release = seq_release_private,
634         .write = ddebug_proc_write
635 };
636
637 /*
638  * Allocate a new ddebug_table for the given module
639  * and add it to the global list.
640  */
641 int ddebug_add_module(struct _ddebug *tab, unsigned int n,
642                              const char *name)
643 {
644         struct ddebug_table *dt;
645         char *new_name;
646
647         dt = kzalloc(sizeof(*dt), GFP_KERNEL);
648         if (dt == NULL)
649                 return -ENOMEM;
650         new_name = kstrdup(name, GFP_KERNEL);
651         if (new_name == NULL) {
652                 kfree(dt);
653                 return -ENOMEM;
654         }
655         dt->mod_name = new_name;
656         dt->num_ddebugs = n;
657         dt->num_enabled = 0;
658         dt->ddebugs = tab;
659
660         mutex_lock(&ddebug_lock);
661         list_add_tail(&dt->link, &ddebug_tables);
662         mutex_unlock(&ddebug_lock);
663
664         if (verbose)
665                 printk(KERN_INFO "%u debug prints in module %s\n",
666                                  n, dt->mod_name);
667         return 0;
668 }
669 EXPORT_SYMBOL_GPL(ddebug_add_module);
670
671 static void ddebug_table_free(struct ddebug_table *dt)
672 {
673         list_del_init(&dt->link);
674         kfree(dt->mod_name);
675         kfree(dt);
676 }
677
678 /*
679  * Called in response to a module being unloaded.  Removes
680  * any ddebug_table's which point at the module.
681  */
682 int ddebug_remove_module(const char *mod_name)
683 {
684         struct ddebug_table *dt, *nextdt;
685         int ret = -ENOENT;
686
687         if (verbose)
688                 printk(KERN_INFO "%s: removing module \"%s\"\n",
689                                 __func__, mod_name);
690
691         mutex_lock(&ddebug_lock);
692         list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
693                 if (!strcmp(dt->mod_name, mod_name)) {
694                         ddebug_table_free(dt);
695                         ret = 0;
696                 }
697         }
698         mutex_unlock(&ddebug_lock);
699         return ret;
700 }
701 EXPORT_SYMBOL_GPL(ddebug_remove_module);
702
703 static void ddebug_remove_all_tables(void)
704 {
705         mutex_lock(&ddebug_lock);
706         while (!list_empty(&ddebug_tables)) {
707                 struct ddebug_table *dt = list_entry(ddebug_tables.next,
708                                                       struct ddebug_table,
709                                                       link);
710                 ddebug_table_free(dt);
711         }
712         mutex_unlock(&ddebug_lock);
713 }
714
715 static __initdata int ddebug_init_success;
716
717 static int __init dynamic_debug_init_debugfs(void)
718 {
719         struct dentry *dir, *file;
720
721         if (!ddebug_init_success)
722                 return -ENODEV;
723
724         dir = debugfs_create_dir("dynamic_debug", NULL);
725         if (!dir)
726                 return -ENOMEM;
727         file = debugfs_create_file("control", 0644, dir, NULL,
728                                         &ddebug_proc_fops);
729         if (!file) {
730                 debugfs_remove(dir);
731                 return -ENOMEM;
732         }
733         return 0;
734 }
735
736 static int __init dynamic_debug_init(void)
737 {
738         struct _ddebug *iter, *iter_start;
739         const char *modname = NULL;
740         int ret = 0;
741         int n = 0;
742
743         if (__start___verbose != __stop___verbose) {
744                 iter = __start___verbose;
745                 modname = iter->modname;
746                 iter_start = iter;
747                 for (; iter < __stop___verbose; iter++) {
748                         if (strcmp(modname, iter->modname)) {
749                                 ret = ddebug_add_module(iter_start, n, modname);
750                                 if (ret)
751                                         goto out_free;
752                                 n = 0;
753                                 modname = iter->modname;
754                                 iter_start = iter;
755                         }
756                         n++;
757                 }
758                 ret = ddebug_add_module(iter_start, n, modname);
759         }
760
761         /* ddebug_query boot param got passed -> set it up */
762         if (ddebug_setup_string[0] != '\0') {
763                 ret = ddebug_exec_query(ddebug_setup_string);
764                 if (ret)
765                         pr_warning("Invalid ddebug boot param %s",
766                                    ddebug_setup_string);
767                 else
768                         pr_info("ddebug initialized with string %s",
769                                 ddebug_setup_string);
770         }
771
772 out_free:
773         if (ret)
774                 ddebug_remove_all_tables();
775         else
776                 ddebug_init_success = 1;
777         return 0;
778 }
779 /* Allow early initialization for boot messages via boot param */
780 arch_initcall(dynamic_debug_init);
781 /* Debugfs setup must be done later */
782 module_init(dynamic_debug_init_debugfs);