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