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