lib/dynamic_debug.c

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