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