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) "dyndbg: " fmt |
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 | #include <rdma/ib_verbs.h> |
41 | |
42 | extern struct _ddebug __start___dyndbg[]; |
43 | extern struct _ddebug __stop___dyndbg[]; |
44 | extern struct ddebug_class_map __start___dyndbg_classes[]; |
45 | extern struct ddebug_class_map __stop___dyndbg_classes[]; |
46 | |
47 | struct ddebug_table { |
48 | struct list_head link, maps; |
49 | const char *mod_name; |
50 | unsigned int num_ddebugs; |
51 | struct _ddebug *ddebugs; |
52 | }; |
53 | |
54 | struct ddebug_query { |
55 | const char *filename; |
56 | const char *module; |
57 | const char *function; |
58 | const char *format; |
59 | const char *class_string; |
60 | unsigned int first_lineno, last_lineno; |
61 | }; |
62 | |
63 | struct ddebug_iter { |
64 | struct ddebug_table *table; |
65 | int idx; |
66 | }; |
67 | |
68 | struct flag_settings { |
69 | unsigned int flags; |
70 | unsigned int mask; |
71 | }; |
72 | |
73 | static DEFINE_MUTEX(ddebug_lock); |
74 | static LIST_HEAD(ddebug_tables); |
75 | static int verbose; |
76 | module_param(verbose, int, 0644); |
77 | MODULE_PARM_DESC(verbose, " dynamic_debug/control processing " |
78 | "( 0 = off (default), 1 = module add/rm, 2 = >control summary, 3 = parsing, 4 = per-site changes)" ); |
79 | |
80 | /* Return the path relative to source root */ |
81 | static inline const char *trim_prefix(const char *path) |
82 | { |
83 | int skip = strlen(__FILE__) - strlen("lib/dynamic_debug.c" ); |
84 | |
85 | if (strncmp(path, __FILE__, skip)) |
86 | skip = 0; /* prefix mismatch, don't skip */ |
87 | |
88 | return path + skip; |
89 | } |
90 | |
91 | static const struct { unsigned flag:8; char opt_char; } opt_array[] = { |
92 | { _DPRINTK_FLAGS_PRINT, 'p' }, |
93 | { _DPRINTK_FLAGS_INCL_MODNAME, 'm' }, |
94 | { _DPRINTK_FLAGS_INCL_FUNCNAME, 'f' }, |
95 | { _DPRINTK_FLAGS_INCL_SOURCENAME, 's' }, |
96 | { _DPRINTK_FLAGS_INCL_LINENO, 'l' }, |
97 | { _DPRINTK_FLAGS_INCL_TID, 't' }, |
98 | { _DPRINTK_FLAGS_NONE, '_' }, |
99 | }; |
100 | |
101 | struct flagsbuf { char buf[ARRAY_SIZE(opt_array)+1]; }; |
102 | |
103 | /* format a string into buf[] which describes the _ddebug's flags */ |
104 | static char *ddebug_describe_flags(unsigned int flags, struct flagsbuf *fb) |
105 | { |
106 | char *p = fb->buf; |
107 | int i; |
108 | |
109 | for (i = 0; i < ARRAY_SIZE(opt_array); ++i) |
110 | if (flags & opt_array[i].flag) |
111 | *p++ = opt_array[i].opt_char; |
112 | if (p == fb->buf) |
113 | *p++ = '_'; |
114 | *p = '\0'; |
115 | |
116 | return fb->buf; |
117 | } |
118 | |
119 | #define vnpr_info(lvl, fmt, ...) \ |
120 | do { \ |
121 | if (verbose >= lvl) \ |
122 | pr_info(fmt, ##__VA_ARGS__); \ |
123 | } while (0) |
124 | |
125 | #define vpr_info(fmt, ...) vnpr_info(1, fmt, ##__VA_ARGS__) |
126 | #define v2pr_info(fmt, ...) vnpr_info(2, fmt, ##__VA_ARGS__) |
127 | #define v3pr_info(fmt, ...) vnpr_info(3, fmt, ##__VA_ARGS__) |
128 | #define v4pr_info(fmt, ...) vnpr_info(4, fmt, ##__VA_ARGS__) |
129 | |
130 | static void vpr_info_dq(const struct ddebug_query *query, const char *msg) |
131 | { |
132 | /* trim any trailing newlines */ |
133 | int fmtlen = 0; |
134 | |
135 | if (query->format) { |
136 | fmtlen = strlen(query->format); |
137 | while (fmtlen && query->format[fmtlen - 1] == '\n') |
138 | fmtlen--; |
139 | } |
140 | |
141 | v3pr_info("%s: func=\"%s\" file=\"%s\" module=\"%s\" format=\"%.*s\" lineno=%u-%u class=%s\n" , |
142 | msg, |
143 | query->function ?: "" , |
144 | query->filename ?: "" , |
145 | query->module ?: "" , |
146 | fmtlen, query->format ?: "" , |
147 | query->first_lineno, query->last_lineno, query->class_string); |
148 | } |
149 | |
150 | static struct ddebug_class_map *ddebug_find_valid_class(struct ddebug_table const *dt, |
151 | const char *class_string, int *class_id) |
152 | { |
153 | struct ddebug_class_map *map; |
154 | int idx; |
155 | |
156 | list_for_each_entry(map, &dt->maps, link) { |
157 | idx = match_string(array: map->class_names, n: map->length, string: class_string); |
158 | if (idx >= 0) { |
159 | *class_id = idx + map->base; |
160 | return map; |
161 | } |
162 | } |
163 | *class_id = -ENOENT; |
164 | return NULL; |
165 | } |
166 | |
167 | #define __outvar /* filled by callee */ |
168 | /* |
169 | * Search the tables for _ddebug's which match the given `query' and |
170 | * apply the `flags' and `mask' to them. Returns number of matching |
171 | * callsites, normally the same as number of changes. If verbose, |
172 | * logs the changes. Takes ddebug_lock. |
173 | */ |
174 | static int ddebug_change(const struct ddebug_query *query, |
175 | struct flag_settings *modifiers) |
176 | { |
177 | int i; |
178 | struct ddebug_table *dt; |
179 | unsigned int newflags; |
180 | unsigned int nfound = 0; |
181 | struct flagsbuf fbuf, nbuf; |
182 | struct ddebug_class_map *map = NULL; |
183 | int __outvar valid_class; |
184 | |
185 | /* search for matching ddebugs */ |
186 | mutex_lock(&ddebug_lock); |
187 | list_for_each_entry(dt, &ddebug_tables, link) { |
188 | |
189 | /* match against the module name */ |
190 | if (query->module && |
191 | !match_wildcard(pattern: query->module, str: dt->mod_name)) |
192 | continue; |
193 | |
194 | if (query->class_string) { |
195 | map = ddebug_find_valid_class(dt, class_string: query->class_string, class_id: &valid_class); |
196 | if (!map) |
197 | continue; |
198 | } else { |
199 | /* constrain query, do not touch class'd callsites */ |
200 | valid_class = _DPRINTK_CLASS_DFLT; |
201 | } |
202 | |
203 | for (i = 0; i < dt->num_ddebugs; i++) { |
204 | struct _ddebug *dp = &dt->ddebugs[i]; |
205 | |
206 | /* match site against query-class */ |
207 | if (dp->class_id != valid_class) |
208 | continue; |
209 | |
210 | /* match against the source filename */ |
211 | if (query->filename && |
212 | !match_wildcard(pattern: query->filename, str: dp->filename) && |
213 | !match_wildcard(pattern: query->filename, |
214 | str: kbasename(path: dp->filename)) && |
215 | !match_wildcard(pattern: query->filename, |
216 | str: trim_prefix(path: dp->filename))) |
217 | continue; |
218 | |
219 | /* match against the function */ |
220 | if (query->function && |
221 | !match_wildcard(pattern: query->function, str: dp->function)) |
222 | continue; |
223 | |
224 | /* match against the format */ |
225 | if (query->format) { |
226 | if (*query->format == '^') { |
227 | char *p; |
228 | /* anchored search. match must be at beginning */ |
229 | p = strstr(dp->format, query->format+1); |
230 | if (p != dp->format) |
231 | continue; |
232 | } else if (!strstr(dp->format, query->format)) |
233 | continue; |
234 | } |
235 | |
236 | /* match against the line number range */ |
237 | if (query->first_lineno && |
238 | dp->lineno < query->first_lineno) |
239 | continue; |
240 | if (query->last_lineno && |
241 | dp->lineno > query->last_lineno) |
242 | continue; |
243 | |
244 | nfound++; |
245 | |
246 | newflags = (dp->flags & modifiers->mask) | modifiers->flags; |
247 | if (newflags == dp->flags) |
248 | continue; |
249 | #ifdef CONFIG_JUMP_LABEL |
250 | if (dp->flags & _DPRINTK_FLAGS_PRINT) { |
251 | if (!(newflags & _DPRINTK_FLAGS_PRINT)) |
252 | static_branch_disable(&dp->key.dd_key_true); |
253 | } else if (newflags & _DPRINTK_FLAGS_PRINT) { |
254 | static_branch_enable(&dp->key.dd_key_true); |
255 | } |
256 | #endif |
257 | v4pr_info("changed %s:%d [%s]%s %s => %s\n" , |
258 | trim_prefix(dp->filename), dp->lineno, |
259 | dt->mod_name, dp->function, |
260 | ddebug_describe_flags(dp->flags, &fbuf), |
261 | ddebug_describe_flags(newflags, &nbuf)); |
262 | dp->flags = newflags; |
263 | } |
264 | } |
265 | mutex_unlock(lock: &ddebug_lock); |
266 | |
267 | if (!nfound && verbose) |
268 | pr_info("no matches for query\n" ); |
269 | |
270 | return nfound; |
271 | } |
272 | |
273 | /* |
274 | * Split the buffer `buf' into space-separated words. |
275 | * Handles simple " and ' quoting, i.e. without nested, |
276 | * embedded or escaped \". Return the number of words |
277 | * or <0 on error. |
278 | */ |
279 | static int ddebug_tokenize(char *buf, char *words[], int maxwords) |
280 | { |
281 | int nwords = 0; |
282 | |
283 | while (*buf) { |
284 | char *end; |
285 | |
286 | /* Skip leading whitespace */ |
287 | buf = skip_spaces(buf); |
288 | if (!*buf) |
289 | break; /* oh, it was trailing whitespace */ |
290 | if (*buf == '#') |
291 | break; /* token starts comment, skip rest of line */ |
292 | |
293 | /* find `end' of word, whitespace separated or quoted */ |
294 | if (*buf == '"' || *buf == '\'') { |
295 | int quote = *buf++; |
296 | for (end = buf; *end && *end != quote; end++) |
297 | ; |
298 | if (!*end) { |
299 | pr_err("unclosed quote: %s\n" , buf); |
300 | return -EINVAL; /* unclosed quote */ |
301 | } |
302 | } else { |
303 | for (end = buf; *end && !isspace(*end); end++) |
304 | ; |
305 | BUG_ON(end == buf); |
306 | } |
307 | |
308 | /* `buf' is start of word, `end' is one past its end */ |
309 | if (nwords == maxwords) { |
310 | pr_err("too many words, legal max <=%d\n" , maxwords); |
311 | return -EINVAL; /* ran out of words[] before bytes */ |
312 | } |
313 | if (*end) |
314 | *end++ = '\0'; /* terminate the word */ |
315 | words[nwords++] = buf; |
316 | buf = end; |
317 | } |
318 | |
319 | if (verbose >= 3) { |
320 | int i; |
321 | pr_info("split into words:" ); |
322 | for (i = 0; i < nwords; i++) |
323 | pr_cont(" \"%s\"" , words[i]); |
324 | pr_cont("\n" ); |
325 | } |
326 | |
327 | return nwords; |
328 | } |
329 | |
330 | /* |
331 | * Parse a single line number. Note that the empty string "" |
332 | * is treated as a special case and converted to zero, which |
333 | * is later treated as a "don't care" value. |
334 | */ |
335 | static inline int parse_lineno(const char *str, unsigned int *val) |
336 | { |
337 | BUG_ON(str == NULL); |
338 | if (*str == '\0') { |
339 | *val = 0; |
340 | return 0; |
341 | } |
342 | if (kstrtouint(s: str, base: 10, res: val) < 0) { |
343 | pr_err("bad line-number: %s\n" , str); |
344 | return -EINVAL; |
345 | } |
346 | return 0; |
347 | } |
348 | |
349 | static int parse_linerange(struct ddebug_query *query, const char *first) |
350 | { |
351 | char *last = strchr(first, '-'); |
352 | |
353 | if (query->first_lineno || query->last_lineno) { |
354 | pr_err("match-spec: line used 2x\n" ); |
355 | return -EINVAL; |
356 | } |
357 | if (last) |
358 | *last++ = '\0'; |
359 | if (parse_lineno(str: first, val: &query->first_lineno) < 0) |
360 | return -EINVAL; |
361 | if (last) { |
362 | /* range <first>-<last> */ |
363 | if (parse_lineno(str: last, val: &query->last_lineno) < 0) |
364 | return -EINVAL; |
365 | |
366 | /* special case for last lineno not specified */ |
367 | if (query->last_lineno == 0) |
368 | query->last_lineno = UINT_MAX; |
369 | |
370 | if (query->last_lineno < query->first_lineno) { |
371 | pr_err("last-line:%d < 1st-line:%d\n" , |
372 | query->last_lineno, |
373 | query->first_lineno); |
374 | return -EINVAL; |
375 | } |
376 | } else { |
377 | query->last_lineno = query->first_lineno; |
378 | } |
379 | v3pr_info("parsed line %d-%d\n" , query->first_lineno, |
380 | query->last_lineno); |
381 | return 0; |
382 | } |
383 | |
384 | static int check_set(const char **dest, char *src, char *name) |
385 | { |
386 | int rc = 0; |
387 | |
388 | if (*dest) { |
389 | rc = -EINVAL; |
390 | pr_err("match-spec:%s val:%s overridden by %s\n" , |
391 | name, *dest, src); |
392 | } |
393 | *dest = src; |
394 | return rc; |
395 | } |
396 | |
397 | /* |
398 | * Parse words[] as a ddebug query specification, which is a series |
399 | * of (keyword, value) pairs chosen from these possibilities: |
400 | * |
401 | * func <function-name> |
402 | * file <full-pathname> |
403 | * file <base-filename> |
404 | * module <module-name> |
405 | * format <escaped-string-to-find-in-format> |
406 | * line <lineno> |
407 | * line <first-lineno>-<last-lineno> // where either may be empty |
408 | * |
409 | * Only 1 of each type is allowed. |
410 | * Returns 0 on success, <0 on error. |
411 | */ |
412 | static int ddebug_parse_query(char *words[], int nwords, |
413 | struct ddebug_query *query, const char *modname) |
414 | { |
415 | unsigned int i; |
416 | int rc = 0; |
417 | char *fline; |
418 | |
419 | /* check we have an even number of words */ |
420 | if (nwords % 2 != 0) { |
421 | pr_err("expecting pairs of match-spec <value>\n" ); |
422 | return -EINVAL; |
423 | } |
424 | |
425 | for (i = 0; i < nwords; i += 2) { |
426 | char *keyword = words[i]; |
427 | char *arg = words[i+1]; |
428 | |
429 | if (!strcmp(keyword, "func" )) { |
430 | rc = check_set(dest: &query->function, src: arg, name: "func" ); |
431 | } else if (!strcmp(keyword, "file" )) { |
432 | if (check_set(dest: &query->filename, src: arg, name: "file" )) |
433 | return -EINVAL; |
434 | |
435 | /* tail :$info is function or line-range */ |
436 | fline = strchr(query->filename, ':'); |
437 | if (!fline) |
438 | continue; |
439 | *fline++ = '\0'; |
440 | if (isalpha(*fline) || *fline == '*' || *fline == '?') { |
441 | /* take as function name */ |
442 | if (check_set(dest: &query->function, src: fline, name: "func" )) |
443 | return -EINVAL; |
444 | } else { |
445 | if (parse_linerange(query, first: fline)) |
446 | return -EINVAL; |
447 | } |
448 | } else if (!strcmp(keyword, "module" )) { |
449 | rc = check_set(dest: &query->module, src: arg, name: "module" ); |
450 | } else if (!strcmp(keyword, "format" )) { |
451 | string_unescape_inplace(buf: arg, UNESCAPE_SPACE | |
452 | UNESCAPE_OCTAL | |
453 | UNESCAPE_SPECIAL); |
454 | rc = check_set(dest: &query->format, src: arg, name: "format" ); |
455 | } else if (!strcmp(keyword, "line" )) { |
456 | if (parse_linerange(query, first: arg)) |
457 | return -EINVAL; |
458 | } else if (!strcmp(keyword, "class" )) { |
459 | rc = check_set(dest: &query->class_string, src: arg, name: "class" ); |
460 | } else { |
461 | pr_err("unknown keyword \"%s\"\n" , keyword); |
462 | return -EINVAL; |
463 | } |
464 | if (rc) |
465 | return rc; |
466 | } |
467 | if (!query->module && modname) |
468 | /* |
469 | * support $modname.dyndbg=<multiple queries>, when |
470 | * not given in the query itself |
471 | */ |
472 | query->module = modname; |
473 | |
474 | vpr_info_dq(query, msg: "parsed" ); |
475 | return 0; |
476 | } |
477 | |
478 | /* |
479 | * Parse `str' as a flags specification, format [-+=][p]+. |
480 | * Sets up *maskp and *flagsp to be used when changing the |
481 | * flags fields of matched _ddebug's. Returns 0 on success |
482 | * or <0 on error. |
483 | */ |
484 | static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers) |
485 | { |
486 | int op, i; |
487 | |
488 | switch (*str) { |
489 | case '+': |
490 | case '-': |
491 | case '=': |
492 | op = *str++; |
493 | break; |
494 | default: |
495 | pr_err("bad flag-op %c, at start of %s\n" , *str, str); |
496 | return -EINVAL; |
497 | } |
498 | v3pr_info("op='%c'\n" , op); |
499 | |
500 | for (; *str ; ++str) { |
501 | for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) { |
502 | if (*str == opt_array[i].opt_char) { |
503 | modifiers->flags |= opt_array[i].flag; |
504 | break; |
505 | } |
506 | } |
507 | if (i < 0) { |
508 | pr_err("unknown flag '%c'\n" , *str); |
509 | return -EINVAL; |
510 | } |
511 | } |
512 | v3pr_info("flags=0x%x\n" , modifiers->flags); |
513 | |
514 | /* calculate final flags, mask based upon op */ |
515 | switch (op) { |
516 | case '=': |
517 | /* modifiers->flags already set */ |
518 | modifiers->mask = 0; |
519 | break; |
520 | case '+': |
521 | modifiers->mask = ~0U; |
522 | break; |
523 | case '-': |
524 | modifiers->mask = ~modifiers->flags; |
525 | modifiers->flags = 0; |
526 | break; |
527 | } |
528 | v3pr_info("*flagsp=0x%x *maskp=0x%x\n" , modifiers->flags, modifiers->mask); |
529 | |
530 | return 0; |
531 | } |
532 | |
533 | static int ddebug_exec_query(char *query_string, const char *modname) |
534 | { |
535 | struct flag_settings modifiers = {}; |
536 | struct ddebug_query query = {}; |
537 | #define MAXWORDS 9 |
538 | int nwords, nfound; |
539 | char *words[MAXWORDS]; |
540 | |
541 | nwords = ddebug_tokenize(buf: query_string, words, MAXWORDS); |
542 | if (nwords <= 0) { |
543 | pr_err("tokenize failed\n" ); |
544 | return -EINVAL; |
545 | } |
546 | /* check flags 1st (last arg) so query is pairs of spec,val */ |
547 | if (ddebug_parse_flags(str: words[nwords-1], modifiers: &modifiers)) { |
548 | pr_err("flags parse failed\n" ); |
549 | return -EINVAL; |
550 | } |
551 | if (ddebug_parse_query(words, nwords: nwords-1, query: &query, modname)) { |
552 | pr_err("query parse failed\n" ); |
553 | return -EINVAL; |
554 | } |
555 | /* actually go and implement the change */ |
556 | nfound = ddebug_change(query: &query, modifiers: &modifiers); |
557 | vpr_info_dq(query: &query, msg: nfound ? "applied" : "no-match" ); |
558 | |
559 | return nfound; |
560 | } |
561 | |
562 | /* handle multiple queries in query string, continue on error, return |
563 | last error or number of matching callsites. Module name is either |
564 | in param (for boot arg) or perhaps in query string. |
565 | */ |
566 | static int ddebug_exec_queries(char *query, const char *modname) |
567 | { |
568 | char *split; |
569 | int i, errs = 0, exitcode = 0, rc, nfound = 0; |
570 | |
571 | for (i = 0; query; query = split) { |
572 | split = strpbrk(query, ";\n" ); |
573 | if (split) |
574 | *split++ = '\0'; |
575 | |
576 | query = skip_spaces(query); |
577 | if (!query || !*query || *query == '#') |
578 | continue; |
579 | |
580 | vpr_info("query %d: \"%s\" mod:%s\n" , i, query, modname ?: "*" ); |
581 | |
582 | rc = ddebug_exec_query(query_string: query, modname); |
583 | if (rc < 0) { |
584 | errs++; |
585 | exitcode = rc; |
586 | } else { |
587 | nfound += rc; |
588 | } |
589 | i++; |
590 | } |
591 | if (i) |
592 | v2pr_info("processed %d queries, with %d matches, %d errs\n" , |
593 | i, nfound, errs); |
594 | |
595 | if (exitcode) |
596 | return exitcode; |
597 | return nfound; |
598 | } |
599 | |
600 | /* apply a new bitmap to the sys-knob's current bit-state */ |
601 | static int ddebug_apply_class_bitmap(const struct ddebug_class_param *dcp, |
602 | unsigned long *new_bits, unsigned long *old_bits) |
603 | { |
604 | #define QUERY_SIZE 128 |
605 | char query[QUERY_SIZE]; |
606 | const struct ddebug_class_map *map = dcp->map; |
607 | int matches = 0; |
608 | int bi, ct; |
609 | |
610 | v2pr_info("apply: 0x%lx to: 0x%lx\n" , *new_bits, *old_bits); |
611 | |
612 | for (bi = 0; bi < map->length; bi++) { |
613 | if (test_bit(bi, new_bits) == test_bit(bi, old_bits)) |
614 | continue; |
615 | |
616 | snprintf(buf: query, QUERY_SIZE, fmt: "class %s %c%s" , map->class_names[bi], |
617 | test_bit(bi, new_bits) ? '+' : '-', dcp->flags); |
618 | |
619 | ct = ddebug_exec_queries(query, NULL); |
620 | matches += ct; |
621 | |
622 | v2pr_info("bit_%d: %d matches on class: %s -> 0x%lx\n" , bi, |
623 | ct, map->class_names[bi], *new_bits); |
624 | } |
625 | return matches; |
626 | } |
627 | |
628 | /* stub to later conditionally add "$module." prefix where not already done */ |
629 | #define KP_NAME(kp) kp->name |
630 | |
631 | #define CLASSMAP_BITMASK(width) ((1UL << (width)) - 1) |
632 | |
633 | /* accept comma-separated-list of [+-] classnames */ |
634 | static int param_set_dyndbg_classnames(const char *instr, const struct kernel_param *kp) |
635 | { |
636 | const struct ddebug_class_param *dcp = kp->arg; |
637 | const struct ddebug_class_map *map = dcp->map; |
638 | unsigned long curr_bits, old_bits; |
639 | char *cl_str, *p, *tmp; |
640 | int cls_id, totct = 0; |
641 | bool wanted; |
642 | |
643 | cl_str = tmp = kstrdup(s: instr, GFP_KERNEL); |
644 | p = strchr(cl_str, '\n'); |
645 | if (p) |
646 | *p = '\0'; |
647 | |
648 | /* start with previously set state-bits, then modify */ |
649 | curr_bits = old_bits = *dcp->bits; |
650 | vpr_info("\"%s\" > %s:0x%lx\n" , cl_str, KP_NAME(kp), curr_bits); |
651 | |
652 | for (; cl_str; cl_str = p) { |
653 | p = strchr(cl_str, ','); |
654 | if (p) |
655 | *p++ = '\0'; |
656 | |
657 | if (*cl_str == '-') { |
658 | wanted = false; |
659 | cl_str++; |
660 | } else { |
661 | wanted = true; |
662 | if (*cl_str == '+') |
663 | cl_str++; |
664 | } |
665 | cls_id = match_string(array: map->class_names, n: map->length, string: cl_str); |
666 | if (cls_id < 0) { |
667 | pr_err("%s unknown to %s\n" , cl_str, KP_NAME(kp)); |
668 | continue; |
669 | } |
670 | |
671 | /* have one or more valid class_ids of one *_NAMES type */ |
672 | switch (map->map_type) { |
673 | case DD_CLASS_TYPE_DISJOINT_NAMES: |
674 | /* the +/- pertains to a single bit */ |
675 | if (test_bit(cls_id, &curr_bits) == wanted) { |
676 | v3pr_info("no change on %s\n" , cl_str); |
677 | continue; |
678 | } |
679 | curr_bits ^= BIT(cls_id); |
680 | totct += ddebug_apply_class_bitmap(dcp, new_bits: &curr_bits, old_bits: dcp->bits); |
681 | *dcp->bits = curr_bits; |
682 | v2pr_info("%s: changed bit %d:%s\n" , KP_NAME(kp), cls_id, |
683 | map->class_names[cls_id]); |
684 | break; |
685 | case DD_CLASS_TYPE_LEVEL_NAMES: |
686 | /* cls_id = N in 0..max. wanted +/- determines N or N-1 */ |
687 | old_bits = CLASSMAP_BITMASK(*dcp->lvl); |
688 | curr_bits = CLASSMAP_BITMASK(cls_id + (wanted ? 1 : 0 )); |
689 | |
690 | totct += ddebug_apply_class_bitmap(dcp, new_bits: &curr_bits, old_bits: &old_bits); |
691 | *dcp->lvl = (cls_id + (wanted ? 1 : 0)); |
692 | v2pr_info("%s: changed bit-%d: \"%s\" %lx->%lx\n" , KP_NAME(kp), cls_id, |
693 | map->class_names[cls_id], old_bits, curr_bits); |
694 | break; |
695 | default: |
696 | pr_err("illegal map-type value %d\n" , map->map_type); |
697 | } |
698 | } |
699 | kfree(objp: tmp); |
700 | vpr_info("total matches: %d\n" , totct); |
701 | return 0; |
702 | } |
703 | |
704 | /** |
705 | * param_set_dyndbg_classes - class FOO >control |
706 | * @instr: string echo>d to sysfs, input depends on map_type |
707 | * @kp: kp->arg has state: bits/lvl, map, map_type |
708 | * |
709 | * Enable/disable prdbgs by their class, as given in the arguments to |
710 | * DECLARE_DYNDBG_CLASSMAP. For LEVEL map-types, enforce relative |
711 | * levels by bitpos. |
712 | * |
713 | * Returns: 0 or <0 if error. |
714 | */ |
715 | int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp) |
716 | { |
717 | const struct ddebug_class_param *dcp = kp->arg; |
718 | const struct ddebug_class_map *map = dcp->map; |
719 | unsigned long inrep, new_bits, old_bits; |
720 | int rc, totct = 0; |
721 | |
722 | switch (map->map_type) { |
723 | |
724 | case DD_CLASS_TYPE_DISJOINT_NAMES: |
725 | case DD_CLASS_TYPE_LEVEL_NAMES: |
726 | /* handle [+-]classnames list separately, we are done here */ |
727 | return param_set_dyndbg_classnames(instr, kp); |
728 | |
729 | case DD_CLASS_TYPE_DISJOINT_BITS: |
730 | case DD_CLASS_TYPE_LEVEL_NUM: |
731 | /* numeric input, accept and fall-thru */ |
732 | rc = kstrtoul(s: instr, base: 0, res: &inrep); |
733 | if (rc) { |
734 | pr_err("expecting numeric input: %s > %s\n" , instr, KP_NAME(kp)); |
735 | return -EINVAL; |
736 | } |
737 | break; |
738 | default: |
739 | pr_err("%s: bad map type: %d\n" , KP_NAME(kp), map->map_type); |
740 | return -EINVAL; |
741 | } |
742 | |
743 | /* only _BITS,_NUM (numeric) map-types get here */ |
744 | switch (map->map_type) { |
745 | case DD_CLASS_TYPE_DISJOINT_BITS: |
746 | /* expect bits. mask and warn if too many */ |
747 | if (inrep & ~CLASSMAP_BITMASK(map->length)) { |
748 | pr_warn("%s: input: 0x%lx exceeds mask: 0x%lx, masking\n" , |
749 | KP_NAME(kp), inrep, CLASSMAP_BITMASK(map->length)); |
750 | inrep &= CLASSMAP_BITMASK(map->length); |
751 | } |
752 | v2pr_info("bits:%lx > %s\n" , inrep, KP_NAME(kp)); |
753 | totct += ddebug_apply_class_bitmap(dcp, new_bits: &inrep, old_bits: dcp->bits); |
754 | *dcp->bits = inrep; |
755 | break; |
756 | case DD_CLASS_TYPE_LEVEL_NUM: |
757 | /* input is bitpos, of highest verbosity to be enabled */ |
758 | if (inrep > map->length) { |
759 | pr_warn("%s: level:%ld exceeds max:%d, clamping\n" , |
760 | KP_NAME(kp), inrep, map->length); |
761 | inrep = map->length; |
762 | } |
763 | old_bits = CLASSMAP_BITMASK(*dcp->lvl); |
764 | new_bits = CLASSMAP_BITMASK(inrep); |
765 | v2pr_info("lvl:%ld bits:0x%lx > %s\n" , inrep, new_bits, KP_NAME(kp)); |
766 | totct += ddebug_apply_class_bitmap(dcp, new_bits: &new_bits, old_bits: &old_bits); |
767 | *dcp->lvl = inrep; |
768 | break; |
769 | default: |
770 | pr_warn("%s: bad map type: %d\n" , KP_NAME(kp), map->map_type); |
771 | } |
772 | vpr_info("%s: total matches: %d\n" , KP_NAME(kp), totct); |
773 | return 0; |
774 | } |
775 | EXPORT_SYMBOL(param_set_dyndbg_classes); |
776 | |
777 | /** |
778 | * param_get_dyndbg_classes - classes reader |
779 | * @buffer: string description of controlled bits -> classes |
780 | * @kp: kp->arg has state: bits, map |
781 | * |
782 | * Reads last written state, underlying prdbg state may have been |
783 | * altered by direct >control. Displays 0x for DISJOINT, 0-N for |
784 | * LEVEL Returns: #chars written or <0 on error |
785 | */ |
786 | int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp) |
787 | { |
788 | const struct ddebug_class_param *dcp = kp->arg; |
789 | const struct ddebug_class_map *map = dcp->map; |
790 | |
791 | switch (map->map_type) { |
792 | |
793 | case DD_CLASS_TYPE_DISJOINT_NAMES: |
794 | case DD_CLASS_TYPE_DISJOINT_BITS: |
795 | return scnprintf(buf: buffer, PAGE_SIZE, fmt: "0x%lx\n" , *dcp->bits); |
796 | |
797 | case DD_CLASS_TYPE_LEVEL_NAMES: |
798 | case DD_CLASS_TYPE_LEVEL_NUM: |
799 | return scnprintf(buf: buffer, PAGE_SIZE, fmt: "%d\n" , *dcp->lvl); |
800 | default: |
801 | return -1; |
802 | } |
803 | } |
804 | EXPORT_SYMBOL(param_get_dyndbg_classes); |
805 | |
806 | const struct kernel_param_ops param_ops_dyndbg_classes = { |
807 | .set = param_set_dyndbg_classes, |
808 | .get = param_get_dyndbg_classes, |
809 | }; |
810 | EXPORT_SYMBOL(param_ops_dyndbg_classes); |
811 | |
812 | #define PREFIX_SIZE 128 |
813 | |
814 | static int remaining(int wrote) |
815 | { |
816 | if (PREFIX_SIZE - wrote > 0) |
817 | return PREFIX_SIZE - wrote; |
818 | return 0; |
819 | } |
820 | |
821 | static char *__dynamic_emit_prefix(const struct _ddebug *desc, char *buf) |
822 | { |
823 | int pos_after_tid; |
824 | int pos = 0; |
825 | |
826 | if (desc->flags & _DPRINTK_FLAGS_INCL_TID) { |
827 | if (in_interrupt()) |
828 | pos += snprintf(buf: buf + pos, size: remaining(wrote: pos), fmt: "<intr> " ); |
829 | else |
830 | pos += snprintf(buf: buf + pos, size: remaining(wrote: pos), fmt: "[%d] " , |
831 | task_pid_vnr(current)); |
832 | } |
833 | pos_after_tid = pos; |
834 | if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME) |
835 | pos += snprintf(buf: buf + pos, size: remaining(wrote: pos), fmt: "%s:" , |
836 | desc->modname); |
837 | if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME) |
838 | pos += snprintf(buf: buf + pos, size: remaining(wrote: pos), fmt: "%s:" , |
839 | desc->function); |
840 | if (desc->flags & _DPRINTK_FLAGS_INCL_SOURCENAME) |
841 | pos += snprintf(buf: buf + pos, size: remaining(wrote: pos), fmt: "%s:" , |
842 | trim_prefix(path: desc->filename)); |
843 | if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO) |
844 | pos += snprintf(buf: buf + pos, size: remaining(wrote: pos), fmt: "%d:" , |
845 | desc->lineno); |
846 | if (pos - pos_after_tid) |
847 | pos += snprintf(buf: buf + pos, size: remaining(wrote: pos), fmt: " " ); |
848 | if (pos >= PREFIX_SIZE) |
849 | buf[PREFIX_SIZE - 1] = '\0'; |
850 | |
851 | return buf; |
852 | } |
853 | |
854 | static inline char *dynamic_emit_prefix(struct _ddebug *desc, char *buf) |
855 | { |
856 | if (unlikely(desc->flags & _DPRINTK_FLAGS_INCL_ANY)) |
857 | return __dynamic_emit_prefix(desc, buf); |
858 | return buf; |
859 | } |
860 | |
861 | void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...) |
862 | { |
863 | va_list args; |
864 | struct va_format vaf; |
865 | char buf[PREFIX_SIZE] = "" ; |
866 | |
867 | BUG_ON(!descriptor); |
868 | BUG_ON(!fmt); |
869 | |
870 | va_start(args, fmt); |
871 | |
872 | vaf.fmt = fmt; |
873 | vaf.va = &args; |
874 | |
875 | printk(KERN_DEBUG "%s%pV" , dynamic_emit_prefix(descriptor, buf), &vaf); |
876 | |
877 | va_end(args); |
878 | } |
879 | EXPORT_SYMBOL(__dynamic_pr_debug); |
880 | |
881 | void __dynamic_dev_dbg(struct _ddebug *descriptor, |
882 | const struct device *dev, const char *fmt, ...) |
883 | { |
884 | struct va_format vaf; |
885 | va_list args; |
886 | |
887 | BUG_ON(!descriptor); |
888 | BUG_ON(!fmt); |
889 | |
890 | va_start(args, fmt); |
891 | |
892 | vaf.fmt = fmt; |
893 | vaf.va = &args; |
894 | |
895 | if (!dev) { |
896 | printk(KERN_DEBUG "(NULL device *): %pV" , &vaf); |
897 | } else { |
898 | char buf[PREFIX_SIZE] = "" ; |
899 | |
900 | dev_printk_emit(LOGLEVEL_DEBUG, dev, fmt: "%s%s %s: %pV" , |
901 | dynamic_emit_prefix(desc: descriptor, buf), |
902 | dev_driver_string(dev), dev_name(dev), |
903 | &vaf); |
904 | } |
905 | |
906 | va_end(args); |
907 | } |
908 | EXPORT_SYMBOL(__dynamic_dev_dbg); |
909 | |
910 | #ifdef CONFIG_NET |
911 | |
912 | void __dynamic_netdev_dbg(struct _ddebug *descriptor, |
913 | const struct net_device *dev, const char *fmt, ...) |
914 | { |
915 | struct va_format vaf; |
916 | va_list args; |
917 | |
918 | BUG_ON(!descriptor); |
919 | BUG_ON(!fmt); |
920 | |
921 | va_start(args, fmt); |
922 | |
923 | vaf.fmt = fmt; |
924 | vaf.va = &args; |
925 | |
926 | if (dev && dev->dev.parent) { |
927 | char buf[PREFIX_SIZE] = "" ; |
928 | |
929 | dev_printk_emit(LOGLEVEL_DEBUG, dev: dev->dev.parent, |
930 | fmt: "%s%s %s %s%s: %pV" , |
931 | dynamic_emit_prefix(desc: descriptor, buf), |
932 | dev_driver_string(dev: dev->dev.parent), |
933 | dev_name(dev: dev->dev.parent), |
934 | netdev_name(dev), netdev_reg_state(dev), |
935 | &vaf); |
936 | } else if (dev) { |
937 | printk(KERN_DEBUG "%s%s: %pV" , netdev_name(dev), |
938 | netdev_reg_state(dev), &vaf); |
939 | } else { |
940 | printk(KERN_DEBUG "(NULL net_device): %pV" , &vaf); |
941 | } |
942 | |
943 | va_end(args); |
944 | } |
945 | EXPORT_SYMBOL(__dynamic_netdev_dbg); |
946 | |
947 | #endif |
948 | |
949 | #if IS_ENABLED(CONFIG_INFINIBAND) |
950 | |
951 | void __dynamic_ibdev_dbg(struct _ddebug *descriptor, |
952 | const struct ib_device *ibdev, const char *fmt, ...) |
953 | { |
954 | struct va_format vaf; |
955 | va_list args; |
956 | |
957 | va_start(args, fmt); |
958 | |
959 | vaf.fmt = fmt; |
960 | vaf.va = &args; |
961 | |
962 | if (ibdev && ibdev->dev.parent) { |
963 | char buf[PREFIX_SIZE] = "" ; |
964 | |
965 | dev_printk_emit(LOGLEVEL_DEBUG, dev: ibdev->dev.parent, |
966 | fmt: "%s%s %s %s: %pV" , |
967 | dynamic_emit_prefix(desc: descriptor, buf), |
968 | dev_driver_string(dev: ibdev->dev.parent), |
969 | dev_name(dev: ibdev->dev.parent), |
970 | dev_name(dev: &ibdev->dev), |
971 | &vaf); |
972 | } else if (ibdev) { |
973 | printk(KERN_DEBUG "%s: %pV" , dev_name(&ibdev->dev), &vaf); |
974 | } else { |
975 | printk(KERN_DEBUG "(NULL ib_device): %pV" , &vaf); |
976 | } |
977 | |
978 | va_end(args); |
979 | } |
980 | EXPORT_SYMBOL(__dynamic_ibdev_dbg); |
981 | |
982 | #endif |
983 | |
984 | /* |
985 | * Install a noop handler to make dyndbg look like a normal kernel cli param. |
986 | * This avoids warnings about dyndbg being an unknown cli param when supplied |
987 | * by a user. |
988 | */ |
989 | static __init int dyndbg_setup(char *str) |
990 | { |
991 | return 1; |
992 | } |
993 | |
994 | __setup("dyndbg=" , dyndbg_setup); |
995 | |
996 | /* |
997 | * File_ops->write method for <debugfs>/dynamic_debug/control. Gathers the |
998 | * command text from userspace, parses and executes it. |
999 | */ |
1000 | #define USER_BUF_PAGE 4096 |
1001 | static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf, |
1002 | size_t len, loff_t *offp) |
1003 | { |
1004 | char *tmpbuf; |
1005 | int ret; |
1006 | |
1007 | if (len == 0) |
1008 | return 0; |
1009 | if (len > USER_BUF_PAGE - 1) { |
1010 | pr_warn("expected <%d bytes into control\n" , USER_BUF_PAGE); |
1011 | return -E2BIG; |
1012 | } |
1013 | tmpbuf = memdup_user_nul(ubuf, len); |
1014 | if (IS_ERR(ptr: tmpbuf)) |
1015 | return PTR_ERR(ptr: tmpbuf); |
1016 | v2pr_info("read %zu bytes from userspace\n" , len); |
1017 | |
1018 | ret = ddebug_exec_queries(query: tmpbuf, NULL); |
1019 | kfree(objp: tmpbuf); |
1020 | if (ret < 0) |
1021 | return ret; |
1022 | |
1023 | *offp += len; |
1024 | return len; |
1025 | } |
1026 | |
1027 | /* |
1028 | * Set the iterator to point to the first _ddebug object |
1029 | * and return a pointer to that first object. Returns |
1030 | * NULL if there are no _ddebugs at all. |
1031 | */ |
1032 | static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter) |
1033 | { |
1034 | if (list_empty(head: &ddebug_tables)) { |
1035 | iter->table = NULL; |
1036 | return NULL; |
1037 | } |
1038 | iter->table = list_entry(ddebug_tables.next, |
1039 | struct ddebug_table, link); |
1040 | iter->idx = iter->table->num_ddebugs; |
1041 | return &iter->table->ddebugs[--iter->idx]; |
1042 | } |
1043 | |
1044 | /* |
1045 | * Advance the iterator to point to the next _ddebug |
1046 | * object from the one the iterator currently points at, |
1047 | * and returns a pointer to the new _ddebug. Returns |
1048 | * NULL if the iterator has seen all the _ddebugs. |
1049 | */ |
1050 | static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter) |
1051 | { |
1052 | if (iter->table == NULL) |
1053 | return NULL; |
1054 | if (--iter->idx < 0) { |
1055 | /* iterate to next table */ |
1056 | if (list_is_last(list: &iter->table->link, head: &ddebug_tables)) { |
1057 | iter->table = NULL; |
1058 | return NULL; |
1059 | } |
1060 | iter->table = list_entry(iter->table->link.next, |
1061 | struct ddebug_table, link); |
1062 | iter->idx = iter->table->num_ddebugs; |
1063 | --iter->idx; |
1064 | } |
1065 | return &iter->table->ddebugs[iter->idx]; |
1066 | } |
1067 | |
1068 | /* |
1069 | * Seq_ops start method. Called at the start of every |
1070 | * read() call from userspace. Takes the ddebug_lock and |
1071 | * seeks the seq_file's iterator to the given position. |
1072 | */ |
1073 | static void *ddebug_proc_start(struct seq_file *m, loff_t *pos) |
1074 | { |
1075 | struct ddebug_iter *iter = m->private; |
1076 | struct _ddebug *dp; |
1077 | int n = *pos; |
1078 | |
1079 | mutex_lock(&ddebug_lock); |
1080 | |
1081 | if (!n) |
1082 | return SEQ_START_TOKEN; |
1083 | if (n < 0) |
1084 | return NULL; |
1085 | dp = ddebug_iter_first(iter); |
1086 | while (dp != NULL && --n > 0) |
1087 | dp = ddebug_iter_next(iter); |
1088 | return dp; |
1089 | } |
1090 | |
1091 | /* |
1092 | * Seq_ops next method. Called several times within a read() |
1093 | * call from userspace, with ddebug_lock held. Walks to the |
1094 | * next _ddebug object with a special case for the header line. |
1095 | */ |
1096 | static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos) |
1097 | { |
1098 | struct ddebug_iter *iter = m->private; |
1099 | struct _ddebug *dp; |
1100 | |
1101 | if (p == SEQ_START_TOKEN) |
1102 | dp = ddebug_iter_first(iter); |
1103 | else |
1104 | dp = ddebug_iter_next(iter); |
1105 | ++*pos; |
1106 | return dp; |
1107 | } |
1108 | |
1109 | #define class_in_range(class_id, map) \ |
1110 | (class_id >= map->base && class_id < map->base + map->length) |
1111 | |
1112 | static const char *ddebug_class_name(struct ddebug_iter *iter, struct _ddebug *dp) |
1113 | { |
1114 | struct ddebug_class_map *map; |
1115 | |
1116 | list_for_each_entry(map, &iter->table->maps, link) |
1117 | if (class_in_range(dp->class_id, map)) |
1118 | return map->class_names[dp->class_id - map->base]; |
1119 | |
1120 | return NULL; |
1121 | } |
1122 | |
1123 | /* |
1124 | * Seq_ops show method. Called several times within a read() |
1125 | * call from userspace, with ddebug_lock held. Formats the |
1126 | * current _ddebug as a single human-readable line, with a |
1127 | * special case for the header line. |
1128 | */ |
1129 | static int ddebug_proc_show(struct seq_file *m, void *p) |
1130 | { |
1131 | struct ddebug_iter *iter = m->private; |
1132 | struct _ddebug *dp = p; |
1133 | struct flagsbuf flags; |
1134 | char const *class; |
1135 | |
1136 | if (p == SEQ_START_TOKEN) { |
1137 | seq_puts(m, |
1138 | s: "# filename:lineno [module]function flags format\n" ); |
1139 | return 0; |
1140 | } |
1141 | |
1142 | seq_printf(m, fmt: "%s:%u [%s]%s =%s \"" , |
1143 | trim_prefix(path: dp->filename), dp->lineno, |
1144 | iter->table->mod_name, dp->function, |
1145 | ddebug_describe_flags(flags: dp->flags, fb: &flags)); |
1146 | seq_escape_str(m, src: dp->format, ESCAPE_SPACE, esc: "\t\r\n\"" ); |
1147 | seq_puts(m, s: "\"" ); |
1148 | |
1149 | if (dp->class_id != _DPRINTK_CLASS_DFLT) { |
1150 | class = ddebug_class_name(iter, dp); |
1151 | if (class) |
1152 | seq_printf(m, fmt: " class:%s" , class); |
1153 | else |
1154 | seq_printf(m, fmt: " class unknown, _id:%d" , dp->class_id); |
1155 | } |
1156 | seq_puts(m, s: "\n" ); |
1157 | |
1158 | return 0; |
1159 | } |
1160 | |
1161 | /* |
1162 | * Seq_ops stop method. Called at the end of each read() |
1163 | * call from userspace. Drops ddebug_lock. |
1164 | */ |
1165 | static void ddebug_proc_stop(struct seq_file *m, void *p) |
1166 | { |
1167 | mutex_unlock(lock: &ddebug_lock); |
1168 | } |
1169 | |
1170 | static const struct seq_operations ddebug_proc_seqops = { |
1171 | .start = ddebug_proc_start, |
1172 | .next = ddebug_proc_next, |
1173 | .show = ddebug_proc_show, |
1174 | .stop = ddebug_proc_stop |
1175 | }; |
1176 | |
1177 | static int ddebug_proc_open(struct inode *inode, struct file *file) |
1178 | { |
1179 | return seq_open_private(file, &ddebug_proc_seqops, |
1180 | sizeof(struct ddebug_iter)); |
1181 | } |
1182 | |
1183 | static const struct file_operations ddebug_proc_fops = { |
1184 | .owner = THIS_MODULE, |
1185 | .open = ddebug_proc_open, |
1186 | .read = seq_read, |
1187 | .llseek = seq_lseek, |
1188 | .release = seq_release_private, |
1189 | .write = ddebug_proc_write |
1190 | }; |
1191 | |
1192 | static const struct proc_ops proc_fops = { |
1193 | .proc_open = ddebug_proc_open, |
1194 | .proc_read = seq_read, |
1195 | .proc_lseek = seq_lseek, |
1196 | .proc_release = seq_release_private, |
1197 | .proc_write = ddebug_proc_write |
1198 | }; |
1199 | |
1200 | static void ddebug_attach_module_classes(struct ddebug_table *dt, |
1201 | struct ddebug_class_map *classes, |
1202 | int num_classes) |
1203 | { |
1204 | struct ddebug_class_map *cm; |
1205 | int i, j, ct = 0; |
1206 | |
1207 | for (cm = classes, i = 0; i < num_classes; i++, cm++) { |
1208 | |
1209 | if (!strcmp(cm->mod_name, dt->mod_name)) { |
1210 | |
1211 | v2pr_info("class[%d]: module:%s base:%d len:%d ty:%d\n" , i, |
1212 | cm->mod_name, cm->base, cm->length, cm->map_type); |
1213 | |
1214 | for (j = 0; j < cm->length; j++) |
1215 | v3pr_info(" %d: %d %s\n" , j + cm->base, j, |
1216 | cm->class_names[j]); |
1217 | |
1218 | list_add(new: &cm->link, head: &dt->maps); |
1219 | ct++; |
1220 | } |
1221 | } |
1222 | if (ct) |
1223 | vpr_info("module:%s attached %d classes\n" , dt->mod_name, ct); |
1224 | } |
1225 | |
1226 | /* |
1227 | * Allocate a new ddebug_table for the given module |
1228 | * and add it to the global list. |
1229 | */ |
1230 | static int ddebug_add_module(struct _ddebug_info *di, const char *modname) |
1231 | { |
1232 | struct ddebug_table *dt; |
1233 | |
1234 | v3pr_info("add-module: %s.%d sites\n" , modname, di->num_descs); |
1235 | if (!di->num_descs) { |
1236 | v3pr_info(" skip %s\n" , modname); |
1237 | return 0; |
1238 | } |
1239 | |
1240 | dt = kzalloc(size: sizeof(*dt), GFP_KERNEL); |
1241 | if (dt == NULL) { |
1242 | pr_err("error adding module: %s\n" , modname); |
1243 | return -ENOMEM; |
1244 | } |
1245 | /* |
1246 | * For built-in modules, name lives in .rodata and is |
1247 | * immortal. For loaded modules, name points at the name[] |
1248 | * member of struct module, which lives at least as long as |
1249 | * this struct ddebug_table. |
1250 | */ |
1251 | dt->mod_name = modname; |
1252 | dt->ddebugs = di->descs; |
1253 | dt->num_ddebugs = di->num_descs; |
1254 | |
1255 | INIT_LIST_HEAD(list: &dt->link); |
1256 | INIT_LIST_HEAD(list: &dt->maps); |
1257 | |
1258 | if (di->classes && di->num_classes) |
1259 | ddebug_attach_module_classes(dt, classes: di->classes, num_classes: di->num_classes); |
1260 | |
1261 | mutex_lock(&ddebug_lock); |
1262 | list_add_tail(new: &dt->link, head: &ddebug_tables); |
1263 | mutex_unlock(lock: &ddebug_lock); |
1264 | |
1265 | vpr_info("%3u debug prints in module %s\n" , di->num_descs, modname); |
1266 | return 0; |
1267 | } |
1268 | |
1269 | /* helper for ddebug_dyndbg_(boot|module)_param_cb */ |
1270 | static int ddebug_dyndbg_param_cb(char *param, char *val, |
1271 | const char *modname, int on_err) |
1272 | { |
1273 | char *sep; |
1274 | |
1275 | sep = strchr(param, '.'); |
1276 | if (sep) { |
1277 | /* needed only for ddebug_dyndbg_boot_param_cb */ |
1278 | *sep = '\0'; |
1279 | modname = param; |
1280 | param = sep + 1; |
1281 | } |
1282 | if (strcmp(param, "dyndbg" )) |
1283 | return on_err; /* determined by caller */ |
1284 | |
1285 | ddebug_exec_queries(query: (val ? val : "+p" ), modname); |
1286 | |
1287 | return 0; /* query failure shouldn't stop module load */ |
1288 | } |
1289 | |
1290 | /* handle both dyndbg and $module.dyndbg params at boot */ |
1291 | static int ddebug_dyndbg_boot_param_cb(char *param, char *val, |
1292 | const char *unused, void *arg) |
1293 | { |
1294 | vpr_info("%s=\"%s\"\n" , param, val); |
1295 | return ddebug_dyndbg_param_cb(param, val, NULL, on_err: 0); |
1296 | } |
1297 | |
1298 | /* |
1299 | * modprobe foo finds foo.params in boot-args, strips "foo.", and |
1300 | * passes them to load_module(). This callback gets unknown params, |
1301 | * processes dyndbg params, rejects others. |
1302 | */ |
1303 | int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module) |
1304 | { |
1305 | vpr_info("module: %s %s=\"%s\"\n" , module, param, val); |
1306 | return ddebug_dyndbg_param_cb(param, val, modname: module, on_err: -ENOENT); |
1307 | } |
1308 | |
1309 | static void ddebug_table_free(struct ddebug_table *dt) |
1310 | { |
1311 | list_del_init(entry: &dt->link); |
1312 | kfree(objp: dt); |
1313 | } |
1314 | |
1315 | #ifdef CONFIG_MODULES |
1316 | |
1317 | /* |
1318 | * Called in response to a module being unloaded. Removes |
1319 | * any ddebug_table's which point at the module. |
1320 | */ |
1321 | static int ddebug_remove_module(const char *mod_name) |
1322 | { |
1323 | struct ddebug_table *dt, *nextdt; |
1324 | int ret = -ENOENT; |
1325 | |
1326 | mutex_lock(&ddebug_lock); |
1327 | list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) { |
1328 | if (dt->mod_name == mod_name) { |
1329 | ddebug_table_free(dt); |
1330 | ret = 0; |
1331 | break; |
1332 | } |
1333 | } |
1334 | mutex_unlock(lock: &ddebug_lock); |
1335 | if (!ret) |
1336 | v2pr_info("removed module \"%s\"\n" , mod_name); |
1337 | return ret; |
1338 | } |
1339 | |
1340 | static int ddebug_module_notify(struct notifier_block *self, unsigned long val, |
1341 | void *data) |
1342 | { |
1343 | struct module *mod = data; |
1344 | int ret = 0; |
1345 | |
1346 | switch (val) { |
1347 | case MODULE_STATE_COMING: |
1348 | ret = ddebug_add_module(di: &mod->dyndbg_info, modname: mod->name); |
1349 | if (ret) |
1350 | WARN(1, "Failed to allocate memory: dyndbg may not work properly.\n" ); |
1351 | break; |
1352 | case MODULE_STATE_GOING: |
1353 | ddebug_remove_module(mod_name: mod->name); |
1354 | break; |
1355 | } |
1356 | |
1357 | return notifier_from_errno(err: ret); |
1358 | } |
1359 | |
1360 | static struct notifier_block ddebug_module_nb = { |
1361 | .notifier_call = ddebug_module_notify, |
1362 | .priority = 0, /* dynamic debug depends on jump label */ |
1363 | }; |
1364 | |
1365 | #endif /* CONFIG_MODULES */ |
1366 | |
1367 | static void ddebug_remove_all_tables(void) |
1368 | { |
1369 | mutex_lock(&ddebug_lock); |
1370 | while (!list_empty(head: &ddebug_tables)) { |
1371 | struct ddebug_table *dt = list_entry(ddebug_tables.next, |
1372 | struct ddebug_table, |
1373 | link); |
1374 | ddebug_table_free(dt); |
1375 | } |
1376 | mutex_unlock(lock: &ddebug_lock); |
1377 | } |
1378 | |
1379 | static __initdata int ddebug_init_success; |
1380 | |
1381 | static int __init dynamic_debug_init_control(void) |
1382 | { |
1383 | struct proc_dir_entry *procfs_dir; |
1384 | struct dentry *debugfs_dir; |
1385 | |
1386 | if (!ddebug_init_success) |
1387 | return -ENODEV; |
1388 | |
1389 | /* Create the control file in debugfs if it is enabled */ |
1390 | if (debugfs_initialized()) { |
1391 | debugfs_dir = debugfs_create_dir(name: "dynamic_debug" , NULL); |
1392 | debugfs_create_file(name: "control" , mode: 0644, parent: debugfs_dir, NULL, |
1393 | fops: &ddebug_proc_fops); |
1394 | } |
1395 | |
1396 | /* Also create the control file in procfs */ |
1397 | procfs_dir = proc_mkdir("dynamic_debug" , NULL); |
1398 | if (procfs_dir) |
1399 | proc_create(name: "control" , mode: 0644, parent: procfs_dir, proc_ops: &proc_fops); |
1400 | |
1401 | return 0; |
1402 | } |
1403 | |
1404 | static int __init dynamic_debug_init(void) |
1405 | { |
1406 | struct _ddebug *iter, *iter_mod_start; |
1407 | int ret, i, mod_sites, mod_ct; |
1408 | const char *modname; |
1409 | char *cmdline; |
1410 | |
1411 | struct _ddebug_info di = { |
1412 | .descs = __start___dyndbg, |
1413 | .classes = __start___dyndbg_classes, |
1414 | .num_descs = __stop___dyndbg - __start___dyndbg, |
1415 | .num_classes = __stop___dyndbg_classes - __start___dyndbg_classes, |
1416 | }; |
1417 | |
1418 | #ifdef CONFIG_MODULES |
1419 | ret = register_module_notifier(nb: &ddebug_module_nb); |
1420 | if (ret) { |
1421 | pr_warn("Failed to register dynamic debug module notifier\n" ); |
1422 | return ret; |
1423 | } |
1424 | #endif /* CONFIG_MODULES */ |
1425 | |
1426 | if (&__start___dyndbg == &__stop___dyndbg) { |
1427 | if (IS_ENABLED(CONFIG_DYNAMIC_DEBUG)) { |
1428 | pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n" ); |
1429 | return 1; |
1430 | } |
1431 | pr_info("Ignore empty _ddebug table in a CONFIG_DYNAMIC_DEBUG_CORE build\n" ); |
1432 | ddebug_init_success = 1; |
1433 | return 0; |
1434 | } |
1435 | |
1436 | iter = iter_mod_start = __start___dyndbg; |
1437 | modname = iter->modname; |
1438 | i = mod_sites = mod_ct = 0; |
1439 | |
1440 | for (; iter < __stop___dyndbg; iter++, i++, mod_sites++) { |
1441 | |
1442 | if (strcmp(modname, iter->modname)) { |
1443 | mod_ct++; |
1444 | di.num_descs = mod_sites; |
1445 | di.descs = iter_mod_start; |
1446 | ret = ddebug_add_module(di: &di, modname); |
1447 | if (ret) |
1448 | goto out_err; |
1449 | |
1450 | mod_sites = 0; |
1451 | modname = iter->modname; |
1452 | iter_mod_start = iter; |
1453 | } |
1454 | } |
1455 | di.num_descs = mod_sites; |
1456 | di.descs = iter_mod_start; |
1457 | ret = ddebug_add_module(di: &di, modname); |
1458 | if (ret) |
1459 | goto out_err; |
1460 | |
1461 | ddebug_init_success = 1; |
1462 | vpr_info("%d prdebugs in %d modules, %d KiB in ddebug tables, %d kiB in __dyndbg section\n" , |
1463 | i, mod_ct, (int)((mod_ct * sizeof(struct ddebug_table)) >> 10), |
1464 | (int)((i * sizeof(struct _ddebug)) >> 10)); |
1465 | |
1466 | if (di.num_classes) |
1467 | v2pr_info(" %d builtin ddebug class-maps\n" , di.num_classes); |
1468 | |
1469 | /* now that ddebug tables are loaded, process all boot args |
1470 | * again to find and activate queries given in dyndbg params. |
1471 | * While this has already been done for known boot params, it |
1472 | * ignored the unknown ones (dyndbg in particular). Reusing |
1473 | * parse_args avoids ad-hoc parsing. This will also attempt |
1474 | * to activate queries for not-yet-loaded modules, which is |
1475 | * slightly noisy if verbose, but harmless. |
1476 | */ |
1477 | cmdline = kstrdup(s: saved_command_line, GFP_KERNEL); |
1478 | parse_args(name: "dyndbg params" , args: cmdline, NULL, |
1479 | num: 0, level_min: 0, level_max: 0, NULL, unknown: &ddebug_dyndbg_boot_param_cb); |
1480 | kfree(objp: cmdline); |
1481 | return 0; |
1482 | |
1483 | out_err: |
1484 | ddebug_remove_all_tables(); |
1485 | return 0; |
1486 | } |
1487 | /* Allow early initialization for boot messages via boot param */ |
1488 | early_initcall(dynamic_debug_init); |
1489 | |
1490 | /* Debugfs setup must be done later */ |
1491 | fs_initcall(dynamic_debug_init_control); |
1492 | |