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