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