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