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