blob: 7288e38e17575952664af1df3a69ba488812c8e3 [file] [log] [blame]
Jason Barone9d376f2009-02-05 11:51:38 -05001/*
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.
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010010 * Copyright (C) 2011 Bart Van Assche. All Rights Reserved.
Du, Changbin578b1e02014-01-23 15:54:14 -080011 * Copyright (C) 2013 Du, Changbin <changbin.du@gmail.com>
Jason Barone9d376f2009-02-05 11:51:38 -050012 */
13
Joe Perches4ad275e2011-08-11 14:36:33 -040014#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
15
Jason Barone9d376f2009-02-05 11:51:38 -050016#include <linux/kernel.h>
17#include <linux/module.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070018#include <linux/moduleparam.h>
19#include <linux/kallsyms.h>
20#include <linux/types.h>
Jason Barone9d376f2009-02-05 11:51:38 -050021#include <linux/mutex.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070022#include <linux/proc_fs.h>
Jason Barone9d376f2009-02-05 11:51:38 -050023#include <linux/seq_file.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070024#include <linux/list.h>
25#include <linux/sysctl.h>
Jason Barone9d376f2009-02-05 11:51:38 -050026#include <linux/ctype.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070027#include <linux/string.h>
Du, Changbin578b1e02014-01-23 15:54:14 -080028#include <linux/parser.h>
Andy Shevchenkod338b132013-04-30 15:27:32 -070029#include <linux/string_helpers.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070030#include <linux/uaccess.h>
Jason Barone9d376f2009-02-05 11:51:38 -050031#include <linux/dynamic_debug.h>
32#include <linux/debugfs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/slab.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070034#include <linux/jump_label.h>
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010035#include <linux/hardirq.h>
Greg Kroah-Hartmane8d97922011-02-03 15:59:58 -080036#include <linux/sched.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070037#include <linux/device.h>
Jason Baronffa10cb2011-08-11 14:36:48 -040038#include <linux/netdevice.h>
Jason Barone9d376f2009-02-05 11:51:38 -050039
40extern struct _ddebug __start___verbose[];
41extern struct _ddebug __stop___verbose[];
42
Jason Barone9d376f2009-02-05 11:51:38 -050043struct ddebug_table {
44 struct list_head link;
45 char *mod_name;
46 unsigned int num_ddebugs;
Jason Barone9d376f2009-02-05 11:51:38 -050047 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);
Joe Perchesf657fd22012-12-05 16:48:26 -050065static int verbose;
Jim Cromie74df1382011-12-19 17:12:24 -050066module_param(verbose, int, 0644);
Jason Barone9d376f2009-02-05 11:51:38 -050067
Jim Cromie2b678312011-12-19 17:13:12 -050068/* 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
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010079static 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' },
Jim Cromie5ca7d2a2011-12-19 17:12:44 -050085 { _DPRINTK_FLAGS_NONE, '_' },
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010086};
87
Jason Barone9d376f2009-02-05 11:51:38 -050088/* 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;
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010093 int i;
Jason Barone9d376f2009-02-05 11:51:38 -050094
Jim Cromie5ca7d2a2011-12-19 17:12:44 -050095 BUG_ON(maxlen < 6);
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010096 for (i = 0; i < ARRAY_SIZE(opt_array); ++i)
97 if (dp->flags & opt_array[i].flag)
98 *p++ = opt_array[i].opt_char;
Jason Barone9d376f2009-02-05 11:51:38 -050099 if (p == buf)
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500100 *p++ = '_';
Jason Barone9d376f2009-02-05 11:51:38 -0500101 *p = '\0';
102
103 return buf;
104}
105
Joe Perchesf657fd22012-12-05 16:48:26 -0500106#define vpr_info(fmt, ...) \
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600107do { \
Joe Perchesf657fd22012-12-05 16:48:26 -0500108 if (verbose) \
109 pr_info(fmt, ##__VA_ARGS__); \
Jim Cromie574b3722011-12-19 17:13:16 -0500110} while (0)
111
Joe Perchesf657fd22012-12-05 16:48:26 -0500112static 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
Jason Barone9d376f2009-02-05 11:51:38 -0500132/*
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500133 * 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.
Jason Barone9d376f2009-02-05 11:51:38 -0500137 */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500138static int ddebug_change(const struct ddebug_query *query,
139 unsigned int flags, unsigned int mask)
Jason Barone9d376f2009-02-05 11:51:38 -0500140{
141 int i;
142 struct ddebug_table *dt;
143 unsigned int newflags;
144 unsigned int nfound = 0;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500145 char flagbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500146
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 */
Du, Changbin578b1e02014-01-23 15:54:14 -0800152 if (query->module &&
153 !match_wildcard(query->module, dt->mod_name))
Jason Barone9d376f2009-02-05 11:51:38 -0500154 continue;
155
Joe Perchesf657fd22012-12-05 16:48:26 -0500156 for (i = 0; i < dt->num_ddebugs; i++) {
Jason Barone9d376f2009-02-05 11:51:38 -0500157 struct _ddebug *dp = &dt->ddebugs[i];
158
159 /* match against the source filename */
Jim Cromied6a238d2011-12-19 17:12:39 -0500160 if (query->filename &&
Du, Changbin578b1e02014-01-23 15:54:14 -0800161 !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)))
Jason Barone9d376f2009-02-05 11:51:38 -0500166 continue;
167
168 /* match against the function */
Jim Cromied6a238d2011-12-19 17:12:39 -0500169 if (query->function &&
Du, Changbin578b1e02014-01-23 15:54:14 -0800170 !match_wildcard(query->function, dp->function))
Jason Barone9d376f2009-02-05 11:51:38 -0500171 continue;
172
173 /* match against the format */
Jim Cromied6a238d2011-12-19 17:12:39 -0500174 if (query->format &&
175 !strstr(dp->format, query->format))
Jason Barone9d376f2009-02-05 11:51:38 -0500176 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;
Jason Barone9d376f2009-02-05 11:51:38 -0500191 dp->flags = newflags;
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600192 vpr_info("changed %s:%d [%s]%s =%s\n",
Joe Perchesf657fd22012-12-05 16:48:26 -0500193 trim_prefix(dp->filename), dp->lineno,
194 dt->mod_name, dp->function,
195 ddebug_describe_flags(dp, flagbuf,
196 sizeof(flagbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500197 }
198 }
199 mutex_unlock(&ddebug_lock);
200
201 if (!nfound && verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400202 pr_info("no matches for query\n");
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500203
204 return nfound;
Jason Barone9d376f2009-02-05 11:51:38 -0500205}
206
207/*
Jason Barone9d376f2009-02-05 11:51:38 -0500208 * Split the buffer `buf' into space-separated words.
Greg Banks9898abb2009-02-06 12:54:26 +1100209 * Handles simple " and ' quoting, i.e. without nested,
210 * embedded or escaped \". Return the number of words
211 * or <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500212 */
213static int ddebug_tokenize(char *buf, char *words[], int maxwords)
214{
215 int nwords = 0;
216
Greg Banks9898abb2009-02-06 12:54:26 +1100217 while (*buf) {
218 char *end;
219
220 /* Skip leading whitespace */
André Goddard Rosae7d28602009-12-14 18:01:06 -0800221 buf = skip_spaces(buf);
Greg Banks9898abb2009-02-06 12:54:26 +1100222 if (!*buf)
223 break; /* oh, it was trailing whitespace */
Jim Cromie8bd60262011-12-19 17:13:03 -0500224 if (*buf == '#')
225 break; /* token starts comment, skip rest of line */
Greg Banks9898abb2009-02-06 12:54:26 +1100226
Jim Cromie07100be2011-12-19 17:11:09 -0500227 /* find `end' of word, whitespace separated or quoted */
Greg Banks9898abb2009-02-06 12:54:26 +1100228 if (*buf == '"' || *buf == '\'') {
229 int quote = *buf++;
Joe Perchesf657fd22012-12-05 16:48:26 -0500230 for (end = buf; *end && *end != quote; end++)
Greg Banks9898abb2009-02-06 12:54:26 +1100231 ;
Jim Cromie18c216c2012-12-05 16:48:27 -0500232 if (!*end) {
233 pr_err("unclosed quote: %s\n", buf);
Greg Banks9898abb2009-02-06 12:54:26 +1100234 return -EINVAL; /* unclosed quote */
Jim Cromie18c216c2012-12-05 16:48:27 -0500235 }
Greg Banks9898abb2009-02-06 12:54:26 +1100236 } else {
Joe Perchesf657fd22012-12-05 16:48:26 -0500237 for (end = buf; *end && !isspace(*end); end++)
Greg Banks9898abb2009-02-06 12:54:26 +1100238 ;
239 BUG_ON(end == buf);
240 }
Greg Banks9898abb2009-02-06 12:54:26 +1100241
Jim Cromie07100be2011-12-19 17:11:09 -0500242 /* `buf' is start of word, `end' is one past its end */
Jim Cromie18c216c2012-12-05 16:48:27 -0500243 if (nwords == maxwords) {
244 pr_err("too many words, legal max <=%d\n", maxwords);
Greg Banks9898abb2009-02-06 12:54:26 +1100245 return -EINVAL; /* ran out of words[] before bytes */
Jim Cromie18c216c2012-12-05 16:48:27 -0500246 }
Greg Banks9898abb2009-02-06 12:54:26 +1100247 if (*end)
248 *end++ = '\0'; /* terminate the word */
249 words[nwords++] = buf;
250 buf = end;
251 }
Jason Barone9d376f2009-02-05 11:51:38 -0500252
253 if (verbose) {
254 int i;
Joe Perches4ad275e2011-08-11 14:36:33 -0400255 pr_info("split into words:");
Joe Perchesf657fd22012-12-05 16:48:26 -0500256 for (i = 0; i < nwords; i++)
Joe Perches4ad275e2011-08-11 14:36:33 -0400257 pr_cont(" \"%s\"", words[i]);
258 pr_cont("\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500259 }
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{
Jason Barone9d376f2009-02-05 11:51:38 -0500271 BUG_ON(str == NULL);
272 if (*str == '\0') {
273 *val = 0;
274 return 0;
275 }
Andrey Ryabinin45925992014-01-27 17:06:59 -0800276 if (kstrtouint(str, 10, val) < 0) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500277 pr_err("bad line-number: %s\n", str);
278 return -EINVAL;
279 }
280 return 0;
Jason Barone9d376f2009-02-05 11:51:38 -0500281}
282
Jim Cromie820874c2011-12-19 17:12:49 -0500283static int check_set(const char **dest, char *src, char *name)
284{
285 int rc = 0;
286
287 if (*dest) {
288 rc = -EINVAL;
Joe Perchesf657fd22012-12-05 16:48:26 -0500289 pr_err("match-spec:%s val:%s overridden by %s\n",
290 name, *dest, src);
Jim Cromie820874c2011-12-19 17:12:49 -0500291 }
292 *dest = src;
293 return rc;
294}
295
Jason Barone9d376f2009-02-05 11:51:38 -0500296/*
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
Jim Cromie820874c2011-12-19 17:12:49 -0500307 *
308 * Only 1 of each type is allowed.
309 * Returns 0 on success, <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500310 */
311static int ddebug_parse_query(char *words[], int nwords,
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600312 struct ddebug_query *query, const char *modname)
Jason Barone9d376f2009-02-05 11:51:38 -0500313{
314 unsigned int i;
jbaron@akamai.combd8c154a2013-08-27 16:50:03 +0000315 int rc = 0;
Jason Barone9d376f2009-02-05 11:51:38 -0500316
317 /* check we have an even number of words */
Jim Cromie18c216c2012-12-05 16:48:27 -0500318 if (nwords % 2 != 0) {
319 pr_err("expecting pairs of match-spec <value>\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500320 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500321 }
Jason Barone9d376f2009-02-05 11:51:38 -0500322 memset(query, 0, sizeof(*query));
323
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600324 if (modname)
325 /* support $modname.dyndbg=<multiple queries> */
326 query->module = modname;
327
Joe Perchesf657fd22012-12-05 16:48:26 -0500328 for (i = 0; i < nwords; i += 2) {
329 if (!strcmp(words[i], "func")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500330 rc = check_set(&query->function, words[i+1], "func");
Joe Perchesf657fd22012-12-05 16:48:26 -0500331 } else if (!strcmp(words[i], "file")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500332 rc = check_set(&query->filename, words[i+1], "file");
Joe Perchesf657fd22012-12-05 16:48:26 -0500333 } else if (!strcmp(words[i], "module")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500334 rc = check_set(&query->module, words[i+1], "module");
Joe Perchesf657fd22012-12-05 16:48:26 -0500335 } else if (!strcmp(words[i], "format")) {
Andy Shevchenkod338b132013-04-30 15:27:32 -0700336 string_unescape_inplace(words[i+1], UNESCAPE_SPACE |
337 UNESCAPE_OCTAL |
338 UNESCAPE_SPECIAL);
339 rc = check_set(&query->format, words[i+1], "format");
Joe Perchesf657fd22012-12-05 16:48:26 -0500340 } else if (!strcmp(words[i], "line")) {
Jason Barone9d376f2009-02-05 11:51:38 -0500341 char *first = words[i+1];
342 char *last = strchr(first, '-');
Jim Cromie820874c2011-12-19 17:12:49 -0500343 if (query->first_lineno || query->last_lineno) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500344 pr_err("match-spec: line used 2x\n");
Jim Cromie820874c2011-12-19 17:12:49 -0500345 return -EINVAL;
346 }
Jason Barone9d376f2009-02-05 11:51:38 -0500347 if (last)
348 *last++ = '\0';
Andrey Ryabinind9e133e2014-01-27 17:06:57 -0800349 if (parse_lineno(first, &query->first_lineno) < 0)
Jason Barone9d376f2009-02-05 11:51:38 -0500350 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500351 if (last) {
Jason Barone9d376f2009-02-05 11:51:38 -0500352 /* range <first>-<last> */
Andrey Ryabinin3ace6782014-01-27 17:06:58 -0800353 if (parse_lineno(last, &query->last_lineno) < 0)
354 return -EINVAL;
355
356 if (query->last_lineno < query->first_lineno) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500357 pr_err("last-line:%d < 1st-line:%d\n",
358 query->last_lineno,
359 query->first_lineno);
Jason Barone9d376f2009-02-05 11:51:38 -0500360 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500361 }
Jason Barone9d376f2009-02-05 11:51:38 -0500362 } else {
363 query->last_lineno = query->first_lineno;
364 }
365 } else {
Jim Cromieae27f862011-12-19 17:12:34 -0500366 pr_err("unknown keyword \"%s\"\n", words[i]);
Jason Barone9d376f2009-02-05 11:51:38 -0500367 return -EINVAL;
368 }
Jim Cromie820874c2011-12-19 17:12:49 -0500369 if (rc)
370 return rc;
Jason Barone9d376f2009-02-05 11:51:38 -0500371 }
Jim Cromie574b3722011-12-19 17:13:16 -0500372 vpr_info_dq(query, "parsed");
Jason Barone9d376f2009-02-05 11:51:38 -0500373 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;
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100386 int op = '=', i;
Jason Barone9d376f2009-02-05 11:51:38 -0500387
388 switch (*str) {
389 case '+':
390 case '-':
391 case '=':
392 op = *str++;
393 break;
394 default:
Jim Cromie18c216c2012-12-05 16:48:27 -0500395 pr_err("bad flag-op %c, at start of %s\n", *str, str);
Jason Barone9d376f2009-02-05 11:51:38 -0500396 return -EINVAL;
397 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600398 vpr_info("op='%c'\n", op);
Jason Barone9d376f2009-02-05 11:51:38 -0500399
Joe Perchesf657fd22012-12-05 16:48:26 -0500400 for (; *str ; ++str) {
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100401 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 }
Jason Barone9d376f2009-02-05 11:51:38 -0500406 }
Jim Cromie18c216c2012-12-05 16:48:27 -0500407 if (i < 0) {
408 pr_err("unknown flag '%c' in \"%s\"\n", *str, str);
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100409 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500410 }
Jason Barone9d376f2009-02-05 11:51:38 -0500411 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600412 vpr_info("flags=0x%x\n", flags);
Jason Barone9d376f2009-02-05 11:51:38 -0500413
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 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600429 vpr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
Jason Barone9d376f2009-02-05 11:51:38 -0500430 return 0;
431}
432
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600433static int ddebug_exec_query(char *query_string, const char *modname)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200434{
435 unsigned int flags = 0, mask = 0;
436 struct ddebug_query query;
437#define MAXWORDS 9
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500438 int nwords, nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200439 char *words[MAXWORDS];
440
441 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
Jim Cromie18c216c2012-12-05 16:48:27 -0500442 if (nwords <= 0) {
443 pr_err("tokenize failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200444 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500445 }
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");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200449 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500450 }
451 if (ddebug_parse_query(words, nwords-1, &query, modname)) {
452 pr_err("query parse failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200453 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500454 }
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200455 /* actually go and implement the change */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500456 nfound = ddebug_change(&query, flags, mask);
Joe Perchesf657fd22012-12-05 16:48:26 -0500457 vpr_info_dq(&query, nfound ? "applied" : "no-match");
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500458
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*/
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600466static int ddebug_exec_queries(char *query, const char *modname)
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500467{
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
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600480 vpr_info("query %d: \"%s\"\n", i, query);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500481
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600482 rc = ddebug_exec_query(query, modname);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500483 if (rc < 0) {
484 errs++;
485 exitcode = rc;
Joe Perchesf657fd22012-12-05 16:48:26 -0500486 } else {
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500487 nfound += rc;
Joe Perchesf657fd22012-12-05 16:48:26 -0500488 }
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500489 i++;
490 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600491 vpr_info("processed %d queries, with %d matches, %d errs\n",
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500492 i, nfound, errs);
493
494 if (exitcode)
495 return exitcode;
496 return nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200497}
498
Jason Baron431625d2011-10-04 14:13:19 -0700499#define PREFIX_SIZE 64
500
501static int remaining(int wrote)
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100502{
Jason Baron431625d2011-10-04 14:13:19 -0700503 if (PREFIX_SIZE - wrote > 0)
504 return PREFIX_SIZE - wrote;
505 return 0;
506}
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100507
Jason Baron431625d2011-10-04 14:13:19 -0700508static char *dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
509{
510 int pos_after_tid;
511 int pos = 0;
512
Joe Perches798efc62012-09-12 20:11:29 -0700513 *buf = '\0';
514
Jason Baron431625d2011-10-04 14:13:19 -0700515 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100516 if (in_interrupt())
Joe Perches798efc62012-09-12 20:11:29 -0700517 pos += snprintf(buf + pos, remaining(pos), "<intr> ");
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100518 else
Jason Baron431625d2011-10-04 14:13:19 -0700519 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
Joe Perches798efc62012-09-12 20:11:29 -0700520 task_pid_vnr(current));
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100521 }
Jason Baron431625d2011-10-04 14:13:19 -0700522 pos_after_tid = pos;
523 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
524 pos += snprintf(buf + pos, remaining(pos), "%s:",
Joe Perches798efc62012-09-12 20:11:29 -0700525 desc->modname);
Jason Baron431625d2011-10-04 14:13:19 -0700526 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
527 pos += snprintf(buf + pos, remaining(pos), "%s:",
Joe Perches798efc62012-09-12 20:11:29 -0700528 desc->function);
Jason Baron431625d2011-10-04 14:13:19 -0700529 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
Jim Cromie07100be2011-12-19 17:11:09 -0500530 pos += snprintf(buf + pos, remaining(pos), "%d:",
Joe Perches798efc62012-09-12 20:11:29 -0700531 desc->lineno);
Jason Baron431625d2011-10-04 14:13:19 -0700532 if (pos - pos_after_tid)
533 pos += snprintf(buf + pos, remaining(pos), " ");
534 if (pos >= PREFIX_SIZE)
535 buf[PREFIX_SIZE - 1] = '\0';
Joe Perches6c2140e2011-08-11 14:36:25 -0400536
Jason Baron431625d2011-10-04 14:13:19 -0700537 return buf;
Joe Perches6c2140e2011-08-11 14:36:25 -0400538}
539
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100540int __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
541{
542 va_list args;
543 int res;
Jason Baron431625d2011-10-04 14:13:19 -0700544 struct va_format vaf;
545 char buf[PREFIX_SIZE];
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100546
547 BUG_ON(!descriptor);
548 BUG_ON(!fmt);
549
550 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700551
Jason Baron431625d2011-10-04 14:13:19 -0700552 vaf.fmt = fmt;
553 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700554
555 res = printk(KERN_DEBUG "%s%pV",
556 dynamic_emit_prefix(descriptor, buf), &vaf);
557
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100558 va_end(args);
559
560 return res;
561}
562EXPORT_SYMBOL(__dynamic_pr_debug);
563
Joe Perchescbc46632011-08-11 14:36:21 -0400564int __dynamic_dev_dbg(struct _ddebug *descriptor,
565 const struct device *dev, const char *fmt, ...)
566{
567 struct va_format vaf;
568 va_list args;
569 int res;
570
571 BUG_ON(!descriptor);
572 BUG_ON(!fmt);
573
574 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700575
Joe Perchescbc46632011-08-11 14:36:21 -0400576 vaf.fmt = fmt;
577 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700578
579 if (!dev) {
580 res = printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
581 } else {
582 char buf[PREFIX_SIZE];
Joe Perches798efc62012-09-12 20:11:29 -0700583
Joe Perches666f3552012-09-12 20:14:11 -0700584 res = dev_printk_emit(7, dev, "%s%s %s: %pV",
585 dynamic_emit_prefix(descriptor, buf),
586 dev_driver_string(dev), dev_name(dev),
587 &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700588 }
589
Joe Perchescbc46632011-08-11 14:36:21 -0400590 va_end(args);
591
592 return res;
593}
594EXPORT_SYMBOL(__dynamic_dev_dbg);
595
Jason Baron0feefd92011-10-04 14:13:22 -0700596#ifdef CONFIG_NET
597
Jason Baronffa10cb2011-08-11 14:36:48 -0400598int __dynamic_netdev_dbg(struct _ddebug *descriptor,
Joe Perchesb004ff42012-09-12 20:12:19 -0700599 const struct net_device *dev, const char *fmt, ...)
Jason Baronffa10cb2011-08-11 14:36:48 -0400600{
601 struct va_format vaf;
602 va_list args;
603 int res;
604
605 BUG_ON(!descriptor);
606 BUG_ON(!fmt);
607
608 va_start(args, fmt);
Joe Perchesb004ff42012-09-12 20:12:19 -0700609
Jason Baronffa10cb2011-08-11 14:36:48 -0400610 vaf.fmt = fmt;
611 vaf.va = &args;
Joe Perchesb004ff42012-09-12 20:12:19 -0700612
613 if (dev && dev->dev.parent) {
614 char buf[PREFIX_SIZE];
Joe Perchesb004ff42012-09-12 20:12:19 -0700615
Joe Perches666f3552012-09-12 20:14:11 -0700616 res = dev_printk_emit(7, dev->dev.parent,
617 "%s%s %s %s: %pV",
618 dynamic_emit_prefix(descriptor, buf),
619 dev_driver_string(dev->dev.parent),
620 dev_name(dev->dev.parent),
621 netdev_name(dev), &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700622 } else if (dev) {
623 res = printk(KERN_DEBUG "%s: %pV", netdev_name(dev), &vaf);
624 } else {
625 res = printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
626 }
627
Jason Baronffa10cb2011-08-11 14:36:48 -0400628 va_end(args);
629
630 return res;
631}
632EXPORT_SYMBOL(__dynamic_netdev_dbg);
633
Jason Baron0feefd92011-10-04 14:13:22 -0700634#endif
635
Jim Cromiebc757f62011-12-19 17:12:29 -0500636#define DDEBUG_STRING_SIZE 1024
637static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
638
Thomas Renningera648ec02010-08-06 16:11:02 +0200639static __init int ddebug_setup_query(char *str)
640{
Jim Cromiebc757f62011-12-19 17:12:29 -0500641 if (strlen(str) >= DDEBUG_STRING_SIZE) {
Joe Perches4ad275e2011-08-11 14:36:33 -0400642 pr_warn("ddebug boot param string too large\n");
Thomas Renningera648ec02010-08-06 16:11:02 +0200643 return 0;
644 }
Jim Cromiebc757f62011-12-19 17:12:29 -0500645 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
Thomas Renningera648ec02010-08-06 16:11:02 +0200646 return 1;
647}
648
649__setup("ddebug_query=", ddebug_setup_query);
650
Jason Barone9d376f2009-02-05 11:51:38 -0500651/*
652 * File_ops->write method for <debugfs>/dynamic_debug/conrol. Gathers the
653 * command text from userspace, parses and executes it.
654 */
Jim Cromie72814912011-12-19 17:13:07 -0500655#define USER_BUF_PAGE 4096
Jason Barone9d376f2009-02-05 11:51:38 -0500656static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
657 size_t len, loff_t *offp)
658{
Jim Cromie72814912011-12-19 17:13:07 -0500659 char *tmpbuf;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200660 int ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500661
662 if (len == 0)
663 return 0;
Jim Cromie72814912011-12-19 17:13:07 -0500664 if (len > USER_BUF_PAGE - 1) {
665 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
Jason Barone9d376f2009-02-05 11:51:38 -0500666 return -E2BIG;
Jim Cromie72814912011-12-19 17:13:07 -0500667 }
668 tmpbuf = kmalloc(len + 1, GFP_KERNEL);
669 if (!tmpbuf)
670 return -ENOMEM;
671 if (copy_from_user(tmpbuf, ubuf, len)) {
672 kfree(tmpbuf);
Jason Barone9d376f2009-02-05 11:51:38 -0500673 return -EFAULT;
Jim Cromie72814912011-12-19 17:13:07 -0500674 }
Jason Barone9d376f2009-02-05 11:51:38 -0500675 tmpbuf[len] = '\0';
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600676 vpr_info("read %d bytes from userspace\n", (int)len);
Jason Barone9d376f2009-02-05 11:51:38 -0500677
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600678 ret = ddebug_exec_queries(tmpbuf, NULL);
Jim Cromie72814912011-12-19 17:13:07 -0500679 kfree(tmpbuf);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500680 if (ret < 0)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200681 return ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500682
683 *offp += len;
684 return len;
685}
686
687/*
688 * Set the iterator to point to the first _ddebug object
689 * and return a pointer to that first object. Returns
690 * NULL if there are no _ddebugs at all.
691 */
692static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
693{
694 if (list_empty(&ddebug_tables)) {
695 iter->table = NULL;
696 iter->idx = 0;
697 return NULL;
698 }
699 iter->table = list_entry(ddebug_tables.next,
700 struct ddebug_table, link);
701 iter->idx = 0;
702 return &iter->table->ddebugs[iter->idx];
703}
704
705/*
706 * Advance the iterator to point to the next _ddebug
707 * object from the one the iterator currently points at,
708 * and returns a pointer to the new _ddebug. Returns
709 * NULL if the iterator has seen all the _ddebugs.
710 */
711static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
712{
713 if (iter->table == NULL)
714 return NULL;
715 if (++iter->idx == iter->table->num_ddebugs) {
716 /* iterate to next table */
717 iter->idx = 0;
718 if (list_is_last(&iter->table->link, &ddebug_tables)) {
719 iter->table = NULL;
720 return NULL;
721 }
722 iter->table = list_entry(iter->table->link.next,
723 struct ddebug_table, link);
724 }
725 return &iter->table->ddebugs[iter->idx];
726}
727
728/*
729 * Seq_ops start method. Called at the start of every
730 * read() call from userspace. Takes the ddebug_lock and
731 * seeks the seq_file's iterator to the given position.
732 */
733static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
734{
735 struct ddebug_iter *iter = m->private;
736 struct _ddebug *dp;
737 int n = *pos;
738
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600739 vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500740
741 mutex_lock(&ddebug_lock);
742
743 if (!n)
744 return SEQ_START_TOKEN;
745 if (n < 0)
746 return NULL;
747 dp = ddebug_iter_first(iter);
748 while (dp != NULL && --n > 0)
749 dp = ddebug_iter_next(iter);
750 return dp;
751}
752
753/*
754 * Seq_ops next method. Called several times within a read()
755 * call from userspace, with ddebug_lock held. Walks to the
756 * next _ddebug object with a special case for the header line.
757 */
758static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
759{
760 struct ddebug_iter *iter = m->private;
761 struct _ddebug *dp;
762
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600763 vpr_info("called m=%p p=%p *pos=%lld\n",
Joe Perchesf657fd22012-12-05 16:48:26 -0500764 m, p, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500765
766 if (p == SEQ_START_TOKEN)
767 dp = ddebug_iter_first(iter);
768 else
769 dp = ddebug_iter_next(iter);
770 ++*pos;
771 return dp;
772}
773
774/*
775 * Seq_ops show method. Called several times within a read()
776 * call from userspace, with ddebug_lock held. Formats the
777 * current _ddebug as a single human-readable line, with a
778 * special case for the header line.
779 */
780static int ddebug_proc_show(struct seq_file *m, void *p)
781{
782 struct ddebug_iter *iter = m->private;
783 struct _ddebug *dp = p;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500784 char flagsbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500785
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600786 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500787
788 if (p == SEQ_START_TOKEN) {
789 seq_puts(m,
Joe Perchesf657fd22012-12-05 16:48:26 -0500790 "# filename:lineno [module]function flags format\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500791 return 0;
792 }
793
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500794 seq_printf(m, "%s:%u [%s]%s =%s \"",
Joe Perchesf657fd22012-12-05 16:48:26 -0500795 trim_prefix(dp->filename), dp->lineno,
796 iter->table->mod_name, dp->function,
797 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500798 seq_escape(m, dp->format, "\t\r\n\"");
799 seq_puts(m, "\"\n");
800
801 return 0;
802}
803
804/*
805 * Seq_ops stop method. Called at the end of each read()
806 * call from userspace. Drops ddebug_lock.
807 */
808static void ddebug_proc_stop(struct seq_file *m, void *p)
809{
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600810 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500811 mutex_unlock(&ddebug_lock);
812}
813
814static const struct seq_operations ddebug_proc_seqops = {
815 .start = ddebug_proc_start,
816 .next = ddebug_proc_next,
817 .show = ddebug_proc_show,
818 .stop = ddebug_proc_stop
819};
820
821/*
Jim Cromie07100be2011-12-19 17:11:09 -0500822 * File_ops->open method for <debugfs>/dynamic_debug/control. Does
823 * the seq_file setup dance, and also creates an iterator to walk the
824 * _ddebugs. Note that we create a seq_file always, even for O_WRONLY
825 * files where it's not needed, as doing so simplifies the ->release
826 * method.
Jason Barone9d376f2009-02-05 11:51:38 -0500827 */
828static int ddebug_proc_open(struct inode *inode, struct file *file)
829{
830 struct ddebug_iter *iter;
831 int err;
832
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600833 vpr_info("called\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500834
835 iter = kzalloc(sizeof(*iter), GFP_KERNEL);
836 if (iter == NULL)
837 return -ENOMEM;
838
839 err = seq_open(file, &ddebug_proc_seqops);
840 if (err) {
841 kfree(iter);
842 return err;
843 }
Joe Perchesf657fd22012-12-05 16:48:26 -0500844 ((struct seq_file *)file->private_data)->private = iter;
Jason Barone9d376f2009-02-05 11:51:38 -0500845 return 0;
846}
847
848static const struct file_operations ddebug_proc_fops = {
849 .owner = THIS_MODULE,
850 .open = ddebug_proc_open,
851 .read = seq_read,
852 .llseek = seq_lseek,
853 .release = seq_release_private,
854 .write = ddebug_proc_write
855};
856
857/*
858 * Allocate a new ddebug_table for the given module
859 * and add it to the global list.
860 */
861int ddebug_add_module(struct _ddebug *tab, unsigned int n,
862 const char *name)
863{
864 struct ddebug_table *dt;
865 char *new_name;
866
867 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
868 if (dt == NULL)
869 return -ENOMEM;
870 new_name = kstrdup(name, GFP_KERNEL);
871 if (new_name == NULL) {
872 kfree(dt);
873 return -ENOMEM;
874 }
875 dt->mod_name = new_name;
876 dt->num_ddebugs = n;
Jason Barone9d376f2009-02-05 11:51:38 -0500877 dt->ddebugs = tab;
878
879 mutex_lock(&ddebug_lock);
880 list_add_tail(&dt->link, &ddebug_tables);
881 mutex_unlock(&ddebug_lock);
882
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600883 vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500884 return 0;
885}
886EXPORT_SYMBOL_GPL(ddebug_add_module);
887
Jim Cromie6ab676e2012-04-27 14:30:37 -0600888/* helper for ddebug_dyndbg_(boot|module)_param_cb */
889static int ddebug_dyndbg_param_cb(char *param, char *val,
890 const char *modname, int on_err)
Jim Cromieb48420c2012-04-27 14:30:35 -0600891{
Jim Cromieb48420c2012-04-27 14:30:35 -0600892 char *sep;
893
894 sep = strchr(param, '.');
895 if (sep) {
Jim Cromie6ab676e2012-04-27 14:30:37 -0600896 /* needed only for ddebug_dyndbg_boot_param_cb */
Jim Cromieb48420c2012-04-27 14:30:35 -0600897 *sep = '\0';
898 modname = param;
899 param = sep + 1;
900 }
901 if (strcmp(param, "dyndbg"))
Jim Cromie6ab676e2012-04-27 14:30:37 -0600902 return on_err; /* determined by caller */
Jim Cromieb48420c2012-04-27 14:30:35 -0600903
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600904 ddebug_exec_queries((val ? val : "+p"), modname);
905
Jim Cromieb48420c2012-04-27 14:30:35 -0600906 return 0; /* query failure shouldnt stop module load */
907}
908
Jim Cromie6ab676e2012-04-27 14:30:37 -0600909/* handle both dyndbg and $module.dyndbg params at boot */
910static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
911 const char *unused)
Jim Cromieb48420c2012-04-27 14:30:35 -0600912{
Jim Cromie6ab676e2012-04-27 14:30:37 -0600913 vpr_info("%s=\"%s\"\n", param, val);
914 return ddebug_dyndbg_param_cb(param, val, NULL, 0);
915}
Jim Cromieb48420c2012-04-27 14:30:35 -0600916
Jim Cromie6ab676e2012-04-27 14:30:37 -0600917/*
918 * modprobe foo finds foo.params in boot-args, strips "foo.", and
919 * passes them to load_module(). This callback gets unknown params,
920 * processes dyndbg params, rejects others.
921 */
922int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
923{
924 vpr_info("module: %s %s=\"%s\"\n", module, param, val);
925 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
Jim Cromieb48420c2012-04-27 14:30:35 -0600926}
927
Jason Barone9d376f2009-02-05 11:51:38 -0500928static void ddebug_table_free(struct ddebug_table *dt)
929{
930 list_del_init(&dt->link);
931 kfree(dt->mod_name);
932 kfree(dt);
933}
934
935/*
936 * Called in response to a module being unloaded. Removes
937 * any ddebug_table's which point at the module.
938 */
Yehuda Sadehff49d742010-07-03 13:07:35 +1000939int ddebug_remove_module(const char *mod_name)
Jason Barone9d376f2009-02-05 11:51:38 -0500940{
941 struct ddebug_table *dt, *nextdt;
942 int ret = -ENOENT;
943
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600944 vpr_info("removing module \"%s\"\n", mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500945
946 mutex_lock(&ddebug_lock);
947 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
948 if (!strcmp(dt->mod_name, mod_name)) {
949 ddebug_table_free(dt);
950 ret = 0;
951 }
952 }
953 mutex_unlock(&ddebug_lock);
954 return ret;
955}
956EXPORT_SYMBOL_GPL(ddebug_remove_module);
957
958static void ddebug_remove_all_tables(void)
959{
960 mutex_lock(&ddebug_lock);
961 while (!list_empty(&ddebug_tables)) {
962 struct ddebug_table *dt = list_entry(ddebug_tables.next,
963 struct ddebug_table,
964 link);
965 ddebug_table_free(dt);
966 }
967 mutex_unlock(&ddebug_lock);
968}
969
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200970static __initdata int ddebug_init_success;
971
972static int __init dynamic_debug_init_debugfs(void)
Jason Barone9d376f2009-02-05 11:51:38 -0500973{
974 struct dentry *dir, *file;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200975
976 if (!ddebug_init_success)
977 return -ENODEV;
Jason Barone9d376f2009-02-05 11:51:38 -0500978
979 dir = debugfs_create_dir("dynamic_debug", NULL);
980 if (!dir)
981 return -ENOMEM;
982 file = debugfs_create_file("control", 0644, dir, NULL,
983 &ddebug_proc_fops);
984 if (!file) {
985 debugfs_remove(dir);
986 return -ENOMEM;
987 }
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200988 return 0;
989}
990
991static int __init dynamic_debug_init(void)
992{
993 struct _ddebug *iter, *iter_start;
994 const char *modname = NULL;
Jim Cromieb48420c2012-04-27 14:30:35 -0600995 char *cmdline;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200996 int ret = 0;
Jim Cromie41076922012-04-27 14:30:39 -0600997 int n = 0, entries = 0, modct = 0;
998 int verbose_bytes = 0;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200999
Jim Cromieb5b78f82011-12-19 17:12:54 -05001000 if (__start___verbose == __stop___verbose) {
Joe Perchesf657fd22012-12-05 16:48:26 -05001001 pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
Jim Cromieb5b78f82011-12-19 17:12:54 -05001002 return 1;
Jason Barone9d376f2009-02-05 11:51:38 -05001003 }
Jim Cromieb5b78f82011-12-19 17:12:54 -05001004 iter = __start___verbose;
1005 modname = iter->modname;
1006 iter_start = iter;
1007 for (; iter < __stop___verbose; iter++) {
Jim Cromie41076922012-04-27 14:30:39 -06001008 entries++;
1009 verbose_bytes += strlen(iter->modname) + strlen(iter->function)
1010 + strlen(iter->filename) + strlen(iter->format);
1011
Jim Cromieb5b78f82011-12-19 17:12:54 -05001012 if (strcmp(modname, iter->modname)) {
Jim Cromie41076922012-04-27 14:30:39 -06001013 modct++;
Jim Cromieb5b78f82011-12-19 17:12:54 -05001014 ret = ddebug_add_module(iter_start, n, modname);
1015 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -06001016 goto out_err;
Jim Cromieb5b78f82011-12-19 17:12:54 -05001017 n = 0;
1018 modname = iter->modname;
1019 iter_start = iter;
1020 }
1021 n++;
1022 }
1023 ret = ddebug_add_module(iter_start, n, modname);
1024 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -06001025 goto out_err;
Thomas Renningera648ec02010-08-06 16:11:02 +02001026
Jim Cromieaf442392012-04-27 14:30:38 -06001027 ddebug_init_success = 1;
Joe Perchesf657fd22012-12-05 16:48:26 -05001028 vpr_info("%d modules, %d entries and %d bytes in ddebug tables, %d bytes in (readonly) verbose section\n",
1029 modct, entries, (int)(modct * sizeof(struct ddebug_table)),
1030 verbose_bytes + (int)(__stop___verbose - __start___verbose));
Jim Cromieaf442392012-04-27 14:30:38 -06001031
1032 /* apply ddebug_query boot param, dont unload tables on err */
Thomas Renningera648ec02010-08-06 16:11:02 +02001033 if (ddebug_setup_string[0] != '\0') {
Joe Perchesf657fd22012-12-05 16:48:26 -05001034 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
Jim Cromie8e59b5cf2012-04-27 14:30:40 -06001035 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001036 if (ret < 0)
Joe Perchesf657fd22012-12-05 16:48:26 -05001037 pr_warn("Invalid ddebug boot param %s\n",
Joe Perches4ad275e2011-08-11 14:36:33 -04001038 ddebug_setup_string);
Thomas Renningera648ec02010-08-06 16:11:02 +02001039 else
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001040 pr_info("%d changes by ddebug_query\n", ret);
Jason Barone9d376f2009-02-05 11:51:38 -05001041 }
Jim Cromieb48420c2012-04-27 14:30:35 -06001042 /* now that ddebug tables are loaded, process all boot args
1043 * again to find and activate queries given in dyndbg params.
1044 * While this has already been done for known boot params, it
1045 * ignored the unknown ones (dyndbg in particular). Reusing
1046 * parse_args avoids ad-hoc parsing. This will also attempt
1047 * to activate queries for not-yet-loaded modules, which is
1048 * slightly noisy if verbose, but harmless.
1049 */
1050 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1051 parse_args("dyndbg params", cmdline, NULL,
1052 0, 0, 0, &ddebug_dyndbg_boot_param_cb);
1053 kfree(cmdline);
Jim Cromieaf442392012-04-27 14:30:38 -06001054 return 0;
Thomas Renningera648ec02010-08-06 16:11:02 +02001055
Jim Cromieaf442392012-04-27 14:30:38 -06001056out_err:
1057 ddebug_remove_all_tables();
Jason Barone9d376f2009-02-05 11:51:38 -05001058 return 0;
1059}
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001060/* Allow early initialization for boot messages via boot param */
Jim Cromie3ec56522012-04-27 14:30:42 -06001061early_initcall(dynamic_debug_init);
Jim Cromieb48420c2012-04-27 14:30:35 -06001062
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001063/* Debugfs setup must be done later */
Jim Cromie3ec56522012-04-27 14:30:42 -06001064fs_initcall(dynamic_debug_init_debugfs);