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