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