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        *buf = '\0';
 525
 526        if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
 527                if (in_interrupt())
 528                        pos += snprintf(buf + pos, remaining(pos), "<intr> ");
 529                else
 530                        pos += snprintf(buf + pos, remaining(pos), "[%d] ",
 531                                        task_pid_vnr(current));
 532        }
 533        pos_after_tid = pos;
 534        if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
 535                pos += snprintf(buf + pos, remaining(pos), "%s:",
 536                                desc->modname);
 537        if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
 538                pos += snprintf(buf + pos, remaining(pos), "%s:",
 539                                desc->function);
 540        if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
 541                pos += snprintf(buf + pos, remaining(pos), "%d:",
 542                                desc->lineno);
 543        if (pos - pos_after_tid)
 544                pos += snprintf(buf + pos, remaining(pos), " ");
 545        if (pos >= PREFIX_SIZE)
 546                buf[PREFIX_SIZE - 1] = '\0';
 547
 548        return buf;
 549}
 550
 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
 563        vaf.fmt = fmt;
 564        vaf.va = &args;
 565
 566        res = printk(KERN_DEBUG "%s%pV",
 567                     dynamic_emit_prefix(descriptor, buf), &vaf);
 568
 569        va_end(args);
 570
 571        return res;
 572}
 573EXPORT_SYMBOL(__dynamic_pr_debug);
 574
 575int __dynamic_dev_dbg(struct _ddebug *descriptor,
 576                      const struct device *dev, const char *fmt, ...)
 577{
 578        struct va_format vaf;
 579        va_list args;
 580        int res;
 581
 582        BUG_ON(!descriptor);
 583        BUG_ON(!fmt);
 584
 585        va_start(args, fmt);
 586
 587        vaf.fmt = fmt;
 588        vaf.va = &args;
 589
 590        if (!dev) {
 591                res = printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
 592        } else {
 593                char buf[PREFIX_SIZE];
 594
 595                res = dev_printk_emit(7, dev, "%s%s %s: %pV",
 596                                      dynamic_emit_prefix(descriptor, buf),
 597                                      dev_driver_string(dev), dev_name(dev),
 598                                      &vaf);
 599        }
 600
 601        va_end(args);
 602
 603        return res;
 604}
 605EXPORT_SYMBOL(__dynamic_dev_dbg);
 606
 607#ifdef CONFIG_NET
 608
 609int __dynamic_netdev_dbg(struct _ddebug *descriptor,
 610                         const struct net_device *dev, const char *fmt, ...)
 611{
 612        struct va_format vaf;
 613        va_list args;
 614        int res;
 615
 616        BUG_ON(!descriptor);
 617        BUG_ON(!fmt);
 618
 619        va_start(args, fmt);
 620
 621        vaf.fmt = fmt;
 622        vaf.va = &args;
 623
 624        if (dev && dev->dev.parent) {
 625                char buf[PREFIX_SIZE];
 626
 627                res = dev_printk_emit(7, dev->dev.parent,
 628                                      "%s%s %s %s: %pV",
 629                                      dynamic_emit_prefix(descriptor, buf),
 630                                      dev_driver_string(dev->dev.parent),
 631                                      dev_name(dev->dev.parent),
 632                                      netdev_name(dev), &vaf);
 633        } else if (dev) {
 634                res = printk(KERN_DEBUG "%s: %pV", netdev_name(dev), &vaf);
 635        } else {
 636                res = printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
 637        }
 638
 639        va_end(args);
 640
 641        return res;
 642}
 643EXPORT_SYMBOL(__dynamic_netdev_dbg);
 644
 645#endif
 646
 647#define DDEBUG_STRING_SIZE 1024
 648static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
 649
 650static __init int ddebug_setup_query(char *str)
 651{
 652        if (strlen(str) >= DDEBUG_STRING_SIZE) {
 653                pr_warn("ddebug boot param string too large\n");
 654                return 0;
 655        }
 656        strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
 657        return 1;
 658}
 659
 660__setup("ddebug_query=", ddebug_setup_query);
 661
 662/*
 663 * File_ops->write method for <debugfs>/dynamic_debug/conrol.  Gathers the
 664 * command text from userspace, parses and executes it.
 665 */
 666#define USER_BUF_PAGE 4096
 667static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
 668                                  size_t len, loff_t *offp)
 669{
 670        char *tmpbuf;
 671        int ret;
 672
 673        if (len == 0)
 674                return 0;
 675        if (len > USER_BUF_PAGE - 1) {
 676                pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
 677                return -E2BIG;
 678        }
 679        tmpbuf = kmalloc(len + 1, GFP_KERNEL);
 680        if (!tmpbuf)
 681                return -ENOMEM;
 682        if (copy_from_user(tmpbuf, ubuf, len)) {
 683                kfree(tmpbuf);
 684                return -EFAULT;
 685        }
 686        tmpbuf[len] = '\0';
 687        vpr_info("read %d bytes from userspace\n", (int)len);
 688
 689        ret = ddebug_exec_queries(tmpbuf, NULL);
 690        kfree(tmpbuf);
 691        if (ret < 0)
 692                return ret;
 693
 694        *offp += len;
 695        return len;
 696}
 697
 698/*
 699 * Set the iterator to point to the first _ddebug object
 700 * and return a pointer to that first object.  Returns
 701 * NULL if there are no _ddebugs at all.
 702 */
 703static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
 704{
 705        if (list_empty(&ddebug_tables)) {
 706                iter->table = NULL;
 707                iter->idx = 0;
 708                return NULL;
 709        }
 710        iter->table = list_entry(ddebug_tables.next,
 711                                 struct ddebug_table, link);
 712        iter->idx = 0;
 713        return &iter->table->ddebugs[iter->idx];
 714}
 715
 716/*
 717 * Advance the iterator to point to the next _ddebug
 718 * object from the one the iterator currently points at,
 719 * and returns a pointer to the new _ddebug.  Returns
 720 * NULL if the iterator has seen all the _ddebugs.
 721 */
 722static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
 723{
 724        if (iter->table == NULL)
 725                return NULL;
 726        if (++iter->idx == iter->table->num_ddebugs) {
 727                /* iterate to next table */
 728                iter->idx = 0;
 729                if (list_is_last(&iter->table->link, &ddebug_tables)) {
 730                        iter->table = NULL;
 731                        return NULL;
 732                }
 733                iter->table = list_entry(iter->table->link.next,
 734                                         struct ddebug_table, link);
 735        }
 736        return &iter->table->ddebugs[iter->idx];
 737}
 738
 739/*
 740 * Seq_ops start method.  Called at the start of every
 741 * read() call from userspace.  Takes the ddebug_lock and
 742 * seeks the seq_file's iterator to the given position.
 743 */
 744static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
 745{
 746        struct ddebug_iter *iter = m->private;
 747        struct _ddebug *dp;
 748        int n = *pos;
 749
 750        vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
 751
 752        mutex_lock(&ddebug_lock);
 753
 754        if (!n)
 755                return SEQ_START_TOKEN;
 756        if (n < 0)
 757                return NULL;
 758        dp = ddebug_iter_first(iter);
 759        while (dp != NULL && --n > 0)
 760                dp = ddebug_iter_next(iter);
 761        return dp;
 762}
 763
 764/*
 765 * Seq_ops next method.  Called several times within a read()
 766 * call from userspace, with ddebug_lock held.  Walks to the
 767 * next _ddebug object with a special case for the header line.
 768 */
 769static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
 770{
 771        struct ddebug_iter *iter = m->private;
 772        struct _ddebug *dp;
 773
 774        vpr_info("called m=%p p=%p *pos=%lld\n",
 775                m, p, (unsigned long long)*pos);
 776
 777        if (p == SEQ_START_TOKEN)
 778                dp = ddebug_iter_first(iter);
 779        else
 780                dp = ddebug_iter_next(iter);
 781        ++*pos;
 782        return dp;
 783}
 784
 785/*
 786 * Seq_ops show method.  Called several times within a read()
 787 * call from userspace, with ddebug_lock held.  Formats the
 788 * current _ddebug as a single human-readable line, with a
 789 * special case for the header line.
 790 */
 791static int ddebug_proc_show(struct seq_file *m, void *p)
 792{
 793        struct ddebug_iter *iter = m->private;
 794        struct _ddebug *dp = p;
 795        char flagsbuf[10];
 796
 797        vpr_info("called m=%p p=%p\n", m, p);
 798
 799        if (p == SEQ_START_TOKEN) {
 800                seq_puts(m,
 801                        "# filename:lineno [module]function flags format\n");
 802                return 0;
 803        }
 804
 805        seq_printf(m, "%s:%u [%s]%s =%s \"",
 806                trim_prefix(dp->filename), dp->lineno,
 807                iter->table->mod_name, dp->function,
 808                ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
 809        seq_escape(m, dp->format, "\t\r\n\"");
 810        seq_puts(m, "\"\n");
 811
 812        return 0;
 813}
 814
 815/*
 816 * Seq_ops stop method.  Called at the end of each read()
 817 * call from userspace.  Drops ddebug_lock.
 818 */
 819static void ddebug_proc_stop(struct seq_file *m, void *p)
 820{
 821        vpr_info("called m=%p p=%p\n", m, p);
 822        mutex_unlock(&ddebug_lock);
 823}
 824
 825static const struct seq_operations ddebug_proc_seqops = {
 826        .start = ddebug_proc_start,
 827        .next = ddebug_proc_next,
 828        .show = ddebug_proc_show,
 829        .stop = ddebug_proc_stop
 830};
 831
 832/*
 833 * File_ops->open method for <debugfs>/dynamic_debug/control.  Does
 834 * the seq_file setup dance, and also creates an iterator to walk the
 835 * _ddebugs.  Note that we create a seq_file always, even for O_WRONLY
 836 * files where it's not needed, as doing so simplifies the ->release
 837 * method.
 838 */
 839static int ddebug_proc_open(struct inode *inode, struct file *file)
 840{
 841        struct ddebug_iter *iter;
 842        int err;
 843
 844        vpr_info("called\n");
 845
 846        iter = kzalloc(sizeof(*iter), GFP_KERNEL);
 847        if (iter == NULL)
 848                return -ENOMEM;
 849
 850        err = seq_open(file, &ddebug_proc_seqops);
 851        if (err) {
 852                kfree(iter);
 853                return err;
 854        }
 855        ((struct seq_file *) file->private_data)->private = iter;
 856        return 0;
 857}
 858
 859static const struct file_operations ddebug_proc_fops = {
 860        .owner = THIS_MODULE,
 861        .open = ddebug_proc_open,
 862        .read = seq_read,
 863        .llseek = seq_lseek,
 864        .release = seq_release_private,
 865        .write = ddebug_proc_write
 866};
 867
 868/*
 869 * Allocate a new ddebug_table for the given module
 870 * and add it to the global list.
 871 */
 872int ddebug_add_module(struct _ddebug *tab, unsigned int n,
 873                             const char *name)
 874{
 875        struct ddebug_table *dt;
 876        char *new_name;
 877
 878        dt = kzalloc(sizeof(*dt), GFP_KERNEL);
 879        if (dt == NULL)
 880                return -ENOMEM;
 881        new_name = kstrdup(name, GFP_KERNEL);
 882        if (new_name == NULL) {
 883                kfree(dt);
 884                return -ENOMEM;
 885        }
 886        dt->mod_name = new_name;
 887        dt->num_ddebugs = n;
 888        dt->ddebugs = tab;
 889
 890        mutex_lock(&ddebug_lock);
 891        list_add_tail(&dt->link, &ddebug_tables);
 892        mutex_unlock(&ddebug_lock);
 893
 894        vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
 895        return 0;
 896}
 897EXPORT_SYMBOL_GPL(ddebug_add_module);
 898
 899/* helper for ddebug_dyndbg_(boot|module)_param_cb */
 900static int ddebug_dyndbg_param_cb(char *param, char *val,
 901                                const char *modname, int on_err)
 902{
 903        char *sep;
 904
 905        sep = strchr(param, '.');
 906        if (sep) {
 907                /* needed only for ddebug_dyndbg_boot_param_cb */
 908                *sep = '\0';
 909                modname = param;
 910                param = sep + 1;
 911        }
 912        if (strcmp(param, "dyndbg"))
 913                return on_err; /* determined by caller */
 914
 915        ddebug_exec_queries((val ? val : "+p"), modname);
 916
 917        return 0; /* query failure shouldnt stop module load */
 918}
 919
 920/* handle both dyndbg and $module.dyndbg params at boot */
 921static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
 922                                const char *unused)
 923{
 924        vpr_info("%s=\"%s\"\n", param, val);
 925        return ddebug_dyndbg_param_cb(param, val, NULL, 0);
 926}
 927
 928/*
 929 * modprobe foo finds foo.params in boot-args, strips "foo.", and
 930 * passes them to load_module().  This callback gets unknown params,
 931 * processes dyndbg params, rejects others.
 932 */
 933int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
 934{
 935        vpr_info("module: %s %s=\"%s\"\n", module, param, val);
 936        return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
 937}
 938
 939static void ddebug_table_free(struct ddebug_table *dt)
 940{
 941        list_del_init(&dt->link);
 942        kfree(dt->mod_name);
 943        kfree(dt);
 944}
 945
 946/*
 947 * Called in response to a module being unloaded.  Removes
 948 * any ddebug_table's which point at the module.
 949 */
 950int ddebug_remove_module(const char *mod_name)
 951{
 952        struct ddebug_table *dt, *nextdt;
 953        int ret = -ENOENT;
 954
 955        vpr_info("removing module \"%s\"\n", mod_name);
 956
 957        mutex_lock(&ddebug_lock);
 958        list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
 959                if (!strcmp(dt->mod_name, mod_name)) {
 960                        ddebug_table_free(dt);
 961                        ret = 0;
 962                }
 963        }
 964        mutex_unlock(&ddebug_lock);
 965        return ret;
 966}
 967EXPORT_SYMBOL_GPL(ddebug_remove_module);
 968
 969static void ddebug_remove_all_tables(void)
 970{
 971        mutex_lock(&ddebug_lock);
 972        while (!list_empty(&ddebug_tables)) {
 973                struct ddebug_table *dt = list_entry(ddebug_tables.next,
 974                                                      struct ddebug_table,
 975                                                      link);
 976                ddebug_table_free(dt);
 977        }
 978        mutex_unlock(&ddebug_lock);
 979}
 980
 981static __initdata int ddebug_init_success;
 982
 983static int __init dynamic_debug_init_debugfs(void)
 984{
 985        struct dentry *dir, *file;
 986
 987        if (!ddebug_init_success)
 988                return -ENODEV;
 989
 990        dir = debugfs_create_dir("dynamic_debug", NULL);
 991        if (!dir)
 992                return -ENOMEM;
 993        file = debugfs_create_file("control", 0644, dir, NULL,
 994                                        &ddebug_proc_fops);
 995        if (!file) {
 996                debugfs_remove(dir);
 997                return -ENOMEM;
 998        }
 999        return 0;
1000}
1001
1002static int __init dynamic_debug_init(void)
1003{
1004        struct _ddebug *iter, *iter_start;
1005        const char *modname = NULL;
1006        char *cmdline;
1007        int ret = 0;
1008        int n = 0, entries = 0, modct = 0;
1009        int verbose_bytes = 0;
1010
1011        if (__start___verbose == __stop___verbose) {
1012                pr_warn("_ddebug table is empty in a "
1013                        "CONFIG_DYNAMIC_DEBUG build");
1014                return 1;
1015        }
1016        iter = __start___verbose;
1017        modname = iter->modname;
1018        iter_start = iter;
1019        for (; iter < __stop___verbose; iter++) {
1020                entries++;
1021                verbose_bytes += strlen(iter->modname) + strlen(iter->function)
1022                        + strlen(iter->filename) + strlen(iter->format);
1023
1024                if (strcmp(modname, iter->modname)) {
1025                        modct++;
1026                        ret = ddebug_add_module(iter_start, n, modname);
1027                        if (ret)
1028                                goto out_err;
1029                        n = 0;
1030                        modname = iter->modname;
1031                        iter_start = iter;
1032                }
1033                n++;
1034        }
1035        ret = ddebug_add_module(iter_start, n, modname);
1036        if (ret)
1037                goto out_err;
1038
1039        ddebug_init_success = 1;
1040        vpr_info("%d modules, %d entries and %d bytes in ddebug tables,"
1041                " %d bytes in (readonly) verbose section\n",
1042                modct, entries, (int)( modct * sizeof(struct ddebug_table)),
1043                verbose_bytes + (int)(__stop___verbose - __start___verbose));
1044
1045        /* apply ddebug_query boot param, dont unload tables on err */
1046        if (ddebug_setup_string[0] != '\0') {
1047                pr_warn("ddebug_query param name is deprecated,"
1048                        " change it to dyndbg\n");
1049                ret = ddebug_exec_queries(ddebug_setup_string, NULL);
1050                if (ret < 0)
1051                        pr_warn("Invalid ddebug boot param %s",
1052                                ddebug_setup_string);
1053                else
1054                        pr_info("%d changes by ddebug_query\n", ret);
1055        }
1056        /* now that ddebug tables are loaded, process all boot args
1057         * again to find and activate queries given in dyndbg params.
1058         * While this has already been done for known boot params, it
1059         * ignored the unknown ones (dyndbg in particular).  Reusing
1060         * parse_args avoids ad-hoc parsing.  This will also attempt
1061         * to activate queries for not-yet-loaded modules, which is
1062         * slightly noisy if verbose, but harmless.
1063         */
1064        cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1065        parse_args("dyndbg params", cmdline, NULL,
1066                   0, 0, 0, &ddebug_dyndbg_boot_param_cb);
1067        kfree(cmdline);
1068        return 0;
1069
1070out_err:
1071        ddebug_remove_all_tables();
1072        return 0;
1073}
1074/* Allow early initialization for boot messages via boot param */
1075early_initcall(dynamic_debug_init);
1076
1077/* Debugfs setup must be done later */
1078fs_initcall(dynamic_debug_init_debugfs);
1079
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.