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