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