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