blob: 7ca29a0a3019685291e33a8b3df86669f9378dea [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 Assche8ba6ebf52011-01-23 17:17:24 +010010 * Copyright (C) 2011 Bart Van Assche. All Rights Reserved.
Jason Barone9d376f2009-02-05 11:51:38 -050011 */
12
Joe Perches4ad275e2011-08-11 14:36:33 -040013#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
14
Jason Barone9d376f2009-02-05 11:51:38 -050015#include <linux/kernel.h>
16#include <linux/module.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070017#include <linux/moduleparam.h>
18#include <linux/kallsyms.h>
19#include <linux/types.h>
Jason Barone9d376f2009-02-05 11:51:38 -050020#include <linux/mutex.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070021#include <linux/proc_fs.h>
Jason Barone9d376f2009-02-05 11:51:38 -050022#include <linux/seq_file.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070023#include <linux/list.h>
24#include <linux/sysctl.h>
Jason Barone9d376f2009-02-05 11:51:38 -050025#include <linux/ctype.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070026#include <linux/string.h>
27#include <linux/uaccess.h>
Jason Barone9d376f2009-02-05 11:51:38 -050028#include <linux/dynamic_debug.h>
29#include <linux/debugfs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/slab.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070031#include <linux/jump_label.h>
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +010032#include <linux/hardirq.h>
Greg Kroah-Hartmane8d97922011-02-03 15:59:58 -080033#include <linux/sched.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070034#include <linux/device.h>
Jason Baronffa10cb2011-08-11 14:36:48 -040035#include <linux/netdevice.h>
Jason Barone9d376f2009-02-05 11:51:38 -050036
37extern struct _ddebug __start___verbose[];
38extern struct _ddebug __stop___verbose[];
39
Jason Barone9d376f2009-02-05 11:51:38 -050040struct ddebug_table {
41 struct list_head link;
42 char *mod_name;
43 unsigned int num_ddebugs;
Jason Barone9d376f2009-02-05 11:51:38 -050044 struct _ddebug *ddebugs;
45};
46
47struct ddebug_query {
48 const char *filename;
49 const char *module;
50 const char *function;
51 const char *format;
52 unsigned int first_lineno, last_lineno;
53};
54
55struct ddebug_iter {
56 struct ddebug_table *table;
57 unsigned int idx;
58};
59
60static DEFINE_MUTEX(ddebug_lock);
61static LIST_HEAD(ddebug_tables);
62static int verbose = 0;
Jim Cromie74df1382011-12-19 17:12:24 -050063module_param(verbose, int, 0644);
Jason Barone9d376f2009-02-05 11:51:38 -050064
65/* Return the last part of a pathname */
66static inline const char *basename(const char *path)
67{
68 const char *tail = strrchr(path, '/');
69 return tail ? tail+1 : path;
70}
71
Jim Cromie2b678312011-12-19 17:13:12 -050072/* Return the path relative to source root */
73static inline const char *trim_prefix(const char *path)
74{
75 int skip = strlen(__FILE__) - strlen("lib/dynamic_debug.c");
76
77 if (strncmp(path, __FILE__, skip))
78 skip = 0; /* prefix mismatch, don't skip */
79
80 return path + skip;
81}
82
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +010083static struct { unsigned flag:8; char opt_char; } opt_array[] = {
84 { _DPRINTK_FLAGS_PRINT, 'p' },
85 { _DPRINTK_FLAGS_INCL_MODNAME, 'm' },
86 { _DPRINTK_FLAGS_INCL_FUNCNAME, 'f' },
87 { _DPRINTK_FLAGS_INCL_LINENO, 'l' },
88 { _DPRINTK_FLAGS_INCL_TID, 't' },
Jim Cromie5ca7d2a2011-12-19 17:12:44 -050089 { _DPRINTK_FLAGS_NONE, '_' },
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +010090};
91
Jason Barone9d376f2009-02-05 11:51:38 -050092/* format a string into buf[] which describes the _ddebug's flags */
93static char *ddebug_describe_flags(struct _ddebug *dp, char *buf,
94 size_t maxlen)
95{
96 char *p = buf;
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +010097 int i;
Jason Barone9d376f2009-02-05 11:51:38 -050098
Jim Cromie5ca7d2a2011-12-19 17:12:44 -050099 BUG_ON(maxlen < 6);
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100100 for (i = 0; i < ARRAY_SIZE(opt_array); ++i)
101 if (dp->flags & opt_array[i].flag)
102 *p++ = opt_array[i].opt_char;
Jason Barone9d376f2009-02-05 11:51:38 -0500103 if (p == buf)
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500104 *p++ = '_';
Jason Barone9d376f2009-02-05 11:51:38 -0500105 *p = '\0';
106
107 return buf;
108}
109
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600110#define vpr_info(fmt, ...) \
111 if (verbose) do { pr_info(fmt, ##__VA_ARGS__); } while (0)
112
113#define vpr_info_dq(q, msg) \
114do { \
115 /* trim last char off format print */ \
116 vpr_info("%s: func=\"%s\" file=\"%s\" " \
117 "module=\"%s\" format=\"%.*s\" " \
118 "lineno=%u-%u", \
119 msg, \
120 q->function ? q->function : "", \
121 q->filename ? q->filename : "", \
122 q->module ? q->module : "", \
123 (int)(q->format ? strlen(q->format) - 1 : 0), \
124 q->format ? q->format : "", \
125 q->first_lineno, q->last_lineno); \
Jim Cromie574b3722011-12-19 17:13:16 -0500126} while (0)
127
Jason Barone9d376f2009-02-05 11:51:38 -0500128/*
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500129 * Search the tables for _ddebug's which match the given `query' and
130 * apply the `flags' and `mask' to them. Returns number of matching
131 * callsites, normally the same as number of changes. If verbose,
132 * logs the changes. Takes ddebug_lock.
Jason Barone9d376f2009-02-05 11:51:38 -0500133 */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500134static int ddebug_change(const struct ddebug_query *query,
135 unsigned int flags, unsigned int mask)
Jason Barone9d376f2009-02-05 11:51:38 -0500136{
137 int i;
138 struct ddebug_table *dt;
139 unsigned int newflags;
140 unsigned int nfound = 0;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500141 char flagbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500142
143 /* search for matching ddebugs */
144 mutex_lock(&ddebug_lock);
145 list_for_each_entry(dt, &ddebug_tables, link) {
146
147 /* match against the module name */
Jim Cromied6a238d2011-12-19 17:12:39 -0500148 if (query->module && strcmp(query->module, dt->mod_name))
Jason Barone9d376f2009-02-05 11:51:38 -0500149 continue;
150
151 for (i = 0 ; i < dt->num_ddebugs ; i++) {
152 struct _ddebug *dp = &dt->ddebugs[i];
153
154 /* match against the source filename */
Jim Cromied6a238d2011-12-19 17:12:39 -0500155 if (query->filename &&
Jason Barone9d376f2009-02-05 11:51:38 -0500156 strcmp(query->filename, dp->filename) &&
Jim Cromie2b678312011-12-19 17:13:12 -0500157 strcmp(query->filename, basename(dp->filename)) &&
158 strcmp(query->filename, trim_prefix(dp->filename)))
Jason Barone9d376f2009-02-05 11:51:38 -0500159 continue;
160
161 /* match against the function */
Jim Cromied6a238d2011-12-19 17:12:39 -0500162 if (query->function &&
Jason Barone9d376f2009-02-05 11:51:38 -0500163 strcmp(query->function, dp->function))
164 continue;
165
166 /* match against the format */
Jim Cromied6a238d2011-12-19 17:12:39 -0500167 if (query->format &&
168 !strstr(dp->format, query->format))
Jason Barone9d376f2009-02-05 11:51:38 -0500169 continue;
170
171 /* match against the line number range */
172 if (query->first_lineno &&
173 dp->lineno < query->first_lineno)
174 continue;
175 if (query->last_lineno &&
176 dp->lineno > query->last_lineno)
177 continue;
178
179 nfound++;
180
181 newflags = (dp->flags & mask) | flags;
182 if (newflags == dp->flags)
183 continue;
Jason Barone9d376f2009-02-05 11:51:38 -0500184 dp->flags = newflags;
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600185 vpr_info("changed %s:%d [%s]%s =%s\n",
186 trim_prefix(dp->filename), dp->lineno,
187 dt->mod_name, dp->function,
188 ddebug_describe_flags(dp, flagbuf,
189 sizeof(flagbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500190 }
191 }
192 mutex_unlock(&ddebug_lock);
193
194 if (!nfound && verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400195 pr_info("no matches for query\n");
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500196
197 return nfound;
Jason Barone9d376f2009-02-05 11:51:38 -0500198}
199
200/*
Jason Barone9d376f2009-02-05 11:51:38 -0500201 * Split the buffer `buf' into space-separated words.
Greg Banks9898abb2009-02-06 12:54:26 +1100202 * Handles simple " and ' quoting, i.e. without nested,
203 * embedded or escaped \". Return the number of words
204 * or <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500205 */
206static int ddebug_tokenize(char *buf, char *words[], int maxwords)
207{
208 int nwords = 0;
209
Greg Banks9898abb2009-02-06 12:54:26 +1100210 while (*buf) {
211 char *end;
212
213 /* Skip leading whitespace */
André Goddard Rosae7d28602009-12-14 18:01:06 -0800214 buf = skip_spaces(buf);
Greg Banks9898abb2009-02-06 12:54:26 +1100215 if (!*buf)
216 break; /* oh, it was trailing whitespace */
Jim Cromie8bd60262011-12-19 17:13:03 -0500217 if (*buf == '#')
218 break; /* token starts comment, skip rest of line */
Greg Banks9898abb2009-02-06 12:54:26 +1100219
Jim Cromie07100be2011-12-19 17:11:09 -0500220 /* find `end' of word, whitespace separated or quoted */
Greg Banks9898abb2009-02-06 12:54:26 +1100221 if (*buf == '"' || *buf == '\'') {
222 int quote = *buf++;
223 for (end = buf ; *end && *end != quote ; end++)
224 ;
225 if (!*end)
226 return -EINVAL; /* unclosed quote */
227 } else {
228 for (end = buf ; *end && !isspace(*end) ; end++)
229 ;
230 BUG_ON(end == buf);
231 }
Greg Banks9898abb2009-02-06 12:54:26 +1100232
Jim Cromie07100be2011-12-19 17:11:09 -0500233 /* `buf' is start of word, `end' is one past its end */
Greg Banks9898abb2009-02-06 12:54:26 +1100234 if (nwords == maxwords)
235 return -EINVAL; /* ran out of words[] before bytes */
236 if (*end)
237 *end++ = '\0'; /* terminate the word */
238 words[nwords++] = buf;
239 buf = end;
240 }
Jason Barone9d376f2009-02-05 11:51:38 -0500241
242 if (verbose) {
243 int i;
Joe Perches4ad275e2011-08-11 14:36:33 -0400244 pr_info("split into words:");
Jason Barone9d376f2009-02-05 11:51:38 -0500245 for (i = 0 ; i < nwords ; i++)
Joe Perches4ad275e2011-08-11 14:36:33 -0400246 pr_cont(" \"%s\"", words[i]);
247 pr_cont("\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500248 }
249
250 return nwords;
251}
252
253/*
254 * Parse a single line number. Note that the empty string ""
255 * is treated as a special case and converted to zero, which
256 * is later treated as a "don't care" value.
257 */
258static inline int parse_lineno(const char *str, unsigned int *val)
259{
260 char *end = NULL;
261 BUG_ON(str == NULL);
262 if (*str == '\0') {
263 *val = 0;
264 return 0;
265 }
266 *val = simple_strtoul(str, &end, 10);
267 return end == NULL || end == str || *end != '\0' ? -EINVAL : 0;
268}
269
270/*
271 * Undo octal escaping in a string, inplace. This is useful to
272 * allow the user to express a query which matches a format
273 * containing embedded spaces.
274 */
275#define isodigit(c) ((c) >= '0' && (c) <= '7')
276static char *unescape(char *str)
277{
278 char *in = str;
279 char *out = str;
280
281 while (*in) {
282 if (*in == '\\') {
283 if (in[1] == '\\') {
284 *out++ = '\\';
285 in += 2;
286 continue;
287 } else if (in[1] == 't') {
288 *out++ = '\t';
289 in += 2;
290 continue;
291 } else if (in[1] == 'n') {
292 *out++ = '\n';
293 in += 2;
294 continue;
295 } else if (isodigit(in[1]) &&
296 isodigit(in[2]) &&
297 isodigit(in[3])) {
298 *out++ = ((in[1] - '0')<<6) |
299 ((in[2] - '0')<<3) |
300 (in[3] - '0');
301 in += 4;
302 continue;
303 }
304 }
305 *out++ = *in++;
306 }
307 *out = '\0';
308
309 return str;
310}
311
Jim Cromie820874c2011-12-19 17:12:49 -0500312static int check_set(const char **dest, char *src, char *name)
313{
314 int rc = 0;
315
316 if (*dest) {
317 rc = -EINVAL;
318 pr_err("match-spec:%s val:%s overridden by %s",
319 name, *dest, src);
320 }
321 *dest = src;
322 return rc;
323}
324
Jason Barone9d376f2009-02-05 11:51:38 -0500325/*
326 * Parse words[] as a ddebug query specification, which is a series
327 * of (keyword, value) pairs chosen from these possibilities:
328 *
329 * func <function-name>
330 * file <full-pathname>
331 * file <base-filename>
332 * module <module-name>
333 * format <escaped-string-to-find-in-format>
334 * line <lineno>
335 * line <first-lineno>-<last-lineno> // where either may be empty
Jim Cromie820874c2011-12-19 17:12:49 -0500336 *
337 * Only 1 of each type is allowed.
338 * Returns 0 on success, <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500339 */
340static int ddebug_parse_query(char *words[], int nwords,
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600341 struct ddebug_query *query, const char *modname)
Jason Barone9d376f2009-02-05 11:51:38 -0500342{
343 unsigned int i;
Jim Cromie820874c2011-12-19 17:12:49 -0500344 int rc;
Jason Barone9d376f2009-02-05 11:51:38 -0500345
346 /* check we have an even number of words */
347 if (nwords % 2 != 0)
348 return -EINVAL;
349 memset(query, 0, sizeof(*query));
350
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600351 if (modname)
352 /* support $modname.dyndbg=<multiple queries> */
353 query->module = modname;
354
Jason Barone9d376f2009-02-05 11:51:38 -0500355 for (i = 0 ; i < nwords ; i += 2) {
356 if (!strcmp(words[i], "func"))
Jim Cromie820874c2011-12-19 17:12:49 -0500357 rc = check_set(&query->function, words[i+1], "func");
Jason Barone9d376f2009-02-05 11:51:38 -0500358 else if (!strcmp(words[i], "file"))
Jim Cromie820874c2011-12-19 17:12:49 -0500359 rc = check_set(&query->filename, words[i+1], "file");
Jason Barone9d376f2009-02-05 11:51:38 -0500360 else if (!strcmp(words[i], "module"))
Jim Cromie820874c2011-12-19 17:12:49 -0500361 rc = check_set(&query->module, words[i+1], "module");
Jason Barone9d376f2009-02-05 11:51:38 -0500362 else if (!strcmp(words[i], "format"))
Jim Cromie820874c2011-12-19 17:12:49 -0500363 rc = check_set(&query->format, unescape(words[i+1]),
364 "format");
Jason Barone9d376f2009-02-05 11:51:38 -0500365 else if (!strcmp(words[i], "line")) {
366 char *first = words[i+1];
367 char *last = strchr(first, '-');
Jim Cromie820874c2011-12-19 17:12:49 -0500368 if (query->first_lineno || query->last_lineno) {
369 pr_err("match-spec:line given 2 times\n");
370 return -EINVAL;
371 }
Jason Barone9d376f2009-02-05 11:51:38 -0500372 if (last)
373 *last++ = '\0';
374 if (parse_lineno(first, &query->first_lineno) < 0)
375 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500376 if (last) {
Jason Barone9d376f2009-02-05 11:51:38 -0500377 /* range <first>-<last> */
Jim Cromie820874c2011-12-19 17:12:49 -0500378 if (parse_lineno(last, &query->last_lineno)
379 < query->first_lineno) {
380 pr_err("last-line < 1st-line\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500381 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500382 }
Jason Barone9d376f2009-02-05 11:51:38 -0500383 } else {
384 query->last_lineno = query->first_lineno;
385 }
386 } else {
Jim Cromieae27f862011-12-19 17:12:34 -0500387 pr_err("unknown keyword \"%s\"\n", words[i]);
Jason Barone9d376f2009-02-05 11:51:38 -0500388 return -EINVAL;
389 }
Jim Cromie820874c2011-12-19 17:12:49 -0500390 if (rc)
391 return rc;
Jason Barone9d376f2009-02-05 11:51:38 -0500392 }
Jim Cromie574b3722011-12-19 17:13:16 -0500393 vpr_info_dq(query, "parsed");
Jason Barone9d376f2009-02-05 11:51:38 -0500394 return 0;
395}
396
397/*
398 * Parse `str' as a flags specification, format [-+=][p]+.
399 * Sets up *maskp and *flagsp to be used when changing the
400 * flags fields of matched _ddebug's. Returns 0 on success
401 * or <0 on error.
402 */
403static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
404 unsigned int *maskp)
405{
406 unsigned flags = 0;
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100407 int op = '=', i;
Jason Barone9d376f2009-02-05 11:51:38 -0500408
409 switch (*str) {
410 case '+':
411 case '-':
412 case '=':
413 op = *str++;
414 break;
415 default:
416 return -EINVAL;
417 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600418 vpr_info("op='%c'\n", op);
Jason Barone9d376f2009-02-05 11:51:38 -0500419
420 for ( ; *str ; ++str) {
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100421 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
422 if (*str == opt_array[i].opt_char) {
423 flags |= opt_array[i].flag;
424 break;
425 }
Jason Barone9d376f2009-02-05 11:51:38 -0500426 }
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100427 if (i < 0)
428 return -EINVAL;
Jason Barone9d376f2009-02-05 11:51:38 -0500429 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600430 vpr_info("flags=0x%x\n", flags);
Jason Barone9d376f2009-02-05 11:51:38 -0500431
432 /* calculate final *flagsp, *maskp according to mask and op */
433 switch (op) {
434 case '=':
435 *maskp = 0;
436 *flagsp = flags;
437 break;
438 case '+':
439 *maskp = ~0U;
440 *flagsp = flags;
441 break;
442 case '-':
443 *maskp = ~flags;
444 *flagsp = 0;
445 break;
446 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600447 vpr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
Jason Barone9d376f2009-02-05 11:51:38 -0500448 return 0;
449}
450
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600451static int ddebug_exec_query(char *query_string, const char *modname)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200452{
453 unsigned int flags = 0, mask = 0;
454 struct ddebug_query query;
455#define MAXWORDS 9
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500456 int nwords, nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200457 char *words[MAXWORDS];
458
459 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
460 if (nwords <= 0)
461 return -EINVAL;
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600462 if (ddebug_parse_query(words, nwords-1, &query, modname))
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200463 return -EINVAL;
464 if (ddebug_parse_flags(words[nwords-1], &flags, &mask))
465 return -EINVAL;
466
467 /* actually go and implement the change */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500468 nfound = ddebug_change(&query, flags, mask);
469 vpr_info_dq((&query), (nfound) ? "applied" : "no-match");
470
471 return nfound;
472}
473
474/* handle multiple queries in query string, continue on error, return
475 last error or number of matching callsites. Module name is either
476 in param (for boot arg) or perhaps in query string.
477*/
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600478static int ddebug_exec_queries(char *query, const char *modname)
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500479{
480 char *split;
481 int i, errs = 0, exitcode = 0, rc, nfound = 0;
482
483 for (i = 0; query; query = split) {
484 split = strpbrk(query, ";\n");
485 if (split)
486 *split++ = '\0';
487
488 query = skip_spaces(query);
489 if (!query || !*query || *query == '#')
490 continue;
491
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600492 vpr_info("query %d: \"%s\"\n", i, query);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500493
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600494 rc = ddebug_exec_query(query, modname);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500495 if (rc < 0) {
496 errs++;
497 exitcode = rc;
498 } else
499 nfound += rc;
500 i++;
501 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600502 vpr_info("processed %d queries, with %d matches, %d errs\n",
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500503 i, nfound, errs);
504
505 if (exitcode)
506 return exitcode;
507 return nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200508}
509
Jason Baron431625d2011-10-04 14:13:19 -0700510#define PREFIX_SIZE 64
511
512static int remaining(int wrote)
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100513{
Jason Baron431625d2011-10-04 14:13:19 -0700514 if (PREFIX_SIZE - wrote > 0)
515 return PREFIX_SIZE - wrote;
516 return 0;
517}
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100518
Jason Baron431625d2011-10-04 14:13:19 -0700519static char *dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
520{
521 int pos_after_tid;
522 int pos = 0;
523
524 pos += snprintf(buf + pos, remaining(pos), "%s", KERN_DEBUG);
525 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100526 if (in_interrupt())
Jason Baron431625d2011-10-04 14:13:19 -0700527 pos += snprintf(buf + pos, remaining(pos), "%s ",
528 "<intr>");
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100529 else
Jason Baron431625d2011-10-04 14:13:19 -0700530 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
531 task_pid_vnr(current));
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100532 }
Jason Baron431625d2011-10-04 14:13:19 -0700533 pos_after_tid = pos;
534 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
535 pos += snprintf(buf + pos, remaining(pos), "%s:",
536 desc->modname);
537 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
538 pos += snprintf(buf + pos, remaining(pos), "%s:",
539 desc->function);
540 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
Jim Cromie07100be2011-12-19 17:11:09 -0500541 pos += snprintf(buf + pos, remaining(pos), "%d:",
542 desc->lineno);
Jason Baron431625d2011-10-04 14:13:19 -0700543 if (pos - pos_after_tid)
544 pos += snprintf(buf + pos, remaining(pos), " ");
545 if (pos >= PREFIX_SIZE)
546 buf[PREFIX_SIZE - 1] = '\0';
Joe Perches6c2140e2011-08-11 14:36:25 -0400547
Jason Baron431625d2011-10-04 14:13:19 -0700548 return buf;
Joe Perches6c2140e2011-08-11 14:36:25 -0400549}
550
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100551int __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
552{
553 va_list args;
554 int res;
Jason Baron431625d2011-10-04 14:13:19 -0700555 struct va_format vaf;
556 char buf[PREFIX_SIZE];
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100557
558 BUG_ON(!descriptor);
559 BUG_ON(!fmt);
560
561 va_start(args, fmt);
Jason Baron431625d2011-10-04 14:13:19 -0700562 vaf.fmt = fmt;
563 vaf.va = &args;
564 res = printk("%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100565 va_end(args);
566
567 return res;
568}
569EXPORT_SYMBOL(__dynamic_pr_debug);
570
Joe Perchescbc46632011-08-11 14:36:21 -0400571int __dynamic_dev_dbg(struct _ddebug *descriptor,
572 const struct device *dev, const char *fmt, ...)
573{
574 struct va_format vaf;
575 va_list args;
576 int res;
Jason Baron431625d2011-10-04 14:13:19 -0700577 char buf[PREFIX_SIZE];
Joe Perchescbc46632011-08-11 14:36:21 -0400578
579 BUG_ON(!descriptor);
580 BUG_ON(!fmt);
581
582 va_start(args, fmt);
Joe Perchescbc46632011-08-11 14:36:21 -0400583 vaf.fmt = fmt;
584 vaf.va = &args;
Jason Baron431625d2011-10-04 14:13:19 -0700585 res = __dev_printk(dynamic_emit_prefix(descriptor, buf), dev, &vaf);
Joe Perchescbc46632011-08-11 14:36:21 -0400586 va_end(args);
587
588 return res;
589}
590EXPORT_SYMBOL(__dynamic_dev_dbg);
591
Jason Baron0feefd92011-10-04 14:13:22 -0700592#ifdef CONFIG_NET
593
Jason Baronffa10cb2011-08-11 14:36:48 -0400594int __dynamic_netdev_dbg(struct _ddebug *descriptor,
595 const struct net_device *dev, const char *fmt, ...)
596{
597 struct va_format vaf;
598 va_list args;
599 int res;
Jason Baron431625d2011-10-04 14:13:19 -0700600 char buf[PREFIX_SIZE];
Jason Baronffa10cb2011-08-11 14:36:48 -0400601
602 BUG_ON(!descriptor);
603 BUG_ON(!fmt);
604
605 va_start(args, fmt);
Jason Baronffa10cb2011-08-11 14:36:48 -0400606 vaf.fmt = fmt;
607 vaf.va = &args;
Jason Baron431625d2011-10-04 14:13:19 -0700608 res = __netdev_printk(dynamic_emit_prefix(descriptor, buf), dev, &vaf);
Jason Baronffa10cb2011-08-11 14:36:48 -0400609 va_end(args);
610
611 return res;
612}
613EXPORT_SYMBOL(__dynamic_netdev_dbg);
614
Jason Baron0feefd92011-10-04 14:13:22 -0700615#endif
616
Jim Cromiebc757f62011-12-19 17:12:29 -0500617#define DDEBUG_STRING_SIZE 1024
618static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
619
Thomas Renningera648ec02010-08-06 16:11:02 +0200620static __init int ddebug_setup_query(char *str)
621{
Jim Cromiebc757f62011-12-19 17:12:29 -0500622 if (strlen(str) >= DDEBUG_STRING_SIZE) {
Joe Perches4ad275e2011-08-11 14:36:33 -0400623 pr_warn("ddebug boot param string too large\n");
Thomas Renningera648ec02010-08-06 16:11:02 +0200624 return 0;
625 }
Jim Cromiebc757f62011-12-19 17:12:29 -0500626 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
Thomas Renningera648ec02010-08-06 16:11:02 +0200627 return 1;
628}
629
630__setup("ddebug_query=", ddebug_setup_query);
631
Jason Barone9d376f2009-02-05 11:51:38 -0500632/*
633 * File_ops->write method for <debugfs>/dynamic_debug/conrol. Gathers the
634 * command text from userspace, parses and executes it.
635 */
Jim Cromie72814912011-12-19 17:13:07 -0500636#define USER_BUF_PAGE 4096
Jason Barone9d376f2009-02-05 11:51:38 -0500637static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
638 size_t len, loff_t *offp)
639{
Jim Cromie72814912011-12-19 17:13:07 -0500640 char *tmpbuf;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200641 int ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500642
643 if (len == 0)
644 return 0;
Jim Cromie72814912011-12-19 17:13:07 -0500645 if (len > USER_BUF_PAGE - 1) {
646 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
Jason Barone9d376f2009-02-05 11:51:38 -0500647 return -E2BIG;
Jim Cromie72814912011-12-19 17:13:07 -0500648 }
649 tmpbuf = kmalloc(len + 1, GFP_KERNEL);
650 if (!tmpbuf)
651 return -ENOMEM;
652 if (copy_from_user(tmpbuf, ubuf, len)) {
653 kfree(tmpbuf);
Jason Barone9d376f2009-02-05 11:51:38 -0500654 return -EFAULT;
Jim Cromie72814912011-12-19 17:13:07 -0500655 }
Jason Barone9d376f2009-02-05 11:51:38 -0500656 tmpbuf[len] = '\0';
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600657 vpr_info("read %d bytes from userspace\n", (int)len);
Jason Barone9d376f2009-02-05 11:51:38 -0500658
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600659 ret = ddebug_exec_queries(tmpbuf, NULL);
Jim Cromie72814912011-12-19 17:13:07 -0500660 kfree(tmpbuf);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500661 if (ret < 0)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200662 return ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500663
664 *offp += len;
665 return len;
666}
667
668/*
669 * Set the iterator to point to the first _ddebug object
670 * and return a pointer to that first object. Returns
671 * NULL if there are no _ddebugs at all.
672 */
673static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
674{
675 if (list_empty(&ddebug_tables)) {
676 iter->table = NULL;
677 iter->idx = 0;
678 return NULL;
679 }
680 iter->table = list_entry(ddebug_tables.next,
681 struct ddebug_table, link);
682 iter->idx = 0;
683 return &iter->table->ddebugs[iter->idx];
684}
685
686/*
687 * Advance the iterator to point to the next _ddebug
688 * object from the one the iterator currently points at,
689 * and returns a pointer to the new _ddebug. Returns
690 * NULL if the iterator has seen all the _ddebugs.
691 */
692static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
693{
694 if (iter->table == NULL)
695 return NULL;
696 if (++iter->idx == iter->table->num_ddebugs) {
697 /* iterate to next table */
698 iter->idx = 0;
699 if (list_is_last(&iter->table->link, &ddebug_tables)) {
700 iter->table = NULL;
701 return NULL;
702 }
703 iter->table = list_entry(iter->table->link.next,
704 struct ddebug_table, link);
705 }
706 return &iter->table->ddebugs[iter->idx];
707}
708
709/*
710 * Seq_ops start method. Called at the start of every
711 * read() call from userspace. Takes the ddebug_lock and
712 * seeks the seq_file's iterator to the given position.
713 */
714static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
715{
716 struct ddebug_iter *iter = m->private;
717 struct _ddebug *dp;
718 int n = *pos;
719
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600720 vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500721
722 mutex_lock(&ddebug_lock);
723
724 if (!n)
725 return SEQ_START_TOKEN;
726 if (n < 0)
727 return NULL;
728 dp = ddebug_iter_first(iter);
729 while (dp != NULL && --n > 0)
730 dp = ddebug_iter_next(iter);
731 return dp;
732}
733
734/*
735 * Seq_ops next method. Called several times within a read()
736 * call from userspace, with ddebug_lock held. Walks to the
737 * next _ddebug object with a special case for the header line.
738 */
739static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
740{
741 struct ddebug_iter *iter = m->private;
742 struct _ddebug *dp;
743
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600744 vpr_info("called m=%p p=%p *pos=%lld\n",
745 m, p, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500746
747 if (p == SEQ_START_TOKEN)
748 dp = ddebug_iter_first(iter);
749 else
750 dp = ddebug_iter_next(iter);
751 ++*pos;
752 return dp;
753}
754
755/*
756 * Seq_ops show method. Called several times within a read()
757 * call from userspace, with ddebug_lock held. Formats the
758 * current _ddebug as a single human-readable line, with a
759 * special case for the header line.
760 */
761static int ddebug_proc_show(struct seq_file *m, void *p)
762{
763 struct ddebug_iter *iter = m->private;
764 struct _ddebug *dp = p;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500765 char flagsbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500766
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600767 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500768
769 if (p == SEQ_START_TOKEN) {
770 seq_puts(m,
771 "# filename:lineno [module]function flags format\n");
772 return 0;
773 }
774
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500775 seq_printf(m, "%s:%u [%s]%s =%s \"",
Jim Cromie2b678312011-12-19 17:13:12 -0500776 trim_prefix(dp->filename), dp->lineno,
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500777 iter->table->mod_name, dp->function,
778 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500779 seq_escape(m, dp->format, "\t\r\n\"");
780 seq_puts(m, "\"\n");
781
782 return 0;
783}
784
785/*
786 * Seq_ops stop method. Called at the end of each read()
787 * call from userspace. Drops ddebug_lock.
788 */
789static void ddebug_proc_stop(struct seq_file *m, void *p)
790{
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600791 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500792 mutex_unlock(&ddebug_lock);
793}
794
795static const struct seq_operations ddebug_proc_seqops = {
796 .start = ddebug_proc_start,
797 .next = ddebug_proc_next,
798 .show = ddebug_proc_show,
799 .stop = ddebug_proc_stop
800};
801
802/*
Jim Cromie07100be2011-12-19 17:11:09 -0500803 * File_ops->open method for <debugfs>/dynamic_debug/control. Does
804 * the seq_file setup dance, and also creates an iterator to walk the
805 * _ddebugs. Note that we create a seq_file always, even for O_WRONLY
806 * files where it's not needed, as doing so simplifies the ->release
807 * method.
Jason Barone9d376f2009-02-05 11:51:38 -0500808 */
809static int ddebug_proc_open(struct inode *inode, struct file *file)
810{
811 struct ddebug_iter *iter;
812 int err;
813
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600814 vpr_info("called\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500815
816 iter = kzalloc(sizeof(*iter), GFP_KERNEL);
817 if (iter == NULL)
818 return -ENOMEM;
819
820 err = seq_open(file, &ddebug_proc_seqops);
821 if (err) {
822 kfree(iter);
823 return err;
824 }
825 ((struct seq_file *) file->private_data)->private = iter;
826 return 0;
827}
828
829static const struct file_operations ddebug_proc_fops = {
830 .owner = THIS_MODULE,
831 .open = ddebug_proc_open,
832 .read = seq_read,
833 .llseek = seq_lseek,
834 .release = seq_release_private,
835 .write = ddebug_proc_write
836};
837
838/*
839 * Allocate a new ddebug_table for the given module
840 * and add it to the global list.
841 */
842int ddebug_add_module(struct _ddebug *tab, unsigned int n,
843 const char *name)
844{
845 struct ddebug_table *dt;
846 char *new_name;
847
848 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
849 if (dt == NULL)
850 return -ENOMEM;
851 new_name = kstrdup(name, GFP_KERNEL);
852 if (new_name == NULL) {
853 kfree(dt);
854 return -ENOMEM;
855 }
856 dt->mod_name = new_name;
857 dt->num_ddebugs = n;
Jason Barone9d376f2009-02-05 11:51:38 -0500858 dt->ddebugs = tab;
859
860 mutex_lock(&ddebug_lock);
861 list_add_tail(&dt->link, &ddebug_tables);
862 mutex_unlock(&ddebug_lock);
863
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600864 vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500865 return 0;
866}
867EXPORT_SYMBOL_GPL(ddebug_add_module);
868
Jim Cromie6ab676e2012-04-27 14:30:37 -0600869/* helper for ddebug_dyndbg_(boot|module)_param_cb */
870static int ddebug_dyndbg_param_cb(char *param, char *val,
871 const char *modname, int on_err)
Jim Cromieb48420c2012-04-27 14:30:35 -0600872{
Jim Cromieb48420c2012-04-27 14:30:35 -0600873 char *sep;
874
875 sep = strchr(param, '.');
876 if (sep) {
Jim Cromie6ab676e2012-04-27 14:30:37 -0600877 /* needed only for ddebug_dyndbg_boot_param_cb */
Jim Cromieb48420c2012-04-27 14:30:35 -0600878 *sep = '\0';
879 modname = param;
880 param = sep + 1;
881 }
882 if (strcmp(param, "dyndbg"))
Jim Cromie6ab676e2012-04-27 14:30:37 -0600883 return on_err; /* determined by caller */
Jim Cromieb48420c2012-04-27 14:30:35 -0600884
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600885 ddebug_exec_queries((val ? val : "+p"), modname);
886
Jim Cromieb48420c2012-04-27 14:30:35 -0600887 return 0; /* query failure shouldnt stop module load */
888}
889
Jim Cromie6ab676e2012-04-27 14:30:37 -0600890/* handle both dyndbg and $module.dyndbg params at boot */
891static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
892 const char *unused)
Jim Cromieb48420c2012-04-27 14:30:35 -0600893{
Jim Cromie6ab676e2012-04-27 14:30:37 -0600894 vpr_info("%s=\"%s\"\n", param, val);
895 return ddebug_dyndbg_param_cb(param, val, NULL, 0);
896}
Jim Cromieb48420c2012-04-27 14:30:35 -0600897
Jim Cromie6ab676e2012-04-27 14:30:37 -0600898/*
899 * modprobe foo finds foo.params in boot-args, strips "foo.", and
900 * passes them to load_module(). This callback gets unknown params,
901 * processes dyndbg params, rejects others.
902 */
903int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
904{
905 vpr_info("module: %s %s=\"%s\"\n", module, param, val);
906 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
Jim Cromieb48420c2012-04-27 14:30:35 -0600907}
908
Jason Barone9d376f2009-02-05 11:51:38 -0500909static void ddebug_table_free(struct ddebug_table *dt)
910{
911 list_del_init(&dt->link);
912 kfree(dt->mod_name);
913 kfree(dt);
914}
915
916/*
917 * Called in response to a module being unloaded. Removes
918 * any ddebug_table's which point at the module.
919 */
Yehuda Sadehff49d742010-07-03 13:07:35 +1000920int ddebug_remove_module(const char *mod_name)
Jason Barone9d376f2009-02-05 11:51:38 -0500921{
922 struct ddebug_table *dt, *nextdt;
923 int ret = -ENOENT;
924
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600925 vpr_info("removing module \"%s\"\n", mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500926
927 mutex_lock(&ddebug_lock);
928 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
929 if (!strcmp(dt->mod_name, mod_name)) {
930 ddebug_table_free(dt);
931 ret = 0;
932 }
933 }
934 mutex_unlock(&ddebug_lock);
935 return ret;
936}
937EXPORT_SYMBOL_GPL(ddebug_remove_module);
938
939static void ddebug_remove_all_tables(void)
940{
941 mutex_lock(&ddebug_lock);
942 while (!list_empty(&ddebug_tables)) {
943 struct ddebug_table *dt = list_entry(ddebug_tables.next,
944 struct ddebug_table,
945 link);
946 ddebug_table_free(dt);
947 }
948 mutex_unlock(&ddebug_lock);
949}
950
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200951static __initdata int ddebug_init_success;
952
953static int __init dynamic_debug_init_debugfs(void)
Jason Barone9d376f2009-02-05 11:51:38 -0500954{
955 struct dentry *dir, *file;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200956
957 if (!ddebug_init_success)
958 return -ENODEV;
Jason Barone9d376f2009-02-05 11:51:38 -0500959
960 dir = debugfs_create_dir("dynamic_debug", NULL);
961 if (!dir)
962 return -ENOMEM;
963 file = debugfs_create_file("control", 0644, dir, NULL,
964 &ddebug_proc_fops);
965 if (!file) {
966 debugfs_remove(dir);
967 return -ENOMEM;
968 }
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200969 return 0;
970}
971
972static int __init dynamic_debug_init(void)
973{
974 struct _ddebug *iter, *iter_start;
975 const char *modname = NULL;
Jim Cromieb48420c2012-04-27 14:30:35 -0600976 char *cmdline;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200977 int ret = 0;
Jim Cromie41076922012-04-27 14:30:39 -0600978 int n = 0, entries = 0, modct = 0;
979 int verbose_bytes = 0;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200980
Jim Cromieb5b78f82011-12-19 17:12:54 -0500981 if (__start___verbose == __stop___verbose) {
982 pr_warn("_ddebug table is empty in a "
983 "CONFIG_DYNAMIC_DEBUG build");
984 return 1;
Jason Barone9d376f2009-02-05 11:51:38 -0500985 }
Jim Cromieb5b78f82011-12-19 17:12:54 -0500986 iter = __start___verbose;
987 modname = iter->modname;
988 iter_start = iter;
989 for (; iter < __stop___verbose; iter++) {
Jim Cromie41076922012-04-27 14:30:39 -0600990 entries++;
991 verbose_bytes += strlen(iter->modname) + strlen(iter->function)
992 + strlen(iter->filename) + strlen(iter->format);
993
Jim Cromieb5b78f82011-12-19 17:12:54 -0500994 if (strcmp(modname, iter->modname)) {
Jim Cromie41076922012-04-27 14:30:39 -0600995 modct++;
Jim Cromieb5b78f82011-12-19 17:12:54 -0500996 ret = ddebug_add_module(iter_start, n, modname);
997 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -0600998 goto out_err;
Jim Cromieb5b78f82011-12-19 17:12:54 -0500999 n = 0;
1000 modname = iter->modname;
1001 iter_start = iter;
1002 }
1003 n++;
1004 }
1005 ret = ddebug_add_module(iter_start, n, modname);
1006 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -06001007 goto out_err;
Thomas Renningera648ec02010-08-06 16:11:02 +02001008
Jim Cromieaf442392012-04-27 14:30:38 -06001009 ddebug_init_success = 1;
Jim Cromie41076922012-04-27 14:30:39 -06001010 vpr_info("%d modules, %d entries and %d bytes in ddebug tables,"
1011 " %d bytes in (readonly) verbose section\n",
1012 modct, entries, (int)( modct * sizeof(struct ddebug_table)),
1013 verbose_bytes + (int)(__stop___verbose - __start___verbose));
Jim Cromieaf442392012-04-27 14:30:38 -06001014
1015 /* apply ddebug_query boot param, dont unload tables on err */
Thomas Renningera648ec02010-08-06 16:11:02 +02001016 if (ddebug_setup_string[0] != '\0') {
Jim Cromief0b919d2012-04-27 14:30:36 -06001017 pr_warn("ddebug_query param name is deprecated,"
1018 " change it to dyndbg\n");
Jim Cromie8e59b5cf2012-04-27 14:30:40 -06001019 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001020 if (ret < 0)
Joe Perches4ad275e2011-08-11 14:36:33 -04001021 pr_warn("Invalid ddebug boot param %s",
1022 ddebug_setup_string);
Thomas Renningera648ec02010-08-06 16:11:02 +02001023 else
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001024 pr_info("%d changes by ddebug_query\n", ret);
Jason Barone9d376f2009-02-05 11:51:38 -05001025 }
Jim Cromieb48420c2012-04-27 14:30:35 -06001026 /* now that ddebug tables are loaded, process all boot args
1027 * again to find and activate queries given in dyndbg params.
1028 * While this has already been done for known boot params, it
1029 * ignored the unknown ones (dyndbg in particular). Reusing
1030 * parse_args avoids ad-hoc parsing. This will also attempt
1031 * to activate queries for not-yet-loaded modules, which is
1032 * slightly noisy if verbose, but harmless.
1033 */
1034 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1035 parse_args("dyndbg params", cmdline, NULL,
1036 0, 0, 0, &ddebug_dyndbg_boot_param_cb);
1037 kfree(cmdline);
Jim Cromieaf442392012-04-27 14:30:38 -06001038 return 0;
Thomas Renningera648ec02010-08-06 16:11:02 +02001039
Jim Cromieaf442392012-04-27 14:30:38 -06001040out_err:
1041 ddebug_remove_all_tables();
Jason Barone9d376f2009-02-05 11:51:38 -05001042 return 0;
1043}
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001044/* Allow early initialization for boot messages via boot param */
Jim Cromie3ec56522012-04-27 14:30:42 -06001045early_initcall(dynamic_debug_init);
Jim Cromieb48420c2012-04-27 14:30:35 -06001046
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001047/* Debugfs setup must be done later */
Jim Cromie3ec56522012-04-27 14:30:42 -06001048fs_initcall(dynamic_debug_init_debugfs);