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(map->class_names, map->length, 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(query->module, dt->mod_name)) 192 continue; 193 194 if (query->class_string) { 195 map = ddebug_find_valid_class(dt, query->class_string, &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(query->filename, dp->filename) && 213 !match_wildcard(query->filename, 214 kbasename(dp->filename)) && 215 !match_wildcard(query->filename, 216 trim_prefix(dp->filename))) 217 continue; 218 219 /* match against the function */ 220 if (query->function && 221 !match_wildcard(query->function, 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(&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(str, 10, 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(first, &query->first_lineno) < 0) 360 return -EINVAL; 361 if (last) { 362 /* range <first>-<last> */ 363 if (parse_lineno(last, &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(&query->function, arg, "func"); 431 } else if (!strcmp(keyword, "file")) { 432 if (check_set(&query->filename, arg, "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(&query->function, fline, "func")) 443 return -EINVAL; 444 } else { 445 if (parse_linerange(query, fline)) 446 return -EINVAL; 447 } 448 } else if (!strcmp(keyword, "module")) { 449 rc = check_set(&query->module, arg, "module"); 450 } else if (!strcmp(keyword, "format")) { 451 string_unescape_inplace(arg, UNESCAPE_SPACE | 452 UNESCAPE_OCTAL | 453 UNESCAPE_SPECIAL); 454 rc = check_set(&query->format, arg, "format"); 455 } else if (!strcmp(keyword, "line")) { 456 if (parse_linerange(query, arg)) 457 return -EINVAL; 458 } else if (!strcmp(keyword, "class")) { 459 rc = check_set(&query->class_string, arg, "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, "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(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(words[nwords-1], &modifiers)) { 548 pr_err("flags parse failed\n"); 549 return -EINVAL; 550 } 551 if (ddebug_parse_query(words, nwords-1, &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, &modifiers); 557 vpr_info_dq(&query, 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, 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(query, QUERY_SIZE, "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_and_replace(instr, '\n', '\0', GFP_KERNEL); 644 if (!tmp) 645 return -ENOMEM; 646 647 /* start with previously set state-bits, then modify */ 648 curr_bits = old_bits = *dcp->bits; 649 vpr_info("\"%s\" > %s:0x%lx\n", cl_str, KP_NAME(kp), curr_bits); 650 651 for (; cl_str; cl_str = p) { 652 p = strchr(cl_str, ','); 653 if (p) 654 *p++ = '\0'; 655 656 if (*cl_str == '-') { 657 wanted = false; 658 cl_str++; 659 } else { 660 wanted = true; 661 if (*cl_str == '+') 662 cl_str++; 663 } 664 cls_id = match_string(map->class_names, map->length, cl_str); 665 if (cls_id < 0) { 666 pr_err("%s unknown to %s\n", cl_str, KP_NAME(kp)); 667 continue; 668 } 669 670 /* have one or more valid class_ids of one *_NAMES type */ 671 switch (map->map_type) { 672 case DD_CLASS_TYPE_DISJOINT_NAMES: 673 /* the +/- pertains to a single bit */ 674 if (test_bit(cls_id, &curr_bits) == wanted) { 675 v3pr_info("no change on %s\n", cl_str); 676 continue; 677 } 678 curr_bits ^= BIT(cls_id); 679 totct += ddebug_apply_class_bitmap(dcp, &curr_bits, dcp->bits); 680 *dcp->bits = curr_bits; 681 v2pr_info("%s: changed bit %d:%s\n", KP_NAME(kp), cls_id, 682 map->class_names[cls_id]); 683 break; 684 case DD_CLASS_TYPE_LEVEL_NAMES: 685 /* cls_id = N in 0..max. wanted +/- determines N or N-1 */ 686 old_bits = CLASSMAP_BITMASK(*dcp->lvl); 687 curr_bits = CLASSMAP_BITMASK(cls_id + (wanted ? 1 : 0 )); 688 689 totct += ddebug_apply_class_bitmap(dcp, &curr_bits, &old_bits); 690 *dcp->lvl = (cls_id + (wanted ? 1 : 0)); 691 v2pr_info("%s: changed bit-%d: \"%s\" %lx->%lx\n", KP_NAME(kp), cls_id, 692 map->class_names[cls_id], old_bits, curr_bits); 693 break; 694 default: 695 pr_err("illegal map-type value %d\n", map->map_type); 696 } 697 } 698 kfree(tmp); 699 vpr_info("total matches: %d\n", totct); 700 return 0; 701 } 702 703 /** 704 * param_set_dyndbg_classes - class FOO >control 705 * @instr: string echo>d to sysfs, input depends on map_type 706 * @kp: kp->arg has state: bits/lvl, map, map_type 707 * 708 * Enable/disable prdbgs by their class, as given in the arguments to 709 * DECLARE_DYNDBG_CLASSMAP. For LEVEL map-types, enforce relative 710 * levels by bitpos. 711 * 712 * Returns: 0 or <0 if error. 713 */ 714 int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp) 715 { 716 const struct ddebug_class_param *dcp = kp->arg; 717 const struct ddebug_class_map *map = dcp->map; 718 unsigned long inrep, new_bits, old_bits; 719 int rc, totct = 0; 720 721 switch (map->map_type) { 722 723 case DD_CLASS_TYPE_DISJOINT_NAMES: 724 case DD_CLASS_TYPE_LEVEL_NAMES: 725 /* handle [+-]classnames list separately, we are done here */ 726 return param_set_dyndbg_classnames(instr, kp); 727 728 case DD_CLASS_TYPE_DISJOINT_BITS: 729 case DD_CLASS_TYPE_LEVEL_NUM: 730 /* numeric input, accept and fall-thru */ 731 rc = kstrtoul(instr, 0, &inrep); 732 if (rc) { 733 pr_err("expecting numeric input: %s > %s\n", instr, KP_NAME(kp)); 734 return -EINVAL; 735 } 736 break; 737 default: 738 pr_err("%s: bad map type: %d\n", KP_NAME(kp), map->map_type); 739 return -EINVAL; 740 } 741 742 /* only _BITS,_NUM (numeric) map-types get here */ 743 switch (map->map_type) { 744 case DD_CLASS_TYPE_DISJOINT_BITS: 745 /* expect bits. mask and warn if too many */ 746 if (inrep & ~CLASSMAP_BITMASK(map->length)) { 747 pr_warn("%s: input: 0x%lx exceeds mask: 0x%lx, masking\n", 748 KP_NAME(kp), inrep, CLASSMAP_BITMASK(map->length)); 749 inrep &= CLASSMAP_BITMASK(map->length); 750 } 751 v2pr_info("bits:%lx > %s\n", inrep, KP_NAME(kp)); 752 totct += ddebug_apply_class_bitmap(dcp, &inrep, dcp->bits); 753 *dcp->bits = inrep; 754 break; 755 case DD_CLASS_TYPE_LEVEL_NUM: 756 /* input is bitpos, of highest verbosity to be enabled */ 757 if (inrep > map->length) { 758 pr_warn("%s: level:%ld exceeds max:%d, clamping\n", 759 KP_NAME(kp), inrep, map->length); 760 inrep = map->length; 761 } 762 old_bits = CLASSMAP_BITMASK(*dcp->lvl); 763 new_bits = CLASSMAP_BITMASK(inrep); 764 v2pr_info("lvl:%ld bits:0x%lx > %s\n", inrep, new_bits, KP_NAME(kp)); 765 totct += ddebug_apply_class_bitmap(dcp, &new_bits, &old_bits); 766 *dcp->lvl = inrep; 767 break; 768 default: 769 pr_warn("%s: bad map type: %d\n", KP_NAME(kp), map->map_type); 770 } 771 vpr_info("%s: total matches: %d\n", KP_NAME(kp), totct); 772 return 0; 773 } 774 EXPORT_SYMBOL(param_set_dyndbg_classes); 775 776 /** 777 * param_get_dyndbg_classes - classes reader 778 * @buffer: string description of controlled bits -> classes 779 * @kp: kp->arg has state: bits, map 780 * 781 * Reads last written state, underlying prdbg state may have been 782 * altered by direct >control. Displays 0x for DISJOINT, 0-N for 783 * LEVEL Returns: #chars written or <0 on error 784 */ 785 int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp) 786 { 787 const struct ddebug_class_param *dcp = kp->arg; 788 const struct ddebug_class_map *map = dcp->map; 789 790 switch (map->map_type) { 791 792 case DD_CLASS_TYPE_DISJOINT_NAMES: 793 case DD_CLASS_TYPE_DISJOINT_BITS: 794 return scnprintf(buffer, PAGE_SIZE, "0x%lx\n", *dcp->bits); 795 796 case DD_CLASS_TYPE_LEVEL_NAMES: 797 case DD_CLASS_TYPE_LEVEL_NUM: 798 return scnprintf(buffer, PAGE_SIZE, "%d\n", *dcp->lvl); 799 default: 800 return -1; 801 } 802 } 803 EXPORT_SYMBOL(param_get_dyndbg_classes); 804 805 const struct kernel_param_ops param_ops_dyndbg_classes = { 806 .set = param_set_dyndbg_classes, 807 .get = param_get_dyndbg_classes, 808 }; 809 EXPORT_SYMBOL(param_ops_dyndbg_classes); 810 811 #define PREFIX_SIZE 128 812 813 static int remaining(int wrote) 814 { 815 if (PREFIX_SIZE - wrote > 0) 816 return PREFIX_SIZE - wrote; 817 return 0; 818 } 819 820 static char *__dynamic_emit_prefix(const struct _ddebug *desc, char *buf) 821 { 822 int pos_after_tid; 823 int pos = 0; 824 825 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) { 826 if (in_interrupt()) 827 pos += snprintf(buf + pos, remaining(pos), "<intr> "); 828 else 829 pos += snprintf(buf + pos, remaining(pos), "[%d] ", 830 task_pid_vnr(current)); 831 } 832 pos_after_tid = pos; 833 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME) 834 pos += snprintf(buf + pos, remaining(pos), "%s:", 835 desc->modname); 836 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME) 837 pos += snprintf(buf + pos, remaining(pos), "%s:", 838 desc->function); 839 if (desc->flags & _DPRINTK_FLAGS_INCL_SOURCENAME) 840 pos += snprintf(buf + pos, remaining(pos), "%s:", 841 trim_prefix(desc->filename)); 842 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO) 843 pos += snprintf(buf + pos, remaining(pos), "%d:", 844 desc->lineno); 845 if (pos - pos_after_tid) 846 pos += snprintf(buf + pos, remaining(pos), " "); 847 if (pos >= PREFIX_SIZE) 848 buf[PREFIX_SIZE - 1] = '\0'; 849 850 return buf; 851 } 852 853 static inline char *dynamic_emit_prefix(struct _ddebug *desc, char *buf) 854 { 855 if (unlikely(desc->flags & _DPRINTK_FLAGS_INCL_ANY)) 856 return __dynamic_emit_prefix(desc, buf); 857 return buf; 858 } 859 860 void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...) 861 { 862 va_list args; 863 struct va_format vaf; 864 char buf[PREFIX_SIZE] = ""; 865 866 BUG_ON(!descriptor); 867 BUG_ON(!fmt); 868 869 va_start(args, fmt); 870 871 vaf.fmt = fmt; 872 vaf.va = &args; 873 874 printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf); 875 876 va_end(args); 877 } 878 EXPORT_SYMBOL(__dynamic_pr_debug); 879 880 void __dynamic_dev_dbg(struct _ddebug *descriptor, 881 const struct device *dev, const char *fmt, ...) 882 { 883 struct va_format vaf; 884 va_list args; 885 886 BUG_ON(!descriptor); 887 BUG_ON(!fmt); 888 889 va_start(args, fmt); 890 891 vaf.fmt = fmt; 892 vaf.va = &args; 893 894 if (!dev) { 895 printk(KERN_DEBUG "(NULL device *): %pV", &vaf); 896 } else { 897 char buf[PREFIX_SIZE] = ""; 898 899 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV", 900 dynamic_emit_prefix(descriptor, buf), 901 dev_driver_string(dev), dev_name(dev), 902 &vaf); 903 } 904 905 va_end(args); 906 } 907 EXPORT_SYMBOL(__dynamic_dev_dbg); 908 909 #ifdef CONFIG_NET 910 911 void __dynamic_netdev_dbg(struct _ddebug *descriptor, 912 const struct net_device *dev, const char *fmt, ...) 913 { 914 struct va_format vaf; 915 va_list args; 916 917 BUG_ON(!descriptor); 918 BUG_ON(!fmt); 919 920 va_start(args, fmt); 921 922 vaf.fmt = fmt; 923 vaf.va = &args; 924 925 if (dev && dev->dev.parent) { 926 char buf[PREFIX_SIZE] = ""; 927 928 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent, 929 "%s%s %s %s%s: %pV", 930 dynamic_emit_prefix(descriptor, buf), 931 dev_driver_string(dev->dev.parent), 932 dev_name(dev->dev.parent), 933 netdev_name(dev), netdev_reg_state(dev), 934 &vaf); 935 } else if (dev) { 936 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev), 937 netdev_reg_state(dev), &vaf); 938 } else { 939 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf); 940 } 941 942 va_end(args); 943 } 944 EXPORT_SYMBOL(__dynamic_netdev_dbg); 945 946 #endif 947 948 #if IS_ENABLED(CONFIG_INFINIBAND) 949 950 void __dynamic_ibdev_dbg(struct _ddebug *descriptor, 951 const struct ib_device *ibdev, const char *fmt, ...) 952 { 953 struct va_format vaf; 954 va_list args; 955 956 va_start(args, fmt); 957 958 vaf.fmt = fmt; 959 vaf.va = &args; 960 961 if (ibdev && ibdev->dev.parent) { 962 char buf[PREFIX_SIZE] = ""; 963 964 dev_printk_emit(LOGLEVEL_DEBUG, ibdev->dev.parent, 965 "%s%s %s %s: %pV", 966 dynamic_emit_prefix(descriptor, buf), 967 dev_driver_string(ibdev->dev.parent), 968 dev_name(ibdev->dev.parent), 969 dev_name(&ibdev->dev), 970 &vaf); 971 } else if (ibdev) { 972 printk(KERN_DEBUG "%s: %pV", dev_name(&ibdev->dev), &vaf); 973 } else { 974 printk(KERN_DEBUG "(NULL ib_device): %pV", &vaf); 975 } 976 977 va_end(args); 978 } 979 EXPORT_SYMBOL(__dynamic_ibdev_dbg); 980 981 #endif 982 983 /* 984 * Install a noop handler to make dyndbg look like a normal kernel cli param. 985 * This avoids warnings about dyndbg being an unknown cli param when supplied 986 * by a user. 987 */ 988 static __init int dyndbg_setup(char *str) 989 { 990 return 1; 991 } 992 993 __setup("dyndbg=", dyndbg_setup); 994 995 /* 996 * File_ops->write method for <debugfs>/dynamic_debug/control. Gathers the 997 * command text from userspace, parses and executes it. 998 */ 999 #define USER_BUF_PAGE 4096 1000 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf, 1001 size_t len, loff_t *offp) 1002 { 1003 char *tmpbuf; 1004 int ret; 1005 1006 if (len == 0) 1007 return 0; 1008 if (len > USER_BUF_PAGE - 1) { 1009 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE); 1010 return -E2BIG; 1011 } 1012 tmpbuf = memdup_user_nul(ubuf, len); 1013 if (IS_ERR(tmpbuf)) 1014 return PTR_ERR(tmpbuf); 1015 v2pr_info("read %zu bytes from userspace\n", len); 1016 1017 ret = ddebug_exec_queries(tmpbuf, NULL); 1018 kfree(tmpbuf); 1019 if (ret < 0) 1020 return ret; 1021 1022 *offp += len; 1023 return len; 1024 } 1025 1026 /* 1027 * Set the iterator to point to the first _ddebug object 1028 * and return a pointer to that first object. Returns 1029 * NULL if there are no _ddebugs at all. 1030 */ 1031 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter) 1032 { 1033 if (list_empty(&ddebug_tables)) { 1034 iter->table = NULL; 1035 return NULL; 1036 } 1037 iter->table = list_entry(ddebug_tables.next, 1038 struct ddebug_table, link); 1039 iter->idx = iter->table->num_ddebugs; 1040 return &iter->table->ddebugs[--iter->idx]; 1041 } 1042 1043 /* 1044 * Advance the iterator to point to the next _ddebug 1045 * object from the one the iterator currently points at, 1046 * and returns a pointer to the new _ddebug. Returns 1047 * NULL if the iterator has seen all the _ddebugs. 1048 */ 1049 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter) 1050 { 1051 if (iter->table == NULL) 1052 return NULL; 1053 if (--iter->idx < 0) { 1054 /* iterate to next table */ 1055 if (list_is_last(&iter->table->link, &ddebug_tables)) { 1056 iter->table = NULL; 1057 return NULL; 1058 } 1059 iter->table = list_entry(iter->table->link.next, 1060 struct ddebug_table, link); 1061 iter->idx = iter->table->num_ddebugs; 1062 --iter->idx; 1063 } 1064 return &iter->table->ddebugs[iter->idx]; 1065 } 1066 1067 /* 1068 * Seq_ops start method. Called at the start of every 1069 * read() call from userspace. Takes the ddebug_lock and 1070 * seeks the seq_file's iterator to the given position. 1071 */ 1072 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos) 1073 { 1074 struct ddebug_iter *iter = m->private; 1075 struct _ddebug *dp; 1076 int n = *pos; 1077 1078 mutex_lock(&ddebug_lock); 1079 1080 if (!n) 1081 return SEQ_START_TOKEN; 1082 if (n < 0) 1083 return NULL; 1084 dp = ddebug_iter_first(iter); 1085 while (dp != NULL && --n > 0) 1086 dp = ddebug_iter_next(iter); 1087 return dp; 1088 } 1089 1090 /* 1091 * Seq_ops next method. Called several times within a read() 1092 * call from userspace, with ddebug_lock held. Walks to the 1093 * next _ddebug object with a special case for the header line. 1094 */ 1095 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos) 1096 { 1097 struct ddebug_iter *iter = m->private; 1098 struct _ddebug *dp; 1099 1100 if (p == SEQ_START_TOKEN) 1101 dp = ddebug_iter_first(iter); 1102 else 1103 dp = ddebug_iter_next(iter); 1104 ++*pos; 1105 return dp; 1106 } 1107 1108 #define class_in_range(class_id, map) \ 1109 (class_id >= map->base && class_id < map->base + map->length) 1110 1111 static const char *ddebug_class_name(struct ddebug_iter *iter, struct _ddebug *dp) 1112 { 1113 struct ddebug_class_map *map; 1114 1115 list_for_each_entry(map, &iter->table->maps, link) 1116 if (class_in_range(dp->class_id, map)) 1117 return map->class_names[dp->class_id - map->base]; 1118 1119 return NULL; 1120 } 1121 1122 /* 1123 * Seq_ops show method. Called several times within a read() 1124 * call from userspace, with ddebug_lock held. Formats the 1125 * current _ddebug as a single human-readable line, with a 1126 * special case for the header line. 1127 */ 1128 static int ddebug_proc_show(struct seq_file *m, void *p) 1129 { 1130 struct ddebug_iter *iter = m->private; 1131 struct _ddebug *dp = p; 1132 struct flagsbuf flags; 1133 char const *class; 1134 1135 if (p == SEQ_START_TOKEN) { 1136 seq_puts(m, 1137 "# filename:lineno [module]function flags format\n"); 1138 return 0; 1139 } 1140 1141 seq_printf(m, "%s:%u [%s]%s =%s \"", 1142 trim_prefix(dp->filename), dp->lineno, 1143 iter->table->mod_name, dp->function, 1144 ddebug_describe_flags(dp->flags, &flags)); 1145 seq_escape_str(m, dp->format, ESCAPE_SPACE, "\t\r\n\""); 1146 seq_puts(m, "\""); 1147 1148 if (dp->class_id != _DPRINTK_CLASS_DFLT) { 1149 class = ddebug_class_name(iter, dp); 1150 if (class) 1151 seq_printf(m, " class:%s", class); 1152 else 1153 seq_printf(m, " class unknown, _id:%d", dp->class_id); 1154 } 1155 seq_puts(m, "\n"); 1156 1157 return 0; 1158 } 1159 1160 /* 1161 * Seq_ops stop method. Called at the end of each read() 1162 * call from userspace. Drops ddebug_lock. 1163 */ 1164 static void ddebug_proc_stop(struct seq_file *m, void *p) 1165 { 1166 mutex_unlock(&ddebug_lock); 1167 } 1168 1169 static const struct seq_operations ddebug_proc_seqops = { 1170 .start = ddebug_proc_start, 1171 .next = ddebug_proc_next, 1172 .show = ddebug_proc_show, 1173 .stop = ddebug_proc_stop 1174 }; 1175 1176 static int ddebug_proc_open(struct inode *inode, struct file *file) 1177 { 1178 return seq_open_private(file, &ddebug_proc_seqops, 1179 sizeof(struct ddebug_iter)); 1180 } 1181 1182 static const struct file_operations ddebug_proc_fops = { 1183 .owner = THIS_MODULE, 1184 .open = ddebug_proc_open, 1185 .read = seq_read, 1186 .llseek = seq_lseek, 1187 .release = seq_release_private, 1188 .write = ddebug_proc_write 1189 }; 1190 1191 static const struct proc_ops proc_fops = { 1192 .proc_open = ddebug_proc_open, 1193 .proc_read = seq_read, 1194 .proc_lseek = seq_lseek, 1195 .proc_release = seq_release_private, 1196 .proc_write = ddebug_proc_write 1197 }; 1198 1199 static void ddebug_attach_module_classes(struct ddebug_table *dt, 1200 struct ddebug_class_map *classes, 1201 int num_classes) 1202 { 1203 struct ddebug_class_map *cm; 1204 int i, j, ct = 0; 1205 1206 for (cm = classes, i = 0; i < num_classes; i++, cm++) { 1207 1208 if (!strcmp(cm->mod_name, dt->mod_name)) { 1209 1210 v2pr_info("class[%d]: module:%s base:%d len:%d ty:%d\n", i, 1211 cm->mod_name, cm->base, cm->length, cm->map_type); 1212 1213 for (j = 0; j < cm->length; j++) 1214 v3pr_info(" %d: %d %s\n", j + cm->base, j, 1215 cm->class_names[j]); 1216 1217 list_add(&cm->link, &dt->maps); 1218 ct++; 1219 } 1220 } 1221 if (ct) 1222 vpr_info("module:%s attached %d classes\n", dt->mod_name, ct); 1223 } 1224 1225 /* 1226 * Allocate a new ddebug_table for the given module 1227 * and add it to the global list. 1228 */ 1229 static int ddebug_add_module(struct _ddebug_info *di, const char *modname) 1230 { 1231 struct ddebug_table *dt; 1232 1233 v3pr_info("add-module: %s.%d sites\n", modname, di->num_descs); 1234 if (!di->num_descs) { 1235 v3pr_info(" skip %s\n", modname); 1236 return 0; 1237 } 1238 1239 dt = kzalloc(sizeof(*dt), GFP_KERNEL); 1240 if (dt == NULL) { 1241 pr_err("error adding module: %s\n", modname); 1242 return -ENOMEM; 1243 } 1244 /* 1245 * For built-in modules, name lives in .rodata and is 1246 * immortal. For loaded modules, name points at the name[] 1247 * member of struct module, which lives at least as long as 1248 * this struct ddebug_table. 1249 */ 1250 dt->mod_name = modname; 1251 dt->ddebugs = di->descs; 1252 dt->num_ddebugs = di->num_descs; 1253 1254 INIT_LIST_HEAD(&dt->link); 1255 INIT_LIST_HEAD(&dt->maps); 1256 1257 if (di->classes && di->num_classes) 1258 ddebug_attach_module_classes(dt, di->classes, di->num_classes); 1259 1260 mutex_lock(&ddebug_lock); 1261 list_add_tail(&dt->link, &ddebug_tables); 1262 mutex_unlock(&ddebug_lock); 1263 1264 vpr_info("%3u debug prints in module %s\n", di->num_descs, modname); 1265 return 0; 1266 } 1267 1268 /* helper for ddebug_dyndbg_(boot|module)_param_cb */ 1269 static int ddebug_dyndbg_param_cb(char *param, char *val, 1270 const char *modname, int on_err) 1271 { 1272 char *sep; 1273 1274 sep = strchr(param, '.'); 1275 if (sep) { 1276 /* needed only for ddebug_dyndbg_boot_param_cb */ 1277 *sep = '\0'; 1278 modname = param; 1279 param = sep + 1; 1280 } 1281 if (strcmp(param, "dyndbg")) 1282 return on_err; /* determined by caller */ 1283 1284 ddebug_exec_queries((val ? val : "+p"), modname); 1285 1286 return 0; /* query failure shouldn't stop module load */ 1287 } 1288 1289 /* handle both dyndbg and $module.dyndbg params at boot */ 1290 static int ddebug_dyndbg_boot_param_cb(char *param, char *val, 1291 const char *unused, void *arg) 1292 { 1293 vpr_info("%s=\"%s\"\n", param, val); 1294 return ddebug_dyndbg_param_cb(param, val, NULL, 0); 1295 } 1296 1297 /* 1298 * modprobe foo finds foo.params in boot-args, strips "foo.", and 1299 * passes them to load_module(). This callback gets unknown params, 1300 * processes dyndbg params, rejects others. 1301 */ 1302 int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module) 1303 { 1304 vpr_info("module: %s %s=\"%s\"\n", module, param, val); 1305 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT); 1306 } 1307 1308 static void ddebug_table_free(struct ddebug_table *dt) 1309 { 1310 list_del_init(&dt->link); 1311 kfree(dt); 1312 } 1313 1314 #ifdef CONFIG_MODULES 1315 1316 /* 1317 * Called in response to a module being unloaded. Removes 1318 * any ddebug_table's which point at the module. 1319 */ 1320 static int ddebug_remove_module(const char *mod_name) 1321 { 1322 struct ddebug_table *dt, *nextdt; 1323 int ret = -ENOENT; 1324 1325 mutex_lock(&ddebug_lock); 1326 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) { 1327 if (dt->mod_name == mod_name) { 1328 ddebug_table_free(dt); 1329 ret = 0; 1330 break; 1331 } 1332 } 1333 mutex_unlock(&ddebug_lock); 1334 if (!ret) 1335 v2pr_info("removed module \"%s\"\n", mod_name); 1336 return ret; 1337 } 1338 1339 static int ddebug_module_notify(struct notifier_block *self, unsigned long val, 1340 void *data) 1341 { 1342 struct module *mod = data; 1343 int ret = 0; 1344 1345 switch (val) { 1346 case MODULE_STATE_COMING: 1347 ret = ddebug_add_module(&mod->dyndbg_info, mod->name); 1348 if (ret) 1349 WARN(1, "Failed to allocate memory: dyndbg may not work properly.\n"); 1350 break; 1351 case MODULE_STATE_GOING: 1352 ddebug_remove_module(mod->name); 1353 break; 1354 } 1355 1356 return notifier_from_errno(ret); 1357 } 1358 1359 static struct notifier_block ddebug_module_nb = { 1360 .notifier_call = ddebug_module_notify, 1361 .priority = 0, /* dynamic debug depends on jump label */ 1362 }; 1363 1364 #endif /* CONFIG_MODULES */ 1365 1366 static void ddebug_remove_all_tables(void) 1367 { 1368 mutex_lock(&ddebug_lock); 1369 while (!list_empty(&ddebug_tables)) { 1370 struct ddebug_table *dt = list_entry(ddebug_tables.next, 1371 struct ddebug_table, 1372 link); 1373 ddebug_table_free(dt); 1374 } 1375 mutex_unlock(&ddebug_lock); 1376 } 1377 1378 static __initdata int ddebug_init_success; 1379 1380 static int __init dynamic_debug_init_control(void) 1381 { 1382 struct proc_dir_entry *procfs_dir; 1383 struct dentry *debugfs_dir; 1384 1385 if (!ddebug_init_success) 1386 return -ENODEV; 1387 1388 /* Create the control file in debugfs if it is enabled */ 1389 if (debugfs_initialized()) { 1390 debugfs_dir = debugfs_create_dir("dynamic_debug", NULL); 1391 debugfs_create_file("control", 0644, debugfs_dir, NULL, 1392 &ddebug_proc_fops); 1393 } 1394 1395 /* Also create the control file in procfs */ 1396 procfs_dir = proc_mkdir("dynamic_debug", NULL); 1397 if (procfs_dir) 1398 proc_create("control", 0644, procfs_dir, &proc_fops); 1399 1400 return 0; 1401 } 1402 1403 static int __init dynamic_debug_init(void) 1404 { 1405 struct _ddebug *iter, *iter_mod_start; 1406 int ret, i, mod_sites, mod_ct; 1407 const char *modname; 1408 char *cmdline; 1409 1410 struct _ddebug_info di = { 1411 .descs = __start___dyndbg, 1412 .classes = __start___dyndbg_classes, 1413 .num_descs = __stop___dyndbg - __start___dyndbg, 1414 .num_classes = __stop___dyndbg_classes - __start___dyndbg_classes, 1415 }; 1416 1417 #ifdef CONFIG_MODULES 1418 ret = register_module_notifier(&ddebug_module_nb); 1419 if (ret) { 1420 pr_warn("Failed to register dynamic debug module notifier\n"); 1421 return ret; 1422 } 1423 #endif /* CONFIG_MODULES */ 1424 1425 if (&__start___dyndbg == &__stop___dyndbg) { 1426 if (IS_ENABLED(CONFIG_DYNAMIC_DEBUG)) { 1427 pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n"); 1428 return 1; 1429 } 1430 pr_info("Ignore empty _ddebug table in a CONFIG_DYNAMIC_DEBUG_CORE build\n"); 1431 ddebug_init_success = 1; 1432 return 0; 1433 } 1434 1435 iter = iter_mod_start = __start___dyndbg; 1436 modname = iter->modname; 1437 i = mod_sites = mod_ct = 0; 1438 1439 for (; iter < __stop___dyndbg; iter++, i++, mod_sites++) { 1440 1441 if (strcmp(modname, iter->modname)) { 1442 mod_ct++; 1443 di.num_descs = mod_sites; 1444 di.descs = iter_mod_start; 1445 ret = ddebug_add_module(&di, modname); 1446 if (ret) 1447 goto out_err; 1448 1449 mod_sites = 0; 1450 modname = iter->modname; 1451 iter_mod_start = iter; 1452 } 1453 } 1454 di.num_descs = mod_sites; 1455 di.descs = iter_mod_start; 1456 ret = ddebug_add_module(&di, modname); 1457 if (ret) 1458 goto out_err; 1459 1460 ddebug_init_success = 1; 1461 vpr_info("%d prdebugs in %d modules, %d KiB in ddebug tables, %d kiB in __dyndbg section\n", 1462 i, mod_ct, (int)((mod_ct * sizeof(struct ddebug_table)) >> 10), 1463 (int)((i * sizeof(struct _ddebug)) >> 10)); 1464 1465 if (di.num_classes) 1466 v2pr_info(" %d builtin ddebug class-maps\n", di.num_classes); 1467 1468 /* now that ddebug tables are loaded, process all boot args 1469 * again to find and activate queries given in dyndbg params. 1470 * While this has already been done for known boot params, it 1471 * ignored the unknown ones (dyndbg in particular). Reusing 1472 * parse_args avoids ad-hoc parsing. This will also attempt 1473 * to activate queries for not-yet-loaded modules, which is 1474 * slightly noisy if verbose, but harmless. 1475 */ 1476 cmdline = kstrdup(saved_command_line, GFP_KERNEL); 1477 parse_args("dyndbg params", cmdline, NULL, 1478 0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb); 1479 kfree(cmdline); 1480 return 0; 1481 1482 out_err: 1483 ddebug_remove_all_tables(); 1484 return 0; 1485 } 1486 /* Allow early initialization for boot messages via boot param */ 1487 early_initcall(dynamic_debug_init); 1488 1489 /* Debugfs setup must be done later */ 1490 fs_initcall(dynamic_debug_init_control); 1491