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