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