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