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 extern struct ddebug_class_map __start___dyndbg_classes[];
  45 extern struct ddebug_class_map __stop___dyndbg_classes[];
  46
  47 struct ddebug_table {
  48         struct list_head link, maps;
  49         const char *mod_name;
  50         unsigned int num_ddebugs;
  51         struct _ddebug *ddebugs;
  52 };
  53
  54 struct ddebug_query {
  55         const char *filename;
  56         const char *module;
  57         const char *function;
  58         const char *format;
  59         const char *class_string;
  60         unsigned int first_lineno, last_lineno;
  61 };
  62
  63 struct ddebug_iter {
  64         struct ddebug_table *table;
  65         int idx;
  66 };
  67
  68 struct flag_settings {
  69         unsigned int flags;
  70         unsigned int mask;
  71 };
  72
  73 static DEFINE_MUTEX(ddebug_lock);
  74 static LIST_HEAD(ddebug_tables);
  75 static int verbose;
  76 module_param(verbose, int, 0644);
  77 MODULE_PARM_DESC(verbose, " dynamic_debug/control processing "
  78                  "( 0 = off (default), 1 = module add/rm, 2 = >control summary, 3 = parsing, 4 = per-site changes)");
  79
  80 /* Return the path relative to source root */
  81 static inline const char *trim_prefix(const char *path)
  82 {
  83         int skip = strlen(__FILE__) - strlen("lib/dynamic_debug.c");
  84
  85         if (strncmp(path, __FILE__, skip))
  86                 skip = 0; /* prefix mismatch, don't skip */
  87
  88         return path + skip;
  89 }
  90
  91 static const struct { unsigned flag:8; char opt_char; } opt_array[] = {
  92         { _DPRINTK_FLAGS_PRINT, 'p' },
  93         { _DPRINTK_FLAGS_INCL_MODNAME, 'm' },
  94         { _DPRINTK_FLAGS_INCL_FUNCNAME, 'f' },
  95         { _DPRINTK_FLAGS_INCL_SOURCENAME, 's' },
  96         { _DPRINTK_FLAGS_INCL_LINENO, 'l' },
  97         { _DPRINTK_FLAGS_INCL_TID, 't' },
  98         { _DPRINTK_FLAGS_NONE, '_' },
  99 };
 100
 101 struct flagsbuf { char buf[ARRAY_SIZE(opt_array)+1]; };
 102
 103 /* format a string into buf[] which describes the _ddebug's flags */
 104 static char *ddebug_describe_flags(unsigned int flags, struct flagsbuf *fb)
 105 {
 106         char *p = fb->buf;
 107         int i;
 108
 109         for (i = 0; i < ARRAY_SIZE(opt_array); ++i)
 110                 if (flags & opt_array[i].flag)
 111                         *p++ = opt_array[i].opt_char;
 112         if (p == fb->buf)
 113                 *p++ = '_';
 114         *p = '\0';
 115
 116         return fb->buf;
 117 }
 118
 119 #define vnpr_info(lvl, fmt, ...)                                \
 120 do {                                                            \
 121         if (verbose >= lvl)                                     \
 122                 pr_info(fmt, ##__VA_ARGS__);                    \
 123 } while (0)
 124
 125 #define vpr_info(fmt, ...)      vnpr_info(1, fmt, ##__VA_ARGS__)
 126 #define v2pr_info(fmt, ...)     vnpr_info(2, fmt, ##__VA_ARGS__)
 127 #define v3pr_info(fmt, ...)     vnpr_info(3, fmt, ##__VA_ARGS__)
 128 #define v4pr_info(fmt, ...)     vnpr_info(4, fmt, ##__VA_ARGS__)
 129
 130 static void vpr_info_dq(const struct ddebug_query *query, const char *msg)
 131 {
 132         /* trim any trailing newlines */
 133         int fmtlen = 0;
 134
 135         if (query->format) {
 136                 fmtlen = strlen(query->format);
 137                 while (fmtlen && query->format[fmtlen - 1] == '\n')
 138                         fmtlen--;
 139         }
 140
 141         v3pr_info("%s: func=\"%s\" file=\"%s\" module=\"%s\" format=\"%.*s\" lineno=%u-%u class=%s\n",
 142                   msg,
 143                   query->function ?: "",
 144                   query->filename ?: "",
 145                   query->module ?: "",
 146                   fmtlen, query->format ?: "",
 147                   query->first_lineno, query->last_lineno, query->class_string);
 148 }
 149
 150 static struct ddebug_class_map *ddebug_find_valid_class(struct ddebug_table const *dt,
 151                                                           const char *class_string, int *class_id)
 152 {
 153         struct ddebug_class_map *map;
 154         int idx;
 155
 156         list_for_each_entry(map, &dt->maps, link) {
 157                 idx = match_string(map->class_names, map->length, class_string);
 158                 if (idx >= 0) {
 159                         *class_id = idx + map->base;
 160                         return map;
 161                 }
 162         }
 163         *class_id = -ENOENT;
 164         return NULL;
 165 }
 166
 167 #define __outvar /* filled by callee */
 168 /*
 169  * Search the tables for _ddebug's which match the given `query' and
 170  * apply the `flags' and `mask' to them.  Returns number of matching
 171  * callsites, normally the same as number of changes.  If verbose,
 172  * logs the changes.  Takes ddebug_lock.
 173  */
 174 static int ddebug_change(const struct ddebug_query *query,
 175                          struct flag_settings *modifiers)
 176 {
 177         int i;
 178         struct ddebug_table *dt;
 179         unsigned int newflags;
 180         unsigned int nfound = 0;
 181         struct flagsbuf fbuf, nbuf;
 182         struct ddebug_class_map *map = NULL;
 183         int __outvar valid_class;
 184
 185         /* search for matching ddebugs */
 186         mutex_lock(&ddebug_lock);
 187         list_for_each_entry(dt, &ddebug_tables, link) {
 188
 189                 /* match against the module name */
 190                 if (query->module &&
 191                     !match_wildcard(query->module, dt->mod_name))
 192                         continue;
 193
 194                 if (query->class_string) {
 195                         map = ddebug_find_valid_class(dt, query->class_string, &valid_class);
 196                         if (!map)
 197                                 continue;
 198                 } else {
 199                         /* constrain query, do not touch class'd callsites */
 200                         valid_class = _DPRINTK_CLASS_DFLT;
 201                 }
 202
 203                 for (i = 0; i < dt->num_ddebugs; i++) {
 204                         struct _ddebug *dp = &dt->ddebugs[i];
 205
 206                         /* match site against query-class */
 207                         if (dp->class_id != valid_class)
 208                                 continue;
 209
 210                         /* match against the source filename */
 211                         if (query->filename &&
 212                             !match_wildcard(query->filename, dp->filename) &&
 213                             !match_wildcard(query->filename,
 214                                            kbasename(dp->filename)) &&
 215                             !match_wildcard(query->filename,
 216                                            trim_prefix(dp->filename)))
 217                                 continue;
 218
 219                         /* match against the function */
 220                         if (query->function &&
 221                             !match_wildcard(query->function, dp->function))
 222                                 continue;
 223
 224                         /* match against the format */
 225                         if (query->format) {
 226                                 if (*query->format == '^') {
 227                                         char *p;
 228                                         /* anchored search. match must be at beginning */
 229                                         p = strstr(dp->format, query->format+1);
 230                                         if (p != dp->format)
 231                                                 continue;
 232                                 } else if (!strstr(dp->format, query->format))
 233                                         continue;
 234                         }
 235
 236                         /* match against the line number range */
 237                         if (query->first_lineno &&
 238                             dp->lineno < query->first_lineno)
 239                                 continue;
 240                         if (query->last_lineno &&
 241                             dp->lineno > query->last_lineno)
 242                                 continue;
 243
 244                         nfound++;
 245
 246                         newflags = (dp->flags & modifiers->mask) | modifiers->flags;
 247                         if (newflags == dp->flags)
 248                                 continue;
 249 #ifdef CONFIG_JUMP_LABEL
 250                         if (dp->flags & _DPRINTK_FLAGS_PRINT) {
 251                                 if (!(newflags & _DPRINTK_FLAGS_PRINT))
 252                                         static_branch_disable(&dp->key.dd_key_true);
 253                         } else if (newflags & _DPRINTK_FLAGS_PRINT) {
 254                                 static_branch_enable(&dp->key.dd_key_true);
 255                         }
 256 #endif
 257                         v4pr_info("changed %s:%d [%s]%s %s => %s\n",
 258                                   trim_prefix(dp->filename), dp->lineno,
 259                                   dt->mod_name, dp->function,
 260                                   ddebug_describe_flags(dp->flags, &fbuf),
 261                                   ddebug_describe_flags(newflags, &nbuf));
 262                         dp->flags = newflags;
 263                 }
 264         }
 265         mutex_unlock(&ddebug_lock);
 266
 267         if (!nfound && verbose)
 268                 pr_info("no matches for query\n");
 269
 270         return nfound;
 271 }
 272
 273 /*
 274  * Split the buffer `buf' into space-separated words.
 275  * Handles simple " and ' quoting, i.e. without nested,
 276  * embedded or escaped \".  Return the number of words
 277  * or <0 on error.
 278  */
 279 static int ddebug_tokenize(char *buf, char *words[], int maxwords)
 280 {
 281         int nwords = 0;
 282
 283         while (*buf) {
 284                 char *end;
 285
 286                 /* Skip leading whitespace */
 287                 buf = skip_spaces(buf);
 288                 if (!*buf)
 289                         break;  /* oh, it was trailing whitespace */
 290                 if (*buf == '#')
 291                         break;  /* token starts comment, skip rest of line */
 292
 293                 /* find `end' of word, whitespace separated or quoted */
 294                 if (*buf == '"' || *buf == '\'') {
 295                         int quote = *buf++;
 296                         for (end = buf; *end && *end != quote; end++)
 297                                 ;
 298                         if (!*end) {
 299                                 pr_err("unclosed quote: %s\n", buf);
 300                                 return -EINVAL; /* unclosed quote */
 301                         }
 302                 } else {
 303                         for (end = buf; *end && !isspace(*end); end++)
 304                                 ;
 305                         BUG_ON(end == buf);
 306                 }
 307
 308                 /* `buf' is start of word, `end' is one past its end */
 309                 if (nwords == maxwords) {
 310                         pr_err("too many words, legal max <=%d\n", maxwords);
 311                         return -EINVAL; /* ran out of words[] before bytes */
 312                 }
 313                 if (*end)
 314                         *end++ = '\0';  /* terminate the word */
 315                 words[nwords++] = buf;
 316                 buf = end;
 317         }
 318
 319         if (verbose >= 3) {
 320                 int i;
 321                 pr_info("split into words:");
 322                 for (i = 0; i < nwords; i++)
 323                         pr_cont(" \"%s\"", words[i]);
 324                 pr_cont("\n");
 325         }
 326
 327         return nwords;
 328 }
 329
 330 /*
 331  * Parse a single line number.  Note that the empty string ""
 332  * is treated as a special case and converted to zero, which
 333  * is later treated as a "don't care" value.
 334  */
 335 static inline int parse_lineno(const char *str, unsigned int *val)
 336 {
 337         BUG_ON(str == NULL);
 338         if (*str == '\0') {
 339                 *val = 0;
 340                 return 0;
 341         }
 342         if (kstrtouint(str, 10, val) < 0) {
 343                 pr_err("bad line-number: %s\n", str);
 344                 return -EINVAL;
 345         }
 346         return 0;
 347 }
 348
 349 static int parse_linerange(struct ddebug_query *query, const char *first)
 350 {
 351         char *last = strchr(first, '-');
 352
 353         if (query->first_lineno || query->last_lineno) {
 354                 pr_err("match-spec: line used 2x\n");
 355                 return -EINVAL;
 356         }
 357         if (last)
 358                 *last++ = '\0';
 359         if (parse_lineno(first, &query->first_lineno) < 0)
 360                 return -EINVAL;
 361         if (last) {
 362                 /* range <first>-<last> */
 363                 if (parse_lineno(last, &query->last_lineno) < 0)
 364                         return -EINVAL;
 365
 366                 /* special case for last lineno not specified */
 367                 if (query->last_lineno == 0)
 368                         query->last_lineno = UINT_MAX;
 369
 370                 if (query->last_lineno < query->first_lineno) {
 371                         pr_err("last-line:%d < 1st-line:%d\n",
 372                                query->last_lineno,
 373                                query->first_lineno);
 374                         return -EINVAL;
 375                 }
 376         } else {
 377                 query->last_lineno = query->first_lineno;
 378         }
 379         v3pr_info("parsed line %d-%d\n", query->first_lineno,
 380                  query->last_lineno);
 381         return 0;
 382 }
 383
 384 static int check_set(const char **dest, char *src, char *name)
 385 {
 386         int rc = 0;
 387
 388         if (*dest) {
 389                 rc = -EINVAL;
 390                 pr_err("match-spec:%s val:%s overridden by %s\n",
 391                        name, *dest, src);
 392         }
 393         *dest = src;
 394         return rc;
 395 }
 396
 397 /*
 398  * Parse words[] as a ddebug query specification, which is a series
 399  * of (keyword, value) pairs chosen from these possibilities:
 400  *
 401  * func <function-name>
 402  * file <full-pathname>
 403  * file <base-filename>
 404  * module <module-name>
 405  * format <escaped-string-to-find-in-format>
 406  * line <lineno>
 407  * line <first-lineno>-<last-lineno> // where either may be empty
 408  *
 409  * Only 1 of each type is allowed.
 410  * Returns 0 on success, <0 on error.
 411  */
 412 static int ddebug_parse_query(char *words[], int nwords,
 413                         struct ddebug_query *query, const char *modname)
 414 {
 415         unsigned int i;
 416         int rc = 0;
 417         char *fline;
 418
 419         /* check we have an even number of words */
 420         if (nwords % 2 != 0) {
 421                 pr_err("expecting pairs of match-spec <value>\n");
 422                 return -EINVAL;
 423         }
 424
 425         for (i = 0; i < nwords; i += 2) {
 426                 char *keyword = words[i];
 427                 char *arg = words[i+1];
 428
 429                 if (!strcmp(keyword, "func")) {
 430                         rc = check_set(&query->function, arg, "func");
 431                 } else if (!strcmp(keyword, "file")) {
 432                         if (check_set(&query->filename, arg, "file"))
 433                                 return -EINVAL;
 434
 435                         /* tail :$info is function or line-range */
 436                         fline = strchr(query->filename, ':');
 437                         if (!fline)
 438                                 continue;
 439                         *fline++ = '\0';
 440                         if (isalpha(*fline) || *fline == '*' || *fline == '?') {
 441                                 /* take as function name */
 442                                 if (check_set(&query->function, fline, "func"))
 443                                         return -EINVAL;
 444                         } else {
 445                                 if (parse_linerange(query, fline))
 446                                         return -EINVAL;
 447                         }
 448                 } else if (!strcmp(keyword, "module")) {
 449                         rc = check_set(&query->module, arg, "module");
 450                 } else if (!strcmp(keyword, "format")) {
 451                         string_unescape_inplace(arg, UNESCAPE_SPACE |
 452                                                             UNESCAPE_OCTAL |
 453                                                             UNESCAPE_SPECIAL);
 454                         rc = check_set(&query->format, arg, "format");
 455                 } else if (!strcmp(keyword, "line")) {
 456                         if (parse_linerange(query, arg))
 457                                 return -EINVAL;
 458                 } else if (!strcmp(keyword, "class")) {
 459                         rc = check_set(&query->class_string, arg, "class");
 460                 } else {
 461                         pr_err("unknown keyword \"%s\"\n", keyword);
 462                         return -EINVAL;
 463                 }
 464                 if (rc)
 465                         return rc;
 466         }
 467         if (!query->module && modname)
 468                 /*
 469                  * support $modname.dyndbg=<multiple queries>, when
 470                  * not given in the query itself
 471                  */
 472                 query->module = modname;
 473
 474         vpr_info_dq(query, "parsed");
 475         return 0;
 476 }
 477
 478 /*
 479  * Parse `str' as a flags specification, format [-+=][p]+.
 480  * Sets up *maskp and *flagsp to be used when changing the
 481  * flags fields of matched _ddebug's.  Returns 0 on success
 482  * or <0 on error.
 483  */
 484 static int ddebug_parse_flags(const char *str, struct flag_settings *modifiers)
 485 {
 486         int op, i;
 487
 488         switch (*str) {
 489         case '+':
 490         case '-':
 491         case '=':
 492                 op = *str++;
 493                 break;
 494         default:
 495                 pr_err("bad flag-op %c, at start of %s\n", *str, str);
 496                 return -EINVAL;
 497         }
 498         v3pr_info("op='%c'\n", op);
 499
 500         for (; *str ; ++str) {
 501                 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
 502                         if (*str == opt_array[i].opt_char) {
 503                                 modifiers->flags |= opt_array[i].flag;
 504                                 break;
 505                         }
 506                 }
 507                 if (i < 0) {
 508                         pr_err("unknown flag '%c'\n", *str);
 509                         return -EINVAL;
 510                 }
 511         }
 512         v3pr_info("flags=0x%x\n", modifiers->flags);
 513
 514         /* calculate final flags, mask based upon op */
 515         switch (op) {
 516         case '=':
 517                 /* modifiers->flags already set */
 518                 modifiers->mask = 0;
 519                 break;
 520         case '+':
 521                 modifiers->mask = ~0U;
 522                 break;
 523         case '-':
 524                 modifiers->mask = ~modifiers->flags;
 525                 modifiers->flags = 0;
 526                 break;
 527         }
 528         v3pr_info("*flagsp=0x%x *maskp=0x%x\n", modifiers->flags, modifiers->mask);
 529
 530         return 0;
 531 }
 532
 533 static int ddebug_exec_query(char *query_string, const char *modname)
 534 {
 535         struct flag_settings modifiers = {};
 536         struct ddebug_query query = {};
 537 #define MAXWORDS 9
 538         int nwords, nfound;
 539         char *words[MAXWORDS];
 540
 541         nwords = ddebug_tokenize(query_string, words, MAXWORDS);
 542         if (nwords <= 0) {
 543                 pr_err("tokenize failed\n");
 544                 return -EINVAL;
 545         }
 546         /* check flags 1st (last arg) so query is pairs of spec,val */
 547         if (ddebug_parse_flags(words[nwords-1], &modifiers)) {
 548                 pr_err("flags parse failed\n");
 549                 return -EINVAL;
 550         }
 551         if (ddebug_parse_query(words, nwords-1, &query, modname)) {
 552                 pr_err("query parse failed\n");
 553                 return -EINVAL;
 554         }
 555         /* actually go and implement the change */
 556         nfound = ddebug_change(&query, &modifiers);
 557         vpr_info_dq(&query, nfound ? "applied" : "no-match");
 558
 559         return nfound;
 560 }
 561
 562 /* handle multiple queries in query string, continue on error, return
 563    last error or number of matching callsites.  Module name is either
 564    in param (for boot arg) or perhaps in query string.
 565 */
 566 static int ddebug_exec_queries(char *query, const char *modname)
 567 {
 568         char *split;
 569         int i, errs = 0, exitcode = 0, rc, nfound = 0;
 570
 571         for (i = 0; query; query = split) {
 572                 split = strpbrk(query, ";\n");
 573                 if (split)
 574                         *split++ = '\0';
 575
 576                 query = skip_spaces(query);
 577                 if (!query || !*query || *query == '#')
 578                         continue;
 579
 580                 vpr_info("query %d: \"%s\" mod:%s\n", i, query, modname ?: "*");
 581
 582                 rc = ddebug_exec_query(query, modname);
 583                 if (rc < 0) {
 584                         errs++;
 585                         exitcode = rc;
 586                 } else {
 587                         nfound += rc;
 588                 }
 589                 i++;
 590         }
 591         if (i)
 592                 v2pr_info("processed %d queries, with %d matches, %d errs\n",
 593                          i, nfound, errs);
 594
 595         if (exitcode)
 596                 return exitcode;
 597         return nfound;
 598 }
 599
 600 /* apply a new bitmap to the sys-knob's current bit-state */
 601 static int ddebug_apply_class_bitmap(const struct ddebug_class_param *dcp,
 602                                      unsigned long *new_bits, unsigned long *old_bits)
 603 {
 604 #define QUERY_SIZE 128
 605         char query[QUERY_SIZE];
 606         const struct ddebug_class_map *map = dcp->map;
 607         int matches = 0;
 608         int bi, ct;
 609
 610         v2pr_info("apply: 0x%lx to: 0x%lx\n", *new_bits, *old_bits);
 611
 612         for (bi = 0; bi < map->length; bi++) {
 613                 if (test_bit(bi, new_bits) == test_bit(bi, old_bits))
 614                         continue;
 615
 616                 snprintf(query, QUERY_SIZE, "class %s %c%s", map->class_names[bi],
 617                          test_bit(bi, new_bits) ? '+' : '-', dcp->flags);
 618
 619                 ct = ddebug_exec_queries(query, NULL);
 620                 matches += ct;
 621
 622                 v2pr_info("bit_%d: %d matches on class: %s -> 0x%lx\n", bi,
 623                           ct, map->class_names[bi], *new_bits);
 624         }
 625         return matches;
 626 }
 627
 628 /* stub to later conditionally add "$module." prefix where not already done */
 629 #define KP_NAME(kp)     kp->name
 630
 631 #define CLASSMAP_BITMASK(width) ((1UL << (width)) - 1)
 632
 633 /* accept comma-separated-list of [+-] classnames */
 634 static int param_set_dyndbg_classnames(const char *instr, const struct kernel_param *kp)
 635 {
 636         const struct ddebug_class_param *dcp = kp->arg;
 637         const struct ddebug_class_map *map = dcp->map;
 638         unsigned long curr_bits, old_bits;
 639         char *cl_str, *p, *tmp;
 640         int cls_id, totct = 0;
 641         bool wanted;
 642
 643         cl_str = tmp = kstrdup_and_replace(instr, '\n', '\0', GFP_KERNEL);
 644         if (!tmp)
 645                 return -ENOMEM;
 646
 647         /* start with previously set state-bits, then modify */
 648         curr_bits = old_bits = *dcp->bits;
 649         vpr_info("\"%s\" > %s:0x%lx\n", cl_str, KP_NAME(kp), curr_bits);
 650
 651         for (; cl_str; cl_str = p) {
 652                 p = strchr(cl_str, ',');
 653                 if (p)
 654                         *p++ = '\0';
 655
 656                 if (*cl_str == '-') {
 657                         wanted = false;
 658                         cl_str++;
 659                 } else {
 660                         wanted = true;
 661                         if (*cl_str == '+')
 662                                 cl_str++;
 663                 }
 664                 cls_id = match_string(map->class_names, map->length, cl_str);
 665                 if (cls_id < 0) {
 666                         pr_err("%s unknown to %s\n", cl_str, KP_NAME(kp));
 667                         continue;
 668                 }
 669
 670                 /* have one or more valid class_ids of one *_NAMES type */
 671                 switch (map->map_type) {
 672                 case DD_CLASS_TYPE_DISJOINT_NAMES:
 673                         /* the +/- pertains to a single bit */
 674                         if (test_bit(cls_id, &curr_bits) == wanted) {
 675                                 v3pr_info("no change on %s\n", cl_str);
 676                                 continue;
 677                         }
 678                         curr_bits ^= BIT(cls_id);
 679                         totct += ddebug_apply_class_bitmap(dcp, &curr_bits, dcp->bits);
 680                         *dcp->bits = curr_bits;
 681                         v2pr_info("%s: changed bit %d:%s\n", KP_NAME(kp), cls_id,
 682                                   map->class_names[cls_id]);
 683                         break;
 684                 case DD_CLASS_TYPE_LEVEL_NAMES:
 685                         /* cls_id = N in 0..max. wanted +/- determines N or N-1 */
 686                         old_bits = CLASSMAP_BITMASK(*dcp->lvl);
 687                         curr_bits = CLASSMAP_BITMASK(cls_id + (wanted ? 1 : 0 ));
 688
 689                         totct += ddebug_apply_class_bitmap(dcp, &curr_bits, &old_bits);
 690                         *dcp->lvl = (cls_id + (wanted ? 1 : 0));
 691                         v2pr_info("%s: changed bit-%d: \"%s\" %lx->%lx\n", KP_NAME(kp), cls_id,
 692                                   map->class_names[cls_id], old_bits, curr_bits);
 693                         break;
 694                 default:
 695                         pr_err("illegal map-type value %d\n", map->map_type);
 696                 }
 697         }
 698         kfree(tmp);
 699         vpr_info("total matches: %d\n", totct);
 700         return 0;
 701 }
 702
 703 /**
 704  * param_set_dyndbg_classes - class FOO >control
 705  * @instr: string echo>d to sysfs, input depends on map_type
 706  * @kp:    kp->arg has state: bits/lvl, map, map_type
 707  *
 708  * Enable/disable prdbgs by their class, as given in the arguments to
 709  * DECLARE_DYNDBG_CLASSMAP.  For LEVEL map-types, enforce relative
 710  * levels by bitpos.
 711  *
 712  * Returns: 0 or <0 if error.
 713  */
 714 int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp)
 715 {
 716         const struct ddebug_class_param *dcp = kp->arg;
 717         const struct ddebug_class_map *map = dcp->map;
 718         unsigned long inrep, new_bits, old_bits;
 719         int rc, totct = 0;
 720
 721         switch (map->map_type) {
 722
 723         case DD_CLASS_TYPE_DISJOINT_NAMES:
 724         case DD_CLASS_TYPE_LEVEL_NAMES:
 725                 /* handle [+-]classnames list separately, we are done here */
 726                 return param_set_dyndbg_classnames(instr, kp);
 727
 728         case DD_CLASS_TYPE_DISJOINT_BITS:
 729         case DD_CLASS_TYPE_LEVEL_NUM:
 730                 /* numeric input, accept and fall-thru */
 731                 rc = kstrtoul(instr, 0, &inrep);
 732                 if (rc) {
 733                         pr_err("expecting numeric input: %s > %s\n", instr, KP_NAME(kp));
 734                         return -EINVAL;
 735                 }
 736                 break;
 737         default:
 738                 pr_err("%s: bad map type: %d\n", KP_NAME(kp), map->map_type);
 739                 return -EINVAL;
 740         }
 741
 742         /* only _BITS,_NUM (numeric) map-types get here */
 743         switch (map->map_type) {
 744         case DD_CLASS_TYPE_DISJOINT_BITS:
 745                 /* expect bits. mask and warn if too many */
 746                 if (inrep & ~CLASSMAP_BITMASK(map->length)) {
 747                         pr_warn("%s: input: 0x%lx exceeds mask: 0x%lx, masking\n",
 748                                 KP_NAME(kp), inrep, CLASSMAP_BITMASK(map->length));
 749                         inrep &= CLASSMAP_BITMASK(map->length);
 750                 }
 751                 v2pr_info("bits:%lx > %s\n", inrep, KP_NAME(kp));
 752                 totct += ddebug_apply_class_bitmap(dcp, &inrep, dcp->bits);
 753                 *dcp->bits = inrep;
 754                 break;
 755         case DD_CLASS_TYPE_LEVEL_NUM:
 756                 /* input is bitpos, of highest verbosity to be enabled */
 757                 if (inrep > map->length) {
 758                         pr_warn("%s: level:%ld exceeds max:%d, clamping\n",
 759                                 KP_NAME(kp), inrep, map->length);
 760                         inrep = map->length;
 761                 }
 762                 old_bits = CLASSMAP_BITMASK(*dcp->lvl);
 763                 new_bits = CLASSMAP_BITMASK(inrep);
 764                 v2pr_info("lvl:%ld bits:0x%lx > %s\n", inrep, new_bits, KP_NAME(kp));
 765                 totct += ddebug_apply_class_bitmap(dcp, &new_bits, &old_bits);
 766                 *dcp->lvl = inrep;
 767                 break;
 768         default:
 769                 pr_warn("%s: bad map type: %d\n", KP_NAME(kp), map->map_type);
 770         }
 771         vpr_info("%s: total matches: %d\n", KP_NAME(kp), totct);
 772         return 0;
 773 }
 774 EXPORT_SYMBOL(param_set_dyndbg_classes);
 775
 776 /**
 777  * param_get_dyndbg_classes - classes reader
 778  * @buffer: string description of controlled bits -> classes
 779  * @kp:     kp->arg has state: bits, map
 780  *
 781  * Reads last written state, underlying prdbg state may have been
 782  * altered by direct >control.  Displays 0x for DISJOINT, 0-N for
 783  * LEVEL Returns: #chars written or <0 on error
 784  */
 785 int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp)
 786 {
 787         const struct ddebug_class_param *dcp = kp->arg;
 788         const struct ddebug_class_map *map = dcp->map;
 789
 790         switch (map->map_type) {
 791
 792         case DD_CLASS_TYPE_DISJOINT_NAMES:
 793         case DD_CLASS_TYPE_DISJOINT_BITS:
 794                 return scnprintf(buffer, PAGE_SIZE, "0x%lx\n", *dcp->bits);
 795
 796         case DD_CLASS_TYPE_LEVEL_NAMES:
 797         case DD_CLASS_TYPE_LEVEL_NUM:
 798                 return scnprintf(buffer, PAGE_SIZE, "%d\n", *dcp->lvl);
 799         default:
 800                 return -1;
 801         }
 802 }
 803 EXPORT_SYMBOL(param_get_dyndbg_classes);
 804
 805 const struct kernel_param_ops param_ops_dyndbg_classes = {
 806         .set = param_set_dyndbg_classes,
 807         .get = param_get_dyndbg_classes,
 808 };
 809 EXPORT_SYMBOL(param_ops_dyndbg_classes);
 810
 811 #define PREFIX_SIZE 128
 812
 813 static int remaining(int wrote)
 814 {
 815         if (PREFIX_SIZE - wrote > 0)
 816                 return PREFIX_SIZE - wrote;
 817         return 0;
 818 }
 819
 820 static char *__dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
 821 {
 822         int pos_after_tid;
 823         int pos = 0;
 824
 825         if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
 826                 if (in_interrupt())
 827                         pos += snprintf(buf + pos, remaining(pos), "<intr> ");
 828                 else
 829                         pos += snprintf(buf + pos, remaining(pos), "[%d] ",
 830                                         task_pid_vnr(current));
 831         }
 832         pos_after_tid = pos;
 833         if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
 834                 pos += snprintf(buf + pos, remaining(pos), "%s:",
 835                                 desc->modname);
 836         if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
 837                 pos += snprintf(buf + pos, remaining(pos), "%s:",
 838                                 desc->function);
 839         if (desc->flags & _DPRINTK_FLAGS_INCL_SOURCENAME)
 840                 pos += snprintf(buf + pos, remaining(pos), "%s:",
 841                                 trim_prefix(desc->filename));
 842         if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
 843                 pos += snprintf(buf + pos, remaining(pos), "%d:",
 844                                 desc->lineno);
 845         if (pos - pos_after_tid)
 846                 pos += snprintf(buf + pos, remaining(pos), " ");
 847         if (pos >= PREFIX_SIZE)
 848                 buf[PREFIX_SIZE - 1] = '\0';
 849
 850         return buf;
 851 }
 852
 853 static inline char *dynamic_emit_prefix(struct _ddebug *desc, char *buf)
 854 {
 855         if (unlikely(desc->flags & _DPRINTK_FLAGS_INCL_ANY))
 856                 return __dynamic_emit_prefix(desc, buf);
 857         return buf;
 858 }
 859
 860 void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
 861 {
 862         va_list args;
 863         struct va_format vaf;
 864         char buf[PREFIX_SIZE] = "";
 865
 866         BUG_ON(!descriptor);
 867         BUG_ON(!fmt);
 868
 869         va_start(args, fmt);
 870
 871         vaf.fmt = fmt;
 872         vaf.va = &args;
 873
 874         printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
 875
 876         va_end(args);
 877 }
 878 EXPORT_SYMBOL(__dynamic_pr_debug);
 879
 880 void __dynamic_dev_dbg(struct _ddebug *descriptor,
 881                       const struct device *dev, const char *fmt, ...)
 882 {
 883         struct va_format vaf;
 884         va_list args;
 885
 886         BUG_ON(!descriptor);
 887         BUG_ON(!fmt);
 888
 889         va_start(args, fmt);
 890
 891         vaf.fmt = fmt;
 892         vaf.va = &args;
 893
 894         if (!dev) {
 895                 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
 896         } else {
 897                 char buf[PREFIX_SIZE] = "";
 898
 899                 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
 900                                 dynamic_emit_prefix(descriptor, buf),
 901                                 dev_driver_string(dev), dev_name(dev),
 902                                 &vaf);
 903         }
 904
 905         va_end(args);
 906 }
 907 EXPORT_SYMBOL(__dynamic_dev_dbg);
 908
 909 #ifdef CONFIG_NET
 910
 911 void __dynamic_netdev_dbg(struct _ddebug *descriptor,
 912                           const struct net_device *dev, const char *fmt, ...)
 913 {
 914         struct va_format vaf;
 915         va_list args;
 916
 917         BUG_ON(!descriptor);
 918         BUG_ON(!fmt);
 919
 920         va_start(args, fmt);
 921
 922         vaf.fmt = fmt;
 923         vaf.va = &args;
 924
 925         if (dev && dev->dev.parent) {
 926                 char buf[PREFIX_SIZE] = "";
 927
 928                 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
 929                                 "%s%s %s %s%s: %pV",
 930                                 dynamic_emit_prefix(descriptor, buf),
 931                                 dev_driver_string(dev->dev.parent),
 932                                 dev_name(dev->dev.parent),
 933                                 netdev_name(dev), netdev_reg_state(dev),
 934                                 &vaf);
 935         } else if (dev) {
 936                 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
 937                        netdev_reg_state(dev), &vaf);
 938         } else {
 939                 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
 940         }
 941
 942         va_end(args);
 943 }
 944 EXPORT_SYMBOL(__dynamic_netdev_dbg);
 945
 946 #endif
 947
 948 #if IS_ENABLED(CONFIG_INFINIBAND)
 949
 950 void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
 951                          const struct ib_device *ibdev, const char *fmt, ...)
 952 {
 953         struct va_format vaf;
 954         va_list args;
 955
 956         va_start(args, fmt);
 957
 958         vaf.fmt = fmt;
 959         vaf.va = &args;
 960
 961         if (ibdev && ibdev->dev.parent) {
 962                 char buf[PREFIX_SIZE] = "";
 963
 964                 dev_printk_emit(LOGLEVEL_DEBUG, ibdev->dev.parent,
 965                                 "%s%s %s %s: %pV",
 966                                 dynamic_emit_prefix(descriptor, buf),
 967                                 dev_driver_string(ibdev->dev.parent),
 968                                 dev_name(ibdev->dev.parent),
 969                                 dev_name(&ibdev->dev),
 970                                 &vaf);
 971         } else if (ibdev) {
 972                 printk(KERN_DEBUG "%s: %pV", dev_name(&ibdev->dev), &vaf);
 973         } else {
 974                 printk(KERN_DEBUG "(NULL ib_device): %pV", &vaf);
 975         }
 976
 977         va_end(args);
 978 }
 979 EXPORT_SYMBOL(__dynamic_ibdev_dbg);
 980
 981 #endif
 982
 983 /*
 984  * Install a noop handler to make dyndbg look like a normal kernel cli param.
 985  * This avoids warnings about dyndbg being an unknown cli param when supplied
 986  * by a user.
 987  */
 988 static __init int dyndbg_setup(char *str)
 989 {
 990         return 1;
 991 }
 992
 993 __setup("dyndbg=", dyndbg_setup);
 994
 995 /*
 996  * File_ops->write method for <debugfs>/dynamic_debug/control.  Gathers the
 997  * command text from userspace, parses and executes it.
 998  */
 999 #define USER_BUF_PAGE 4096
1000 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
1001                                   size_t len, loff_t *offp)
1002 {
1003         char *tmpbuf;
1004         int ret;
1005
1006         if (len == 0)
1007                 return 0;
1008         if (len > USER_BUF_PAGE - 1) {
1009                 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
1010                 return -E2BIG;
1011         }
1012         tmpbuf = memdup_user_nul(ubuf, len);
1013         if (IS_ERR(tmpbuf))
1014                 return PTR_ERR(tmpbuf);
1015         v2pr_info("read %zu bytes from userspace\n", len);
1016
1017         ret = ddebug_exec_queries(tmpbuf, NULL);
1018         kfree(tmpbuf);
1019         if (ret < 0)
1020                 return ret;
1021
1022         *offp += len;
1023         return len;
1024 }
1025
1026 /*
1027  * Set the iterator to point to the first _ddebug object
1028  * and return a pointer to that first object.  Returns
1029  * NULL if there are no _ddebugs at all.
1030  */
1031 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
1032 {
1033         if (list_empty(&ddebug_tables)) {
1034                 iter->table = NULL;
1035                 return NULL;
1036         }
1037         iter->table = list_entry(ddebug_tables.next,
1038                                  struct ddebug_table, link);
1039         iter->idx = iter->table->num_ddebugs;
1040         return &iter->table->ddebugs[--iter->idx];
1041 }
1042
1043 /*
1044  * Advance the iterator to point to the next _ddebug
1045  * object from the one the iterator currently points at,
1046  * and returns a pointer to the new _ddebug.  Returns
1047  * NULL if the iterator has seen all the _ddebugs.
1048  */
1049 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
1050 {
1051         if (iter->table == NULL)
1052                 return NULL;
1053         if (--iter->idx < 0) {
1054                 /* iterate to next table */
1055                 if (list_is_last(&iter->table->link, &ddebug_tables)) {
1056                         iter->table = NULL;
1057                         return NULL;
1058                 }
1059                 iter->table = list_entry(iter->table->link.next,
1060                                          struct ddebug_table, link);
1061                 iter->idx = iter->table->num_ddebugs;
1062                 --iter->idx;
1063         }
1064         return &iter->table->ddebugs[iter->idx];
1065 }
1066
1067 /*
1068  * Seq_ops start method.  Called at the start of every
1069  * read() call from userspace.  Takes the ddebug_lock and
1070  * seeks the seq_file's iterator to the given position.
1071  */
1072 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
1073 {
1074         struct ddebug_iter *iter = m->private;
1075         struct _ddebug *dp;
1076         int n = *pos;
1077
1078         mutex_lock(&ddebug_lock);
1079
1080         if (!n)
1081                 return SEQ_START_TOKEN;
1082         if (n < 0)
1083                 return NULL;
1084         dp = ddebug_iter_first(iter);
1085         while (dp != NULL && --n > 0)
1086                 dp = ddebug_iter_next(iter);
1087         return dp;
1088 }
1089
1090 /*
1091  * Seq_ops next method.  Called several times within a read()
1092  * call from userspace, with ddebug_lock held.  Walks to the
1093  * next _ddebug object with a special case for the header line.
1094  */
1095 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
1096 {
1097         struct ddebug_iter *iter = m->private;
1098         struct _ddebug *dp;
1099
1100         if (p == SEQ_START_TOKEN)
1101                 dp = ddebug_iter_first(iter);
1102         else
1103                 dp = ddebug_iter_next(iter);
1104         ++*pos;
1105         return dp;
1106 }
1107
1108 #define class_in_range(class_id, map)                                   \
1109         (class_id >= map->base && class_id < map->base + map->length)
1110
1111 static const char *ddebug_class_name(struct ddebug_iter *iter, struct _ddebug *dp)
1112 {
1113         struct ddebug_class_map *map;
1114
1115         list_for_each_entry(map, &iter->table->maps, link)
1116                 if (class_in_range(dp->class_id, map))
1117                         return map->class_names[dp->class_id - map->base];
1118
1119         return NULL;
1120 }
1121
1122 /*
1123  * Seq_ops show method.  Called several times within a read()
1124  * call from userspace, with ddebug_lock held.  Formats the
1125  * current _ddebug as a single human-readable line, with a
1126  * special case for the header line.
1127  */
1128 static int ddebug_proc_show(struct seq_file *m, void *p)
1129 {
1130         struct ddebug_iter *iter = m->private;
1131         struct _ddebug *dp = p;
1132         struct flagsbuf flags;
1133         char const *class;
1134
1135         if (p == SEQ_START_TOKEN) {
1136                 seq_puts(m,
1137                          "# filename:lineno [module]function flags format\n");
1138                 return 0;
1139         }
1140
1141         seq_printf(m, "%s:%u [%s]%s =%s \"",
1142                    trim_prefix(dp->filename), dp->lineno,
1143                    iter->table->mod_name, dp->function,
1144                    ddebug_describe_flags(dp->flags, &flags));
1145         seq_escape_str(m, dp->format, ESCAPE_SPACE, "\t\r\n\"");
1146         seq_puts(m, "\"");
1147
1148         if (dp->class_id != _DPRINTK_CLASS_DFLT) {
1149                 class = ddebug_class_name(iter, dp);
1150                 if (class)
1151                         seq_printf(m, " class:%s", class);
1152                 else
1153                         seq_printf(m, " class unknown, _id:%d", dp->class_id);
1154         }
1155         seq_puts(m, "\n");
1156
1157         return 0;
1158 }
1159
1160 /*
1161  * Seq_ops stop method.  Called at the end of each read()
1162  * call from userspace.  Drops ddebug_lock.
1163  */
1164 static void ddebug_proc_stop(struct seq_file *m, void *p)
1165 {
1166         mutex_unlock(&ddebug_lock);
1167 }
1168
1169 static const struct seq_operations ddebug_proc_seqops = {
1170         .start = ddebug_proc_start,
1171         .next = ddebug_proc_next,
1172         .show = ddebug_proc_show,
1173         .stop = ddebug_proc_stop
1174 };
1175
1176 static int ddebug_proc_open(struct inode *inode, struct file *file)
1177 {
1178         return seq_open_private(file, &ddebug_proc_seqops,
1179                                 sizeof(struct ddebug_iter));
1180 }
1181
1182 static const struct file_operations ddebug_proc_fops = {
1183         .owner = THIS_MODULE,
1184         .open = ddebug_proc_open,
1185         .read = seq_read,
1186         .llseek = seq_lseek,
1187         .release = seq_release_private,
1188         .write = ddebug_proc_write
1189 };
1190
1191 static const struct proc_ops proc_fops = {
1192         .proc_open = ddebug_proc_open,
1193         .proc_read = seq_read,
1194         .proc_lseek = seq_lseek,
1195         .proc_release = seq_release_private,
1196         .proc_write = ddebug_proc_write
1197 };
1198
1199 static void ddebug_attach_module_classes(struct ddebug_table *dt,
1200                                          struct ddebug_class_map *classes,
1201                                          int num_classes)
1202 {
1203         struct ddebug_class_map *cm;
1204         int i, j, ct = 0;
1205
1206         for (cm = classes, i = 0; i < num_classes; i++, cm++) {
1207
1208                 if (!strcmp(cm->mod_name, dt->mod_name)) {
1209
1210                         v2pr_info("class[%d]: module:%s base:%d len:%d ty:%d\n", i,
1211                                   cm->mod_name, cm->base, cm->length, cm->map_type);
1212
1213                         for (j = 0; j < cm->length; j++)
1214                                 v3pr_info(" %d: %d %s\n", j + cm->base, j,
1215                                           cm->class_names[j]);
1216
1217                         list_add(&cm->link, &dt->maps);
1218                         ct++;
1219                 }
1220         }
1221         if (ct)
1222                 vpr_info("module:%s attached %d classes\n", dt->mod_name, ct);
1223 }
1224
1225 /*
1226  * Allocate a new ddebug_table for the given module
1227  * and add it to the global list.
1228  */
1229 static int ddebug_add_module(struct _ddebug_info *di, const char *modname)
1230 {
1231         struct ddebug_table *dt;
1232
1233         v3pr_info("add-module: %s.%d sites\n", modname, di->num_descs);
1234         if (!di->num_descs) {
1235                 v3pr_info(" skip %s\n", modname);
1236                 return 0;
1237         }
1238
1239         dt = kzalloc(sizeof(*dt), GFP_KERNEL);
1240         if (dt == NULL) {
1241                 pr_err("error adding module: %s\n", modname);
1242                 return -ENOMEM;
1243         }
1244         /*
1245          * For built-in modules, name lives in .rodata and is
1246          * immortal. For loaded modules, name points at the name[]
1247          * member of struct module, which lives at least as long as
1248          * this struct ddebug_table.
1249          */
1250         dt->mod_name = modname;
1251         dt->ddebugs = di->descs;
1252         dt->num_ddebugs = di->num_descs;
1253
1254         INIT_LIST_HEAD(&dt->link);
1255         INIT_LIST_HEAD(&dt->maps);
1256
1257         if (di->classes && di->num_classes)
1258                 ddebug_attach_module_classes(dt, di->classes, di->num_classes);
1259
1260         mutex_lock(&ddebug_lock);
1261         list_add_tail(&dt->link, &ddebug_tables);
1262         mutex_unlock(&ddebug_lock);
1263
1264         vpr_info("%3u debug prints in module %s\n", di->num_descs, modname);
1265         return 0;
1266 }
1267
1268 /* helper for ddebug_dyndbg_(boot|module)_param_cb */
1269 static int ddebug_dyndbg_param_cb(char *param, char *val,
1270                                 const char *modname, int on_err)
1271 {
1272         char *sep;
1273
1274         sep = strchr(param, '.');
1275         if (sep) {
1276                 /* needed only for ddebug_dyndbg_boot_param_cb */
1277                 *sep = '\0';
1278                 modname = param;
1279                 param = sep + 1;
1280         }
1281         if (strcmp(param, "dyndbg"))
1282                 return on_err; /* determined by caller */
1283
1284         ddebug_exec_queries((val ? val : "+p"), modname);
1285
1286         return 0; /* query failure shouldn't stop module load */
1287 }
1288
1289 /* handle both dyndbg and $module.dyndbg params at boot */
1290 static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
1291                                 const char *unused, void *arg)
1292 {
1293         vpr_info("%s=\"%s\"\n", param, val);
1294         return ddebug_dyndbg_param_cb(param, val, NULL, 0);
1295 }
1296
1297 /*
1298  * modprobe foo finds foo.params in boot-args, strips "foo.", and
1299  * passes them to load_module().  This callback gets unknown params,
1300  * processes dyndbg params, rejects others.
1301  */
1302 int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
1303 {
1304         vpr_info("module: %s %s=\"%s\"\n", module, param, val);
1305         return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
1306 }
1307
1308 static void ddebug_table_free(struct ddebug_table *dt)
1309 {
1310         list_del_init(&dt->link);
1311         kfree(dt);
1312 }
1313
1314 #ifdef CONFIG_MODULES
1315
1316 /*
1317  * Called in response to a module being unloaded.  Removes
1318  * any ddebug_table's which point at the module.
1319  */
1320 static int ddebug_remove_module(const char *mod_name)
1321 {
1322         struct ddebug_table *dt, *nextdt;
1323         int ret = -ENOENT;
1324
1325         mutex_lock(&ddebug_lock);
1326         list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
1327                 if (dt->mod_name == mod_name) {
1328                         ddebug_table_free(dt);
1329                         ret = 0;
1330                         break;
1331                 }
1332         }
1333         mutex_unlock(&ddebug_lock);
1334         if (!ret)
1335                 v2pr_info("removed module \"%s\"\n", mod_name);
1336         return ret;
1337 }
1338
1339 static int ddebug_module_notify(struct notifier_block *self, unsigned long val,
1340                                 void *data)
1341 {
1342         struct module *mod = data;
1343         int ret = 0;
1344
1345         switch (val) {
1346         case MODULE_STATE_COMING:
1347                 ret = ddebug_add_module(&mod->dyndbg_info, mod->name);
1348                 if (ret)
1349                         WARN(1, "Failed to allocate memory: dyndbg may not work properly.\n");
1350                 break;
1351         case MODULE_STATE_GOING:
1352                 ddebug_remove_module(mod->name);
1353                 break;
1354         }
1355
1356         return notifier_from_errno(ret);
1357 }
1358
1359 static struct notifier_block ddebug_module_nb = {
1360         .notifier_call = ddebug_module_notify,
1361         .priority = 0, /* dynamic debug depends on jump label */
1362 };
1363
1364 #endif /* CONFIG_MODULES */
1365
1366 static void ddebug_remove_all_tables(void)
1367 {
1368         mutex_lock(&ddebug_lock);
1369         while (!list_empty(&ddebug_tables)) {
1370                 struct ddebug_table *dt = list_entry(ddebug_tables.next,
1371                                                       struct ddebug_table,
1372                                                       link);
1373                 ddebug_table_free(dt);
1374         }
1375         mutex_unlock(&ddebug_lock);
1376 }
1377
1378 static __initdata int ddebug_init_success;
1379
1380 static int __init dynamic_debug_init_control(void)
1381 {
1382         struct proc_dir_entry *procfs_dir;
1383         struct dentry *debugfs_dir;
1384
1385         if (!ddebug_init_success)
1386                 return -ENODEV;
1387
1388         /* Create the control file in debugfs if it is enabled */
1389         if (debugfs_initialized()) {
1390                 debugfs_dir = debugfs_create_dir("dynamic_debug", NULL);
1391                 debugfs_create_file("control", 0644, debugfs_dir, NULL,
1392                                     &ddebug_proc_fops);
1393         }
1394
1395         /* Also create the control file in procfs */
1396         procfs_dir = proc_mkdir("dynamic_debug", NULL);
1397         if (procfs_dir)
1398                 proc_create("control", 0644, procfs_dir, &proc_fops);
1399
1400         return 0;
1401 }
1402
1403 static int __init dynamic_debug_init(void)
1404 {
1405         struct _ddebug *iter, *iter_mod_start;
1406         int ret, i, mod_sites, mod_ct;
1407         const char *modname;
1408         char *cmdline;
1409
1410         struct _ddebug_info di = {
1411                 .descs = __start___dyndbg,
1412                 .classes = __start___dyndbg_classes,
1413                 .num_descs = __stop___dyndbg - __start___dyndbg,
1414                 .num_classes = __stop___dyndbg_classes - __start___dyndbg_classes,
1415         };
1416
1417 #ifdef CONFIG_MODULES
1418         ret = register_module_notifier(&ddebug_module_nb);
1419         if (ret) {
1420                 pr_warn("Failed to register dynamic debug module notifier\n");
1421                 return ret;
1422         }
1423 #endif /* CONFIG_MODULES */
1424
1425         if (&__start___dyndbg == &__stop___dyndbg) {
1426                 if (IS_ENABLED(CONFIG_DYNAMIC_DEBUG)) {
1427                         pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
1428                         return 1;
1429                 }
1430                 pr_info("Ignore empty _ddebug table in a CONFIG_DYNAMIC_DEBUG_CORE build\n");
1431                 ddebug_init_success = 1;
1432                 return 0;
1433         }
1434
1435         iter = iter_mod_start = __start___dyndbg;
1436         modname = iter->modname;
1437         i = mod_sites = mod_ct = 0;
1438
1439         for (; iter < __stop___dyndbg; iter++, i++, mod_sites++) {
1440
1441                 if (strcmp(modname, iter->modname)) {
1442                         mod_ct++;
1443                         di.num_descs = mod_sites;
1444                         di.descs = iter_mod_start;
1445                         ret = ddebug_add_module(&di, modname);
1446                         if (ret)
1447                                 goto out_err;
1448
1449                         mod_sites = 0;
1450                         modname = iter->modname;
1451                         iter_mod_start = iter;
1452                 }
1453         }
1454         di.num_descs = mod_sites;
1455         di.descs = iter_mod_start;
1456         ret = ddebug_add_module(&di, modname);
1457         if (ret)
1458                 goto out_err;
1459
1460         ddebug_init_success = 1;
1461         vpr_info("%d prdebugs in %d modules, %d KiB in ddebug tables, %d kiB in __dyndbg section\n",
1462                  i, mod_ct, (int)((mod_ct * sizeof(struct ddebug_table)) >> 10),
1463                  (int)((i * sizeof(struct _ddebug)) >> 10));
1464
1465         if (di.num_classes)
1466                 v2pr_info("  %d builtin ddebug class-maps\n", di.num_classes);
1467
1468         /* now that ddebug tables are loaded, process all boot args
1469          * again to find and activate queries given in dyndbg params.
1470          * While this has already been done for known boot params, it
1471          * ignored the unknown ones (dyndbg in particular).  Reusing
1472          * parse_args avoids ad-hoc parsing.  This will also attempt
1473          * to activate queries for not-yet-loaded modules, which is
1474          * slightly noisy if verbose, but harmless.
1475          */
1476         cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1477         parse_args("dyndbg params", cmdline, NULL,
1478                    0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
1479         kfree(cmdline);
1480         return 0;
1481
1482 out_err:
1483         ddebug_remove_all_tables();
1484         return 0;
1485 }
1486 /* Allow early initialization for boot messages via boot param */
1487 early_initcall(dynamic_debug_init);
1488
1489 /* Debugfs setup must be done later */
1490 fs_initcall(dynamic_debug_init_control);