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