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

TOMOYO Linux Cross Reference
Linux/lib/dynamic_debug.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ 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                                 /* special case for last lineno not specified */
357                                 if (query->last_lineno == 0)
358                                         query->last_lineno = UINT_MAX;
359 
360                                 if (query->last_lineno < query->first_lineno) {
361                                         pr_err("last-line:%d < 1st-line:%d\n",
362                                                 query->last_lineno,
363                                                 query->first_lineno);
364                                         return -EINVAL;
365                                 }
366                         } else {
367                                 query->last_lineno = query->first_lineno;
368                         }
369                 } else {
370                         pr_err("unknown keyword \"%s\"\n", words[i]);
371                         return -EINVAL;
372                 }
373                 if (rc)
374                         return rc;
375         }
376         vpr_info_dq(query, "parsed");
377         return 0;
378 }
379 
380 /*
381  * Parse `str' as a flags specification, format [-+=][p]+.
382  * Sets up *maskp and *flagsp to be used when changing the
383  * flags fields of matched _ddebug's.  Returns 0 on success
384  * or <0 on error.
385  */
386 static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
387                                unsigned int *maskp)
388 {
389         unsigned flags = 0;
390         int op = '=', i;
391 
392         switch (*str) {
393         case '+':
394         case '-':
395         case '=':
396                 op = *str++;
397                 break;
398         default:
399                 pr_err("bad flag-op %c, at start of %s\n", *str, str);
400                 return -EINVAL;
401         }
402         vpr_info("op='%c'\n", op);
403 
404         for (; *str ; ++str) {
405                 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
406                         if (*str == opt_array[i].opt_char) {
407                                 flags |= opt_array[i].flag;
408                                 break;
409                         }
410                 }
411                 if (i < 0) {
412                         pr_err("unknown flag '%c' in \"%s\"\n", *str, str);
413                         return -EINVAL;
414                 }
415         }
416         vpr_info("flags=0x%x\n", flags);
417 
418         /* calculate final *flagsp, *maskp according to mask and op */
419         switch (op) {
420         case '=':
421                 *maskp = 0;
422                 *flagsp = flags;
423                 break;
424         case '+':
425                 *maskp = ~0U;
426                 *flagsp = flags;
427                 break;
428         case '-':
429                 *maskp = ~flags;
430                 *flagsp = 0;
431                 break;
432         }
433         vpr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
434         return 0;
435 }
436 
437 static int ddebug_exec_query(char *query_string, const char *modname)
438 {
439         unsigned int flags = 0, mask = 0;
440         struct ddebug_query query;
441 #define MAXWORDS 9
442         int nwords, nfound;
443         char *words[MAXWORDS];
444 
445         nwords = ddebug_tokenize(query_string, words, MAXWORDS);
446         if (nwords <= 0) {
447                 pr_err("tokenize failed\n");
448                 return -EINVAL;
449         }
450         /* check flags 1st (last arg) so query is pairs of spec,val */
451         if (ddebug_parse_flags(words[nwords-1], &flags, &mask)) {
452                 pr_err("flags parse failed\n");
453                 return -EINVAL;
454         }
455         if (ddebug_parse_query(words, nwords-1, &query, modname)) {
456                 pr_err("query parse failed\n");
457                 return -EINVAL;
458         }
459         /* actually go and implement the change */
460         nfound = ddebug_change(&query, flags, mask);
461         vpr_info_dq(&query, nfound ? "applied" : "no-match");
462 
463         return nfound;
464 }
465 
466 /* handle multiple queries in query string, continue on error, return
467    last error or number of matching callsites.  Module name is either
468    in param (for boot arg) or perhaps in query string.
469 */
470 static int ddebug_exec_queries(char *query, const char *modname)
471 {
472         char *split;
473         int i, errs = 0, exitcode = 0, rc, nfound = 0;
474 
475         for (i = 0; query; query = split) {
476                 split = strpbrk(query, ";\n");
477                 if (split)
478                         *split++ = '\0';
479 
480                 query = skip_spaces(query);
481                 if (!query || !*query || *query == '#')
482                         continue;
483 
484                 vpr_info("query %d: \"%s\"\n", i, query);
485 
486                 rc = ddebug_exec_query(query, modname);
487                 if (rc < 0) {
488                         errs++;
489                         exitcode = rc;
490                 } else {
491                         nfound += rc;
492                 }
493                 i++;
494         }
495         vpr_info("processed %d queries, with %d matches, %d errs\n",
496                  i, nfound, errs);
497 
498         if (exitcode)
499                 return exitcode;
500         return nfound;
501 }
502 
503 #define PREFIX_SIZE 64
504 
505 static int remaining(int wrote)
506 {
507         if (PREFIX_SIZE - wrote > 0)
508                 return PREFIX_SIZE - wrote;
509         return 0;
510 }
511 
512 static char *dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
513 {
514         int pos_after_tid;
515         int pos = 0;
516 
517         *buf = '\0';
518 
519         if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
520                 if (in_interrupt())
521                         pos += snprintf(buf + pos, remaining(pos), "<intr> ");
522                 else
523                         pos += snprintf(buf + pos, remaining(pos), "[%d] ",
524                                         task_pid_vnr(current));
525         }
526         pos_after_tid = pos;
527         if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
528                 pos += snprintf(buf + pos, remaining(pos), "%s:",
529                                 desc->modname);
530         if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
531                 pos += snprintf(buf + pos, remaining(pos), "%s:",
532                                 desc->function);
533         if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
534                 pos += snprintf(buf + pos, remaining(pos), "%d:",
535                                 desc->lineno);
536         if (pos - pos_after_tid)
537                 pos += snprintf(buf + pos, remaining(pos), " ");
538         if (pos >= PREFIX_SIZE)
539                 buf[PREFIX_SIZE - 1] = '\0';
540 
541         return buf;
542 }
543 
544 void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
545 {
546         va_list args;
547         struct va_format vaf;
548         char buf[PREFIX_SIZE];
549 
550         BUG_ON(!descriptor);
551         BUG_ON(!fmt);
552 
553         va_start(args, fmt);
554 
555         vaf.fmt = fmt;
556         vaf.va = &args;
557 
558         printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
559 
560         va_end(args);
561 }
562 EXPORT_SYMBOL(__dynamic_pr_debug);
563 
564 void __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 
570         BUG_ON(!descriptor);
571         BUG_ON(!fmt);
572 
573         va_start(args, fmt);
574 
575         vaf.fmt = fmt;
576         vaf.va = &args;
577 
578         if (!dev) {
579                 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
580         } else {
581                 char buf[PREFIX_SIZE];
582 
583                 dev_printk_emit(7, dev, "%s%s %s: %pV",
584                                 dynamic_emit_prefix(descriptor, buf),
585                                 dev_driver_string(dev), dev_name(dev),
586                                 &vaf);
587         }
588 
589         va_end(args);
590 }
591 EXPORT_SYMBOL(__dynamic_dev_dbg);
592 
593 #ifdef CONFIG_NET
594 
595 void __dynamic_netdev_dbg(struct _ddebug *descriptor,
596                           const struct net_device *dev, const char *fmt, ...)
597 {
598         struct va_format vaf;
599         va_list args;
600 
601         BUG_ON(!descriptor);
602         BUG_ON(!fmt);
603 
604         va_start(args, fmt);
605 
606         vaf.fmt = fmt;
607         vaf.va = &args;
608 
609         if (dev && dev->dev.parent) {
610                 char buf[PREFIX_SIZE];
611 
612                 dev_printk_emit(7, dev->dev.parent,
613                                 "%s%s %s %s%s: %pV",
614                                 dynamic_emit_prefix(descriptor, buf),
615                                 dev_driver_string(dev->dev.parent),
616                                 dev_name(dev->dev.parent),
617                                 netdev_name(dev), netdev_reg_state(dev),
618                                 &vaf);
619         } else if (dev) {
620                 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
621                        netdev_reg_state(dev), &vaf);
622         } else {
623                 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
624         }
625 
626         va_end(args);
627 }
628 EXPORT_SYMBOL(__dynamic_netdev_dbg);
629 
630 #endif
631 
632 #define DDEBUG_STRING_SIZE 1024
633 static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
634 
635 static __init int ddebug_setup_query(char *str)
636 {
637         if (strlen(str) >= DDEBUG_STRING_SIZE) {
638                 pr_warn("ddebug boot param string too large\n");
639                 return 0;
640         }
641         strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
642         return 1;
643 }
644 
645 __setup("ddebug_query=", ddebug_setup_query);
646 
647 /*
648  * File_ops->write method for <debugfs>/dynamic_debug/conrol.  Gathers the
649  * command text from userspace, parses and executes it.
650  */
651 #define USER_BUF_PAGE 4096
652 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
653                                   size_t len, loff_t *offp)
654 {
655         char *tmpbuf;
656         int ret;
657 
658         if (len == 0)
659                 return 0;
660         if (len > USER_BUF_PAGE - 1) {
661                 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
662                 return -E2BIG;
663         }
664         tmpbuf = kmalloc(len + 1, GFP_KERNEL);
665         if (!tmpbuf)
666                 return -ENOMEM;
667         if (copy_from_user(tmpbuf, ubuf, len)) {
668                 kfree(tmpbuf);
669                 return -EFAULT;
670         }
671         tmpbuf[len] = '\0';
672         vpr_info("read %d bytes from userspace\n", (int)len);
673 
674         ret = ddebug_exec_queries(tmpbuf, NULL);
675         kfree(tmpbuf);
676         if (ret < 0)
677                 return ret;
678 
679         *offp += len;
680         return len;
681 }
682 
683 /*
684  * Set the iterator to point to the first _ddebug object
685  * and return a pointer to that first object.  Returns
686  * NULL if there are no _ddebugs at all.
687  */
688 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
689 {
690         if (list_empty(&ddebug_tables)) {
691                 iter->table = NULL;
692                 iter->idx = 0;
693                 return NULL;
694         }
695         iter->table = list_entry(ddebug_tables.next,
696                                  struct ddebug_table, link);
697         iter->idx = 0;
698         return &iter->table->ddebugs[iter->idx];
699 }
700 
701 /*
702  * Advance the iterator to point to the next _ddebug
703  * object from the one the iterator currently points at,
704  * and returns a pointer to the new _ddebug.  Returns
705  * NULL if the iterator has seen all the _ddebugs.
706  */
707 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
708 {
709         if (iter->table == NULL)
710                 return NULL;
711         if (++iter->idx == iter->table->num_ddebugs) {
712                 /* iterate to next table */
713                 iter->idx = 0;
714                 if (list_is_last(&iter->table->link, &ddebug_tables)) {
715                         iter->table = NULL;
716                         return NULL;
717                 }
718                 iter->table = list_entry(iter->table->link.next,
719                                          struct ddebug_table, link);
720         }
721         return &iter->table->ddebugs[iter->idx];
722 }
723 
724 /*
725  * Seq_ops start method.  Called at the start of every
726  * read() call from userspace.  Takes the ddebug_lock and
727  * seeks the seq_file's iterator to the given position.
728  */
729 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
730 {
731         struct ddebug_iter *iter = m->private;
732         struct _ddebug *dp;
733         int n = *pos;
734 
735         vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
736 
737         mutex_lock(&ddebug_lock);
738 
739         if (!n)
740                 return SEQ_START_TOKEN;
741         if (n < 0)
742                 return NULL;
743         dp = ddebug_iter_first(iter);
744         while (dp != NULL && --n > 0)
745                 dp = ddebug_iter_next(iter);
746         return dp;
747 }
748 
749 /*
750  * Seq_ops next method.  Called several times within a read()
751  * call from userspace, with ddebug_lock held.  Walks to the
752  * next _ddebug object with a special case for the header line.
753  */
754 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
755 {
756         struct ddebug_iter *iter = m->private;
757         struct _ddebug *dp;
758 
759         vpr_info("called m=%p p=%p *pos=%lld\n",
760                  m, p, (unsigned long long)*pos);
761 
762         if (p == SEQ_START_TOKEN)
763                 dp = ddebug_iter_first(iter);
764         else
765                 dp = ddebug_iter_next(iter);
766         ++*pos;
767         return dp;
768 }
769 
770 /*
771  * Seq_ops show method.  Called several times within a read()
772  * call from userspace, with ddebug_lock held.  Formats the
773  * current _ddebug as a single human-readable line, with a
774  * special case for the header line.
775  */
776 static int ddebug_proc_show(struct seq_file *m, void *p)
777 {
778         struct ddebug_iter *iter = m->private;
779         struct _ddebug *dp = p;
780         char flagsbuf[10];
781 
782         vpr_info("called m=%p p=%p\n", m, p);
783 
784         if (p == SEQ_START_TOKEN) {
785                 seq_puts(m,
786                          "# filename:lineno [module]function flags format\n");
787                 return 0;
788         }
789 
790         seq_printf(m, "%s:%u [%s]%s =%s \"",
791                    trim_prefix(dp->filename), dp->lineno,
792                    iter->table->mod_name, dp->function,
793                    ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
794         seq_escape(m, dp->format, "\t\r\n\"");
795         seq_puts(m, "\"\n");
796 
797         return 0;
798 }
799 
800 /*
801  * Seq_ops stop method.  Called at the end of each read()
802  * call from userspace.  Drops ddebug_lock.
803  */
804 static void ddebug_proc_stop(struct seq_file *m, void *p)
805 {
806         vpr_info("called m=%p p=%p\n", m, p);
807         mutex_unlock(&ddebug_lock);
808 }
809 
810 static const struct seq_operations ddebug_proc_seqops = {
811         .start = ddebug_proc_start,
812         .next = ddebug_proc_next,
813         .show = ddebug_proc_show,
814         .stop = ddebug_proc_stop
815 };
816 
817 /*
818  * File_ops->open method for <debugfs>/dynamic_debug/control.  Does
819  * the seq_file setup dance, and also creates an iterator to walk the
820  * _ddebugs.  Note that we create a seq_file always, even for O_WRONLY
821  * files where it's not needed, as doing so simplifies the ->release
822  * method.
823  */
824 static int ddebug_proc_open(struct inode *inode, struct file *file)
825 {
826         vpr_info("called\n");
827         return seq_open_private(file, &ddebug_proc_seqops,
828                                 sizeof(struct ddebug_iter));
829 }
830 
831 static const struct file_operations ddebug_proc_fops = {
832         .owner = THIS_MODULE,
833         .open = ddebug_proc_open,
834         .read = seq_read,
835         .llseek = seq_lseek,
836         .release = seq_release_private,
837         .write = ddebug_proc_write
838 };
839 
840 /*
841  * Allocate a new ddebug_table for the given module
842  * and add it to the global list.
843  */
844 int ddebug_add_module(struct _ddebug *tab, unsigned int n,
845                              const char *name)
846 {
847         struct ddebug_table *dt;
848         char *new_name;
849 
850         dt = kzalloc(sizeof(*dt), GFP_KERNEL);
851         if (dt == NULL)
852                 return -ENOMEM;
853         new_name = kstrdup(name, GFP_KERNEL);
854         if (new_name == NULL) {
855                 kfree(dt);
856                 return -ENOMEM;
857         }
858         dt->mod_name = new_name;
859         dt->num_ddebugs = n;
860         dt->ddebugs = tab;
861 
862         mutex_lock(&ddebug_lock);
863         list_add_tail(&dt->link, &ddebug_tables);
864         mutex_unlock(&ddebug_lock);
865 
866         vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
867         return 0;
868 }
869 EXPORT_SYMBOL_GPL(ddebug_add_module);
870 
871 /* helper for ddebug_dyndbg_(boot|module)_param_cb */
872 static int ddebug_dyndbg_param_cb(char *param, char *val,
873                                 const char *modname, int on_err)
874 {
875         char *sep;
876 
877         sep = strchr(param, '.');
878         if (sep) {
879                 /* needed only for ddebug_dyndbg_boot_param_cb */
880                 *sep = '\0';
881                 modname = param;
882                 param = sep + 1;
883         }
884         if (strcmp(param, "dyndbg"))
885                 return on_err; /* determined by caller */
886 
887         ddebug_exec_queries((val ? val : "+p"), modname);
888 
889         return 0; /* query failure shouldnt stop module load */
890 }
891 
892 /* handle both dyndbg and $module.dyndbg params at boot */
893 static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
894                                 const char *unused)
895 {
896         vpr_info("%s=\"%s\"\n", param, val);
897         return ddebug_dyndbg_param_cb(param, val, NULL, 0);
898 }
899 
900 /*
901  * modprobe foo finds foo.params in boot-args, strips "foo.", and
902  * passes them to load_module().  This callback gets unknown params,
903  * processes dyndbg params, rejects others.
904  */
905 int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
906 {
907         vpr_info("module: %s %s=\"%s\"\n", module, param, val);
908         return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
909 }
910 
911 static void ddebug_table_free(struct ddebug_table *dt)
912 {
913         list_del_init(&dt->link);
914         kfree(dt->mod_name);
915         kfree(dt);
916 }
917 
918 /*
919  * Called in response to a module being unloaded.  Removes
920  * any ddebug_table's which point at the module.
921  */
922 int ddebug_remove_module(const char *mod_name)
923 {
924         struct ddebug_table *dt, *nextdt;
925         int ret = -ENOENT;
926 
927         vpr_info("removing module \"%s\"\n", mod_name);
928 
929         mutex_lock(&ddebug_lock);
930         list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
931                 if (!strcmp(dt->mod_name, mod_name)) {
932                         ddebug_table_free(dt);
933                         ret = 0;
934                 }
935         }
936         mutex_unlock(&ddebug_lock);
937         return ret;
938 }
939 EXPORT_SYMBOL_GPL(ddebug_remove_module);
940 
941 static void ddebug_remove_all_tables(void)
942 {
943         mutex_lock(&ddebug_lock);
944         while (!list_empty(&ddebug_tables)) {
945                 struct ddebug_table *dt = list_entry(ddebug_tables.next,
946                                                       struct ddebug_table,
947                                                       link);
948                 ddebug_table_free(dt);
949         }
950         mutex_unlock(&ddebug_lock);
951 }
952 
953 static __initdata int ddebug_init_success;
954 
955 static int __init dynamic_debug_init_debugfs(void)
956 {
957         struct dentry *dir, *file;
958 
959         if (!ddebug_init_success)
960                 return -ENODEV;
961 
962         dir = debugfs_create_dir("dynamic_debug", NULL);
963         if (!dir)
964                 return -ENOMEM;
965         file = debugfs_create_file("control", 0644, dir, NULL,
966                                         &ddebug_proc_fops);
967         if (!file) {
968                 debugfs_remove(dir);
969                 return -ENOMEM;
970         }
971         return 0;
972 }
973 
974 static int __init dynamic_debug_init(void)
975 {
976         struct _ddebug *iter, *iter_start;
977         const char *modname = NULL;
978         char *cmdline;
979         int ret = 0;
980         int n = 0, entries = 0, modct = 0;
981         int verbose_bytes = 0;
982 
983         if (__start___verbose == __stop___verbose) {
984                 pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
985                 return 1;
986         }
987         iter = __start___verbose;
988         modname = iter->modname;
989         iter_start = iter;
990         for (; iter < __stop___verbose; iter++) {
991                 entries++;
992                 verbose_bytes += strlen(iter->modname) + strlen(iter->function)
993                         + strlen(iter->filename) + strlen(iter->format);
994 
995                 if (strcmp(modname, iter->modname)) {
996                         modct++;
997                         ret = ddebug_add_module(iter_start, n, modname);
998                         if (ret)
999                                 goto out_err;
1000                         n = 0;
1001                         modname = iter->modname;
1002                         iter_start = iter;
1003                 }
1004                 n++;
1005         }
1006         ret = ddebug_add_module(iter_start, n, modname);
1007         if (ret)
1008                 goto out_err;
1009 
1010         ddebug_init_success = 1;
1011         vpr_info("%d modules, %d entries and %d bytes in ddebug tables, %d bytes in (readonly) verbose section\n",
1012                  modct, entries, (int)(modct * sizeof(struct ddebug_table)),
1013                  verbose_bytes + (int)(__stop___verbose - __start___verbose));
1014 
1015         /* apply ddebug_query boot param, dont unload tables on err */
1016         if (ddebug_setup_string[0] != '\0') {
1017                 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
1018                 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
1019                 if (ret < 0)
1020                         pr_warn("Invalid ddebug boot param %s\n",
1021                                 ddebug_setup_string);
1022                 else
1023                         pr_info("%d changes by ddebug_query\n", ret);
1024         }
1025         /* now that ddebug tables are loaded, process all boot args
1026          * again to find and activate queries given in dyndbg params.
1027          * While this has already been done for known boot params, it
1028          * ignored the unknown ones (dyndbg in particular).  Reusing
1029          * parse_args avoids ad-hoc parsing.  This will also attempt
1030          * to activate queries for not-yet-loaded modules, which is
1031          * slightly noisy if verbose, but harmless.
1032          */
1033         cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1034         parse_args("dyndbg params", cmdline, NULL,
1035                    0, 0, 0, &ddebug_dyndbg_boot_param_cb);
1036         kfree(cmdline);
1037         return 0;
1038 
1039 out_err:
1040         ddebug_remove_all_tables();
1041         return 0;
1042 }
1043 /* Allow early initialization for boot messages via boot param */
1044 early_initcall(dynamic_debug_init);
1045 
1046 /* Debugfs setup must be done later */
1047 fs_initcall(dynamic_debug_init_debugfs);
1048 

~ [ 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