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