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