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                 char dict[128];
 595                 size_t dictlen;
 596
 597                 dictlen = create_syslog_header(dev, dict, sizeof(dict));
 598
 599                 res = printk_emit(0, 7, dictlen ? dict : NULL, dictlen,
 600                                   "%s%s %s: %pV",
 601                                   dynamic_emit_prefix(descriptor, buf),
 602                                   dev_driver_string(dev), dev_name(dev), &vaf);
 603         }
 604
 605         va_end(args);
 606
 607         return res;
 608 }
 609 EXPORT_SYMBOL(__dynamic_dev_dbg);
 610
 611 #ifdef CONFIG_NET
 612
 613 int __dynamic_netdev_dbg(struct _ddebug *descriptor,
 614                          const struct net_device *dev, const char *fmt, ...)
 615 {
 616         struct va_format vaf;
 617         va_list args;
 618         int res;
 619
 620         BUG_ON(!descriptor);
 621         BUG_ON(!fmt);
 622
 623         va_start(args, fmt);
 624
 625         vaf.fmt = fmt;
 626         vaf.va = &args;
 627
 628         if (dev && dev->dev.parent) {
 629                 char buf[PREFIX_SIZE];
 630                 char dict[128];
 631                 size_t dictlen;
 632
 633                 dictlen = create_syslog_header(dev->dev.parent,
 634                                                dict, sizeof(dict));
 635
 636                 res = printk_emit(0, 7, dictlen ? dict : NULL, dictlen,
 637                                   "%s%s %s %s: %pV",
 638                                   dynamic_emit_prefix(descriptor, buf),
 639                                   dev_driver_string(dev->dev.parent),
 640                                   dev_name(dev->dev.parent),
 641                                   netdev_name(dev), &vaf);
 642         } else if (dev) {
 643                 res = printk(KERN_DEBUG "%s: %pV", netdev_name(dev), &vaf);
 644         } else {
 645                 res = printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
 646         }
 647
 648         va_end(args);
 649
 650         return res;
 651 }
 652 EXPORT_SYMBOL(__dynamic_netdev_dbg);
 653
 654 #endif
 655
 656 #define DDEBUG_STRING_SIZE 1024
 657 static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
 658
 659 static __init int ddebug_setup_query(char *str)
 660 {
 661         if (strlen(str) >= DDEBUG_STRING_SIZE) {
 662                 pr_warn("ddebug boot param string too large\n");
 663                 return 0;
 664         }
 665         strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
 666         return 1;
 667 }
 668
 669 __setup("ddebug_query=", ddebug_setup_query);
 670
 671 /*
 672  * File_ops->write method for <debugfs>/dynamic_debug/conrol.  Gathers the
 673  * command text from userspace, parses and executes it.
 674  */
 675 #define USER_BUF_PAGE 4096
 676 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
 677                                   size_t len, loff_t *offp)
 678 {
 679         char *tmpbuf;
 680         int ret;
 681
 682         if (len == 0)
 683                 return 0;
 684         if (len > USER_BUF_PAGE - 1) {
 685                 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
 686                 return -E2BIG;
 687         }
 688         tmpbuf = kmalloc(len + 1, GFP_KERNEL);
 689         if (!tmpbuf)
 690                 return -ENOMEM;
 691         if (copy_from_user(tmpbuf, ubuf, len)) {
 692                 kfree(tmpbuf);
 693                 return -EFAULT;
 694         }
 695         tmpbuf[len] = '\0';
 696         vpr_info("read %d bytes from userspace\n", (int)len);
 697
 698         ret = ddebug_exec_queries(tmpbuf, NULL);
 699         kfree(tmpbuf);
 700         if (ret < 0)
 701                 return ret;
 702
 703         *offp += len;
 704         return len;
 705 }
 706
 707 /*
 708  * Set the iterator to point to the first _ddebug object
 709  * and return a pointer to that first object.  Returns
 710  * NULL if there are no _ddebugs at all.
 711  */
 712 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
 713 {
 714         if (list_empty(&ddebug_tables)) {
 715                 iter->table = NULL;
 716                 iter->idx = 0;
 717                 return NULL;
 718         }
 719         iter->table = list_entry(ddebug_tables.next,
 720                                  struct ddebug_table, link);
 721         iter->idx = 0;
 722         return &iter->table->ddebugs[iter->idx];
 723 }
 724
 725 /*
 726  * Advance the iterator to point to the next _ddebug
 727  * object from the one the iterator currently points at,
 728  * and returns a pointer to the new _ddebug.  Returns
 729  * NULL if the iterator has seen all the _ddebugs.
 730  */
 731 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
 732 {
 733         if (iter->table == NULL)
 734                 return NULL;
 735         if (++iter->idx == iter->table->num_ddebugs) {
 736                 /* iterate to next table */
 737                 iter->idx = 0;
 738                 if (list_is_last(&iter->table->link, &ddebug_tables)) {
 739                         iter->table = NULL;
 740                         return NULL;
 741                 }
 742                 iter->table = list_entry(iter->table->link.next,
 743                                          struct ddebug_table, link);
 744         }
 745         return &iter->table->ddebugs[iter->idx];
 746 }
 747
 748 /*
 749  * Seq_ops start method.  Called at the start of every
 750  * read() call from userspace.  Takes the ddebug_lock and
 751  * seeks the seq_file's iterator to the given position.
 752  */
 753 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
 754 {
 755         struct ddebug_iter *iter = m->private;
 756         struct _ddebug *dp;
 757         int n = *pos;
 758
 759         vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
 760
 761         mutex_lock(&ddebug_lock);
 762
 763         if (!n)
 764                 return SEQ_START_TOKEN;
 765         if (n < 0)
 766                 return NULL;
 767         dp = ddebug_iter_first(iter);
 768         while (dp != NULL && --n > 0)
 769                 dp = ddebug_iter_next(iter);
 770         return dp;
 771 }
 772
 773 /*
 774  * Seq_ops next method.  Called several times within a read()
 775  * call from userspace, with ddebug_lock held.  Walks to the
 776  * next _ddebug object with a special case for the header line.
 777  */
 778 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
 779 {
 780         struct ddebug_iter *iter = m->private;
 781         struct _ddebug *dp;
 782
 783         vpr_info("called m=%p p=%p *pos=%lld\n",
 784                 m, p, (unsigned long long)*pos);
 785
 786         if (p == SEQ_START_TOKEN)
 787                 dp = ddebug_iter_first(iter);
 788         else
 789                 dp = ddebug_iter_next(iter);
 790         ++*pos;
 791         return dp;
 792 }
 793
 794 /*
 795  * Seq_ops show method.  Called several times within a read()
 796  * call from userspace, with ddebug_lock held.  Formats the
 797  * current _ddebug as a single human-readable line, with a
 798  * special case for the header line.
 799  */
 800 static int ddebug_proc_show(struct seq_file *m, void *p)
 801 {
 802         struct ddebug_iter *iter = m->private;
 803         struct _ddebug *dp = p;
 804         char flagsbuf[10];
 805
 806         vpr_info("called m=%p p=%p\n", m, p);
 807
 808         if (p == SEQ_START_TOKEN) {
 809                 seq_puts(m,
 810                         "# filename:lineno [module]function flags format\n");
 811                 return 0;
 812         }
 813
 814         seq_printf(m, "%s:%u [%s]%s =%s \"",
 815                 trim_prefix(dp->filename), dp->lineno,
 816                 iter->table->mod_name, dp->function,
 817                 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
 818         seq_escape(m, dp->format, "\t\r\n\"");
 819         seq_puts(m, "\"\n");
 820
 821         return 0;
 822 }
 823
 824 /*
 825  * Seq_ops stop method.  Called at the end of each read()
 826  * call from userspace.  Drops ddebug_lock.
 827  */
 828 static void ddebug_proc_stop(struct seq_file *m, void *p)
 829 {
 830         vpr_info("called m=%p p=%p\n", m, p);
 831         mutex_unlock(&ddebug_lock);
 832 }
 833
 834 static const struct seq_operations ddebug_proc_seqops = {
 835         .start = ddebug_proc_start,
 836         .next = ddebug_proc_next,
 837         .show = ddebug_proc_show,
 838         .stop = ddebug_proc_stop
 839 };
 840
 841 /*
 842  * File_ops->open method for <debugfs>/dynamic_debug/control.  Does
 843  * the seq_file setup dance, and also creates an iterator to walk the
 844  * _ddebugs.  Note that we create a seq_file always, even for O_WRONLY
 845  * files where it's not needed, as doing so simplifies the ->release
 846  * method.
 847  */
 848 static int ddebug_proc_open(struct inode *inode, struct file *file)
 849 {
 850         struct ddebug_iter *iter;
 851         int err;
 852
 853         vpr_info("called\n");
 854
 855         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
 856         if (iter == NULL)
 857                 return -ENOMEM;
 858
 859         err = seq_open(file, &ddebug_proc_seqops);
 860         if (err) {
 861                 kfree(iter);
 862                 return err;
 863         }
 864         ((struct seq_file *) file->private_data)->private = iter;
 865         return 0;
 866 }
 867
 868 static const struct file_operations ddebug_proc_fops = {
 869         .owner = THIS_MODULE,
 870         .open = ddebug_proc_open,
 871         .read = seq_read,
 872         .llseek = seq_lseek,
 873         .release = seq_release_private,
 874         .write = ddebug_proc_write
 875 };
 876
 877 /*
 878  * Allocate a new ddebug_table for the given module
 879  * and add it to the global list.
 880  */
 881 int ddebug_add_module(struct _ddebug *tab, unsigned int n,
 882                              const char *name)
 883 {
 884         struct ddebug_table *dt;
 885         char *new_name;
 886
 887         dt = kzalloc(sizeof(*dt), GFP_KERNEL);
 888         if (dt == NULL)
 889                 return -ENOMEM;
 890         new_name = kstrdup(name, GFP_KERNEL);
 891         if (new_name == NULL) {
 892                 kfree(dt);
 893                 return -ENOMEM;
 894         }
 895         dt->mod_name = new_name;
 896         dt->num_ddebugs = n;
 897         dt->ddebugs = tab;
 898
 899         mutex_lock(&ddebug_lock);
 900         list_add_tail(&dt->link, &ddebug_tables);
 901         mutex_unlock(&ddebug_lock);
 902
 903         vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
 904         return 0;
 905 }
 906 EXPORT_SYMBOL_GPL(ddebug_add_module);
 907
 908 /* helper for ddebug_dyndbg_(boot|module)_param_cb */
 909 static int ddebug_dyndbg_param_cb(char *param, char *val,
 910                                 const char *modname, int on_err)
 911 {
 912         char *sep;
 913
 914         sep = strchr(param, '.');
 915         if (sep) {
 916                 /* needed only for ddebug_dyndbg_boot_param_cb */
 917                 *sep = '\0';
 918                 modname = param;
 919                 param = sep + 1;
 920         }
 921         if (strcmp(param, "dyndbg"))
 922                 return on_err; /* determined by caller */
 923
 924         ddebug_exec_queries((val ? val : "+p"), modname);
 925
 926         return 0; /* query failure shouldnt stop module load */
 927 }
 928
 929 /* handle both dyndbg and $module.dyndbg params at boot */
 930 static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
 931                                 const char *unused)
 932 {
 933         vpr_info("%s=\"%s\"\n", param, val);
 934         return ddebug_dyndbg_param_cb(param, val, NULL, 0);
 935 }
 936
 937 /*
 938  * modprobe foo finds foo.params in boot-args, strips "foo.", and
 939  * passes them to load_module().  This callback gets unknown params,
 940  * processes dyndbg params, rejects others.
 941  */
 942 int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
 943 {
 944         vpr_info("module: %s %s=\"%s\"\n", module, param, val);
 945         return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
 946 }
 947
 948 static void ddebug_table_free(struct ddebug_table *dt)
 949 {
 950         list_del_init(&dt->link);
 951         kfree(dt->mod_name);
 952         kfree(dt);
 953 }
 954
 955 /*
 956  * Called in response to a module being unloaded.  Removes
 957  * any ddebug_table's which point at the module.
 958  */
 959 int ddebug_remove_module(const char *mod_name)
 960 {
 961         struct ddebug_table *dt, *nextdt;
 962         int ret = -ENOENT;
 963
 964         vpr_info("removing module \"%s\"\n", mod_name);
 965
 966         mutex_lock(&ddebug_lock);
 967         list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
 968                 if (!strcmp(dt->mod_name, mod_name)) {
 969                         ddebug_table_free(dt);
 970                         ret = 0;
 971                 }
 972         }
 973         mutex_unlock(&ddebug_lock);
 974         return ret;
 975 }
 976 EXPORT_SYMBOL_GPL(ddebug_remove_module);
 977
 978 static void ddebug_remove_all_tables(void)
 979 {
 980         mutex_lock(&ddebug_lock);
 981         while (!list_empty(&ddebug_tables)) {
 982                 struct ddebug_table *dt = list_entry(ddebug_tables.next,
 983                                                       struct ddebug_table,
 984                                                       link);
 985                 ddebug_table_free(dt);
 986         }
 987         mutex_unlock(&ddebug_lock);
 988 }
 989
 990 static __initdata int ddebug_init_success;
 991
 992 static int __init dynamic_debug_init_debugfs(void)
 993 {
 994         struct dentry *dir, *file;
 995
 996         if (!ddebug_init_success)
 997                 return -ENODEV;
 998
 999         dir = debugfs_create_dir("dynamic_debug", NULL);
1000         if (!dir)
1001                 return -ENOMEM;
1002         file = debugfs_create_file("control", 0644, dir, NULL,
1003                                         &ddebug_proc_fops);
1004         if (!file) {
1005                 debugfs_remove(dir);
1006                 return -ENOMEM;
1007         }
1008         return 0;
1009 }
1010
1011 static int __init dynamic_debug_init(void)
1012 {
1013         struct _ddebug *iter, *iter_start;
1014         const char *modname = NULL;
1015         char *cmdline;
1016         int ret = 0;
1017         int n = 0, entries = 0, modct = 0;
1018         int verbose_bytes = 0;
1019
1020         if (__start___verbose == __stop___verbose) {
1021                 pr_warn("_ddebug table is empty in a "
1022                         "CONFIG_DYNAMIC_DEBUG build");
1023                 return 1;
1024         }
1025         iter = __start___verbose;
1026         modname = iter->modname;
1027         iter_start = iter;
1028         for (; iter < __stop___verbose; iter++) {
1029                 entries++;
1030                 verbose_bytes += strlen(iter->modname) + strlen(iter->function)
1031                         + strlen(iter->filename) + strlen(iter->format);
1032
1033                 if (strcmp(modname, iter->modname)) {
1034                         modct++;
1035                         ret = ddebug_add_module(iter_start, n, modname);
1036                         if (ret)
1037                                 goto out_err;
1038                         n = 0;
1039                         modname = iter->modname;
1040                         iter_start = iter;
1041                 }
1042                 n++;
1043         }
1044         ret = ddebug_add_module(iter_start, n, modname);
1045         if (ret)
1046                 goto out_err;
1047
1048         ddebug_init_success = 1;
1049         vpr_info("%d modules, %d entries and %d bytes in ddebug tables,"
1050                 " %d bytes in (readonly) verbose section\n",
1051                 modct, entries, (int)( modct * sizeof(struct ddebug_table)),
1052                 verbose_bytes + (int)(__stop___verbose - __start___verbose));
1053
1054         /* apply ddebug_query boot param, dont unload tables on err */
1055         if (ddebug_setup_string[0] != '\0') {
1056                 pr_warn("ddebug_query param name is deprecated,"
1057                         " change it to dyndbg\n");
1058                 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
1059                 if (ret < 0)
1060                         pr_warn("Invalid ddebug boot param %s",
1061                                 ddebug_setup_string);
1062                 else
1063                         pr_info("%d changes by ddebug_query\n", ret);
1064         }
1065         /* now that ddebug tables are loaded, process all boot args
1066          * again to find and activate queries given in dyndbg params.
1067          * While this has already been done for known boot params, it
1068          * ignored the unknown ones (dyndbg in particular).  Reusing
1069          * parse_args avoids ad-hoc parsing.  This will also attempt
1070          * to activate queries for not-yet-loaded modules, which is
1071          * slightly noisy if verbose, but harmless.
1072          */
1073         cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1074         parse_args("dyndbg params", cmdline, NULL,
1075                    0, 0, 0, &ddebug_dyndbg_boot_param_cb);
1076         kfree(cmdline);
1077         return 0;
1078
1079 out_err:
1080         ddebug_remove_all_tables();
1081         return 0;
1082 }
1083 /* Allow early initialization for boot messages via boot param */
1084 early_initcall(dynamic_debug_init);
1085
1086 /* Debugfs setup must be done later */
1087 fs_initcall(dynamic_debug_init_debugfs);