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