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