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 (!(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  */
 236 static 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  */
 292 static 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
 306 static 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
 341 static 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 or combined keyword=value terms,
 357  * 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         char *keyword, *arg;
 377
 378         if (modname)
 379                 /* support $modname.dyndbg=<multiple queries> */
 380                 query->module = modname;
 381
 382         for (i = 0; i < nwords; i++) {
 383                 /* accept keyword=arg */
 384                 vpr_info("%d w:%s\n", i, words[i]);
 385
 386                 keyword = words[i];
 387                 arg = strchr(keyword, '=');
 388                 if (arg) {
 389                         *arg++ = '\0';
 390                 } else {
 391                         i++; /* next word is arg */
 392                         if (!(i < nwords)) {
 393                                 pr_err("missing arg to keyword: %s\n", keyword);
 394                                 return -EINVAL;
 395                         }
 396                         arg = words[i];
 397                 }
 398                 vpr_info("%d key:%s arg:%s\n", i, keyword, arg);
 399
 400                 if (!strcmp(keyword, "func")) {
 401                         rc = check_set(&query->function, arg, "func");
 402                 } else if (!strcmp(keyword, "file")) {
 403                         if (check_set(&query->filename, arg, "file"))
 404                                 return -EINVAL;
 405
 406                         /* tail :$info is function or line-range */
 407                         fline = strchr(query->filename, ':');
 408                         if (!fline)
 409                                 break;
 410                         *fline++ = '\0';
 411                         if (isalpha(*fline) || *fline == '*' || *fline == '?') {
 412                                 /* take as function name */
 413                                 if (check_set(&query->function, fline, "func"))
 414                                         return -EINVAL;
 415                         } else {
 416                                 if (parse_linerange(query, fline))
 417                                         return -EINVAL;
 418                         }
 419                 } else if (!strcmp(keyword, "module")) {
 420                         rc = check_set(&query->module, arg, "module");
 421                 } else if (!strcmp(keyword, "format")) {
 422                         string_unescape_inplace(arg, UNESCAPE_SPACE |
 423                                                             UNESCAPE_OCTAL |
 424                                                             UNESCAPE_SPECIAL);
 425                         rc = check_set(&query->format, arg, "format");
 426                 } else if (!strcmp(keyword, "line")) {
 427                         if (parse_linerange(query, arg))
 428                                 return -EINVAL;
 429                 } else {
 430                         pr_err("unknown keyword \"%s\"\n", keyword);
 431                         return -EINVAL;
 432                 }
 433                 if (rc)
 434                         return rc;
 435         }
 436         vpr_info_dq(query, "parsed");
 437         return 0;
 438 }
 439
 440 /*
 441  * Parse `str' as a flags specification, format [-+=][p]+.
 442  * Sets up *maskp and *flagsp to be used when changing the
 443  * flags fields of matched _ddebug's.  Returns 0 on success
 444  * or <0 on error.
 445  */
 446 static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers)
 447 {
 448         int op, i;
 449
 450         switch (*str) {
 451         case '+':
 452         case '-':
 453         case '=':
 454                 op = *str++;
 455                 break;
 456         default:
 457                 pr_err("bad flag-op %c, at start of %s\n", *str, str);
 458                 return -EINVAL;
 459         }
 460         vpr_info("op='%c'\n", op);
 461
 462         for (; *str ; ++str) {
 463                 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
 464                         if (*str == opt_array[i].opt_char) {
 465                                 modifiers->flags |= opt_array[i].flag;
 466                                 break;
 467                         }
 468                 }
 469                 if (i < 0) {
 470                         pr_err("unknown flag '%c'\n", *str);
 471                         return -EINVAL;
 472                 }
 473         }
 474         vpr_info("flags=0x%x\n", modifiers->flags);
 475
 476         /* calculate final flags, mask based upon op */
 477         switch (op) {
 478         case '=':
 479                 /* modifiers->flags already set */
 480                 modifiers->mask = 0;
 481                 break;
 482         case '+':
 483                 modifiers->mask = ~0U;
 484                 break;
 485         case '-':
 486                 modifiers->mask = ~modifiers->flags;
 487                 modifiers->flags = 0;
 488                 break;
 489         }
 490         vpr_info("*flagsp=0x%x *maskp=0x%x\n", modifiers->flags, modifiers->mask);
 491
 492         return 0;
 493 }
 494
 495 static int ddebug_exec_query(char *query_string, const char *modname)
 496 {
 497         struct flag_settings modifiers = {};
 498         struct ddebug_query query = {};
 499 #define MAXWORDS 9
 500         int nwords, nfound;
 501         char *words[MAXWORDS];
 502
 503         nwords = ddebug_tokenize(query_string, words, MAXWORDS);
 504         if (nwords <= 0) {
 505                 pr_err("tokenize failed\n");
 506                 return -EINVAL;
 507         }
 508         /* check flags 1st (last arg) so query is pairs of spec,val */
 509         if (ddebug_parse_flags(words[nwords-1], &modifiers)) {
 510                 pr_err("flags parse failed\n");
 511                 return -EINVAL;
 512         }
 513         if (ddebug_parse_query(words, nwords-1, &query, modname)) {
 514                 pr_err("query parse failed\n");
 515                 return -EINVAL;
 516         }
 517         /* actually go and implement the change */
 518         nfound = ddebug_change(&query, &modifiers);
 519         vpr_info_dq(&query, nfound ? "applied" : "no-match");
 520
 521         return nfound;
 522 }
 523
 524 /* handle multiple queries in query string, continue on error, return
 525    last error or number of matching callsites.  Module name is either
 526    in param (for boot arg) or perhaps in query string.
 527 */
 528 int ddebug_exec_queries(char *query, const char *modname)
 529 {
 530         char *split;
 531         int i, errs = 0, exitcode = 0, rc, nfound = 0;
 532
 533         for (i = 0; query; query = split) {
 534                 split = strpbrk(query, ";\n");
 535                 if (split)
 536                         *split++ = '\0';
 537
 538                 query = skip_spaces(query);
 539                 if (!query || !*query || *query == '#')
 540                         continue;
 541
 542                 vpr_info("query %d: \"%s\"\n", i, query);
 543
 544                 rc = ddebug_exec_query(query, modname);
 545                 if (rc < 0) {
 546                         errs++;
 547                         exitcode = rc;
 548                 } else {
 549                         nfound += rc;
 550                 }
 551                 i++;
 552         }
 553         vpr_info("processed %d queries, with %d matches, %d errs\n",
 554                  i, nfound, errs);
 555
 556         if (exitcode)
 557                 return exitcode;
 558         return nfound;
 559 }
 560 EXPORT_SYMBOL_GPL(ddebug_exec_queries);
 561
 562 #define PREFIX_SIZE 64
 563
 564 static int remaining(int wrote)
 565 {
 566         if (PREFIX_SIZE - wrote > 0)
 567                 return PREFIX_SIZE - wrote;
 568         return 0;
 569 }
 570
 571 static char *dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
 572 {
 573         int pos_after_tid;
 574         int pos = 0;
 575
 576         *buf = '\0';
 577
 578         if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
 579                 if (in_interrupt())
 580                         pos += snprintf(buf + pos, remaining(pos), "<intr> ");
 581                 else
 582                         pos += snprintf(buf + pos, remaining(pos), "[%d] ",
 583                                         task_pid_vnr(current));
 584         }
 585         pos_after_tid = pos;
 586         if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
 587                 pos += snprintf(buf + pos, remaining(pos), "%s:",
 588                                 desc->modname);
 589         if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
 590                 pos += snprintf(buf + pos, remaining(pos), "%s:",
 591                                 desc->function);
 592         if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
 593                 pos += snprintf(buf + pos, remaining(pos), "%d:",
 594                                 desc->lineno);
 595         if (pos - pos_after_tid)
 596                 pos += snprintf(buf + pos, remaining(pos), " ");
 597         if (pos >= PREFIX_SIZE)
 598                 buf[PREFIX_SIZE - 1] = '\0';
 599
 600         return buf;
 601 }
 602
 603 void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
 604 {
 605         va_list args;
 606         struct va_format vaf;
 607         char buf[PREFIX_SIZE];
 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         printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
 618
 619         va_end(args);
 620 }
 621 EXPORT_SYMBOL(__dynamic_pr_debug);
 622
 623 void __dynamic_dev_dbg(struct _ddebug *descriptor,
 624                       const struct device *dev, const char *fmt, ...)
 625 {
 626         struct va_format vaf;
 627         va_list args;
 628
 629         BUG_ON(!descriptor);
 630         BUG_ON(!fmt);
 631
 632         va_start(args, fmt);
 633
 634         vaf.fmt = fmt;
 635         vaf.va = &args;
 636
 637         if (!dev) {
 638                 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
 639         } else {
 640                 char buf[PREFIX_SIZE];
 641
 642                 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
 643                                 dynamic_emit_prefix(descriptor, buf),
 644                                 dev_driver_string(dev), dev_name(dev),
 645                                 &vaf);
 646         }
 647
 648         va_end(args);
 649 }
 650 EXPORT_SYMBOL(__dynamic_dev_dbg);
 651
 652 #ifdef CONFIG_NET
 653
 654 void __dynamic_netdev_dbg(struct _ddebug *descriptor,
 655                           const struct net_device *dev, const char *fmt, ...)
 656 {
 657         struct va_format vaf;
 658         va_list args;
 659
 660         BUG_ON(!descriptor);
 661         BUG_ON(!fmt);
 662
 663         va_start(args, fmt);
 664
 665         vaf.fmt = fmt;
 666         vaf.va = &args;
 667
 668         if (dev && dev->dev.parent) {
 669                 char buf[PREFIX_SIZE];
 670
 671                 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
 672                                 "%s%s %s %s%s: %pV",
 673                                 dynamic_emit_prefix(descriptor, buf),
 674                                 dev_driver_string(dev->dev.parent),
 675                                 dev_name(dev->dev.parent),
 676                                 netdev_name(dev), netdev_reg_state(dev),
 677                                 &vaf);
 678         } else if (dev) {
 679                 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
 680                        netdev_reg_state(dev), &vaf);
 681         } else {
 682                 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
 683         }
 684
 685         va_end(args);
 686 }
 687 EXPORT_SYMBOL(__dynamic_netdev_dbg);
 688
 689 #endif
 690
 691 #if IS_ENABLED(CONFIG_INFINIBAND)
 692
 693 void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
 694                          const struct ib_device *ibdev, const char *fmt, ...)
 695 {
 696         struct va_format vaf;
 697         va_list args;
 698
 699         va_start(args, fmt);
 700
 701         vaf.fmt = fmt;
 702         vaf.va = &args;
 703
 704         if (ibdev && ibdev->dev.parent) {
 705                 char buf[PREFIX_SIZE];
 706
 707                 dev_printk_emit(LOGLEVEL_DEBUG, ibdev->dev.parent,
 708                                 "%s%s %s %s: %pV",
 709                                 dynamic_emit_prefix(descriptor, buf),
 710                                 dev_driver_string(ibdev->dev.parent),
 711                                 dev_name(ibdev->dev.parent),
 712                                 dev_name(&ibdev->dev),
 713                                 &vaf);
 714         } else if (ibdev) {
 715                 printk(KERN_DEBUG "%s: %pV", dev_name(&ibdev->dev), &vaf);
 716         } else {
 717                 printk(KERN_DEBUG "(NULL ib_device): %pV", &vaf);
 718         }
 719
 720         va_end(args);
 721 }
 722 EXPORT_SYMBOL(__dynamic_ibdev_dbg);
 723
 724 #endif
 725
 726 #define DDEBUG_STRING_SIZE 1024
 727 static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
 728
 729 static __init int ddebug_setup_query(char *str)
 730 {
 731         if (strlen(str) >= DDEBUG_STRING_SIZE) {
 732                 pr_warn("ddebug boot param string too large\n");
 733                 return 0;
 734         }
 735         strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
 736         return 1;
 737 }
 738
 739 __setup("ddebug_query=", ddebug_setup_query);
 740
 741 /*
 742  * File_ops->write method for <debugfs>/dynamic_debug/control.  Gathers the
 743  * command text from userspace, parses and executes it.
 744  */
 745 #define USER_BUF_PAGE 4096
 746 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
 747                                   size_t len, loff_t *offp)
 748 {
 749         char *tmpbuf;
 750         int ret;
 751
 752         if (len == 0)
 753                 return 0;
 754         if (len > USER_BUF_PAGE - 1) {
 755                 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
 756                 return -E2BIG;
 757         }
 758         tmpbuf = memdup_user_nul(ubuf, len);
 759         if (IS_ERR(tmpbuf))
 760                 return PTR_ERR(tmpbuf);
 761         vpr_info("read %d bytes from userspace\n", (int)len);
 762
 763         ret = ddebug_exec_queries(tmpbuf, NULL);
 764         kfree(tmpbuf);
 765         if (ret < 0)
 766                 return ret;
 767
 768         *offp += len;
 769         return len;
 770 }
 771
 772 /*
 773  * Set the iterator to point to the first _ddebug object
 774  * and return a pointer to that first object.  Returns
 775  * NULL if there are no _ddebugs at all.
 776  */
 777 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
 778 {
 779         if (list_empty(&ddebug_tables)) {
 780                 iter->table = NULL;
 781                 iter->idx = 0;
 782                 return NULL;
 783         }
 784         iter->table = list_entry(ddebug_tables.next,
 785                                  struct ddebug_table, link);
 786         iter->idx = 0;
 787         return &iter->table->ddebugs[iter->idx];
 788 }
 789
 790 /*
 791  * Advance the iterator to point to the next _ddebug
 792  * object from the one the iterator currently points at,
 793  * and returns a pointer to the new _ddebug.  Returns
 794  * NULL if the iterator has seen all the _ddebugs.
 795  */
 796 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
 797 {
 798         if (iter->table == NULL)
 799                 return NULL;
 800         if (++iter->idx == iter->table->num_ddebugs) {
 801                 /* iterate to next table */
 802                 iter->idx = 0;
 803                 if (list_is_last(&iter->table->link, &ddebug_tables)) {
 804                         iter->table = NULL;
 805                         return NULL;
 806                 }
 807                 iter->table = list_entry(iter->table->link.next,
 808                                          struct ddebug_table, link);
 809         }
 810         return &iter->table->ddebugs[iter->idx];
 811 }
 812
 813 /*
 814  * Seq_ops start method.  Called at the start of every
 815  * read() call from userspace.  Takes the ddebug_lock and
 816  * seeks the seq_file's iterator to the given position.
 817  */
 818 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
 819 {
 820         struct ddebug_iter *iter = m->private;
 821         struct _ddebug *dp;
 822         int n = *pos;
 823
 824         mutex_lock(&ddebug_lock);
 825
 826         if (!n)
 827                 return SEQ_START_TOKEN;
 828         if (n < 0)
 829                 return NULL;
 830         dp = ddebug_iter_first(iter);
 831         while (dp != NULL && --n > 0)
 832                 dp = ddebug_iter_next(iter);
 833         return dp;
 834 }
 835
 836 /*
 837  * Seq_ops next method.  Called several times within a read()
 838  * call from userspace, with ddebug_lock held.  Walks to the
 839  * next _ddebug object with a special case for the header line.
 840  */
 841 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
 842 {
 843         struct ddebug_iter *iter = m->private;
 844         struct _ddebug *dp;
 845
 846         if (p == SEQ_START_TOKEN)
 847                 dp = ddebug_iter_first(iter);
 848         else
 849                 dp = ddebug_iter_next(iter);
 850         ++*pos;
 851         return dp;
 852 }
 853
 854 /*
 855  * Seq_ops show method.  Called several times within a read()
 856  * call from userspace, with ddebug_lock held.  Formats the
 857  * current _ddebug as a single human-readable line, with a
 858  * special case for the header line.
 859  */
 860 static int ddebug_proc_show(struct seq_file *m, void *p)
 861 {
 862         struct ddebug_iter *iter = m->private;
 863         struct _ddebug *dp = p;
 864         struct flagsbuf flags;
 865
 866         if (p == SEQ_START_TOKEN) {
 867                 seq_puts(m,
 868                          "# filename:lineno [module]function flags format\n");
 869                 return 0;
 870         }
 871
 872         seq_printf(m, "%s:%u [%s]%s =%s \"",
 873                    trim_prefix(dp->filename), dp->lineno,
 874                    iter->table->mod_name, dp->function,
 875                    ddebug_describe_flags(dp->flags, &flags));
 876         seq_escape(m, dp->format, "\t\r\n\"");
 877         seq_puts(m, "\"\n");
 878
 879         return 0;
 880 }
 881
 882 /*
 883  * Seq_ops stop method.  Called at the end of each read()
 884  * call from userspace.  Drops ddebug_lock.
 885  */
 886 static void ddebug_proc_stop(struct seq_file *m, void *p)
 887 {
 888         mutex_unlock(&ddebug_lock);
 889 }
 890
 891 static const struct seq_operations ddebug_proc_seqops = {
 892         .start = ddebug_proc_start,
 893         .next = ddebug_proc_next,
 894         .show = ddebug_proc_show,
 895         .stop = ddebug_proc_stop
 896 };
 897
 898 static int ddebug_proc_open(struct inode *inode, struct file *file)
 899 {
 900         vpr_info("called\n");
 901         return seq_open_private(file, &ddebug_proc_seqops,
 902                                 sizeof(struct ddebug_iter));
 903 }
 904
 905 static const struct file_operations ddebug_proc_fops = {
 906         .owner = THIS_MODULE,
 907         .open = ddebug_proc_open,
 908         .read = seq_read,
 909         .llseek = seq_lseek,
 910         .release = seq_release_private,
 911         .write = ddebug_proc_write
 912 };
 913
 914 static const struct proc_ops proc_fops = {
 915         .proc_open = ddebug_proc_open,
 916         .proc_read = seq_read,
 917         .proc_lseek = seq_lseek,
 918         .proc_release = seq_release_private,
 919         .proc_write = ddebug_proc_write
 920 };
 921
 922 /*
 923  * Allocate a new ddebug_table for the given module
 924  * and add it to the global list.
 925  */
 926 int ddebug_add_module(struct _ddebug *tab, unsigned int n,
 927                              const char *name)
 928 {
 929         struct ddebug_table *dt;
 930
 931         dt = kzalloc(sizeof(*dt), GFP_KERNEL);
 932         if (dt == NULL) {
 933                 pr_err("error adding module: %s\n", name);
 934                 return -ENOMEM;
 935         }
 936         /*
 937          * For built-in modules, name lives in .rodata and is
 938          * immortal. For loaded modules, name points at the name[]
 939          * member of struct module, which lives at least as long as
 940          * this struct ddebug_table.
 941          */
 942         dt->mod_name = name;
 943         dt->num_ddebugs = n;
 944         dt->ddebugs = tab;
 945
 946         mutex_lock(&ddebug_lock);
 947         list_add(&dt->link, &ddebug_tables);
 948         mutex_unlock(&ddebug_lock);
 949
 950         v2pr_info("%u debug prints in module %s\n", n, dt->mod_name);
 951         return 0;
 952 }
 953
 954 /* helper for ddebug_dyndbg_(boot|module)_param_cb */
 955 static int ddebug_dyndbg_param_cb(char *param, char *val,
 956                                 const char *modname, int on_err)
 957 {
 958         char *sep;
 959
 960         sep = strchr(param, '.');
 961         if (sep) {
 962                 /* needed only for ddebug_dyndbg_boot_param_cb */
 963                 *sep = '\0';
 964                 modname = param;
 965                 param = sep + 1;
 966         }
 967         if (strcmp(param, "dyndbg"))
 968                 return on_err; /* determined by caller */
 969
 970         ddebug_exec_queries((val ? val : "+p"), modname);
 971
 972         return 0; /* query failure shouldnt stop module load */
 973 }
 974
 975 /* handle both dyndbg and $module.dyndbg params at boot */
 976 static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
 977                                 const char *unused, void *arg)
 978 {
 979         vpr_info("%s=\"%s\"\n", param, val);
 980         return ddebug_dyndbg_param_cb(param, val, NULL, 0);
 981 }
 982
 983 /*
 984  * modprobe foo finds foo.params in boot-args, strips "foo.", and
 985  * passes them to load_module().  This callback gets unknown params,
 986  * processes dyndbg params, rejects others.
 987  */
 988 int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
 989 {
 990         vpr_info("module: %s %s=\"%s\"\n", module, param, val);
 991         return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
 992 }
 993
 994 static void ddebug_table_free(struct ddebug_table *dt)
 995 {
 996         list_del_init(&dt->link);
 997         kfree(dt);
 998 }
 999
1000 /*
1001  * Called in response to a module being unloaded.  Removes
1002  * any ddebug_table's which point at the module.
1003  */
1004 int ddebug_remove_module(const char *mod_name)
1005 {
1006         struct ddebug_table *dt, *nextdt;
1007         int ret = -ENOENT;
1008
1009         v2pr_info("removing module \"%s\"\n", mod_name);
1010
1011         mutex_lock(&ddebug_lock);
1012         list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
1013                 if (dt->mod_name == mod_name) {
1014                         ddebug_table_free(dt);
1015                         ret = 0;
1016                         break;
1017                 }
1018         }
1019         mutex_unlock(&ddebug_lock);
1020         return ret;
1021 }
1022
1023 static void ddebug_remove_all_tables(void)
1024 {
1025         mutex_lock(&ddebug_lock);
1026         while (!list_empty(&ddebug_tables)) {
1027                 struct ddebug_table *dt = list_entry(ddebug_tables.next,
1028                                                       struct ddebug_table,
1029                                                       link);
1030                 ddebug_table_free(dt);
1031         }
1032         mutex_unlock(&ddebug_lock);
1033 }
1034
1035 static __initdata int ddebug_init_success;
1036
1037 static int __init dynamic_debug_init_control(void)
1038 {
1039         struct proc_dir_entry *procfs_dir;
1040         struct dentry *debugfs_dir;
1041
1042         if (!ddebug_init_success)
1043                 return -ENODEV;
1044
1045         /* Create the control file in debugfs if it is enabled */
1046         if (debugfs_initialized()) {
1047                 debugfs_dir = debugfs_create_dir("dynamic_debug", NULL);
1048                 debugfs_create_file("control", 0644, debugfs_dir, NULL,
1049                                     &ddebug_proc_fops);
1050         }
1051
1052         /* Also create the control file in procfs */
1053         procfs_dir = proc_mkdir("dynamic_debug", NULL);
1054         if (procfs_dir)
1055                 proc_create("control", 0644, procfs_dir, &proc_fops);
1056
1057         return 0;
1058 }
1059
1060 static int __init dynamic_debug_init(void)
1061 {
1062         struct _ddebug *iter, *iter_start;
1063         const char *modname = NULL;
1064         char *cmdline;
1065         int ret = 0;
1066         int n = 0, entries = 0, modct = 0;
1067
1068         if (&__start___dyndbg == &__stop___dyndbg) {
1069                 if (IS_ENABLED(CONFIG_DYNAMIC_DEBUG)) {
1070                         pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
1071                         return 1;
1072                 }
1073                 pr_info("Ignore empty _ddebug table in a CONFIG_DYNAMIC_DEBUG_CORE build\n");
1074                 ddebug_init_success = 1;
1075                 return 0;
1076         }
1077         iter = __start___dyndbg;
1078         modname = iter->modname;
1079         iter_start = iter;
1080         for (; iter < __stop___dyndbg; iter++) {
1081                 entries++;
1082                 if (strcmp(modname, iter->modname)) {
1083                         modct++;
1084                         ret = ddebug_add_module(iter_start, n, modname);
1085                         if (ret)
1086                                 goto out_err;
1087                         n = 0;
1088                         modname = iter->modname;
1089                         iter_start = iter;
1090                 }
1091                 n++;
1092         }
1093         ret = ddebug_add_module(iter_start, n, modname);
1094         if (ret)
1095                 goto out_err;
1096
1097         ddebug_init_success = 1;
1098         vpr_info("%d modules, %d entries and %d bytes in ddebug tables, %d bytes in __dyndbg section\n",
1099                  modct, entries, (int)(modct * sizeof(struct ddebug_table)),
1100                  (int)(entries * sizeof(struct _ddebug)));
1101
1102         /* apply ddebug_query boot param, dont unload tables on err */
1103         if (ddebug_setup_string[0] != '\0') {
1104                 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
1105                 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
1106                 if (ret < 0)
1107                         pr_warn("Invalid ddebug boot param %s\n",
1108                                 ddebug_setup_string);
1109                 else
1110                         pr_info("%d changes by ddebug_query\n", ret);
1111         }
1112         /* now that ddebug tables are loaded, process all boot args
1113          * again to find and activate queries given in dyndbg params.
1114          * While this has already been done for known boot params, it
1115          * ignored the unknown ones (dyndbg in particular).  Reusing
1116          * parse_args avoids ad-hoc parsing.  This will also attempt
1117          * to activate queries for not-yet-loaded modules, which is
1118          * slightly noisy if verbose, but harmless.
1119          */
1120         cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1121         parse_args("dyndbg params", cmdline, NULL,
1122                    0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
1123         kfree(cmdline);
1124         return 0;
1125
1126 out_err:
1127         ddebug_remove_all_tables();
1128         return 0;
1129 }
1130 /* Allow early initialization for boot messages via boot param */
1131 early_initcall(dynamic_debug_init);
1132
1133 /* Debugfs setup must be done later */
1134 fs_initcall(dynamic_debug_init_control);