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