dynamic_debug.c 25.4 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 * lib/dynamic_debug.c
 *
 * make pr_debug()/dev_dbg() calls runtime configurable based upon their
 * source module.
 *
 * Copyright (C) 2008 Jason Baron <jbaron@redhat.com>
 * By Greg Banks <gnb@melbourne.sgi.com>
 * Copyright (c) 2008 Silicon Graphics Inc.  All Rights Reserved.
B
Bart Van Assche 已提交
10
 * Copyright (C) 2011 Bart Van Assche.  All Rights Reserved.
11 12
 */

13 14
#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__

15 16
#include <linux/kernel.h>
#include <linux/module.h>
17 18 19
#include <linux/moduleparam.h>
#include <linux/kallsyms.h>
#include <linux/types.h>
20
#include <linux/mutex.h>
21
#include <linux/proc_fs.h>
22
#include <linux/seq_file.h>
23 24
#include <linux/list.h>
#include <linux/sysctl.h>
25
#include <linux/ctype.h>
26 27
#include <linux/string.h>
#include <linux/uaccess.h>
28 29
#include <linux/dynamic_debug.h>
#include <linux/debugfs.h>
30
#include <linux/slab.h>
31
#include <linux/jump_label.h>
B
Bart Van Assche 已提交
32
#include <linux/hardirq.h>
33
#include <linux/sched.h>
34
#include <linux/device.h>
35
#include <linux/netdevice.h>
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

extern struct _ddebug __start___verbose[];
extern struct _ddebug __stop___verbose[];

struct ddebug_table {
	struct list_head link;
	char *mod_name;
	unsigned int num_ddebugs;
	struct _ddebug *ddebugs;
};

struct ddebug_query {
	const char *filename;
	const char *module;
	const char *function;
	const char *format;
	unsigned int first_lineno, last_lineno;
};

struct ddebug_iter {
	struct ddebug_table *table;
	unsigned int idx;
};

static DEFINE_MUTEX(ddebug_lock);
static LIST_HEAD(ddebug_tables);
62
static int verbose;
63
module_param(verbose, int, 0644);
64

65 66 67 68 69 70 71 72 73 74 75
/* Return the path relative to source root */
static inline const char *trim_prefix(const char *path)
{
	int skip = strlen(__FILE__) - strlen("lib/dynamic_debug.c");

	if (strncmp(path, __FILE__, skip))
		skip = 0; /* prefix mismatch, don't skip */

	return path + skip;
}

B
Bart Van Assche 已提交
76 77 78 79 80 81
static struct { unsigned flag:8; char opt_char; } opt_array[] = {
	{ _DPRINTK_FLAGS_PRINT, 'p' },
	{ _DPRINTK_FLAGS_INCL_MODNAME, 'm' },
	{ _DPRINTK_FLAGS_INCL_FUNCNAME, 'f' },
	{ _DPRINTK_FLAGS_INCL_LINENO, 'l' },
	{ _DPRINTK_FLAGS_INCL_TID, 't' },
82
	{ _DPRINTK_FLAGS_NONE, '_' },
B
Bart Van Assche 已提交
83 84
};

85 86 87 88 89
/* format a string into buf[] which describes the _ddebug's flags */
static char *ddebug_describe_flags(struct _ddebug *dp, char *buf,
				    size_t maxlen)
{
	char *p = buf;
B
Bart Van Assche 已提交
90
	int i;
91

92
	BUG_ON(maxlen < 6);
B
Bart Van Assche 已提交
93 94 95
	for (i = 0; i < ARRAY_SIZE(opt_array); ++i)
		if (dp->flags & opt_array[i].flag)
			*p++ = opt_array[i].opt_char;
96
	if (p == buf)
97
		*p++ = '_';
98 99 100 101 102
	*p = '\0';

	return buf;
}

103
#define vpr_info(fmt, ...)					\
104
do {								\
105 106
	if (verbose)						\
		pr_info(fmt, ##__VA_ARGS__);			\
107 108
} while (0)

109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
static void vpr_info_dq(const struct ddebug_query *query, const char *msg)
{
	/* trim any trailing newlines */
	int fmtlen = 0;

	if (query->format) {
		fmtlen = strlen(query->format);
		while (fmtlen && query->format[fmtlen - 1] == '\n')
			fmtlen--;
	}

	vpr_info("%s: func=\"%s\" file=\"%s\" module=\"%s\" format=\"%.*s\" lineno=%u-%u\n",
		 msg,
		 query->function ? query->function : "",
		 query->filename ? query->filename : "",
		 query->module ? query->module : "",
		 fmtlen, query->format ? query->format : "",
		 query->first_lineno, query->last_lineno);
}

129
/*
130 131 132 133
 * Search the tables for _ddebug's which match the given `query' and
 * apply the `flags' and `mask' to them.  Returns number of matching
 * callsites, normally the same as number of changes.  If verbose,
 * logs the changes.  Takes ddebug_lock.
134
 */
135 136
static int ddebug_change(const struct ddebug_query *query,
			unsigned int flags, unsigned int mask)
137 138 139 140 141
{
	int i;
	struct ddebug_table *dt;
	unsigned int newflags;
	unsigned int nfound = 0;
142
	char flagbuf[10];
143 144 145 146 147 148

	/* search for matching ddebugs */
	mutex_lock(&ddebug_lock);
	list_for_each_entry(dt, &ddebug_tables, link) {

		/* match against the module name */
149
		if (query->module && strcmp(query->module, dt->mod_name))
150 151
			continue;

152
		for (i = 0; i < dt->num_ddebugs; i++) {
153 154 155
			struct _ddebug *dp = &dt->ddebugs[i];

			/* match against the source filename */
156
			if (query->filename &&
157
			    strcmp(query->filename, dp->filename) &&
158
			    strcmp(query->filename, kbasename(dp->filename)) &&
159
			    strcmp(query->filename, trim_prefix(dp->filename)))
160 161 162
				continue;

			/* match against the function */
163
			if (query->function &&
164 165 166 167
			    strcmp(query->function, dp->function))
				continue;

			/* match against the format */
168 169
			if (query->format &&
			    !strstr(dp->format, query->format))
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
				continue;

			/* match against the line number range */
			if (query->first_lineno &&
			    dp->lineno < query->first_lineno)
				continue;
			if (query->last_lineno &&
			    dp->lineno > query->last_lineno)
				continue;

			nfound++;

			newflags = (dp->flags & mask) | flags;
			if (newflags == dp->flags)
				continue;
			dp->flags = newflags;
186
			vpr_info("changed %s:%d [%s]%s =%s\n",
187 188 189 190
				 trim_prefix(dp->filename), dp->lineno,
				 dt->mod_name, dp->function,
				 ddebug_describe_flags(dp, flagbuf,
						       sizeof(flagbuf)));
191 192 193 194 195
		}
	}
	mutex_unlock(&ddebug_lock);

	if (!nfound && verbose)
196
		pr_info("no matches for query\n");
197 198

	return nfound;
199 200 201 202
}

/*
 * Split the buffer `buf' into space-separated words.
203 204 205
 * Handles simple " and ' quoting, i.e. without nested,
 * embedded or escaped \".  Return the number of words
 * or <0 on error.
206 207 208 209 210
 */
static int ddebug_tokenize(char *buf, char *words[], int maxwords)
{
	int nwords = 0;

211 212 213 214
	while (*buf) {
		char *end;

		/* Skip leading whitespace */
215
		buf = skip_spaces(buf);
216 217
		if (!*buf)
			break;	/* oh, it was trailing whitespace */
218 219
		if (*buf == '#')
			break;	/* token starts comment, skip rest of line */
220

221
		/* find `end' of word, whitespace separated or quoted */
222 223
		if (*buf == '"' || *buf == '\'') {
			int quote = *buf++;
224
			for (end = buf; *end && *end != quote; end++)
225 226 227 228
				;
			if (!*end)
				return -EINVAL;	/* unclosed quote */
		} else {
229
			for (end = buf; *end && !isspace(*end); end++)
230 231 232 233
				;
			BUG_ON(end == buf);
		}

234
		/* `buf' is start of word, `end' is one past its end */
235 236 237 238 239 240 241
		if (nwords == maxwords)
			return -EINVAL;	/* ran out of words[] before bytes */
		if (*end)
			*end++ = '\0';	/* terminate the word */
		words[nwords++] = buf;
		buf = end;
	}
242 243 244

	if (verbose) {
		int i;
245
		pr_info("split into words:");
246
		for (i = 0; i < nwords; i++)
247 248
			pr_cont(" \"%s\"", words[i]);
		pr_cont("\n");
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
	}

	return nwords;
}

/*
 * Parse a single line number.  Note that the empty string ""
 * is treated as a special case and converted to zero, which
 * is later treated as a "don't care" value.
 */
static inline int parse_lineno(const char *str, unsigned int *val)
{
	char *end = NULL;
	BUG_ON(str == NULL);
	if (*str == '\0') {
		*val = 0;
		return 0;
	}
	*val = simple_strtoul(str, &end, 10);
	return end == NULL || end == str || *end != '\0' ? -EINVAL : 0;
}

/*
 * Undo octal escaping in a string, inplace.  This is useful to
 * allow the user to express a query which matches a format
 * containing embedded spaces.
 */
#define isodigit(c)		((c) >= '0' && (c) <= '7')
static char *unescape(char *str)
{
	char *in = str;
	char *out = str;

	while (*in) {
		if (*in == '\\') {
			if (in[1] == '\\') {
				*out++ = '\\';
				in += 2;
				continue;
			} else if (in[1] == 't') {
				*out++ = '\t';
				in += 2;
				continue;
			} else if (in[1] == 'n') {
				*out++ = '\n';
				in += 2;
				continue;
			} else if (isodigit(in[1]) &&
297 298 299 300 301
				   isodigit(in[2]) &&
				   isodigit(in[3])) {
				*out++ = (((in[1] - '0') << 6) |
					  ((in[2] - '0') << 3) |
					  (in[3] - '0'));
302 303 304 305 306 307 308 309 310 311 312
				in += 4;
				continue;
			}
		}
		*out++ = *in++;
	}
	*out = '\0';

	return str;
}

313 314 315 316 317 318
static int check_set(const char **dest, char *src, char *name)
{
	int rc = 0;

	if (*dest) {
		rc = -EINVAL;
319 320
		pr_err("match-spec:%s val:%s overridden by %s\n",
		       name, *dest, src);
321 322 323 324 325
	}
	*dest = src;
	return rc;
}

326 327 328 329 330 331 332 333 334 335 336
/*
 * Parse words[] as a ddebug query specification, which is a series
 * of (keyword, value) pairs chosen from these possibilities:
 *
 * func <function-name>
 * file <full-pathname>
 * file <base-filename>
 * module <module-name>
 * format <escaped-string-to-find-in-format>
 * line <lineno>
 * line <first-lineno>-<last-lineno> // where either may be empty
337 338 339
 *
 * Only 1 of each type is allowed.
 * Returns 0 on success, <0 on error.
340 341
 */
static int ddebug_parse_query(char *words[], int nwords,
342
			struct ddebug_query *query, const char *modname)
343 344
{
	unsigned int i;
345
	int rc;
346 347 348 349 350 351

	/* check we have an even number of words */
	if (nwords % 2 != 0)
		return -EINVAL;
	memset(query, 0, sizeof(*query));

352 353 354 355
	if (modname)
		/* support $modname.dyndbg=<multiple queries> */
		query->module = modname;

356 357
	for (i = 0; i < nwords; i += 2) {
		if (!strcmp(words[i], "func")) {
358
			rc = check_set(&query->function, words[i+1], "func");
359
		} else if (!strcmp(words[i], "file")) {
360
			rc = check_set(&query->filename, words[i+1], "file");
361
		} else if (!strcmp(words[i], "module")) {
362
			rc = check_set(&query->module, words[i+1], "module");
363
		} else if (!strcmp(words[i], "format")) {
364
			rc = check_set(&query->format, unescape(words[i+1]),
365 366
				       "format");
		} else if (!strcmp(words[i], "line")) {
367 368
			char *first = words[i+1];
			char *last = strchr(first, '-');
369 370 371 372
			if (query->first_lineno || query->last_lineno) {
				pr_err("match-spec:line given 2 times\n");
				return -EINVAL;
			}
373 374 375 376
			if (last)
				*last++ = '\0';
			if (parse_lineno(first, &query->first_lineno) < 0)
				return -EINVAL;
377
			if (last) {
378
				/* range <first>-<last> */
379 380 381
				if (parse_lineno(last, &query->last_lineno)
				    < query->first_lineno) {
					pr_err("last-line < 1st-line\n");
382
					return -EINVAL;
383
				}
384 385 386 387
			} else {
				query->last_lineno = query->first_lineno;
			}
		} else {
388
			pr_err("unknown keyword \"%s\"\n", words[i]);
389 390
			return -EINVAL;
		}
391 392
		if (rc)
			return rc;
393
	}
394
	vpr_info_dq(query, "parsed");
395 396 397 398 399 400 401 402 403 404 405 406 407
	return 0;
}

/*
 * Parse `str' as a flags specification, format [-+=][p]+.
 * Sets up *maskp and *flagsp to be used when changing the
 * flags fields of matched _ddebug's.  Returns 0 on success
 * or <0 on error.
 */
static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
			       unsigned int *maskp)
{
	unsigned flags = 0;
B
Bart Van Assche 已提交
408
	int op = '=', i;
409 410 411 412 413 414 415 416 417 418

	switch (*str) {
	case '+':
	case '-':
	case '=':
		op = *str++;
		break;
	default:
		return -EINVAL;
	}
419
	vpr_info("op='%c'\n", op);
420

421
	for (; *str ; ++str) {
B
Bart Van Assche 已提交
422 423 424 425 426
		for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
			if (*str == opt_array[i].opt_char) {
				flags |= opt_array[i].flag;
				break;
			}
427
		}
B
Bart Van Assche 已提交
428 429
		if (i < 0)
			return -EINVAL;
430
	}
431
	vpr_info("flags=0x%x\n", flags);
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447

	/* calculate final *flagsp, *maskp according to mask and op */
	switch (op) {
	case '=':
		*maskp = 0;
		*flagsp = flags;
		break;
	case '+':
		*maskp = ~0U;
		*flagsp = flags;
		break;
	case '-':
		*maskp = ~flags;
		*flagsp = 0;
		break;
	}
448
	vpr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
449 450 451
	return 0;
}

452
static int ddebug_exec_query(char *query_string, const char *modname)
453 454 455 456
{
	unsigned int flags = 0, mask = 0;
	struct ddebug_query query;
#define MAXWORDS 9
457
	int nwords, nfound;
458 459 460 461 462
	char *words[MAXWORDS];

	nwords = ddebug_tokenize(query_string, words, MAXWORDS);
	if (nwords <= 0)
		return -EINVAL;
463
	if (ddebug_parse_query(words, nwords-1, &query, modname))
464 465 466 467 468
		return -EINVAL;
	if (ddebug_parse_flags(words[nwords-1], &flags, &mask))
		return -EINVAL;

	/* actually go and implement the change */
469
	nfound = ddebug_change(&query, flags, mask);
470
	vpr_info_dq(&query, nfound ? "applied" : "no-match");
471 472 473 474 475 476 477 478

	return nfound;
}

/* handle multiple queries in query string, continue on error, return
   last error or number of matching callsites.  Module name is either
   in param (for boot arg) or perhaps in query string.
*/
479
static int ddebug_exec_queries(char *query, const char *modname)
480 481 482 483 484 485 486 487 488 489 490 491 492
{
	char *split;
	int i, errs = 0, exitcode = 0, rc, nfound = 0;

	for (i = 0; query; query = split) {
		split = strpbrk(query, ";\n");
		if (split)
			*split++ = '\0';

		query = skip_spaces(query);
		if (!query || !*query || *query == '#')
			continue;

493
		vpr_info("query %d: \"%s\"\n", i, query);
494

495
		rc = ddebug_exec_query(query, modname);
496 497 498
		if (rc < 0) {
			errs++;
			exitcode = rc;
499
		} else {
500
			nfound += rc;
501
		}
502 503
		i++;
	}
504
	vpr_info("processed %d queries, with %d matches, %d errs\n",
505 506 507 508 509
		 i, nfound, errs);

	if (exitcode)
		return exitcode;
	return nfound;
510 511
}

512 513 514 515 516 517 518 519 520 521
#define PREFIX_SIZE 64

static int remaining(int wrote)
{
	if (PREFIX_SIZE - wrote > 0)
		return PREFIX_SIZE - wrote;
	return 0;
}

static char *dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
B
Bart Van Assche 已提交
522
{
523 524
	int pos_after_tid;
	int pos = 0;
B
Bart Van Assche 已提交
525

526 527
	*buf = '\0';

528
	if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
B
Bart Van Assche 已提交
529
		if (in_interrupt())
530
			pos += snprintf(buf + pos, remaining(pos), "<intr> ");
B
Bart Van Assche 已提交
531
		else
532
			pos += snprintf(buf + pos, remaining(pos), "[%d] ",
533
					task_pid_vnr(current));
B
Bart Van Assche 已提交
534
	}
535 536 537
	pos_after_tid = pos;
	if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
		pos += snprintf(buf + pos, remaining(pos), "%s:",
538
				desc->modname);
539 540
	if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
		pos += snprintf(buf + pos, remaining(pos), "%s:",
541
				desc->function);
542
	if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
543
		pos += snprintf(buf + pos, remaining(pos), "%d:",
544
				desc->lineno);
545 546 547 548
	if (pos - pos_after_tid)
		pos += snprintf(buf + pos, remaining(pos), " ");
	if (pos >= PREFIX_SIZE)
		buf[PREFIX_SIZE - 1] = '\0';
549

550
	return buf;
551 552
}

B
Bart Van Assche 已提交
553 554 555 556
int __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
{
	va_list args;
	int res;
557 558
	struct va_format vaf;
	char buf[PREFIX_SIZE];
B
Bart Van Assche 已提交
559 560 561 562 563

	BUG_ON(!descriptor);
	BUG_ON(!fmt);

	va_start(args, fmt);
564

565 566
	vaf.fmt = fmt;
	vaf.va = &args;
567 568 569 570

	res = printk(KERN_DEBUG "%s%pV",
		     dynamic_emit_prefix(descriptor, buf), &vaf);

B
Bart Van Assche 已提交
571 572 573 574 575 576
	va_end(args);

	return res;
}
EXPORT_SYMBOL(__dynamic_pr_debug);

577 578 579 580 581 582 583 584 585 586 587
int __dynamic_dev_dbg(struct _ddebug *descriptor,
		      const struct device *dev, const char *fmt, ...)
{
	struct va_format vaf;
	va_list args;
	int res;

	BUG_ON(!descriptor);
	BUG_ON(!fmt);

	va_start(args, fmt);
588

589 590
	vaf.fmt = fmt;
	vaf.va = &args;
591 592 593 594 595 596

	if (!dev) {
		res = printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
	} else {
		char buf[PREFIX_SIZE];

597 598 599 600
		res = dev_printk_emit(7, dev, "%s%s %s: %pV",
				      dynamic_emit_prefix(descriptor, buf),
				      dev_driver_string(dev), dev_name(dev),
				      &vaf);
601 602
	}

603 604 605 606 607 608
	va_end(args);

	return res;
}
EXPORT_SYMBOL(__dynamic_dev_dbg);

609 610
#ifdef CONFIG_NET

611
int __dynamic_netdev_dbg(struct _ddebug *descriptor,
612
			 const struct net_device *dev, const char *fmt, ...)
613 614 615 616 617 618 619 620 621
{
	struct va_format vaf;
	va_list args;
	int res;

	BUG_ON(!descriptor);
	BUG_ON(!fmt);

	va_start(args, fmt);
622

623 624
	vaf.fmt = fmt;
	vaf.va = &args;
625 626 627

	if (dev && dev->dev.parent) {
		char buf[PREFIX_SIZE];
628 629 630 631 632 633 634

		res = dev_printk_emit(7, dev->dev.parent,
				      "%s%s %s %s: %pV",
				      dynamic_emit_prefix(descriptor, buf),
				      dev_driver_string(dev->dev.parent),
				      dev_name(dev->dev.parent),
				      netdev_name(dev), &vaf);
635 636 637 638 639 640
	} else if (dev) {
		res = printk(KERN_DEBUG "%s: %pV", netdev_name(dev), &vaf);
	} else {
		res = printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
	}

641 642 643 644 645 646
	va_end(args);

	return res;
}
EXPORT_SYMBOL(__dynamic_netdev_dbg);

647 648
#endif

649 650 651
#define DDEBUG_STRING_SIZE 1024
static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];

652 653
static __init int ddebug_setup_query(char *str)
{
654
	if (strlen(str) >= DDEBUG_STRING_SIZE) {
655
		pr_warn("ddebug boot param string too large\n");
656 657
		return 0;
	}
658
	strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
659 660 661 662 663
	return 1;
}

__setup("ddebug_query=", ddebug_setup_query);

664 665 666 667
/*
 * File_ops->write method for <debugfs>/dynamic_debug/conrol.  Gathers the
 * command text from userspace, parses and executes it.
 */
668
#define USER_BUF_PAGE 4096
669 670 671
static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
				  size_t len, loff_t *offp)
{
672
	char *tmpbuf;
673
	int ret;
674 675 676

	if (len == 0)
		return 0;
677 678
	if (len > USER_BUF_PAGE - 1) {
		pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
679
		return -E2BIG;
680 681 682 683 684 685
	}
	tmpbuf = kmalloc(len + 1, GFP_KERNEL);
	if (!tmpbuf)
		return -ENOMEM;
	if (copy_from_user(tmpbuf, ubuf, len)) {
		kfree(tmpbuf);
686
		return -EFAULT;
687
	}
688
	tmpbuf[len] = '\0';
689
	vpr_info("read %d bytes from userspace\n", (int)len);
690

691
	ret = ddebug_exec_queries(tmpbuf, NULL);
692
	kfree(tmpbuf);
693
	if (ret < 0)
694
		return ret;
695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751

	*offp += len;
	return len;
}

/*
 * Set the iterator to point to the first _ddebug object
 * and return a pointer to that first object.  Returns
 * NULL if there are no _ddebugs at all.
 */
static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
{
	if (list_empty(&ddebug_tables)) {
		iter->table = NULL;
		iter->idx = 0;
		return NULL;
	}
	iter->table = list_entry(ddebug_tables.next,
				 struct ddebug_table, link);
	iter->idx = 0;
	return &iter->table->ddebugs[iter->idx];
}

/*
 * Advance the iterator to point to the next _ddebug
 * object from the one the iterator currently points at,
 * and returns a pointer to the new _ddebug.  Returns
 * NULL if the iterator has seen all the _ddebugs.
 */
static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
{
	if (iter->table == NULL)
		return NULL;
	if (++iter->idx == iter->table->num_ddebugs) {
		/* iterate to next table */
		iter->idx = 0;
		if (list_is_last(&iter->table->link, &ddebug_tables)) {
			iter->table = NULL;
			return NULL;
		}
		iter->table = list_entry(iter->table->link.next,
					 struct ddebug_table, link);
	}
	return &iter->table->ddebugs[iter->idx];
}

/*
 * Seq_ops start method.  Called at the start of every
 * read() call from userspace.  Takes the ddebug_lock and
 * seeks the seq_file's iterator to the given position.
 */
static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
{
	struct ddebug_iter *iter = m->private;
	struct _ddebug *dp;
	int n = *pos;

752
	vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775

	mutex_lock(&ddebug_lock);

	if (!n)
		return SEQ_START_TOKEN;
	if (n < 0)
		return NULL;
	dp = ddebug_iter_first(iter);
	while (dp != NULL && --n > 0)
		dp = ddebug_iter_next(iter);
	return dp;
}

/*
 * Seq_ops next method.  Called several times within a read()
 * call from userspace, with ddebug_lock held.  Walks to the
 * next _ddebug object with a special case for the header line.
 */
static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
{
	struct ddebug_iter *iter = m->private;
	struct _ddebug *dp;

776
	vpr_info("called m=%p p=%p *pos=%lld\n",
777
		 m, p, (unsigned long long)*pos);
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796

	if (p == SEQ_START_TOKEN)
		dp = ddebug_iter_first(iter);
	else
		dp = ddebug_iter_next(iter);
	++*pos;
	return dp;
}

/*
 * Seq_ops show method.  Called several times within a read()
 * call from userspace, with ddebug_lock held.  Formats the
 * current _ddebug as a single human-readable line, with a
 * special case for the header line.
 */
static int ddebug_proc_show(struct seq_file *m, void *p)
{
	struct ddebug_iter *iter = m->private;
	struct _ddebug *dp = p;
797
	char flagsbuf[10];
798

799
	vpr_info("called m=%p p=%p\n", m, p);
800 801 802

	if (p == SEQ_START_TOKEN) {
		seq_puts(m,
803
			 "# filename:lineno [module]function flags format\n");
804 805 806
		return 0;
	}

807
	seq_printf(m, "%s:%u [%s]%s =%s \"",
808 809 810
		   trim_prefix(dp->filename), dp->lineno,
		   iter->table->mod_name, dp->function,
		   ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
811 812 813 814 815 816 817 818 819 820 821 822
	seq_escape(m, dp->format, "\t\r\n\"");
	seq_puts(m, "\"\n");

	return 0;
}

/*
 * Seq_ops stop method.  Called at the end of each read()
 * call from userspace.  Drops ddebug_lock.
 */
static void ddebug_proc_stop(struct seq_file *m, void *p)
{
823
	vpr_info("called m=%p p=%p\n", m, p);
824 825 826 827 828 829 830 831 832 833 834
	mutex_unlock(&ddebug_lock);
}

static const struct seq_operations ddebug_proc_seqops = {
	.start = ddebug_proc_start,
	.next = ddebug_proc_next,
	.show = ddebug_proc_show,
	.stop = ddebug_proc_stop
};

/*
835 836 837 838 839
 * File_ops->open method for <debugfs>/dynamic_debug/control.  Does
 * the seq_file setup dance, and also creates an iterator to walk the
 * _ddebugs.  Note that we create a seq_file always, even for O_WRONLY
 * files where it's not needed, as doing so simplifies the ->release
 * method.
840 841 842 843 844 845
 */
static int ddebug_proc_open(struct inode *inode, struct file *file)
{
	struct ddebug_iter *iter;
	int err;

846
	vpr_info("called\n");
847 848 849 850 851 852 853 854 855 856

	iter = kzalloc(sizeof(*iter), GFP_KERNEL);
	if (iter == NULL)
		return -ENOMEM;

	err = seq_open(file, &ddebug_proc_seqops);
	if (err) {
		kfree(iter);
		return err;
	}
857
	((struct seq_file *)file->private_data)->private = iter;
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895
	return 0;
}

static const struct file_operations ddebug_proc_fops = {
	.owner = THIS_MODULE,
	.open = ddebug_proc_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release_private,
	.write = ddebug_proc_write
};

/*
 * Allocate a new ddebug_table for the given module
 * and add it to the global list.
 */
int ddebug_add_module(struct _ddebug *tab, unsigned int n,
			     const char *name)
{
	struct ddebug_table *dt;
	char *new_name;

	dt = kzalloc(sizeof(*dt), GFP_KERNEL);
	if (dt == NULL)
		return -ENOMEM;
	new_name = kstrdup(name, GFP_KERNEL);
	if (new_name == NULL) {
		kfree(dt);
		return -ENOMEM;
	}
	dt->mod_name = new_name;
	dt->num_ddebugs = n;
	dt->ddebugs = tab;

	mutex_lock(&ddebug_lock);
	list_add_tail(&dt->link, &ddebug_tables);
	mutex_unlock(&ddebug_lock);

896
	vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
897 898 899 900
	return 0;
}
EXPORT_SYMBOL_GPL(ddebug_add_module);

901 902 903
/* helper for ddebug_dyndbg_(boot|module)_param_cb */
static int ddebug_dyndbg_param_cb(char *param, char *val,
				const char *modname, int on_err)
904 905 906 907 908
{
	char *sep;

	sep = strchr(param, '.');
	if (sep) {
909
		/* needed only for ddebug_dyndbg_boot_param_cb */
910 911 912 913 914
		*sep = '\0';
		modname = param;
		param = sep + 1;
	}
	if (strcmp(param, "dyndbg"))
915
		return on_err; /* determined by caller */
916

917 918
	ddebug_exec_queries((val ? val : "+p"), modname);

919 920 921
	return 0; /* query failure shouldnt stop module load */
}

922 923 924
/* handle both dyndbg and $module.dyndbg params at boot */
static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
				const char *unused)
925
{
926 927 928
	vpr_info("%s=\"%s\"\n", param, val);
	return ddebug_dyndbg_param_cb(param, val, NULL, 0);
}
929

930 931 932 933 934 935 936 937 938
/*
 * modprobe foo finds foo.params in boot-args, strips "foo.", and
 * passes them to load_module().  This callback gets unknown params,
 * processes dyndbg params, rejects others.
 */
int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
{
	vpr_info("module: %s %s=\"%s\"\n", module, param, val);
	return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
939 940
}

941 942 943 944 945 946 947 948 949 950 951
static void ddebug_table_free(struct ddebug_table *dt)
{
	list_del_init(&dt->link);
	kfree(dt->mod_name);
	kfree(dt);
}

/*
 * Called in response to a module being unloaded.  Removes
 * any ddebug_table's which point at the module.
 */
952
int ddebug_remove_module(const char *mod_name)
953 954 955 956
{
	struct ddebug_table *dt, *nextdt;
	int ret = -ENOENT;

957
	vpr_info("removing module \"%s\"\n", mod_name);
958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982

	mutex_lock(&ddebug_lock);
	list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
		if (!strcmp(dt->mod_name, mod_name)) {
			ddebug_table_free(dt);
			ret = 0;
		}
	}
	mutex_unlock(&ddebug_lock);
	return ret;
}
EXPORT_SYMBOL_GPL(ddebug_remove_module);

static void ddebug_remove_all_tables(void)
{
	mutex_lock(&ddebug_lock);
	while (!list_empty(&ddebug_tables)) {
		struct ddebug_table *dt = list_entry(ddebug_tables.next,
						      struct ddebug_table,
						      link);
		ddebug_table_free(dt);
	}
	mutex_unlock(&ddebug_lock);
}

983 984 985
static __initdata int ddebug_init_success;

static int __init dynamic_debug_init_debugfs(void)
986 987
{
	struct dentry *dir, *file;
988 989 990

	if (!ddebug_init_success)
		return -ENODEV;
991 992 993 994 995 996 997 998 999 1000

	dir = debugfs_create_dir("dynamic_debug", NULL);
	if (!dir)
		return -ENOMEM;
	file = debugfs_create_file("control", 0644, dir, NULL,
					&ddebug_proc_fops);
	if (!file) {
		debugfs_remove(dir);
		return -ENOMEM;
	}
1001 1002 1003 1004 1005 1006 1007
	return 0;
}

static int __init dynamic_debug_init(void)
{
	struct _ddebug *iter, *iter_start;
	const char *modname = NULL;
1008
	char *cmdline;
1009
	int ret = 0;
1010 1011
	int n = 0, entries = 0, modct = 0;
	int verbose_bytes = 0;
1012

1013
	if (__start___verbose == __stop___verbose) {
1014
		pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
1015 1016 1017 1018 1019 1020
		return 1;
	}
	iter = __start___verbose;
	modname = iter->modname;
	iter_start = iter;
	for (; iter < __stop___verbose; iter++) {
1021 1022 1023 1024
		entries++;
		verbose_bytes += strlen(iter->modname) + strlen(iter->function)
			+ strlen(iter->filename) + strlen(iter->format);

1025
		if (strcmp(modname, iter->modname)) {
1026
			modct++;
1027 1028
			ret = ddebug_add_module(iter_start, n, modname);
			if (ret)
1029
				goto out_err;
1030 1031 1032
			n = 0;
			modname = iter->modname;
			iter_start = iter;
1033
		}
1034
		n++;
1035
	}
1036 1037
	ret = ddebug_add_module(iter_start, n, modname);
	if (ret)
1038
		goto out_err;
1039

1040
	ddebug_init_success = 1;
1041 1042 1043
	vpr_info("%d modules, %d entries and %d bytes in ddebug tables, %d bytes in (readonly) verbose section\n",
		 modct, entries, (int)(modct * sizeof(struct ddebug_table)),
		 verbose_bytes + (int)(__stop___verbose - __start___verbose));
1044 1045

	/* apply ddebug_query boot param, dont unload tables on err */
1046
	if (ddebug_setup_string[0] != '\0') {
1047
		pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
1048
		ret = ddebug_exec_queries(ddebug_setup_string, NULL);
1049
		if (ret < 0)
1050
			pr_warn("Invalid ddebug boot param %s\n",
1051
				ddebug_setup_string);
1052
		else
1053
			pr_info("%d changes by ddebug_query\n", ret);
1054
	}
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
	/* now that ddebug tables are loaded, process all boot args
	 * again to find and activate queries given in dyndbg params.
	 * While this has already been done for known boot params, it
	 * ignored the unknown ones (dyndbg in particular).  Reusing
	 * parse_args avoids ad-hoc parsing.  This will also attempt
	 * to activate queries for not-yet-loaded modules, which is
	 * slightly noisy if verbose, but harmless.
	 */
	cmdline = kstrdup(saved_command_line, GFP_KERNEL);
	parse_args("dyndbg params", cmdline, NULL,
		   0, 0, 0, &ddebug_dyndbg_boot_param_cb);
	kfree(cmdline);
1067
	return 0;
1068

1069 1070
out_err:
	ddebug_remove_all_tables();
1071 1072
	return 0;
}
1073
/* Allow early initialization for boot messages via boot param */
1074
early_initcall(dynamic_debug_init);
1075

1076
/* Debugfs setup must be done later */
1077
fs_initcall(dynamic_debug_init_debugfs);