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