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(instr, GFP_KERNEL);
 644         p = strchr(cl_str, '\n');
 645         if (p)
 646                 *p = '\0';
 647
 648         /* start with previously set state-bits, then modify */
 649         curr_bits = old_bits = *dcp->bits;
 650         vpr_info("\"%s\" > %s:0x%lx\n", cl_str, KP_NAME(kp), curr_bits);
 651
 652         for (; cl_str; cl_str = p) {
 653                 p = strchr(cl_str, ',');
 654                 if (p)
 655                         *p++ = '\0';
 656
 657                 if (*cl_str == '-') {
 658                         wanted = false;
 659                         cl_str++;
 660                 } else {
 661                         wanted = true;
 662                         if (*cl_str == '+')
 663                                 cl_str++;
 664                 }
 665                 cls_id = match_string(map->class_names, map->length, cl_str);
 666                 if (cls_id < 0) {
 667                         pr_err("%s unknown to %s\n", cl_str, KP_NAME(kp));
 668                         continue;
 669                 }
 670
 671                 /* have one or more valid class_ids of one *_NAMES type */
 672                 switch (map->map_type) {
 673                 case DD_CLASS_TYPE_DISJOINT_NAMES:
 674                         /* the +/- pertains to a single bit */
 675                         if (test_bit(cls_id, &curr_bits) == wanted) {
 676                                 v3pr_info("no change on %s\n", cl_str);
 677                                 continue;
 678                         }
 679                         curr_bits ^= BIT(cls_id);
 680                         totct += ddebug_apply_class_bitmap(dcp, &curr_bits, dcp->bits);
 681                         *dcp->bits = curr_bits;
 682                         v2pr_info("%s: changed bit %d:%s\n", KP_NAME(kp), cls_id,
 683                                   map->class_names[cls_id]);
 684                         break;
 685                 case DD_CLASS_TYPE_LEVEL_NAMES:
 686                         /* cls_id = N in 0..max. wanted +/- determines N or N-1 */
 687                         old_bits = CLASSMAP_BITMASK(*dcp->lvl);
 688                         curr_bits = CLASSMAP_BITMASK(cls_id + (wanted ? 1 : 0 ));
 689
 690                         totct += ddebug_apply_class_bitmap(dcp, &curr_bits, &old_bits);
 691                         *dcp->lvl = (cls_id + (wanted ? 1 : 0));
 692                         v2pr_info("%s: changed bit-%d: \"%s\" %lx->%lx\n", KP_NAME(kp), cls_id,
 693                                   map->class_names[cls_id], old_bits, curr_bits);
 694                         break;
 695                 default:
 696                         pr_err("illegal map-type value %d\n", map->map_type);
 697                 }
 698         }
 699         kfree(tmp);
 700         vpr_info("total matches: %d\n", totct);
 701         return 0;
 702 }
 703
 704 /**
 705  * param_set_dyndbg_classes - class FOO >control
 706  * @instr: string echo>d to sysfs, input depends on map_type
 707  * @kp:    kp->arg has state: bits/lvl, map, map_type
 708  *
 709  * Enable/disable prdbgs by their class, as given in the arguments to
 710  * DECLARE_DYNDBG_CLASSMAP.  For LEVEL map-types, enforce relative
 711  * levels by bitpos.
 712  *
 713  * Returns: 0 or <0 if error.
 714  */
 715 int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp)
 716 {
 717         const struct ddebug_class_param *dcp = kp->arg;
 718         const struct ddebug_class_map *map = dcp->map;
 719         unsigned long inrep, new_bits, old_bits;
 720         int rc, totct = 0;
 721
 722         switch (map->map_type) {
 723
 724         case DD_CLASS_TYPE_DISJOINT_NAMES:
 725         case DD_CLASS_TYPE_LEVEL_NAMES:
 726                 /* handle [+-]classnames list separately, we are done here */
 727                 return param_set_dyndbg_classnames(instr, kp);
 728
 729         case DD_CLASS_TYPE_DISJOINT_BITS:
 730         case DD_CLASS_TYPE_LEVEL_NUM:
 731                 /* numeric input, accept and fall-thru */
 732                 rc = kstrtoul(instr, 0, &inrep);
 733                 if (rc) {
 734                         pr_err("expecting numeric input: %s > %s\n", instr, KP_NAME(kp));
 735                         return -EINVAL;
 736                 }
 737                 break;
 738         default:
 739                 pr_err("%s: bad map type: %d\n", KP_NAME(kp), map->map_type);
 740                 return -EINVAL;
 741         }
 742
 743         /* only _BITS,_NUM (numeric) map-types get here */
 744         switch (map->map_type) {
 745         case DD_CLASS_TYPE_DISJOINT_BITS:
 746                 /* expect bits. mask and warn if too many */
 747                 if (inrep & ~CLASSMAP_BITMASK(map->length)) {
 748                         pr_warn("%s: input: 0x%lx exceeds mask: 0x%lx, masking\n",
 749                                 KP_NAME(kp), inrep, CLASSMAP_BITMASK(map->length));
 750                         inrep &= CLASSMAP_BITMASK(map->length);
 751                 }
 752                 v2pr_info("bits:%lx > %s\n", inrep, KP_NAME(kp));
 753                 totct += ddebug_apply_class_bitmap(dcp, &inrep, dcp->bits);
 754                 *dcp->bits = inrep;
 755                 break;
 756         case DD_CLASS_TYPE_LEVEL_NUM:
 757                 /* input is bitpos, of highest verbosity to be enabled */
 758                 if (inrep > map->length) {
 759                         pr_warn("%s: level:%ld exceeds max:%d, clamping\n",
 760                                 KP_NAME(kp), inrep, map->length);
 761                         inrep = map->length;
 762                 }
 763                 old_bits = CLASSMAP_BITMASK(*dcp->lvl);
 764                 new_bits = CLASSMAP_BITMASK(inrep);
 765                 v2pr_info("lvl:%ld bits:0x%lx > %s\n", inrep, new_bits, KP_NAME(kp));
 766                 totct += ddebug_apply_class_bitmap(dcp, &new_bits, &old_bits);
 767                 *dcp->lvl = inrep;
 768                 break;
 769         default:
 770                 pr_warn("%s: bad map type: %d\n", KP_NAME(kp), map->map_type);
 771         }
 772         vpr_info("%s: total matches: %d\n", KP_NAME(kp), totct);
 773         return 0;
 774 }
 775 EXPORT_SYMBOL(param_set_dyndbg_classes);
 776
 777 /**
 778  * param_get_dyndbg_classes - classes reader
 779  * @buffer: string description of controlled bits -> classes
 780  * @kp:     kp->arg has state: bits, map
 781  *
 782  * Reads last written state, underlying prdbg state may have been
 783  * altered by direct >control.  Displays 0x for DISJOINT, 0-N for
 784  * LEVEL Returns: #chars written or <0 on error
 785  */
 786 int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp)
 787 {
 788         const struct ddebug_class_param *dcp = kp->arg;
 789         const struct ddebug_class_map *map = dcp->map;
 790
 791         switch (map->map_type) {
 792
 793         case DD_CLASS_TYPE_DISJOINT_NAMES:
 794         case DD_CLASS_TYPE_DISJOINT_BITS:
 795                 return scnprintf(buffer, PAGE_SIZE, "0x%lx\n", *dcp->bits);
 796
 797         case DD_CLASS_TYPE_LEVEL_NAMES:
 798         case DD_CLASS_TYPE_LEVEL_NUM:
 799                 return scnprintf(buffer, PAGE_SIZE, "%d\n", *dcp->lvl);
 800         default:
 801                 return -1;
 802         }
 803 }
 804 EXPORT_SYMBOL(param_get_dyndbg_classes);
 805
 806 const struct kernel_param_ops param_ops_dyndbg_classes = {
 807         .set = param_set_dyndbg_classes,
 808         .get = param_get_dyndbg_classes,
 809 };
 810 EXPORT_SYMBOL(param_ops_dyndbg_classes);
 811
 812 #define PREFIX_SIZE 128
 813
 814 static int remaining(int wrote)
 815 {
 816         if (PREFIX_SIZE - wrote > 0)
 817                 return PREFIX_SIZE - wrote;
 818         return 0;
 819 }
 820
 821 static char *__dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
 822 {
 823         int pos_after_tid;
 824         int pos = 0;
 825
 826         if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
 827                 if (in_interrupt())
 828                         pos += snprintf(buf + pos, remaining(pos), "<intr> ");
 829                 else
 830                         pos += snprintf(buf + pos, remaining(pos), "[%d] ",
 831                                         task_pid_vnr(current));
 832         }
 833         pos_after_tid = pos;
 834         if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
 835                 pos += snprintf(buf + pos, remaining(pos), "%s:",
 836                                 desc->modname);
 837         if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
 838                 pos += snprintf(buf + pos, remaining(pos), "%s:",
 839                                 desc->function);
 840         if (desc->flags & _DPRINTK_FLAGS_INCL_SOURCENAME)
 841                 pos += snprintf(buf + pos, remaining(pos), "%s:",
 842                                 trim_prefix(desc->filename));
 843         if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
 844                 pos += snprintf(buf + pos, remaining(pos), "%d:",
 845                                 desc->lineno);
 846         if (pos - pos_after_tid)
 847                 pos += snprintf(buf + pos, remaining(pos), " ");
 848         if (pos >= PREFIX_SIZE)
 849                 buf[PREFIX_SIZE - 1] = '\0';
 850
 851         return buf;
 852 }
 853
 854 static inline char *dynamic_emit_prefix(struct _ddebug *desc, char *buf)
 855 {
 856         if (unlikely(desc->flags & _DPRINTK_FLAGS_INCL_ANY))
 857                 return __dynamic_emit_prefix(desc, buf);
 858         return buf;
 859 }
 860
 861 void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
 862 {
 863         va_list args;
 864         struct va_format vaf;
 865         char buf[PREFIX_SIZE] = "";
 866
 867         BUG_ON(!descriptor);
 868         BUG_ON(!fmt);
 869
 870         va_start(args, fmt);
 871
 872         vaf.fmt = fmt;
 873         vaf.va = &args;
 874
 875         printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
 876
 877         va_end(args);
 878 }
 879 EXPORT_SYMBOL(__dynamic_pr_debug);
 880
 881 void __dynamic_dev_dbg(struct _ddebug *descriptor,
 882                       const struct device *dev, const char *fmt, ...)
 883 {
 884         struct va_format vaf;
 885         va_list args;
 886
 887         BUG_ON(!descriptor);
 888         BUG_ON(!fmt);
 889
 890         va_start(args, fmt);
 891
 892         vaf.fmt = fmt;
 893         vaf.va = &args;
 894
 895         if (!dev) {
 896                 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
 897         } else {
 898                 char buf[PREFIX_SIZE] = "";
 899
 900                 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
 901                                 dynamic_emit_prefix(descriptor, buf),
 902                                 dev_driver_string(dev), dev_name(dev),
 903                                 &vaf);
 904         }
 905
 906         va_end(args);
 907 }
 908 EXPORT_SYMBOL(__dynamic_dev_dbg);
 909
 910 #ifdef CONFIG_NET
 911
 912 void __dynamic_netdev_dbg(struct _ddebug *descriptor,
 913                           const struct net_device *dev, const char *fmt, ...)
 914 {
 915         struct va_format vaf;
 916         va_list args;
 917
 918         BUG_ON(!descriptor);
 919         BUG_ON(!fmt);
 920
 921         va_start(args, fmt);
 922
 923         vaf.fmt = fmt;
 924         vaf.va = &args;
 925
 926         if (dev && dev->dev.parent) {
 927                 char buf[PREFIX_SIZE] = "";
 928
 929                 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
 930                                 "%s%s %s %s%s: %pV",
 931                                 dynamic_emit_prefix(descriptor, buf),
 932                                 dev_driver_string(dev->dev.parent),
 933                                 dev_name(dev->dev.parent),
 934                                 netdev_name(dev), netdev_reg_state(dev),
 935                                 &vaf);
 936         } else if (dev) {
 937                 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
 938                        netdev_reg_state(dev), &vaf);
 939         } else {
 940                 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
 941         }
 942
 943         va_end(args);
 944 }
 945 EXPORT_SYMBOL(__dynamic_netdev_dbg);
 946
 947 #endif
 948
 949 #if IS_ENABLED(CONFIG_INFINIBAND)
 950
 951 void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
 952                          const struct ib_device *ibdev, const char *fmt, ...)
 953 {
 954         struct va_format vaf;
 955         va_list args;
 956
 957         va_start(args, fmt);
 958
 959         vaf.fmt = fmt;
 960         vaf.va = &args;
 961
 962         if (ibdev && ibdev->dev.parent) {
 963                 char buf[PREFIX_SIZE] = "";
 964
 965                 dev_printk_emit(LOGLEVEL_DEBUG, ibdev->dev.parent,
 966                                 "%s%s %s %s: %pV",
 967                                 dynamic_emit_prefix(descriptor, buf),
 968                                 dev_driver_string(ibdev->dev.parent),
 969                                 dev_name(ibdev->dev.parent),
 970                                 dev_name(&ibdev->dev),
 971                                 &vaf);
 972         } else if (ibdev) {
 973                 printk(KERN_DEBUG "%s: %pV", dev_name(&ibdev->dev), &vaf);
 974         } else {
 975                 printk(KERN_DEBUG "(NULL ib_device): %pV", &vaf);
 976         }
 977
 978         va_end(args);
 979 }
 980 EXPORT_SYMBOL(__dynamic_ibdev_dbg);
 981
 982 #endif
 983
 984 /*
 985  * Install a noop handler to make dyndbg look like a normal kernel cli param.
 986  * This avoids warnings about dyndbg being an unknown cli param when supplied
 987  * by a user.
 988  */
 989 static __init int dyndbg_setup(char *str)
 990 {
 991         return 1;
 992 }
 993
 994 __setup("dyndbg=", dyndbg_setup);
 995
 996 /*
 997  * File_ops->write method for <debugfs>/dynamic_debug/control.  Gathers the
 998  * command text from userspace, parses and executes it.
 999  */
1000 #define USER_BUF_PAGE 4096
1001 static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
1002                                   size_t len, loff_t *offp)
1003 {
1004         char *tmpbuf;
1005         int ret;
1006
1007         if (len == 0)
1008                 return 0;
1009         if (len > USER_BUF_PAGE - 1) {
1010                 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
1011                 return -E2BIG;
1012         }
1013         tmpbuf = memdup_user_nul(ubuf, len);
1014         if (IS_ERR(tmpbuf))
1015                 return PTR_ERR(tmpbuf);
1016         v2pr_info("read %zu bytes from userspace\n", len);
1017
1018         ret = ddebug_exec_queries(tmpbuf, NULL);
1019         kfree(tmpbuf);
1020         if (ret < 0)
1021                 return ret;
1022
1023         *offp += len;
1024         return len;
1025 }
1026
1027 /*
1028  * Set the iterator to point to the first _ddebug object
1029  * and return a pointer to that first object.  Returns
1030  * NULL if there are no _ddebugs at all.
1031  */
1032 static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
1033 {
1034         if (list_empty(&ddebug_tables)) {
1035                 iter->table = NULL;
1036                 return NULL;
1037         }
1038         iter->table = list_entry(ddebug_tables.next,
1039                                  struct ddebug_table, link);
1040         iter->idx = iter->table->num_ddebugs;
1041         return &iter->table->ddebugs[--iter->idx];
1042 }
1043
1044 /*
1045  * Advance the iterator to point to the next _ddebug
1046  * object from the one the iterator currently points at,
1047  * and returns a pointer to the new _ddebug.  Returns
1048  * NULL if the iterator has seen all the _ddebugs.
1049  */
1050 static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
1051 {
1052         if (iter->table == NULL)
1053                 return NULL;
1054         if (--iter->idx < 0) {
1055                 /* iterate to next table */
1056                 if (list_is_last(&iter->table->link, &ddebug_tables)) {
1057                         iter->table = NULL;
1058                         return NULL;
1059                 }
1060                 iter->table = list_entry(iter->table->link.next,
1061                                          struct ddebug_table, link);
1062                 iter->idx = iter->table->num_ddebugs;
1063                 --iter->idx;
1064         }
1065         return &iter->table->ddebugs[iter->idx];
1066 }
1067
1068 /*
1069  * Seq_ops start method.  Called at the start of every
1070  * read() call from userspace.  Takes the ddebug_lock and
1071  * seeks the seq_file's iterator to the given position.
1072  */
1073 static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
1074 {
1075         struct ddebug_iter *iter = m->private;
1076         struct _ddebug *dp;
1077         int n = *pos;
1078
1079         mutex_lock(&ddebug_lock);
1080
1081         if (!n)
1082                 return SEQ_START_TOKEN;
1083         if (n < 0)
1084                 return NULL;
1085         dp = ddebug_iter_first(iter);
1086         while (dp != NULL && --n > 0)
1087                 dp = ddebug_iter_next(iter);
1088         return dp;
1089 }
1090
1091 /*
1092  * Seq_ops next method.  Called several times within a read()
1093  * call from userspace, with ddebug_lock held.  Walks to the
1094  * next _ddebug object with a special case for the header line.
1095  */
1096 static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
1097 {
1098         struct ddebug_iter *iter = m->private;
1099         struct _ddebug *dp;
1100
1101         if (p == SEQ_START_TOKEN)
1102                 dp = ddebug_iter_first(iter);
1103         else
1104                 dp = ddebug_iter_next(iter);
1105         ++*pos;
1106         return dp;
1107 }
1108
1109 #define class_in_range(class_id, map)                                   \
1110         (class_id >= map->base && class_id < map->base + map->length)
1111
1112 static const char *ddebug_class_name(struct ddebug_iter *iter, struct _ddebug *dp)
1113 {
1114         struct ddebug_class_map *map;
1115
1116         list_for_each_entry(map, &iter->table->maps, link)
1117                 if (class_in_range(dp->class_id, map))
1118                         return map->class_names[dp->class_id - map->base];
1119
1120         return NULL;
1121 }
1122
1123 /*
1124  * Seq_ops show method.  Called several times within a read()
1125  * call from userspace, with ddebug_lock held.  Formats the
1126  * current _ddebug as a single human-readable line, with a
1127  * special case for the header line.
1128  */
1129 static int ddebug_proc_show(struct seq_file *m, void *p)
1130 {
1131         struct ddebug_iter *iter = m->private;
1132         struct _ddebug *dp = p;
1133         struct flagsbuf flags;
1134         char const *class;
1135
1136         if (p == SEQ_START_TOKEN) {
1137                 seq_puts(m,
1138                          "# filename:lineno [module]function flags format\n");
1139                 return 0;
1140         }
1141
1142         seq_printf(m, "%s:%u [%s]%s =%s \"",
1143                    trim_prefix(dp->filename), dp->lineno,
1144                    iter->table->mod_name, dp->function,
1145                    ddebug_describe_flags(dp->flags, &flags));
1146         seq_escape_str(m, dp->format, ESCAPE_SPACE, "\t\r\n\"");
1147         seq_puts(m, "\"");
1148
1149         if (dp->class_id != _DPRINTK_CLASS_DFLT) {
1150                 class = ddebug_class_name(iter, dp);
1151                 if (class)
1152                         seq_printf(m, " class:%s", class);
1153                 else
1154                         seq_printf(m, " class unknown, _id:%d", dp->class_id);
1155         }
1156         seq_puts(m, "\n");
1157
1158         return 0;
1159 }
1160
1161 /*
1162  * Seq_ops stop method.  Called at the end of each read()
1163  * call from userspace.  Drops ddebug_lock.
1164  */
1165 static void ddebug_proc_stop(struct seq_file *m, void *p)
1166 {
1167         mutex_unlock(&ddebug_lock);
1168 }
1169
1170 static const struct seq_operations ddebug_proc_seqops = {
1171         .start = ddebug_proc_start,
1172         .next = ddebug_proc_next,
1173         .show = ddebug_proc_show,
1174         .stop = ddebug_proc_stop
1175 };
1176
1177 static int ddebug_proc_open(struct inode *inode, struct file *file)
1178 {
1179         return seq_open_private(file, &ddebug_proc_seqops,
1180                                 sizeof(struct ddebug_iter));
1181 }
1182
1183 static const struct file_operations ddebug_proc_fops = {
1184         .owner = THIS_MODULE,
1185         .open = ddebug_proc_open,
1186         .read = seq_read,
1187         .llseek = seq_lseek,
1188         .release = seq_release_private,
1189         .write = ddebug_proc_write
1190 };
1191
1192 static const struct proc_ops proc_fops = {
1193         .proc_open = ddebug_proc_open,
1194         .proc_read = seq_read,
1195         .proc_lseek = seq_lseek,
1196         .proc_release = seq_release_private,
1197         .proc_write = ddebug_proc_write
1198 };
1199
1200 static void ddebug_attach_module_classes(struct ddebug_table *dt,
1201                                          struct ddebug_class_map *classes,
1202                                          int num_classes)
1203 {
1204         struct ddebug_class_map *cm;
1205         int i, j, ct = 0;
1206
1207         for (cm = classes, i = 0; i < num_classes; i++, cm++) {
1208
1209                 if (!strcmp(cm->mod_name, dt->mod_name)) {
1210
1211                         v2pr_info("class[%d]: module:%s base:%d len:%d ty:%d\n", i,
1212                                   cm->mod_name, cm->base, cm->length, cm->map_type);
1213
1214                         for (j = 0; j < cm->length; j++)
1215                                 v3pr_info(" %d: %d %s\n", j + cm->base, j,
1216                                           cm->class_names[j]);
1217
1218                         list_add(&cm->link, &dt->maps);
1219                         ct++;
1220                 }
1221         }
1222         if (ct)
1223                 vpr_info("module:%s attached %d classes\n", dt->mod_name, ct);
1224 }
1225
1226 /*
1227  * Allocate a new ddebug_table for the given module
1228  * and add it to the global list.
1229  */
1230 static int ddebug_add_module(struct _ddebug_info *di, const char *modname)
1231 {
1232         struct ddebug_table *dt;
1233
1234         v3pr_info("add-module: %s.%d sites\n", modname, di->num_descs);
1235         if (!di->num_descs) {
1236                 v3pr_info(" skip %s\n", modname);
1237                 return 0;
1238         }
1239
1240         dt = kzalloc(sizeof(*dt), GFP_KERNEL);
1241         if (dt == NULL) {
1242                 pr_err("error adding module: %s\n", modname);
1243                 return -ENOMEM;
1244         }
1245         /*
1246          * For built-in modules, name lives in .rodata and is
1247          * immortal. For loaded modules, name points at the name[]
1248          * member of struct module, which lives at least as long as
1249          * this struct ddebug_table.
1250          */
1251         dt->mod_name = modname;
1252         dt->ddebugs = di->descs;
1253         dt->num_ddebugs = di->num_descs;
1254
1255         INIT_LIST_HEAD(&dt->link);
1256         INIT_LIST_HEAD(&dt->maps);
1257
1258         if (di->classes && di->num_classes)
1259                 ddebug_attach_module_classes(dt, di->classes, di->num_classes);
1260
1261         mutex_lock(&ddebug_lock);
1262         list_add_tail(&dt->link, &ddebug_tables);
1263         mutex_unlock(&ddebug_lock);
1264
1265         vpr_info("%3u debug prints in module %s\n", di->num_descs, modname);
1266         return 0;
1267 }
1268
1269 /* helper for ddebug_dyndbg_(boot|module)_param_cb */
1270 static int ddebug_dyndbg_param_cb(char *param, char *val,
1271                                 const char *modname, int on_err)
1272 {
1273         char *sep;
1274
1275         sep = strchr(param, '.');
1276         if (sep) {
1277                 /* needed only for ddebug_dyndbg_boot_param_cb */
1278                 *sep = '\0';
1279                 modname = param;
1280                 param = sep + 1;
1281         }
1282         if (strcmp(param, "dyndbg"))
1283                 return on_err; /* determined by caller */
1284
1285         ddebug_exec_queries((val ? val : "+p"), modname);
1286
1287         return 0; /* query failure shouldn't stop module load */
1288 }
1289
1290 /* handle both dyndbg and $module.dyndbg params at boot */
1291 static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
1292                                 const char *unused, void *arg)
1293 {
1294         vpr_info("%s=\"%s\"\n", param, val);
1295         return ddebug_dyndbg_param_cb(param, val, NULL, 0);
1296 }
1297
1298 /*
1299  * modprobe foo finds foo.params in boot-args, strips "foo.", and
1300  * passes them to load_module().  This callback gets unknown params,
1301  * processes dyndbg params, rejects others.
1302  */
1303 int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
1304 {
1305         vpr_info("module: %s %s=\"%s\"\n", module, param, val);
1306         return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
1307 }
1308
1309 static void ddebug_table_free(struct ddebug_table *dt)
1310 {
1311         list_del_init(&dt->link);
1312         kfree(dt);
1313 }
1314
1315 #ifdef CONFIG_MODULES
1316
1317 /*
1318  * Called in response to a module being unloaded.  Removes
1319  * any ddebug_table's which point at the module.
1320  */
1321 static int ddebug_remove_module(const char *mod_name)
1322 {
1323         struct ddebug_table *dt, *nextdt;
1324         int ret = -ENOENT;
1325
1326         mutex_lock(&ddebug_lock);
1327         list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
1328                 if (dt->mod_name == mod_name) {
1329                         ddebug_table_free(dt);
1330                         ret = 0;
1331                         break;
1332                 }
1333         }
1334         mutex_unlock(&ddebug_lock);
1335         if (!ret)
1336                 v2pr_info("removed module \"%s\"\n", mod_name);
1337         return ret;
1338 }
1339
1340 static int ddebug_module_notify(struct notifier_block *self, unsigned long val,
1341                                 void *data)
1342 {
1343         struct module *mod = data;
1344         int ret = 0;
1345
1346         switch (val) {
1347         case MODULE_STATE_COMING:
1348                 ret = ddebug_add_module(&mod->dyndbg_info, mod->name);
1349                 if (ret)
1350                         WARN(1, "Failed to allocate memory: dyndbg may not work properly.\n");
1351                 break;
1352         case MODULE_STATE_GOING:
1353                 ddebug_remove_module(mod->name);
1354                 break;
1355         }
1356
1357         return notifier_from_errno(ret);
1358 }
1359
1360 static struct notifier_block ddebug_module_nb = {
1361         .notifier_call = ddebug_module_notify,
1362         .priority = 0, /* dynamic debug depends on jump label */
1363 };
1364
1365 #endif /* CONFIG_MODULES */
1366
1367 static void ddebug_remove_all_tables(void)
1368 {
1369         mutex_lock(&ddebug_lock);
1370         while (!list_empty(&ddebug_tables)) {
1371                 struct ddebug_table *dt = list_entry(ddebug_tables.next,
1372                                                       struct ddebug_table,
1373                                                       link);
1374                 ddebug_table_free(dt);
1375         }
1376         mutex_unlock(&ddebug_lock);
1377 }
1378
1379 static __initdata int ddebug_init_success;
1380
1381 static int __init dynamic_debug_init_control(void)
1382 {
1383         struct proc_dir_entry *procfs_dir;
1384         struct dentry *debugfs_dir;
1385
1386         if (!ddebug_init_success)
1387                 return -ENODEV;
1388
1389         /* Create the control file in debugfs if it is enabled */
1390         if (debugfs_initialized()) {
1391                 debugfs_dir = debugfs_create_dir("dynamic_debug", NULL);
1392                 debugfs_create_file("control", 0644, debugfs_dir, NULL,
1393                                     &ddebug_proc_fops);
1394         }
1395
1396         /* Also create the control file in procfs */
1397         procfs_dir = proc_mkdir("dynamic_debug", NULL);
1398         if (procfs_dir)
1399                 proc_create("control", 0644, procfs_dir, &proc_fops);
1400
1401         return 0;
1402 }
1403
1404 static int __init dynamic_debug_init(void)
1405 {
1406         struct _ddebug *iter, *iter_mod_start;
1407         int ret, i, mod_sites, mod_ct;
1408         const char *modname;
1409         char *cmdline;
1410
1411         struct _ddebug_info di = {
1412                 .descs = __start___dyndbg,
1413                 .classes = __start___dyndbg_classes,
1414                 .num_descs = __stop___dyndbg - __start___dyndbg,
1415                 .num_classes = __stop___dyndbg_classes - __start___dyndbg_classes,
1416         };
1417
1418 #ifdef CONFIG_MODULES
1419         ret = register_module_notifier(&ddebug_module_nb);
1420         if (ret) {
1421                 pr_warn("Failed to register dynamic debug module notifier\n");
1422                 return ret;
1423         }
1424 #endif /* CONFIG_MODULES */
1425
1426         if (&__start___dyndbg == &__stop___dyndbg) {
1427                 if (IS_ENABLED(CONFIG_DYNAMIC_DEBUG)) {
1428                         pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
1429                         return 1;
1430                 }
1431                 pr_info("Ignore empty _ddebug table in a CONFIG_DYNAMIC_DEBUG_CORE build\n");
1432                 ddebug_init_success = 1;
1433                 return 0;
1434         }
1435
1436         iter = iter_mod_start = __start___dyndbg;
1437         modname = iter->modname;
1438         i = mod_sites = mod_ct = 0;
1439
1440         for (; iter < __stop___dyndbg; iter++, i++, mod_sites++) {
1441
1442                 if (strcmp(modname, iter->modname)) {
1443                         mod_ct++;
1444                         di.num_descs = mod_sites;
1445                         di.descs = iter_mod_start;
1446                         ret = ddebug_add_module(&di, modname);
1447                         if (ret)
1448                                 goto out_err;
1449
1450                         mod_sites = 0;
1451                         modname = iter->modname;
1452                         iter_mod_start = iter;
1453                 }
1454         }
1455         di.num_descs = mod_sites;
1456         di.descs = iter_mod_start;
1457         ret = ddebug_add_module(&di, modname);
1458         if (ret)
1459                 goto out_err;
1460
1461         ddebug_init_success = 1;
1462         vpr_info("%d prdebugs in %d modules, %d KiB in ddebug tables, %d kiB in __dyndbg section\n",
1463                  i, mod_ct, (int)((mod_ct * sizeof(struct ddebug_table)) >> 10),
1464                  (int)((i * sizeof(struct _ddebug)) >> 10));
1465
1466         if (di.num_classes)
1467                 v2pr_info("  %d builtin ddebug class-maps\n", di.num_classes);
1468
1469         /* now that ddebug tables are loaded, process all boot args
1470          * again to find and activate queries given in dyndbg params.
1471          * While this has already been done for known boot params, it
1472          * ignored the unknown ones (dyndbg in particular).  Reusing
1473          * parse_args avoids ad-hoc parsing.  This will also attempt
1474          * to activate queries for not-yet-loaded modules, which is
1475          * slightly noisy if verbose, but harmless.
1476          */
1477         cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1478         parse_args("dyndbg params", cmdline, NULL,
1479                    0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
1480         kfree(cmdline);
1481         return 0;
1482
1483 out_err:
1484         ddebug_remove_all_tables();
1485         return 0;
1486 }
1487 /* Allow early initialization for boot messages via boot param */
1488 early_initcall(dynamic_debug_init);
1489
1490 /* Debugfs setup must be done later */
1491 fs_initcall(dynamic_debug_init_control);