Root/
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 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9