~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/lib/dynamic_debug.c

Version: ~ [ linux-5.12-rc7 ] ~ [ linux-5.11.13 ] ~ [ linux-5.10.29 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.111 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.186 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.230 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.266 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.266 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp