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