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