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