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         *buf = '\0';
 595
 596         if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
 597                 if (in_interrupt())
 598                         pos += snprintf(buf + pos, remaining(pos), "<intr> ");
 599                 else
 600                         pos += snprintf(buf + pos, remaining(pos), "[%d] ",
 601                                         task_pid_vnr(current));
 602         }
 603         pos_after_tid = pos;
 604         if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
 605                 pos += snprintf(buf + pos, remaining(pos), "%s:",
 606                                 desc->modname);
 607         if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
 608                 pos += snprintf(buf + pos, remaining(pos), "%s:",
 609                                 desc->function);
 610         if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
 611                 pos += snprintf(buf + pos, remaining(pos), "%d:",
 612                                 desc->lineno);
 613         if (pos - pos_after_tid)
 614                 pos += snprintf(buf + pos, remaining(pos), " ");
 615         if (pos >= PREFIX_SIZE)
 616                 buf[PREFIX_SIZE - 1] = '\0';
 617
 618         return buf;
 619 }
 620
 621 void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
 622 {
 623         va_list args;
 624         struct va_format vaf;
 625         char buf[PREFIX_SIZE];
 626
 627         BUG_ON(!descriptor);
 628         BUG_ON(!fmt);
 629
 630         va_start(args, fmt);
 631
 632         vaf.fmt = fmt;
 633         vaf.va = &args;
 634
 635         printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
 636
 637         va_end(args);
 638 }
 639 EXPORT_SYMBOL(__dynamic_pr_debug);
 640
 641 void __dynamic_dev_dbg(struct _ddebug *descriptor,
 642                       const struct device *dev, const char *fmt, ...)
 643 {
 644         struct va_format vaf;
 645         va_list args;
 646
 647         BUG_ON(!descriptor);
 648         BUG_ON(!fmt);
 649
 650         va_start(args, fmt);
 651
 652         vaf.fmt = fmt;
 653         vaf.va = &args;
 654
 655         if (!dev) {
 656                 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
 657         } else {
 658                 char buf[PREFIX_SIZE];
 659
 660                 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
 661                                 dynamic_emit_prefix(descriptor, buf),
 662                                 dev_driver_string(dev), dev_name(dev),
 663                                 &vaf);
 664         }
 665
 666         va_end(args);
 667 }
 668 EXPORT_SYMBOL(__dynamic_dev_dbg);
 669
 670 #ifdef CONFIG_NET
 671
 672 void __dynamic_netdev_dbg(struct _ddebug *descriptor,
 673                           const struct net_device *dev, const char *fmt, ...)
 674 {
 675         struct va_format vaf;
 676         va_list args;
 677
 678         BUG_ON(!descriptor);
 679         BUG_ON(!fmt);
 680
 681         va_start(args, fmt);
 682
 683         vaf.fmt = fmt;
 684         vaf.va = &args;
 685
 686         if (dev && dev->dev.parent) {
 687                 char buf[PREFIX_SIZE];
 688
 689                 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
 690                                 "%s%s %s %s%s: %pV",
 691                                 dynamic_emit_prefix(descriptor, buf),
 692                                 dev_driver_string(dev->dev.parent),
 693                                 dev_name(dev->dev.parent),
 694                                 netdev_name(dev), netdev_reg_state(dev),
 695                                 &vaf);
 696         } else if (dev) {
 697                 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
 698                        netdev_reg_state(dev), &vaf);
 699         } else {
 700                 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
 701         }
 702
 703         va_end(args);
 704 }
 705 EXPORT_SYMBOL(__dynamic_netdev_dbg);
 706
 707 #endif
 708
 709 #if IS_ENABLED(CONFIG_INFINIBAND)
 710
 711 void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
 712                          const struct ib_device *ibdev, const char *fmt, ...)
 713 {
 714         struct va_format vaf;
 715         va_list args;
 716
 717         va_start(args, fmt);
 718
 719         vaf.fmt = fmt;
 720         vaf.va = &args;
 721
 722         if (ibdev && ibdev->dev.parent) {
 723                 char buf[PREFIX_SIZE];
 724
 725                 dev_printk_emit(LOGLEVEL_DEBUG, ibdev->dev.parent,
 726                                 "%s%s %s %s: %pV",
 727                                 dynamic_emit_prefix(descriptor, buf),
 728                                 dev_driver_string(ibdev->dev.parent),
 729                                 dev_name(ibdev->dev.parent),
 730                                 dev_name(&ibdev->dev),
 731                                 &vaf);
 732         } else if (ibdev) {
 733                 printk(KERN_DEBUG "%s: %pV", dev_name(&ibdev->dev), &vaf);
 734         } else {
 735                 printk(KERN_DEBUG "(NULL ib_device): %pV", &vaf);
 736         }
 737
 738         va_end(args);
 739 }
 740 EXPORT_SYMBOL(__dynamic_ibdev_dbg);
 741
 742 #endif
 743
 744 #define DDEBUG_STRING_SIZE 1024
 745 static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
 746
 747 static __init int ddebug_setup_query(char *str)
 748 {
 749         if (strlen(str) >= DDEBUG_STRING_SIZE) {
 750                 pr_warn("ddebug boot param string too large\n");
 751                 return 0;
 752         }
 753         strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
 754         return 1;
 755 }
 756
 757 __setup("ddebug_query=", ddebug_setup_query);
 758
 759 /*
 760  * File_ops->write method for <debugfs>/dynamic_debug/control.  Gathers the
 761  * command text from userspace, parses and executes it.
 762  */
 763 #define USER_BUF_PAGE 4096
 764 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
 765                                   size_t len, loff_t *offp)
 766 {
 767         char *tmpbuf;
 768         int ret;
 769
 770         if (len == 0)
 771                 return 0;
 772         if (len > USER_BUF_PAGE - 1) {
 773                 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
 774                 return -E2BIG;
 775         }
 776         tmpbuf = memdup_user_nul(ubuf, len);
 777         if (IS_ERR(tmpbuf))
 778                 return PTR_ERR(tmpbuf);
 779         vpr_info("read %d bytes from userspace\n", (int)len);
 780
 781         ret = ddebug_exec_queries(tmpbuf, NULL);
 782         kfree(tmpbuf);
 783         if (ret < 0)
 784                 return ret;
 785
 786         *offp += len;
 787         return len;
 788 }
 789
 790 /*
 791  * Set the iterator to point to the first _ddebug object
 792  * and return a pointer to that first object.  Returns
 793  * NULL if there are no _ddebugs at all.
 794  */
 795 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
 796 {
 797         if (list_empty(&ddebug_tables)) {
 798                 iter->table = NULL;
 799                 iter->idx = 0;
 800                 return NULL;
 801         }
 802         iter->table = list_entry(ddebug_tables.next,
 803                                  struct ddebug_table, link);
 804         iter->idx = 0;
 805         return &iter->table->ddebugs[iter->idx];
 806 }
 807
 808 /*
 809  * Advance the iterator to point to the next _ddebug
 810  * object from the one the iterator currently points at,
 811  * and returns a pointer to the new _ddebug.  Returns
 812  * NULL if the iterator has seen all the _ddebugs.
 813  */
 814 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
 815 {
 816         if (iter->table == NULL)
 817                 return NULL;
 818         if (++iter->idx == iter->table->num_ddebugs) {
 819                 /* iterate to next table */
 820                 iter->idx = 0;
 821                 if (list_is_last(&iter->table->link, &ddebug_tables)) {
 822                         iter->table = NULL;
 823                         return NULL;
 824                 }
 825                 iter->table = list_entry(iter->table->link.next,
 826                                          struct ddebug_table, link);
 827         }
 828         return &iter->table->ddebugs[iter->idx];
 829 }
 830
 831 /*
 832  * Seq_ops start method.  Called at the start of every
 833  * read() call from userspace.  Takes the ddebug_lock and
 834  * seeks the seq_file's iterator to the given position.
 835  */
 836 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
 837 {
 838         struct ddebug_iter *iter = m->private;
 839         struct _ddebug *dp;
 840         int n = *pos;
 841
 842         mutex_lock(&ddebug_lock);
 843
 844         if (!n)
 845                 return SEQ_START_TOKEN;
 846         if (n < 0)
 847                 return NULL;
 848         dp = ddebug_iter_first(iter);
 849         while (dp != NULL && --n > 0)
 850                 dp = ddebug_iter_next(iter);
 851         return dp;
 852 }
 853
 854 /*
 855  * Seq_ops next method.  Called several times within a read()
 856  * call from userspace, with ddebug_lock held.  Walks to the
 857  * next _ddebug object with a special case for the header line.
 858  */
 859 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
 860 {
 861         struct ddebug_iter *iter = m->private;
 862         struct _ddebug *dp;
 863
 864         if (p == SEQ_START_TOKEN)
 865                 dp = ddebug_iter_first(iter);
 866         else
 867                 dp = ddebug_iter_next(iter);
 868         ++*pos;
 869         return dp;
 870 }
 871
 872 /*
 873  * Seq_ops show method.  Called several times within a read()
 874  * call from userspace, with ddebug_lock held.  Formats the
 875  * current _ddebug as a single human-readable line, with a
 876  * special case for the header line.
 877  */
 878 static int ddebug_proc_show(struct seq_file *m, void *p)
 879 {
 880         struct ddebug_iter *iter = m->private;
 881         struct _ddebug *dp = p;
 882         struct flagsbuf flags;
 883
 884         if (p == SEQ_START_TOKEN) {
 885                 seq_puts(m,
 886                          "# filename:lineno [module]function flags format\n");
 887                 return 0;
 888         }
 889
 890         seq_printf(m, "%s:%u [%s]%s =%s \"",
 891                    trim_prefix(dp->filename), dp->lineno,
 892                    iter->table->mod_name, dp->function,
 893                    ddebug_describe_flags(dp->flags, &flags));
 894         seq_escape(m, dp->format, "\t\r\n\"");
 895         seq_puts(m, "\"\n");
 896
 897         return 0;
 898 }
 899
 900 /*
 901  * Seq_ops stop method.  Called at the end of each read()
 902  * call from userspace.  Drops ddebug_lock.
 903  */
 904 static void ddebug_proc_stop(struct seq_file *m, void *p)
 905 {
 906         mutex_unlock(&ddebug_lock);
 907 }
 908
 909 static const struct seq_operations ddebug_proc_seqops = {
 910         .start = ddebug_proc_start,
 911         .next = ddebug_proc_next,
 912         .show = ddebug_proc_show,
 913         .stop = ddebug_proc_stop
 914 };
 915
 916 static int ddebug_proc_open(struct inode *inode, struct file *file)
 917 {
 918         vpr_info("called\n");
 919         return seq_open_private(file, &ddebug_proc_seqops,
 920                                 sizeof(struct ddebug_iter));
 921 }
 922
 923 static const struct file_operations ddebug_proc_fops = {
 924         .owner = THIS_MODULE,
 925         .open = ddebug_proc_open,
 926         .read = seq_read,
 927         .llseek = seq_lseek,
 928         .release = seq_release_private,
 929         .write = ddebug_proc_write
 930 };
 931
 932 static const struct proc_ops proc_fops = {
 933         .proc_open = ddebug_proc_open,
 934         .proc_read = seq_read,
 935         .proc_lseek = seq_lseek,
 936         .proc_release = seq_release_private,
 937         .proc_write = ddebug_proc_write
 938 };
 939
 940 /*
 941  * Allocate a new ddebug_table for the given module
 942  * and add it to the global list.
 943  */
 944 int ddebug_add_module(struct _ddebug *tab, unsigned int n,
 945                              const char *name)
 946 {
 947         struct ddebug_table *dt;
 948
 949         dt = kzalloc(sizeof(*dt), GFP_KERNEL);
 950         if (dt == NULL) {
 951                 pr_err("error adding module: %s\n", name);
 952                 return -ENOMEM;
 953         }
 954         /*
 955          * For built-in modules, name lives in .rodata and is
 956          * immortal. For loaded modules, name points at the name[]
 957          * member of struct module, which lives at least as long as
 958          * this struct ddebug_table.
 959          */
 960         dt->mod_name = name;
 961         dt->num_ddebugs = n;
 962         dt->ddebugs = tab;
 963
 964         mutex_lock(&ddebug_lock);
 965         list_add(&dt->link, &ddebug_tables);
 966         mutex_unlock(&ddebug_lock);
 967
 968         v2pr_info("%3u debug prints in module %s\n", n, dt->mod_name);
 969         return 0;
 970 }
 971
 972 /* helper for ddebug_dyndbg_(boot|module)_param_cb */
 973 static int ddebug_dyndbg_param_cb(char *param, char *val,
 974                                 const char *modname, int on_err)
 975 {
 976         char *sep;
 977
 978         sep = strchr(param, '.');
 979         if (sep) {
 980                 /* needed only for ddebug_dyndbg_boot_param_cb */
 981                 *sep = '\0';
 982                 modname = param;
 983                 param = sep + 1;
 984         }
 985         if (strcmp(param, "dyndbg"))
 986                 return on_err; /* determined by caller */
 987
 988         ddebug_exec_queries((val ? val : "+p"), modname);
 989
 990         return 0; /* query failure shouldnt stop module load */
 991 }
 992
 993 /* handle both dyndbg and $module.dyndbg params at boot */
 994 static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
 995                                 const char *unused, void *arg)
 996 {
 997         vpr_info("%s=\"%s\"\n", param, val);
 998         return ddebug_dyndbg_param_cb(param, val, NULL, 0);
 999 }
1000
1001 /*
1002  * modprobe foo finds foo.params in boot-args, strips "foo.", and
1003  * passes them to load_module().  This callback gets unknown params,
1004  * processes dyndbg params, rejects others.
1005  */
1006 int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
1007 {
1008         vpr_info("module: %s %s=\"%s\"\n", module, param, val);
1009         return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
1010 }
1011
1012 static void ddebug_table_free(struct ddebug_table *dt)
1013 {
1014         list_del_init(&dt->link);
1015         kfree(dt);
1016 }
1017
1018 /*
1019  * Called in response to a module being unloaded.  Removes
1020  * any ddebug_table's which point at the module.
1021  */
1022 int ddebug_remove_module(const char *mod_name)
1023 {
1024         struct ddebug_table *dt, *nextdt;
1025         int ret = -ENOENT;
1026
1027         v2pr_info("removing module \"%s\"\n", mod_name);
1028
1029         mutex_lock(&ddebug_lock);
1030         list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
1031                 if (dt->mod_name == mod_name) {
1032                         ddebug_table_free(dt);
1033                         ret = 0;
1034                         break;
1035                 }
1036         }
1037         mutex_unlock(&ddebug_lock);
1038         return ret;
1039 }
1040
1041 static void ddebug_remove_all_tables(void)
1042 {
1043         mutex_lock(&ddebug_lock);
1044         while (!list_empty(&ddebug_tables)) {
1045                 struct ddebug_table *dt = list_entry(ddebug_tables.next,
1046                                                       struct ddebug_table,
1047                                                       link);
1048                 ddebug_table_free(dt);
1049         }
1050         mutex_unlock(&ddebug_lock);
1051 }
1052
1053 static __initdata int ddebug_init_success;
1054
1055 static int __init dynamic_debug_init_control(void)
1056 {
1057         struct proc_dir_entry *procfs_dir;
1058         struct dentry *debugfs_dir;
1059
1060         if (!ddebug_init_success)
1061                 return -ENODEV;
1062
1063         /* Create the control file in debugfs if it is enabled */
1064         if (debugfs_initialized()) {
1065                 debugfs_dir = debugfs_create_dir("dynamic_debug", NULL);
1066                 debugfs_create_file("control", 0644, debugfs_dir, NULL,
1067                                     &ddebug_proc_fops);
1068         }
1069
1070         /* Also create the control file in procfs */
1071         procfs_dir = proc_mkdir("dynamic_debug", NULL);
1072         if (procfs_dir)
1073                 proc_create("control", 0644, procfs_dir, &proc_fops);
1074
1075         return 0;
1076 }
1077
1078 static int __init dynamic_debug_init(void)
1079 {
1080         struct _ddebug *iter, *iter_start;
1081         const char *modname = NULL;
1082         char *cmdline;
1083         int ret = 0;
1084         int n = 0, entries = 0, modct = 0;
1085
1086         if (&__start___dyndbg == &__stop___dyndbg) {
1087                 if (IS_ENABLED(CONFIG_DYNAMIC_DEBUG)) {
1088                         pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
1089                         return 1;
1090                 }
1091                 pr_info("Ignore empty _ddebug table in a CONFIG_DYNAMIC_DEBUG_CORE build\n");
1092                 ddebug_init_success = 1;
1093                 return 0;
1094         }
1095         iter = __start___dyndbg;
1096         modname = iter->modname;
1097         iter_start = iter;
1098         for (; iter < __stop___dyndbg; iter++) {
1099                 entries++;
1100                 if (strcmp(modname, iter->modname)) {
1101                         modct++;
1102                         ret = ddebug_add_module(iter_start, n, modname);
1103                         if (ret)
1104                                 goto out_err;
1105                         n = 0;
1106                         modname = iter->modname;
1107                         iter_start = iter;
1108                 }
1109                 n++;
1110         }
1111         ret = ddebug_add_module(iter_start, n, modname);
1112         if (ret)
1113                 goto out_err;
1114
1115         ddebug_init_success = 1;
1116         vpr_info("%d modules, %d entries and %d bytes in ddebug tables, %d bytes in __dyndbg section\n",
1117                  modct, entries, (int)(modct * sizeof(struct ddebug_table)),
1118                  (int)(entries * sizeof(struct _ddebug)));
1119
1120         /* apply ddebug_query boot param, dont unload tables on err */
1121         if (ddebug_setup_string[0] != '\0') {
1122                 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
1123                 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
1124                 if (ret < 0)
1125                         pr_warn("Invalid ddebug boot param %s\n",
1126                                 ddebug_setup_string);
1127                 else
1128                         pr_info("%d changes by ddebug_query\n", ret);
1129         }
1130         /* now that ddebug tables are loaded, process all boot args
1131          * again to find and activate queries given in dyndbg params.
1132          * While this has already been done for known boot params, it
1133          * ignored the unknown ones (dyndbg in particular).  Reusing
1134          * parse_args avoids ad-hoc parsing.  This will also attempt
1135          * to activate queries for not-yet-loaded modules, which is
1136          * slightly noisy if verbose, but harmless.
1137          */
1138         cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1139         parse_args("dyndbg params", cmdline, NULL,
1140                    0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
1141         kfree(cmdline);
1142         return 0;
1143
1144 out_err:
1145         ddebug_remove_all_tables();
1146         return 0;
1147 }
1148 /* Allow early initialization for boot messages via boot param */
1149 early_initcall(dynamic_debug_init);
1150
1151 /* Debugfs setup must be done later */
1152 fs_initcall(dynamic_debug_init_control);