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