blob: 310c753cf83e27788e80ae81088b48ad824149be [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>
17#include <linux/moduleparam.h>
18#include <linux/kallsyms.h>
Jason Barone9d376f2009-02-05 11:51:38 -050019#include <linux/types.h>
20#include <linux/mutex.h>
21#include <linux/proc_fs.h>
22#include <linux/seq_file.h>
23#include <linux/list.h>
24#include <linux/sysctl.h>
25#include <linux/ctype.h>
André Goddard Rosae7d28602009-12-14 18:01:06 -080026#include <linux/string.h>
Jason Barone9d376f2009-02-05 11:51:38 -050027#include <linux/uaccess.h>
28#include <linux/dynamic_debug.h>
29#include <linux/debugfs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/slab.h>
Jason Baron52159d92010-09-17 11:09:17 -040031#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>
Joe Perchescbc46632011-08-11 14:36:21 -040034#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 Cromie574b3722011-12-19 17:13:16 -0500110#define vpr_info_dq(q, msg) \
111do { \
112 if (verbose) \
113 /* trim last char off format print */ \
114 pr_info("%s: func=\"%s\" file=\"%s\" " \
115 "module=\"%s\" format=\"%.*s\" " \
116 "lineno=%u-%u", \
117 msg, \
118 q->function ? q->function : "", \
119 q->filename ? q->filename : "", \
120 q->module ? q->module : "", \
121 (int)(q->format ? strlen(q->format) - 1 : 0), \
122 q->format ? q->format : "", \
123 q->first_lineno, q->last_lineno); \
124} while (0)
125
Jason Barone9d376f2009-02-05 11:51:38 -0500126/*
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500127 * Search the tables for _ddebug's which match the given `query' and
128 * apply the `flags' and `mask' to them. Returns number of matching
129 * callsites, normally the same as number of changes. If verbose,
130 * logs the changes. Takes ddebug_lock.
Jason Barone9d376f2009-02-05 11:51:38 -0500131 */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500132static int ddebug_change(const struct ddebug_query *query,
133 unsigned int flags, unsigned int mask)
Jason Barone9d376f2009-02-05 11:51:38 -0500134{
135 int i;
136 struct ddebug_table *dt;
137 unsigned int newflags;
138 unsigned int nfound = 0;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500139 char flagbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500140
141 /* search for matching ddebugs */
142 mutex_lock(&ddebug_lock);
143 list_for_each_entry(dt, &ddebug_tables, link) {
144
145 /* match against the module name */
Jim Cromied6a238d2011-12-19 17:12:39 -0500146 if (query->module && strcmp(query->module, dt->mod_name))
Jason Barone9d376f2009-02-05 11:51:38 -0500147 continue;
148
149 for (i = 0 ; i < dt->num_ddebugs ; i++) {
150 struct _ddebug *dp = &dt->ddebugs[i];
151
152 /* match against the source filename */
Jim Cromied6a238d2011-12-19 17:12:39 -0500153 if (query->filename &&
Jason Barone9d376f2009-02-05 11:51:38 -0500154 strcmp(query->filename, dp->filename) &&
Jim Cromie2b678312011-12-19 17:13:12 -0500155 strcmp(query->filename, basename(dp->filename)) &&
156 strcmp(query->filename, trim_prefix(dp->filename)))
Jason Barone9d376f2009-02-05 11:51:38 -0500157 continue;
158
159 /* match against the function */
Jim Cromied6a238d2011-12-19 17:12:39 -0500160 if (query->function &&
Jason Barone9d376f2009-02-05 11:51:38 -0500161 strcmp(query->function, dp->function))
162 continue;
163
164 /* match against the format */
Jim Cromied6a238d2011-12-19 17:12:39 -0500165 if (query->format &&
166 !strstr(dp->format, query->format))
Jason Barone9d376f2009-02-05 11:51:38 -0500167 continue;
168
169 /* match against the line number range */
170 if (query->first_lineno &&
171 dp->lineno < query->first_lineno)
172 continue;
173 if (query->last_lineno &&
174 dp->lineno > query->last_lineno)
175 continue;
176
177 nfound++;
178
179 newflags = (dp->flags & mask) | flags;
180 if (newflags == dp->flags)
181 continue;
Jason Barone9d376f2009-02-05 11:51:38 -0500182 dp->flags = newflags;
Jason Barone9d376f2009-02-05 11:51:38 -0500183 if (verbose)
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500184 pr_info("changed %s:%d [%s]%s =%s\n",
Jim Cromie2b678312011-12-19 17:13:12 -0500185 trim_prefix(dp->filename), dp->lineno,
Jason Barone9d376f2009-02-05 11:51:38 -0500186 dt->mod_name, dp->function,
187 ddebug_describe_flags(dp, flagbuf,
188 sizeof(flagbuf)));
189 }
190 }
191 mutex_unlock(&ddebug_lock);
192
193 if (!nfound && verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400194 pr_info("no matches for query\n");
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500195
196 return nfound;
Jason Barone9d376f2009-02-05 11:51:38 -0500197}
198
199/*
Jason Barone9d376f2009-02-05 11:51:38 -0500200 * Split the buffer `buf' into space-separated words.
Greg Banks9898abb2009-02-06 12:54:26 +1100201 * Handles simple " and ' quoting, i.e. without nested,
202 * embedded or escaped \". Return the number of words
203 * or <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500204 */
205static int ddebug_tokenize(char *buf, char *words[], int maxwords)
206{
207 int nwords = 0;
208
Greg Banks9898abb2009-02-06 12:54:26 +1100209 while (*buf) {
210 char *end;
211
212 /* Skip leading whitespace */
André Goddard Rosae7d28602009-12-14 18:01:06 -0800213 buf = skip_spaces(buf);
Greg Banks9898abb2009-02-06 12:54:26 +1100214 if (!*buf)
215 break; /* oh, it was trailing whitespace */
Jim Cromie8bd60262011-12-19 17:13:03 -0500216 if (*buf == '#')
217 break; /* token starts comment, skip rest of line */
Greg Banks9898abb2009-02-06 12:54:26 +1100218
Jim Cromie07100be2011-12-19 17:11:09 -0500219 /* find `end' of word, whitespace separated or quoted */
Greg Banks9898abb2009-02-06 12:54:26 +1100220 if (*buf == '"' || *buf == '\'') {
221 int quote = *buf++;
222 for (end = buf ; *end && *end != quote ; end++)
223 ;
224 if (!*end)
225 return -EINVAL; /* unclosed quote */
226 } else {
227 for (end = buf ; *end && !isspace(*end) ; end++)
228 ;
229 BUG_ON(end == buf);
230 }
Greg Banks9898abb2009-02-06 12:54:26 +1100231
Jim Cromie07100be2011-12-19 17:11:09 -0500232 /* `buf' is start of word, `end' is one past its end */
Greg Banks9898abb2009-02-06 12:54:26 +1100233 if (nwords == maxwords)
234 return -EINVAL; /* ran out of words[] before bytes */
235 if (*end)
236 *end++ = '\0'; /* terminate the word */
237 words[nwords++] = buf;
238 buf = end;
239 }
Jason Barone9d376f2009-02-05 11:51:38 -0500240
241 if (verbose) {
242 int i;
Joe Perches4ad275e2011-08-11 14:36:33 -0400243 pr_info("split into words:");
Jason Barone9d376f2009-02-05 11:51:38 -0500244 for (i = 0 ; i < nwords ; i++)
Joe Perches4ad275e2011-08-11 14:36:33 -0400245 pr_cont(" \"%s\"", words[i]);
246 pr_cont("\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500247 }
248
249 return nwords;
250}
251
252/*
253 * Parse a single line number. Note that the empty string ""
254 * is treated as a special case and converted to zero, which
255 * is later treated as a "don't care" value.
256 */
257static inline int parse_lineno(const char *str, unsigned int *val)
258{
259 char *end = NULL;
260 BUG_ON(str == NULL);
261 if (*str == '\0') {
262 *val = 0;
263 return 0;
264 }
265 *val = simple_strtoul(str, &end, 10);
266 return end == NULL || end == str || *end != '\0' ? -EINVAL : 0;
267}
268
269/*
270 * Undo octal escaping in a string, inplace. This is useful to
271 * allow the user to express a query which matches a format
272 * containing embedded spaces.
273 */
274#define isodigit(c) ((c) >= '0' && (c) <= '7')
275static char *unescape(char *str)
276{
277 char *in = str;
278 char *out = str;
279
280 while (*in) {
281 if (*in == '\\') {
282 if (in[1] == '\\') {
283 *out++ = '\\';
284 in += 2;
285 continue;
286 } else if (in[1] == 't') {
287 *out++ = '\t';
288 in += 2;
289 continue;
290 } else if (in[1] == 'n') {
291 *out++ = '\n';
292 in += 2;
293 continue;
294 } else if (isodigit(in[1]) &&
295 isodigit(in[2]) &&
296 isodigit(in[3])) {
297 *out++ = ((in[1] - '0')<<6) |
298 ((in[2] - '0')<<3) |
299 (in[3] - '0');
300 in += 4;
301 continue;
302 }
303 }
304 *out++ = *in++;
305 }
306 *out = '\0';
307
308 return str;
309}
310
Jim Cromie820874c2011-12-19 17:12:49 -0500311static int check_set(const char **dest, char *src, char *name)
312{
313 int rc = 0;
314
315 if (*dest) {
316 rc = -EINVAL;
317 pr_err("match-spec:%s val:%s overridden by %s",
318 name, *dest, src);
319 }
320 *dest = src;
321 return rc;
322}
323
Jason Barone9d376f2009-02-05 11:51:38 -0500324/*
325 * Parse words[] as a ddebug query specification, which is a series
326 * of (keyword, value) pairs chosen from these possibilities:
327 *
328 * func <function-name>
329 * file <full-pathname>
330 * file <base-filename>
331 * module <module-name>
332 * format <escaped-string-to-find-in-format>
333 * line <lineno>
334 * line <first-lineno>-<last-lineno> // where either may be empty
Jim Cromie820874c2011-12-19 17:12:49 -0500335 *
336 * Only 1 of each type is allowed.
337 * Returns 0 on success, <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500338 */
339static int ddebug_parse_query(char *words[], int nwords,
340 struct ddebug_query *query)
341{
342 unsigned int i;
Jim Cromie820874c2011-12-19 17:12:49 -0500343 int rc;
Jason Barone9d376f2009-02-05 11:51:38 -0500344
345 /* check we have an even number of words */
346 if (nwords % 2 != 0)
347 return -EINVAL;
348 memset(query, 0, sizeof(*query));
349
350 for (i = 0 ; i < nwords ; i += 2) {
351 if (!strcmp(words[i], "func"))
Jim Cromie820874c2011-12-19 17:12:49 -0500352 rc = check_set(&query->function, words[i+1], "func");
Jason Barone9d376f2009-02-05 11:51:38 -0500353 else if (!strcmp(words[i], "file"))
Jim Cromie820874c2011-12-19 17:12:49 -0500354 rc = check_set(&query->filename, words[i+1], "file");
Jason Barone9d376f2009-02-05 11:51:38 -0500355 else if (!strcmp(words[i], "module"))
Jim Cromie820874c2011-12-19 17:12:49 -0500356 rc = check_set(&query->module, words[i+1], "module");
Jason Barone9d376f2009-02-05 11:51:38 -0500357 else if (!strcmp(words[i], "format"))
Jim Cromie820874c2011-12-19 17:12:49 -0500358 rc = check_set(&query->format, unescape(words[i+1]),
359 "format");
Jason Barone9d376f2009-02-05 11:51:38 -0500360 else if (!strcmp(words[i], "line")) {
361 char *first = words[i+1];
362 char *last = strchr(first, '-');
Jim Cromie820874c2011-12-19 17:12:49 -0500363 if (query->first_lineno || query->last_lineno) {
364 pr_err("match-spec:line given 2 times\n");
365 return -EINVAL;
366 }
Jason Barone9d376f2009-02-05 11:51:38 -0500367 if (last)
368 *last++ = '\0';
369 if (parse_lineno(first, &query->first_lineno) < 0)
370 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500371 if (last) {
Jason Barone9d376f2009-02-05 11:51:38 -0500372 /* range <first>-<last> */
Jim Cromie820874c2011-12-19 17:12:49 -0500373 if (parse_lineno(last, &query->last_lineno)
374 < query->first_lineno) {
375 pr_err("last-line < 1st-line\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500376 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500377 }
Jason Barone9d376f2009-02-05 11:51:38 -0500378 } else {
379 query->last_lineno = query->first_lineno;
380 }
381 } else {
Jim Cromieae27f862011-12-19 17:12:34 -0500382 pr_err("unknown keyword \"%s\"\n", words[i]);
Jason Barone9d376f2009-02-05 11:51:38 -0500383 return -EINVAL;
384 }
Jim Cromie820874c2011-12-19 17:12:49 -0500385 if (rc)
386 return rc;
Jason Barone9d376f2009-02-05 11:51:38 -0500387 }
Jim Cromie574b3722011-12-19 17:13:16 -0500388 vpr_info_dq(query, "parsed");
Jason Barone9d376f2009-02-05 11:51:38 -0500389 return 0;
390}
391
392/*
393 * Parse `str' as a flags specification, format [-+=][p]+.
394 * Sets up *maskp and *flagsp to be used when changing the
395 * flags fields of matched _ddebug's. Returns 0 on success
396 * or <0 on error.
397 */
398static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
399 unsigned int *maskp)
400{
401 unsigned flags = 0;
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100402 int op = '=', i;
Jason Barone9d376f2009-02-05 11:51:38 -0500403
404 switch (*str) {
405 case '+':
406 case '-':
407 case '=':
408 op = *str++;
409 break;
410 default:
411 return -EINVAL;
412 }
413 if (verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400414 pr_info("op='%c'\n", op);
Jason Barone9d376f2009-02-05 11:51:38 -0500415
416 for ( ; *str ; ++str) {
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100417 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
418 if (*str == opt_array[i].opt_char) {
419 flags |= opt_array[i].flag;
420 break;
421 }
Jason Barone9d376f2009-02-05 11:51:38 -0500422 }
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100423 if (i < 0)
424 return -EINVAL;
Jason Barone9d376f2009-02-05 11:51:38 -0500425 }
Jason Barone9d376f2009-02-05 11:51:38 -0500426 if (verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400427 pr_info("flags=0x%x\n", flags);
Jason Barone9d376f2009-02-05 11:51:38 -0500428
429 /* calculate final *flagsp, *maskp according to mask and op */
430 switch (op) {
431 case '=':
432 *maskp = 0;
433 *flagsp = flags;
434 break;
435 case '+':
436 *maskp = ~0U;
437 *flagsp = flags;
438 break;
439 case '-':
440 *maskp = ~flags;
441 *flagsp = 0;
442 break;
443 }
444 if (verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400445 pr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
Jason Barone9d376f2009-02-05 11:51:38 -0500446 return 0;
447}
448
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200449static int ddebug_exec_query(char *query_string)
450{
451 unsigned int flags = 0, mask = 0;
452 struct ddebug_query query;
453#define MAXWORDS 9
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500454 int nwords, nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200455 char *words[MAXWORDS];
456
457 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
458 if (nwords <= 0)
459 return -EINVAL;
460 if (ddebug_parse_query(words, nwords-1, &query))
461 return -EINVAL;
462 if (ddebug_parse_flags(words[nwords-1], &flags, &mask))
463 return -EINVAL;
464
465 /* actually go and implement the change */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500466 nfound = ddebug_change(&query, flags, mask);
467 vpr_info_dq((&query), (nfound) ? "applied" : "no-match");
468
469 return nfound;
470}
471
472/* handle multiple queries in query string, continue on error, return
473 last error or number of matching callsites. Module name is either
474 in param (for boot arg) or perhaps in query string.
475*/
476static int ddebug_exec_queries(char *query)
477{
478 char *split;
479 int i, errs = 0, exitcode = 0, rc, nfound = 0;
480
481 for (i = 0; query; query = split) {
482 split = strpbrk(query, ";\n");
483 if (split)
484 *split++ = '\0';
485
486 query = skip_spaces(query);
487 if (!query || !*query || *query == '#')
488 continue;
489
490 if (verbose)
491 pr_info("query %d: \"%s\"\n", i, query);
492
493 rc = ddebug_exec_query(query);
494 if (rc < 0) {
495 errs++;
496 exitcode = rc;
497 } else
498 nfound += rc;
499 i++;
500 }
501 pr_info("processed %d queries, with %d matches, %d errs\n",
502 i, nfound, errs);
503
504 if (exitcode)
505 return exitcode;
506 return nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200507}
508
Jason Baron431625d2011-10-04 14:13:19 -0700509#define PREFIX_SIZE 64
510
511static int remaining(int wrote)
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100512{
Jason Baron431625d2011-10-04 14:13:19 -0700513 if (PREFIX_SIZE - wrote > 0)
514 return PREFIX_SIZE - wrote;
515 return 0;
516}
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100517
Jason Baron431625d2011-10-04 14:13:19 -0700518static char *dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
519{
520 int pos_after_tid;
521 int pos = 0;
522
523 pos += snprintf(buf + pos, remaining(pos), "%s", KERN_DEBUG);
524 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100525 if (in_interrupt())
Jason Baron431625d2011-10-04 14:13:19 -0700526 pos += snprintf(buf + pos, remaining(pos), "%s ",
527 "<intr>");
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100528 else
Jason Baron431625d2011-10-04 14:13:19 -0700529 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
530 task_pid_vnr(current));
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100531 }
Jason Baron431625d2011-10-04 14:13:19 -0700532 pos_after_tid = pos;
533 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
534 pos += snprintf(buf + pos, remaining(pos), "%s:",
535 desc->modname);
536 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
537 pos += snprintf(buf + pos, remaining(pos), "%s:",
538 desc->function);
539 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
Jim Cromie07100be2011-12-19 17:11:09 -0500540 pos += snprintf(buf + pos, remaining(pos), "%d:",
541 desc->lineno);
Jason Baron431625d2011-10-04 14:13:19 -0700542 if (pos - pos_after_tid)
543 pos += snprintf(buf + pos, remaining(pos), " ");
544 if (pos >= PREFIX_SIZE)
545 buf[PREFIX_SIZE - 1] = '\0';
Joe Perches6c2140e2011-08-11 14:36:25 -0400546
Jason Baron431625d2011-10-04 14:13:19 -0700547 return buf;
Joe Perches6c2140e2011-08-11 14:36:25 -0400548}
549
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100550int __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
551{
552 va_list args;
553 int res;
Jason Baron431625d2011-10-04 14:13:19 -0700554 struct va_format vaf;
555 char buf[PREFIX_SIZE];
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100556
557 BUG_ON(!descriptor);
558 BUG_ON(!fmt);
559
560 va_start(args, fmt);
Jason Baron431625d2011-10-04 14:13:19 -0700561 vaf.fmt = fmt;
562 vaf.va = &args;
563 res = printk("%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100564 va_end(args);
565
566 return res;
567}
568EXPORT_SYMBOL(__dynamic_pr_debug);
569
Joe Perchescbc46632011-08-11 14:36:21 -0400570int __dynamic_dev_dbg(struct _ddebug *descriptor,
571 const struct device *dev, const char *fmt, ...)
572{
573 struct va_format vaf;
574 va_list args;
575 int res;
Jason Baron431625d2011-10-04 14:13:19 -0700576 char buf[PREFIX_SIZE];
Joe Perchescbc46632011-08-11 14:36:21 -0400577
578 BUG_ON(!descriptor);
579 BUG_ON(!fmt);
580
581 va_start(args, fmt);
Joe Perchescbc46632011-08-11 14:36:21 -0400582 vaf.fmt = fmt;
583 vaf.va = &args;
Jason Baron431625d2011-10-04 14:13:19 -0700584 res = __dev_printk(dynamic_emit_prefix(descriptor, buf), dev, &vaf);
Joe Perchescbc46632011-08-11 14:36:21 -0400585 va_end(args);
586
587 return res;
588}
589EXPORT_SYMBOL(__dynamic_dev_dbg);
590
Jason Baron0feefd92011-10-04 14:13:22 -0700591#ifdef CONFIG_NET
592
Jason Baronffa10cb2011-08-11 14:36:48 -0400593int __dynamic_netdev_dbg(struct _ddebug *descriptor,
594 const struct net_device *dev, const char *fmt, ...)
595{
596 struct va_format vaf;
597 va_list args;
598 int res;
Jason Baron431625d2011-10-04 14:13:19 -0700599 char buf[PREFIX_SIZE];
Jason Baronffa10cb2011-08-11 14:36:48 -0400600
601 BUG_ON(!descriptor);
602 BUG_ON(!fmt);
603
604 va_start(args, fmt);
Jason Baronffa10cb2011-08-11 14:36:48 -0400605 vaf.fmt = fmt;
606 vaf.va = &args;
Jason Baron431625d2011-10-04 14:13:19 -0700607 res = __netdev_printk(dynamic_emit_prefix(descriptor, buf), dev, &vaf);
Jason Baronffa10cb2011-08-11 14:36:48 -0400608 va_end(args);
609
610 return res;
611}
612EXPORT_SYMBOL(__dynamic_netdev_dbg);
613
Jason Baron0feefd92011-10-04 14:13:22 -0700614#endif
615
Jim Cromiebc757f62011-12-19 17:12:29 -0500616#define DDEBUG_STRING_SIZE 1024
617static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
618
Thomas Renningera648ec02010-08-06 16:11:02 +0200619static __init int ddebug_setup_query(char *str)
620{
Jim Cromiebc757f62011-12-19 17:12:29 -0500621 if (strlen(str) >= DDEBUG_STRING_SIZE) {
Joe Perches4ad275e2011-08-11 14:36:33 -0400622 pr_warn("ddebug boot param string too large\n");
Thomas Renningera648ec02010-08-06 16:11:02 +0200623 return 0;
624 }
Jim Cromiebc757f62011-12-19 17:12:29 -0500625 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
Thomas Renningera648ec02010-08-06 16:11:02 +0200626 return 1;
627}
628
629__setup("ddebug_query=", ddebug_setup_query);
630
Jason Barone9d376f2009-02-05 11:51:38 -0500631/*
632 * File_ops->write method for <debugfs>/dynamic_debug/conrol. Gathers the
633 * command text from userspace, parses and executes it.
634 */
Jim Cromie72814912011-12-19 17:13:07 -0500635#define USER_BUF_PAGE 4096
Jason Barone9d376f2009-02-05 11:51:38 -0500636static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
637 size_t len, loff_t *offp)
638{
Jim Cromie72814912011-12-19 17:13:07 -0500639 char *tmpbuf;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200640 int ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500641
642 if (len == 0)
643 return 0;
Jim Cromie72814912011-12-19 17:13:07 -0500644 if (len > USER_BUF_PAGE - 1) {
645 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
Jason Barone9d376f2009-02-05 11:51:38 -0500646 return -E2BIG;
Jim Cromie72814912011-12-19 17:13:07 -0500647 }
648 tmpbuf = kmalloc(len + 1, GFP_KERNEL);
649 if (!tmpbuf)
650 return -ENOMEM;
651 if (copy_from_user(tmpbuf, ubuf, len)) {
652 kfree(tmpbuf);
Jason Barone9d376f2009-02-05 11:51:38 -0500653 return -EFAULT;
Jim Cromie72814912011-12-19 17:13:07 -0500654 }
Jason Barone9d376f2009-02-05 11:51:38 -0500655 tmpbuf[len] = '\0';
656 if (verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400657 pr_info("read %d bytes from userspace\n", (int)len);
Jason Barone9d376f2009-02-05 11:51:38 -0500658
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500659 ret = ddebug_exec_queries(tmpbuf);
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
720 if (verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400721 pr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500722
723 mutex_lock(&ddebug_lock);
724
725 if (!n)
726 return SEQ_START_TOKEN;
727 if (n < 0)
728 return NULL;
729 dp = ddebug_iter_first(iter);
730 while (dp != NULL && --n > 0)
731 dp = ddebug_iter_next(iter);
732 return dp;
733}
734
735/*
736 * Seq_ops next method. Called several times within a read()
737 * call from userspace, with ddebug_lock held. Walks to the
738 * next _ddebug object with a special case for the header line.
739 */
740static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
741{
742 struct ddebug_iter *iter = m->private;
743 struct _ddebug *dp;
744
745 if (verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400746 pr_info("called m=%p p=%p *pos=%lld\n",
747 m, p, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500748
749 if (p == SEQ_START_TOKEN)
750 dp = ddebug_iter_first(iter);
751 else
752 dp = ddebug_iter_next(iter);
753 ++*pos;
754 return dp;
755}
756
757/*
758 * Seq_ops show method. Called several times within a read()
759 * call from userspace, with ddebug_lock held. Formats the
760 * current _ddebug as a single human-readable line, with a
761 * special case for the header line.
762 */
763static int ddebug_proc_show(struct seq_file *m, void *p)
764{
765 struct ddebug_iter *iter = m->private;
766 struct _ddebug *dp = p;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500767 char flagsbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500768
769 if (verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400770 pr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500771
772 if (p == SEQ_START_TOKEN) {
773 seq_puts(m,
774 "# filename:lineno [module]function flags format\n");
775 return 0;
776 }
777
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500778 seq_printf(m, "%s:%u [%s]%s =%s \"",
Jim Cromie2b678312011-12-19 17:13:12 -0500779 trim_prefix(dp->filename), dp->lineno,
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500780 iter->table->mod_name, dp->function,
781 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500782 seq_escape(m, dp->format, "\t\r\n\"");
783 seq_puts(m, "\"\n");
784
785 return 0;
786}
787
788/*
789 * Seq_ops stop method. Called at the end of each read()
790 * call from userspace. Drops ddebug_lock.
791 */
792static void ddebug_proc_stop(struct seq_file *m, void *p)
793{
794 if (verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400795 pr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500796 mutex_unlock(&ddebug_lock);
797}
798
799static const struct seq_operations ddebug_proc_seqops = {
800 .start = ddebug_proc_start,
801 .next = ddebug_proc_next,
802 .show = ddebug_proc_show,
803 .stop = ddebug_proc_stop
804};
805
806/*
Jim Cromie07100be2011-12-19 17:11:09 -0500807 * File_ops->open method for <debugfs>/dynamic_debug/control. Does
808 * the seq_file setup dance, and also creates an iterator to walk the
809 * _ddebugs. Note that we create a seq_file always, even for O_WRONLY
810 * files where it's not needed, as doing so simplifies the ->release
811 * method.
Jason Barone9d376f2009-02-05 11:51:38 -0500812 */
813static int ddebug_proc_open(struct inode *inode, struct file *file)
814{
815 struct ddebug_iter *iter;
816 int err;
817
818 if (verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400819 pr_info("called\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500820
821 iter = kzalloc(sizeof(*iter), GFP_KERNEL);
822 if (iter == NULL)
823 return -ENOMEM;
824
825 err = seq_open(file, &ddebug_proc_seqops);
826 if (err) {
827 kfree(iter);
828 return err;
829 }
830 ((struct seq_file *) file->private_data)->private = iter;
831 return 0;
832}
833
834static const struct file_operations ddebug_proc_fops = {
835 .owner = THIS_MODULE,
836 .open = ddebug_proc_open,
837 .read = seq_read,
838 .llseek = seq_lseek,
839 .release = seq_release_private,
840 .write = ddebug_proc_write
841};
842
843/*
844 * Allocate a new ddebug_table for the given module
845 * and add it to the global list.
846 */
847int ddebug_add_module(struct _ddebug *tab, unsigned int n,
848 const char *name)
849{
850 struct ddebug_table *dt;
851 char *new_name;
852
853 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
854 if (dt == NULL)
855 return -ENOMEM;
856 new_name = kstrdup(name, GFP_KERNEL);
857 if (new_name == NULL) {
858 kfree(dt);
859 return -ENOMEM;
860 }
861 dt->mod_name = new_name;
862 dt->num_ddebugs = n;
Jason Barone9d376f2009-02-05 11:51:38 -0500863 dt->ddebugs = tab;
864
865 mutex_lock(&ddebug_lock);
866 list_add_tail(&dt->link, &ddebug_tables);
867 mutex_unlock(&ddebug_lock);
868
869 if (verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400870 pr_info("%u debug prints in module %s\n", n, dt->mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500871 return 0;
872}
873EXPORT_SYMBOL_GPL(ddebug_add_module);
874
875static void ddebug_table_free(struct ddebug_table *dt)
876{
877 list_del_init(&dt->link);
878 kfree(dt->mod_name);
879 kfree(dt);
880}
881
882/*
883 * Called in response to a module being unloaded. Removes
884 * any ddebug_table's which point at the module.
885 */
Yehuda Sadehff49d742010-07-03 13:07:35 +1000886int ddebug_remove_module(const char *mod_name)
Jason Barone9d376f2009-02-05 11:51:38 -0500887{
888 struct ddebug_table *dt, *nextdt;
889 int ret = -ENOENT;
890
891 if (verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400892 pr_info("removing module \"%s\"\n", mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500893
894 mutex_lock(&ddebug_lock);
895 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
896 if (!strcmp(dt->mod_name, mod_name)) {
897 ddebug_table_free(dt);
898 ret = 0;
899 }
900 }
901 mutex_unlock(&ddebug_lock);
902 return ret;
903}
904EXPORT_SYMBOL_GPL(ddebug_remove_module);
905
906static void ddebug_remove_all_tables(void)
907{
908 mutex_lock(&ddebug_lock);
909 while (!list_empty(&ddebug_tables)) {
910 struct ddebug_table *dt = list_entry(ddebug_tables.next,
911 struct ddebug_table,
912 link);
913 ddebug_table_free(dt);
914 }
915 mutex_unlock(&ddebug_lock);
916}
917
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200918static __initdata int ddebug_init_success;
919
920static int __init dynamic_debug_init_debugfs(void)
Jason Barone9d376f2009-02-05 11:51:38 -0500921{
922 struct dentry *dir, *file;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200923
924 if (!ddebug_init_success)
925 return -ENODEV;
Jason Barone9d376f2009-02-05 11:51:38 -0500926
927 dir = debugfs_create_dir("dynamic_debug", NULL);
928 if (!dir)
929 return -ENOMEM;
930 file = debugfs_create_file("control", 0644, dir, NULL,
931 &ddebug_proc_fops);
932 if (!file) {
933 debugfs_remove(dir);
934 return -ENOMEM;
935 }
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200936 return 0;
937}
938
939static int __init dynamic_debug_init(void)
940{
941 struct _ddebug *iter, *iter_start;
942 const char *modname = NULL;
943 int ret = 0;
944 int n = 0;
945
Jim Cromieb5b78f82011-12-19 17:12:54 -0500946 if (__start___verbose == __stop___verbose) {
947 pr_warn("_ddebug table is empty in a "
948 "CONFIG_DYNAMIC_DEBUG build");
949 return 1;
Jason Barone9d376f2009-02-05 11:51:38 -0500950 }
Jim Cromieb5b78f82011-12-19 17:12:54 -0500951 iter = __start___verbose;
952 modname = iter->modname;
953 iter_start = iter;
954 for (; iter < __stop___verbose; iter++) {
955 if (strcmp(modname, iter->modname)) {
956 ret = ddebug_add_module(iter_start, n, modname);
957 if (ret)
958 goto out_free;
959 n = 0;
960 modname = iter->modname;
961 iter_start = iter;
962 }
963 n++;
964 }
965 ret = ddebug_add_module(iter_start, n, modname);
966 if (ret)
967 goto out_free;
Thomas Renningera648ec02010-08-06 16:11:02 +0200968
969 /* ddebug_query boot param got passed -> set it up */
970 if (ddebug_setup_string[0] != '\0') {
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500971 ret = ddebug_exec_queries(ddebug_setup_string);
972 if (ret < 0)
Joe Perches4ad275e2011-08-11 14:36:33 -0400973 pr_warn("Invalid ddebug boot param %s",
974 ddebug_setup_string);
Thomas Renningera648ec02010-08-06 16:11:02 +0200975 else
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500976 pr_info("%d changes by ddebug_query\n", ret);
977
978 /* keep tables even on ddebug_query parse error */
979 ret = 0;
Jason Barone9d376f2009-02-05 11:51:38 -0500980 }
Thomas Renningera648ec02010-08-06 16:11:02 +0200981
Jason Barone9d376f2009-02-05 11:51:38 -0500982out_free:
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200983 if (ret)
Jason Barone9d376f2009-02-05 11:51:38 -0500984 ddebug_remove_all_tables();
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200985 else
986 ddebug_init_success = 1;
Jason Barone9d376f2009-02-05 11:51:38 -0500987 return 0;
988}
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200989/* Allow early initialization for boot messages via boot param */
990arch_initcall(dynamic_debug_init);
991/* Debugfs setup must be done later */
992module_init(dynamic_debug_init_debugfs);