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