lib/dynamic_debug.c

   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  * Install a noop handler to make dyndbg look like a normal kernel cli param.
 766  * This avoids warnings about dyndbg being an unknown cli param when supplied
 767  * by a user.
 768  */
 769 static __init int dyndbg_setup(char *str)
 770 {
 771         return 1;
 772 }
 773
 774 __setup("dyndbg=", dyndbg_setup);
 775
 776 /*
 777  * File_ops->write method for <debugfs>/dynamic_debug/control.  Gathers the
 778  * command text from userspace, parses and executes it.
 779  */
 780 #define USER_BUF_PAGE 4096
 781 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
 782                                   size_t len, loff_t *offp)
 783 {
 784         char *tmpbuf;
 785         int ret;
 786
 787         if (len == 0)
 788                 return 0;
 789         if (len > USER_BUF_PAGE - 1) {
 790                 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
 791                 return -E2BIG;
 792         }
 793         tmpbuf = memdup_user_nul(ubuf, len);
 794         if (IS_ERR(tmpbuf))
 795                 return PTR_ERR(tmpbuf);
 796         vpr_info("read %d bytes from userspace\n", (int)len);
 797
 798         ret = ddebug_exec_queries(tmpbuf, NULL);
 799         kfree(tmpbuf);
 800         if (ret < 0)
 801                 return ret;
 802
 803         *offp += len;
 804         return len;
 805 }
 806
 807 /*
 808  * Set the iterator to point to the first _ddebug object
 809  * and return a pointer to that first object.  Returns
 810  * NULL if there are no _ddebugs at all.
 811  */
 812 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
 813 {
 814         if (list_empty(&ddebug_tables)) {
 815                 iter->table = NULL;
 816                 iter->idx = 0;
 817                 return NULL;
 818         }
 819         iter->table = list_entry(ddebug_tables.next,
 820                                  struct ddebug_table, link);
 821         iter->idx = 0;
 822         return &iter->table->ddebugs[iter->idx];
 823 }
 824
 825 /*
 826  * Advance the iterator to point to the next _ddebug
 827  * object from the one the iterator currently points at,
 828  * and returns a pointer to the new _ddebug.  Returns
 829  * NULL if the iterator has seen all the _ddebugs.
 830  */
 831 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
 832 {
 833         if (iter->table == NULL)
 834                 return NULL;
 835         if (++iter->idx == iter->table->num_ddebugs) {
 836                 /* iterate to next table */
 837                 iter->idx = 0;
 838                 if (list_is_last(&iter->table->link, &ddebug_tables)) {
 839                         iter->table = NULL;
 840                         return NULL;
 841                 }
 842                 iter->table = list_entry(iter->table->link.next,
 843                                          struct ddebug_table, link);
 844         }
 845         return &iter->table->ddebugs[iter->idx];
 846 }
 847
 848 /*
 849  * Seq_ops start method.  Called at the start of every
 850  * read() call from userspace.  Takes the ddebug_lock and
 851  * seeks the seq_file's iterator to the given position.
 852  */
 853 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
 854 {
 855         struct ddebug_iter *iter = m->private;
 856         struct _ddebug *dp;
 857         int n = *pos;
 858
 859         mutex_lock(&ddebug_lock);
 860
 861         if (!n)
 862                 return SEQ_START_TOKEN;
 863         if (n < 0)
 864                 return NULL;
 865         dp = ddebug_iter_first(iter);
 866         while (dp != NULL && --n > 0)
 867                 dp = ddebug_iter_next(iter);
 868         return dp;
 869 }
 870
 871 /*
 872  * Seq_ops next method.  Called several times within a read()
 873  * call from userspace, with ddebug_lock held.  Walks to the
 874  * next _ddebug object with a special case for the header line.
 875  */
 876 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
 877 {
 878         struct ddebug_iter *iter = m->private;
 879         struct _ddebug *dp;
 880
 881         if (p == SEQ_START_TOKEN)
 882                 dp = ddebug_iter_first(iter);
 883         else
 884                 dp = ddebug_iter_next(iter);
 885         ++*pos;
 886         return dp;
 887 }
 888
 889 /*
 890  * Seq_ops show method.  Called several times within a read()
 891  * call from userspace, with ddebug_lock held.  Formats the
 892  * current _ddebug as a single human-readable line, with a
 893  * special case for the header line.
 894  */
 895 static int ddebug_proc_show(struct seq_file *m, void *p)
 896 {
 897         struct ddebug_iter *iter = m->private;
 898         struct _ddebug *dp = p;
 899         struct flagsbuf flags;
 900
 901         if (p == SEQ_START_TOKEN) {
 902                 seq_puts(m,
 903                          "# filename:lineno [module]function flags format\n");
 904                 return 0;
 905         }
 906
 907         seq_printf(m, "%s:%u [%s]%s =%s \"",
 908                    trim_prefix(dp->filename), dp->lineno,
 909                    iter->table->mod_name, dp->function,
 910                    ddebug_describe_flags(dp->flags, &flags));
 911         seq_escape(m, dp->format, "\t\r\n\"");
 912         seq_puts(m, "\"\n");
 913
 914         return 0;
 915 }
 916
 917 /*
 918  * Seq_ops stop method.  Called at the end of each read()
 919  * call from userspace.  Drops ddebug_lock.
 920  */
 921 static void ddebug_proc_stop(struct seq_file *m, void *p)
 922 {
 923         mutex_unlock(&ddebug_lock);
 924 }
 925
 926 static const struct seq_operations ddebug_proc_seqops = {
 927         .start = ddebug_proc_start,
 928         .next = ddebug_proc_next,
 929         .show = ddebug_proc_show,
 930         .stop = ddebug_proc_stop
 931 };
 932
 933 static int ddebug_proc_open(struct inode *inode, struct file *file)
 934 {
 935         return seq_open_private(file, &ddebug_proc_seqops,
 936                                 sizeof(struct ddebug_iter));
 937 }
 938
 939 static const struct file_operations ddebug_proc_fops = {
 940         .owner = THIS_MODULE,
 941         .open = ddebug_proc_open,
 942         .read = seq_read,
 943         .llseek = seq_lseek,
 944         .release = seq_release_private,
 945         .write = ddebug_proc_write
 946 };
 947
 948 static const struct proc_ops proc_fops = {
 949         .proc_open = ddebug_proc_open,
 950         .proc_read = seq_read,
 951         .proc_lseek = seq_lseek,
 952         .proc_release = seq_release_private,
 953         .proc_write = ddebug_proc_write
 954 };
 955
 956 /*
 957  * Allocate a new ddebug_table for the given module
 958  * and add it to the global list.
 959  */
 960 int ddebug_add_module(struct _ddebug *tab, unsigned int n,
 961                              const char *name)
 962 {
 963         struct ddebug_table *dt;
 964
 965         dt = kzalloc(sizeof(*dt), GFP_KERNEL);
 966         if (dt == NULL) {
 967                 pr_err("error adding module: %s\n", name);
 968                 return -ENOMEM;
 969         }
 970         /*
 971          * For built-in modules, name lives in .rodata and is
 972          * immortal. For loaded modules, name points at the name[]
 973          * member of struct module, which lives at least as long as
 974          * this struct ddebug_table.
 975          */
 976         dt->mod_name = name;
 977         dt->num_ddebugs = n;
 978         dt->ddebugs = tab;
 979
 980         mutex_lock(&ddebug_lock);
 981         list_add(&dt->link, &ddebug_tables);
 982         mutex_unlock(&ddebug_lock);
 983
 984         v2pr_info("%3u debug prints in module %s\n", n, dt->mod_name);
 985         return 0;
 986 }
 987
 988 /* helper for ddebug_dyndbg_(boot|module)_param_cb */
 989 static int ddebug_dyndbg_param_cb(char *param, char *val,
 990                                 const char *modname, int on_err)
 991 {
 992         char *sep;
 993
 994         sep = strchr(param, '.');
 995         if (sep) {
 996                 /* needed only for ddebug_dyndbg_boot_param_cb */
 997                 *sep = '\0';
 998                 modname = param;
 999                 param = sep + 1;
1000         }
1001         if (strcmp(param, "dyndbg"))
1002                 return on_err; /* determined by caller */
1003
1004         ddebug_exec_queries((val ? val : "+p"), modname);
1005
1006         return 0; /* query failure shouldn't stop module load */
1007 }
1008
1009 /* handle both dyndbg and $module.dyndbg params at boot */
1010 static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
1011                                 const char *unused, void *arg)
1012 {
1013         vpr_info("%s=\"%s\"\n", param, val);
1014         return ddebug_dyndbg_param_cb(param, val, NULL, 0);
1015 }
1016
1017 /*
1018  * modprobe foo finds foo.params in boot-args, strips "foo.", and
1019  * passes them to load_module().  This callback gets unknown params,
1020  * processes dyndbg params, rejects others.
1021  */
1022 int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
1023 {
1024         vpr_info("module: %s %s=\"%s\"\n", module, param, val);
1025         return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
1026 }
1027
1028 static void ddebug_table_free(struct ddebug_table *dt)
1029 {
1030         list_del_init(&dt->link);
1031         kfree(dt);
1032 }
1033
1034 /*
1035  * Called in response to a module being unloaded.  Removes
1036  * any ddebug_table's which point at the module.
1037  */
1038 int ddebug_remove_module(const char *mod_name)
1039 {
1040         struct ddebug_table *dt, *nextdt;
1041         int ret = -ENOENT;
1042
1043         v2pr_info("removing module \"%s\"\n", mod_name);
1044
1045         mutex_lock(&ddebug_lock);
1046         list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
1047                 if (dt->mod_name == mod_name) {
1048                         ddebug_table_free(dt);
1049                         ret = 0;
1050                         break;
1051                 }
1052         }
1053         mutex_unlock(&ddebug_lock);
1054         return ret;
1055 }
1056
1057 static void ddebug_remove_all_tables(void)
1058 {
1059         mutex_lock(&ddebug_lock);
1060         while (!list_empty(&ddebug_tables)) {
1061                 struct ddebug_table *dt = list_entry(ddebug_tables.next,
1062                                                       struct ddebug_table,
1063                                                       link);
1064                 ddebug_table_free(dt);
1065         }
1066         mutex_unlock(&ddebug_lock);
1067 }
1068
1069 static __initdata int ddebug_init_success;
1070
1071 static int __init dynamic_debug_init_control(void)
1072 {
1073         struct proc_dir_entry *procfs_dir;
1074         struct dentry *debugfs_dir;
1075
1076         if (!ddebug_init_success)
1077                 return -ENODEV;
1078
1079         /* Create the control file in debugfs if it is enabled */
1080         if (debugfs_initialized()) {
1081                 debugfs_dir = debugfs_create_dir("dynamic_debug", NULL);
1082                 debugfs_create_file("control", 0644, debugfs_dir, NULL,
1083                                     &ddebug_proc_fops);
1084         }
1085
1086         /* Also create the control file in procfs */
1087         procfs_dir = proc_mkdir("dynamic_debug", NULL);
1088         if (procfs_dir)
1089                 proc_create("control", 0644, procfs_dir, &proc_fops);
1090
1091         return 0;
1092 }
1093
1094 static int __init dynamic_debug_init(void)
1095 {
1096         struct _ddebug *iter, *iter_start;
1097         const char *modname = NULL;
1098         char *cmdline;
1099         int ret = 0;
1100         int n = 0, entries = 0, modct = 0;
1101
1102         if (&__start___dyndbg == &__stop___dyndbg) {
1103                 if (IS_ENABLED(CONFIG_DYNAMIC_DEBUG)) {
1104                         pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
1105                         return 1;
1106                 }
1107                 pr_info("Ignore empty _ddebug table in a CONFIG_DYNAMIC_DEBUG_CORE build\n");
1108                 ddebug_init_success = 1;
1109                 return 0;
1110         }
1111         iter = __start___dyndbg;
1112         modname = iter->modname;
1113         iter_start = iter;
1114         for (; iter < __stop___dyndbg; iter++) {
1115                 entries++;
1116                 if (strcmp(modname, iter->modname)) {
1117                         modct++;
1118                         ret = ddebug_add_module(iter_start, n, modname);
1119                         if (ret)
1120                                 goto out_err;
1121                         n = 0;
1122                         modname = iter->modname;
1123                         iter_start = iter;
1124                 }
1125                 n++;
1126         }
1127         ret = ddebug_add_module(iter_start, n, modname);
1128         if (ret)
1129                 goto out_err;
1130
1131         ddebug_init_success = 1;
1132         vpr_info("%d prdebugs in %d modules, %d KiB in ddebug tables, %d kiB in __dyndbg section\n",
1133                  entries, modct, (int)((modct * sizeof(struct ddebug_table)) >> 10),
1134                  (int)((entries * sizeof(struct _ddebug)) >> 10));
1135
1136         /* apply ddebug_query boot param, dont unload tables on err */
1137         if (ddebug_setup_string[0] != '\0') {
1138                 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
1139                 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
1140                 if (ret < 0)
1141                         pr_warn("Invalid ddebug boot param %s\n",
1142                                 ddebug_setup_string);
1143                 else
1144                         pr_info("%d changes by ddebug_query\n", ret);
1145         }
1146         /* now that ddebug tables are loaded, process all boot args
1147          * again to find and activate queries given in dyndbg params.
1148          * While this has already been done for known boot params, it
1149          * ignored the unknown ones (dyndbg in particular).  Reusing
1150          * parse_args avoids ad-hoc parsing.  This will also attempt
1151          * to activate queries for not-yet-loaded modules, which is
1152          * slightly noisy if verbose, but harmless.
1153          */
1154         cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1155         parse_args("dyndbg params", cmdline, NULL,
1156                    0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
1157         kfree(cmdline);
1158         return 0;
1159
1160 out_err:
1161         ddebug_remove_all_tables();
1162         return 0;
1163 }
1164 /* Allow early initialization for boot messages via boot param */
1165 early_initcall(dynamic_debug_init);
1166
1167 /* Debugfs setup must be done later */
1168 fs_initcall(dynamic_debug_init_control);