blob: e7f7d993357a57985169ecbfc36ca793798c1a60 [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.
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 Assche8ba6ebf2011-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 Assche8ba6ebf2011-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 Assche8ba6ebf2011-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 Assche8ba6ebf2011-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 Assche8ba6ebf2011-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 Assche8ba6ebf2011-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 Assche8ba6ebf2011-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 Assche8ba6ebf2011-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 Assche8ba6ebf2011-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 Assche8ba6ebf2011-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
Joe Perches798efc62012-09-12 20:11:29 -0700524 *buf = '\0';
525
Jason Baron431625d2011-10-04 14:13:19 -0700526 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100527 if (in_interrupt())
Joe Perches798efc62012-09-12 20:11:29 -0700528 pos += snprintf(buf + pos, remaining(pos), "<intr> ");
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100529 else
Jason Baron431625d2011-10-04 14:13:19 -0700530 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
Joe Perches798efc62012-09-12 20:11:29 -0700531 task_pid_vnr(current));
Bart Van Assche8ba6ebf2011-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:",
Joe Perches798efc62012-09-12 20:11:29 -0700536 desc->modname);
Jason Baron431625d2011-10-04 14:13:19 -0700537 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
538 pos += snprintf(buf + pos, remaining(pos), "%s:",
Joe Perches798efc62012-09-12 20:11:29 -0700539 desc->function);
Jason Baron431625d2011-10-04 14:13:19 -0700540 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
Jim Cromie07100be2011-12-19 17:11:09 -0500541 pos += snprintf(buf + pos, remaining(pos), "%d:",
Joe Perches798efc62012-09-12 20:11:29 -0700542 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 Assche8ba6ebf2011-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 Assche8ba6ebf2011-01-23 17:17:24 +0100557
558 BUG_ON(!descriptor);
559 BUG_ON(!fmt);
560
561 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700562
Jason Baron431625d2011-10-04 14:13:19 -0700563 vaf.fmt = fmt;
564 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700565
566 res = printk(KERN_DEBUG "%s%pV",
567 dynamic_emit_prefix(descriptor, buf), &vaf);
568
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100569 va_end(args);
570
571 return res;
572}
573EXPORT_SYMBOL(__dynamic_pr_debug);
574
Joe Perchescbc46632011-08-11 14:36:21 -0400575int __dynamic_dev_dbg(struct _ddebug *descriptor,
576 const struct device *dev, const char *fmt, ...)
577{
578 struct va_format vaf;
579 va_list args;
580 int res;
581
582 BUG_ON(!descriptor);
583 BUG_ON(!fmt);
584
585 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700586
Joe Perchescbc46632011-08-11 14:36:21 -0400587 vaf.fmt = fmt;
588 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700589
590 if (!dev) {
591 res = printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
592 } else {
593 char buf[PREFIX_SIZE];
Joe Perches798efc62012-09-12 20:11:29 -0700594
Joe Perches666f3552012-09-12 20:14:11 -0700595 res = dev_printk_emit(7, dev, "%s%s %s: %pV",
596 dynamic_emit_prefix(descriptor, buf),
597 dev_driver_string(dev), dev_name(dev),
598 &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700599 }
600
Joe Perchescbc46632011-08-11 14:36:21 -0400601 va_end(args);
602
603 return res;
604}
605EXPORT_SYMBOL(__dynamic_dev_dbg);
606
Jason Baron0feefd92011-10-04 14:13:22 -0700607#ifdef CONFIG_NET
608
Jason Baronffa10cb2011-08-11 14:36:48 -0400609int __dynamic_netdev_dbg(struct _ddebug *descriptor,
Joe Perchesb004ff42012-09-12 20:12:19 -0700610 const struct net_device *dev, const char *fmt, ...)
Jason Baronffa10cb2011-08-11 14:36:48 -0400611{
612 struct va_format vaf;
613 va_list args;
614 int res;
615
616 BUG_ON(!descriptor);
617 BUG_ON(!fmt);
618
619 va_start(args, fmt);
Joe Perchesb004ff42012-09-12 20:12:19 -0700620
Jason Baronffa10cb2011-08-11 14:36:48 -0400621 vaf.fmt = fmt;
622 vaf.va = &args;
Joe Perchesb004ff42012-09-12 20:12:19 -0700623
624 if (dev && dev->dev.parent) {
625 char buf[PREFIX_SIZE];
Joe Perchesb004ff42012-09-12 20:12:19 -0700626
Joe Perches666f3552012-09-12 20:14:11 -0700627 res = dev_printk_emit(7, dev->dev.parent,
628 "%s%s %s %s: %pV",
629 dynamic_emit_prefix(descriptor, buf),
630 dev_driver_string(dev->dev.parent),
631 dev_name(dev->dev.parent),
632 netdev_name(dev), &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700633 } else if (dev) {
634 res = printk(KERN_DEBUG "%s: %pV", netdev_name(dev), &vaf);
635 } else {
636 res = printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
637 }
638
Jason Baronffa10cb2011-08-11 14:36:48 -0400639 va_end(args);
640
641 return res;
642}
643EXPORT_SYMBOL(__dynamic_netdev_dbg);
644
Jason Baron0feefd92011-10-04 14:13:22 -0700645#endif
646
Jim Cromiebc757f62011-12-19 17:12:29 -0500647#define DDEBUG_STRING_SIZE 1024
648static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
649
Thomas Renningera648ec02010-08-06 16:11:02 +0200650static __init int ddebug_setup_query(char *str)
651{
Jim Cromiebc757f62011-12-19 17:12:29 -0500652 if (strlen(str) >= DDEBUG_STRING_SIZE) {
Joe Perches4ad275e2011-08-11 14:36:33 -0400653 pr_warn("ddebug boot param string too large\n");
Thomas Renningera648ec02010-08-06 16:11:02 +0200654 return 0;
655 }
Jim Cromiebc757f62011-12-19 17:12:29 -0500656 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
Thomas Renningera648ec02010-08-06 16:11:02 +0200657 return 1;
658}
659
660__setup("ddebug_query=", ddebug_setup_query);
661
Jason Barone9d376f2009-02-05 11:51:38 -0500662/*
663 * File_ops->write method for <debugfs>/dynamic_debug/conrol. Gathers the
664 * command text from userspace, parses and executes it.
665 */
Jim Cromie72814912011-12-19 17:13:07 -0500666#define USER_BUF_PAGE 4096
Jason Barone9d376f2009-02-05 11:51:38 -0500667static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
668 size_t len, loff_t *offp)
669{
Jim Cromie72814912011-12-19 17:13:07 -0500670 char *tmpbuf;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200671 int ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500672
673 if (len == 0)
674 return 0;
Jim Cromie72814912011-12-19 17:13:07 -0500675 if (len > USER_BUF_PAGE - 1) {
676 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
Jason Barone9d376f2009-02-05 11:51:38 -0500677 return -E2BIG;
Jim Cromie72814912011-12-19 17:13:07 -0500678 }
679 tmpbuf = kmalloc(len + 1, GFP_KERNEL);
680 if (!tmpbuf)
681 return -ENOMEM;
682 if (copy_from_user(tmpbuf, ubuf, len)) {
683 kfree(tmpbuf);
Jason Barone9d376f2009-02-05 11:51:38 -0500684 return -EFAULT;
Jim Cromie72814912011-12-19 17:13:07 -0500685 }
Jason Barone9d376f2009-02-05 11:51:38 -0500686 tmpbuf[len] = '\0';
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600687 vpr_info("read %d bytes from userspace\n", (int)len);
Jason Barone9d376f2009-02-05 11:51:38 -0500688
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600689 ret = ddebug_exec_queries(tmpbuf, NULL);
Jim Cromie72814912011-12-19 17:13:07 -0500690 kfree(tmpbuf);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500691 if (ret < 0)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200692 return ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500693
694 *offp += len;
695 return len;
696}
697
698/*
699 * Set the iterator to point to the first _ddebug object
700 * and return a pointer to that first object. Returns
701 * NULL if there are no _ddebugs at all.
702 */
703static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
704{
705 if (list_empty(&ddebug_tables)) {
706 iter->table = NULL;
707 iter->idx = 0;
708 return NULL;
709 }
710 iter->table = list_entry(ddebug_tables.next,
711 struct ddebug_table, link);
712 iter->idx = 0;
713 return &iter->table->ddebugs[iter->idx];
714}
715
716/*
717 * Advance the iterator to point to the next _ddebug
718 * object from the one the iterator currently points at,
719 * and returns a pointer to the new _ddebug. Returns
720 * NULL if the iterator has seen all the _ddebugs.
721 */
722static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
723{
724 if (iter->table == NULL)
725 return NULL;
726 if (++iter->idx == iter->table->num_ddebugs) {
727 /* iterate to next table */
728 iter->idx = 0;
729 if (list_is_last(&iter->table->link, &ddebug_tables)) {
730 iter->table = NULL;
731 return NULL;
732 }
733 iter->table = list_entry(iter->table->link.next,
734 struct ddebug_table, link);
735 }
736 return &iter->table->ddebugs[iter->idx];
737}
738
739/*
740 * Seq_ops start method. Called at the start of every
741 * read() call from userspace. Takes the ddebug_lock and
742 * seeks the seq_file's iterator to the given position.
743 */
744static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
745{
746 struct ddebug_iter *iter = m->private;
747 struct _ddebug *dp;
748 int n = *pos;
749
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600750 vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500751
752 mutex_lock(&ddebug_lock);
753
754 if (!n)
755 return SEQ_START_TOKEN;
756 if (n < 0)
757 return NULL;
758 dp = ddebug_iter_first(iter);
759 while (dp != NULL && --n > 0)
760 dp = ddebug_iter_next(iter);
761 return dp;
762}
763
764/*
765 * Seq_ops next method. Called several times within a read()
766 * call from userspace, with ddebug_lock held. Walks to the
767 * next _ddebug object with a special case for the header line.
768 */
769static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
770{
771 struct ddebug_iter *iter = m->private;
772 struct _ddebug *dp;
773
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600774 vpr_info("called m=%p p=%p *pos=%lld\n",
775 m, p, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500776
777 if (p == SEQ_START_TOKEN)
778 dp = ddebug_iter_first(iter);
779 else
780 dp = ddebug_iter_next(iter);
781 ++*pos;
782 return dp;
783}
784
785/*
786 * Seq_ops show method. Called several times within a read()
787 * call from userspace, with ddebug_lock held. Formats the
788 * current _ddebug as a single human-readable line, with a
789 * special case for the header line.
790 */
791static int ddebug_proc_show(struct seq_file *m, void *p)
792{
793 struct ddebug_iter *iter = m->private;
794 struct _ddebug *dp = p;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500795 char flagsbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500796
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600797 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500798
799 if (p == SEQ_START_TOKEN) {
800 seq_puts(m,
801 "# filename:lineno [module]function flags format\n");
802 return 0;
803 }
804
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500805 seq_printf(m, "%s:%u [%s]%s =%s \"",
Jim Cromie2b678312011-12-19 17:13:12 -0500806 trim_prefix(dp->filename), dp->lineno,
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500807 iter->table->mod_name, dp->function,
808 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500809 seq_escape(m, dp->format, "\t\r\n\"");
810 seq_puts(m, "\"\n");
811
812 return 0;
813}
814
815/*
816 * Seq_ops stop method. Called at the end of each read()
817 * call from userspace. Drops ddebug_lock.
818 */
819static void ddebug_proc_stop(struct seq_file *m, void *p)
820{
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600821 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500822 mutex_unlock(&ddebug_lock);
823}
824
825static const struct seq_operations ddebug_proc_seqops = {
826 .start = ddebug_proc_start,
827 .next = ddebug_proc_next,
828 .show = ddebug_proc_show,
829 .stop = ddebug_proc_stop
830};
831
832/*
Jim Cromie07100be2011-12-19 17:11:09 -0500833 * File_ops->open method for <debugfs>/dynamic_debug/control. Does
834 * the seq_file setup dance, and also creates an iterator to walk the
835 * _ddebugs. Note that we create a seq_file always, even for O_WRONLY
836 * files where it's not needed, as doing so simplifies the ->release
837 * method.
Jason Barone9d376f2009-02-05 11:51:38 -0500838 */
839static int ddebug_proc_open(struct inode *inode, struct file *file)
840{
841 struct ddebug_iter *iter;
842 int err;
843
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600844 vpr_info("called\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500845
846 iter = kzalloc(sizeof(*iter), GFP_KERNEL);
847 if (iter == NULL)
848 return -ENOMEM;
849
850 err = seq_open(file, &ddebug_proc_seqops);
851 if (err) {
852 kfree(iter);
853 return err;
854 }
855 ((struct seq_file *) file->private_data)->private = iter;
856 return 0;
857}
858
859static const struct file_operations ddebug_proc_fops = {
860 .owner = THIS_MODULE,
861 .open = ddebug_proc_open,
862 .read = seq_read,
863 .llseek = seq_lseek,
864 .release = seq_release_private,
865 .write = ddebug_proc_write
866};
867
868/*
869 * Allocate a new ddebug_table for the given module
870 * and add it to the global list.
871 */
872int ddebug_add_module(struct _ddebug *tab, unsigned int n,
873 const char *name)
874{
875 struct ddebug_table *dt;
876 char *new_name;
877
878 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
879 if (dt == NULL)
880 return -ENOMEM;
881 new_name = kstrdup(name, GFP_KERNEL);
882 if (new_name == NULL) {
883 kfree(dt);
884 return -ENOMEM;
885 }
886 dt->mod_name = new_name;
887 dt->num_ddebugs = n;
Jason Barone9d376f2009-02-05 11:51:38 -0500888 dt->ddebugs = tab;
889
890 mutex_lock(&ddebug_lock);
891 list_add_tail(&dt->link, &ddebug_tables);
892 mutex_unlock(&ddebug_lock);
893
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600894 vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500895 return 0;
896}
897EXPORT_SYMBOL_GPL(ddebug_add_module);
898
Jim Cromie6ab676e2012-04-27 14:30:37 -0600899/* helper for ddebug_dyndbg_(boot|module)_param_cb */
900static int ddebug_dyndbg_param_cb(char *param, char *val,
901 const char *modname, int on_err)
Jim Cromieb48420c2012-04-27 14:30:35 -0600902{
Jim Cromieb48420c2012-04-27 14:30:35 -0600903 char *sep;
904
905 sep = strchr(param, '.');
906 if (sep) {
Jim Cromie6ab676e2012-04-27 14:30:37 -0600907 /* needed only for ddebug_dyndbg_boot_param_cb */
Jim Cromieb48420c2012-04-27 14:30:35 -0600908 *sep = '\0';
909 modname = param;
910 param = sep + 1;
911 }
912 if (strcmp(param, "dyndbg"))
Jim Cromie6ab676e2012-04-27 14:30:37 -0600913 return on_err; /* determined by caller */
Jim Cromieb48420c2012-04-27 14:30:35 -0600914
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600915 ddebug_exec_queries((val ? val : "+p"), modname);
916
Jim Cromieb48420c2012-04-27 14:30:35 -0600917 return 0; /* query failure shouldnt stop module load */
918}
919
Jim Cromie6ab676e2012-04-27 14:30:37 -0600920/* handle both dyndbg and $module.dyndbg params at boot */
921static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
922 const char *unused)
Jim Cromieb48420c2012-04-27 14:30:35 -0600923{
Jim Cromie6ab676e2012-04-27 14:30:37 -0600924 vpr_info("%s=\"%s\"\n", param, val);
925 return ddebug_dyndbg_param_cb(param, val, NULL, 0);
926}
Jim Cromieb48420c2012-04-27 14:30:35 -0600927
Jim Cromie6ab676e2012-04-27 14:30:37 -0600928/*
929 * modprobe foo finds foo.params in boot-args, strips "foo.", and
930 * passes them to load_module(). This callback gets unknown params,
931 * processes dyndbg params, rejects others.
932 */
933int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
934{
935 vpr_info("module: %s %s=\"%s\"\n", module, param, val);
936 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
Jim Cromieb48420c2012-04-27 14:30:35 -0600937}
938
Jason Barone9d376f2009-02-05 11:51:38 -0500939static void ddebug_table_free(struct ddebug_table *dt)
940{
941 list_del_init(&dt->link);
942 kfree(dt->mod_name);
943 kfree(dt);
944}
945
946/*
947 * Called in response to a module being unloaded. Removes
948 * any ddebug_table's which point at the module.
949 */
Yehuda Sadehff49d742010-07-03 13:07:35 +1000950int ddebug_remove_module(const char *mod_name)
Jason Barone9d376f2009-02-05 11:51:38 -0500951{
952 struct ddebug_table *dt, *nextdt;
953 int ret = -ENOENT;
954
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600955 vpr_info("removing module \"%s\"\n", mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500956
957 mutex_lock(&ddebug_lock);
958 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
959 if (!strcmp(dt->mod_name, mod_name)) {
960 ddebug_table_free(dt);
961 ret = 0;
962 }
963 }
964 mutex_unlock(&ddebug_lock);
965 return ret;
966}
967EXPORT_SYMBOL_GPL(ddebug_remove_module);
968
969static void ddebug_remove_all_tables(void)
970{
971 mutex_lock(&ddebug_lock);
972 while (!list_empty(&ddebug_tables)) {
973 struct ddebug_table *dt = list_entry(ddebug_tables.next,
974 struct ddebug_table,
975 link);
976 ddebug_table_free(dt);
977 }
978 mutex_unlock(&ddebug_lock);
979}
980
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200981static __initdata int ddebug_init_success;
982
983static int __init dynamic_debug_init_debugfs(void)
Jason Barone9d376f2009-02-05 11:51:38 -0500984{
985 struct dentry *dir, *file;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200986
987 if (!ddebug_init_success)
988 return -ENODEV;
Jason Barone9d376f2009-02-05 11:51:38 -0500989
990 dir = debugfs_create_dir("dynamic_debug", NULL);
991 if (!dir)
992 return -ENOMEM;
993 file = debugfs_create_file("control", 0644, dir, NULL,
994 &ddebug_proc_fops);
995 if (!file) {
996 debugfs_remove(dir);
997 return -ENOMEM;
998 }
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200999 return 0;
1000}
1001
1002static int __init dynamic_debug_init(void)
1003{
1004 struct _ddebug *iter, *iter_start;
1005 const char *modname = NULL;
Jim Cromieb48420c2012-04-27 14:30:35 -06001006 char *cmdline;
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001007 int ret = 0;
Jim Cromie41076922012-04-27 14:30:39 -06001008 int n = 0, entries = 0, modct = 0;
1009 int verbose_bytes = 0;
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001010
Jim Cromieb5b78f82011-12-19 17:12:54 -05001011 if (__start___verbose == __stop___verbose) {
1012 pr_warn("_ddebug table is empty in a "
1013 "CONFIG_DYNAMIC_DEBUG build");
1014 return 1;
Jason Barone9d376f2009-02-05 11:51:38 -05001015 }
Jim Cromieb5b78f82011-12-19 17:12:54 -05001016 iter = __start___verbose;
1017 modname = iter->modname;
1018 iter_start = iter;
1019 for (; iter < __stop___verbose; iter++) {
Jim Cromie41076922012-04-27 14:30:39 -06001020 entries++;
1021 verbose_bytes += strlen(iter->modname) + strlen(iter->function)
1022 + strlen(iter->filename) + strlen(iter->format);
1023
Jim Cromieb5b78f82011-12-19 17:12:54 -05001024 if (strcmp(modname, iter->modname)) {
Jim Cromie41076922012-04-27 14:30:39 -06001025 modct++;
Jim Cromieb5b78f82011-12-19 17:12:54 -05001026 ret = ddebug_add_module(iter_start, n, modname);
1027 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -06001028 goto out_err;
Jim Cromieb5b78f82011-12-19 17:12:54 -05001029 n = 0;
1030 modname = iter->modname;
1031 iter_start = iter;
1032 }
1033 n++;
1034 }
1035 ret = ddebug_add_module(iter_start, n, modname);
1036 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -06001037 goto out_err;
Thomas Renningera648ec02010-08-06 16:11:02 +02001038
Jim Cromieaf442392012-04-27 14:30:38 -06001039 ddebug_init_success = 1;
Jim Cromie41076922012-04-27 14:30:39 -06001040 vpr_info("%d modules, %d entries and %d bytes in ddebug tables,"
1041 " %d bytes in (readonly) verbose section\n",
1042 modct, entries, (int)( modct * sizeof(struct ddebug_table)),
1043 verbose_bytes + (int)(__stop___verbose - __start___verbose));
Jim Cromieaf442392012-04-27 14:30:38 -06001044
1045 /* apply ddebug_query boot param, dont unload tables on err */
Thomas Renningera648ec02010-08-06 16:11:02 +02001046 if (ddebug_setup_string[0] != '\0') {
Jim Cromief0b919d2012-04-27 14:30:36 -06001047 pr_warn("ddebug_query param name is deprecated,"
1048 " change it to dyndbg\n");
Jim Cromie8e59b5cf2012-04-27 14:30:40 -06001049 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001050 if (ret < 0)
Joe Perches4ad275e2011-08-11 14:36:33 -04001051 pr_warn("Invalid ddebug boot param %s",
1052 ddebug_setup_string);
Thomas Renningera648ec02010-08-06 16:11:02 +02001053 else
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001054 pr_info("%d changes by ddebug_query\n", ret);
Jason Barone9d376f2009-02-05 11:51:38 -05001055 }
Jim Cromieb48420c2012-04-27 14:30:35 -06001056 /* now that ddebug tables are loaded, process all boot args
1057 * again to find and activate queries given in dyndbg params.
1058 * While this has already been done for known boot params, it
1059 * ignored the unknown ones (dyndbg in particular). Reusing
1060 * parse_args avoids ad-hoc parsing. This will also attempt
1061 * to activate queries for not-yet-loaded modules, which is
1062 * slightly noisy if verbose, but harmless.
1063 */
1064 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1065 parse_args("dyndbg params", cmdline, NULL,
1066 0, 0, 0, &ddebug_dyndbg_boot_param_cb);
1067 kfree(cmdline);
Jim Cromieaf442392012-04-27 14:30:38 -06001068 return 0;
Thomas Renningera648ec02010-08-06 16:11:02 +02001069
Jim Cromieaf442392012-04-27 14:30:38 -06001070out_err:
1071 ddebug_remove_all_tables();
Jason Barone9d376f2009-02-05 11:51:38 -05001072 return 0;
1073}
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001074/* Allow early initialization for boot messages via boot param */
Jim Cromie3ec56522012-04-27 14:30:42 -06001075early_initcall(dynamic_debug_init);
Jim Cromieb48420c2012-04-27 14:30:35 -06001076
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001077/* Debugfs setup must be done later */
Jim Cromie3ec56522012-04-27 14:30:42 -06001078fs_initcall(dynamic_debug_init_debugfs);