blob: 8fba401793056fc77db087da2384f502ac9f42cc [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 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,
341 struct ddebug_query *query)
342{
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
351 for (i = 0 ; i < nwords ; i += 2) {
352 if (!strcmp(words[i], "func"))
Jim Cromie820874c2011-12-19 17:12:49 -0500353 rc = check_set(&query->function, words[i+1], "func");
Jason Barone9d376f2009-02-05 11:51:38 -0500354 else if (!strcmp(words[i], "file"))
Jim Cromie820874c2011-12-19 17:12:49 -0500355 rc = check_set(&query->filename, words[i+1], "file");
Jason Barone9d376f2009-02-05 11:51:38 -0500356 else if (!strcmp(words[i], "module"))
Jim Cromie820874c2011-12-19 17:12:49 -0500357 rc = check_set(&query->module, words[i+1], "module");
Jason Barone9d376f2009-02-05 11:51:38 -0500358 else if (!strcmp(words[i], "format"))
Jim Cromie820874c2011-12-19 17:12:49 -0500359 rc = check_set(&query->format, unescape(words[i+1]),
360 "format");
Jason Barone9d376f2009-02-05 11:51:38 -0500361 else if (!strcmp(words[i], "line")) {
362 char *first = words[i+1];
363 char *last = strchr(first, '-');
Jim Cromie820874c2011-12-19 17:12:49 -0500364 if (query->first_lineno || query->last_lineno) {
365 pr_err("match-spec:line given 2 times\n");
366 return -EINVAL;
367 }
Jason Barone9d376f2009-02-05 11:51:38 -0500368 if (last)
369 *last++ = '\0';
370 if (parse_lineno(first, &query->first_lineno) < 0)
371 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500372 if (last) {
Jason Barone9d376f2009-02-05 11:51:38 -0500373 /* range <first>-<last> */
Jim Cromie820874c2011-12-19 17:12:49 -0500374 if (parse_lineno(last, &query->last_lineno)
375 < query->first_lineno) {
376 pr_err("last-line < 1st-line\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500377 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500378 }
Jason Barone9d376f2009-02-05 11:51:38 -0500379 } else {
380 query->last_lineno = query->first_lineno;
381 }
382 } else {
Jim Cromieae27f862011-12-19 17:12:34 -0500383 pr_err("unknown keyword \"%s\"\n", words[i]);
Jason Barone9d376f2009-02-05 11:51:38 -0500384 return -EINVAL;
385 }
Jim Cromie820874c2011-12-19 17:12:49 -0500386 if (rc)
387 return rc;
Jason Barone9d376f2009-02-05 11:51:38 -0500388 }
Jim Cromie574b3722011-12-19 17:13:16 -0500389 vpr_info_dq(query, "parsed");
Jason Barone9d376f2009-02-05 11:51:38 -0500390 return 0;
391}
392
393/*
394 * Parse `str' as a flags specification, format [-+=][p]+.
395 * Sets up *maskp and *flagsp to be used when changing the
396 * flags fields of matched _ddebug's. Returns 0 on success
397 * or <0 on error.
398 */
399static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
400 unsigned int *maskp)
401{
402 unsigned flags = 0;
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100403 int op = '=', i;
Jason Barone9d376f2009-02-05 11:51:38 -0500404
405 switch (*str) {
406 case '+':
407 case '-':
408 case '=':
409 op = *str++;
410 break;
411 default:
412 return -EINVAL;
413 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600414 vpr_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 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600426 vpr_info("flags=0x%x\n", flags);
Jason Barone9d376f2009-02-05 11:51:38 -0500427
428 /* calculate final *flagsp, *maskp according to mask and op */
429 switch (op) {
430 case '=':
431 *maskp = 0;
432 *flagsp = flags;
433 break;
434 case '+':
435 *maskp = ~0U;
436 *flagsp = flags;
437 break;
438 case '-':
439 *maskp = ~flags;
440 *flagsp = 0;
441 break;
442 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600443 vpr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
Jason Barone9d376f2009-02-05 11:51:38 -0500444 return 0;
445}
446
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200447static int ddebug_exec_query(char *query_string)
448{
449 unsigned int flags = 0, mask = 0;
450 struct ddebug_query query;
451#define MAXWORDS 9
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500452 int nwords, nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200453 char *words[MAXWORDS];
454
455 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
456 if (nwords <= 0)
457 return -EINVAL;
458 if (ddebug_parse_query(words, nwords-1, &query))
459 return -EINVAL;
460 if (ddebug_parse_flags(words[nwords-1], &flags, &mask))
461 return -EINVAL;
462
463 /* actually go and implement the change */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500464 nfound = ddebug_change(&query, flags, mask);
465 vpr_info_dq((&query), (nfound) ? "applied" : "no-match");
466
467 return nfound;
468}
469
470/* handle multiple queries in query string, continue on error, return
471 last error or number of matching callsites. Module name is either
472 in param (for boot arg) or perhaps in query string.
473*/
474static int ddebug_exec_queries(char *query)
475{
476 char *split;
477 int i, errs = 0, exitcode = 0, rc, nfound = 0;
478
479 for (i = 0; query; query = split) {
480 split = strpbrk(query, ";\n");
481 if (split)
482 *split++ = '\0';
483
484 query = skip_spaces(query);
485 if (!query || !*query || *query == '#')
486 continue;
487
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600488 vpr_info("query %d: \"%s\"\n", i, query);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500489
490 rc = ddebug_exec_query(query);
491 if (rc < 0) {
492 errs++;
493 exitcode = rc;
494 } else
495 nfound += rc;
496 i++;
497 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600498 vpr_info("processed %d queries, with %d matches, %d errs\n",
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500499 i, nfound, errs);
500
501 if (exitcode)
502 return exitcode;
503 return nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200504}
505
Jason Baron431625d2011-10-04 14:13:19 -0700506#define PREFIX_SIZE 64
507
508static int remaining(int wrote)
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100509{
Jason Baron431625d2011-10-04 14:13:19 -0700510 if (PREFIX_SIZE - wrote > 0)
511 return PREFIX_SIZE - wrote;
512 return 0;
513}
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100514
Jason Baron431625d2011-10-04 14:13:19 -0700515static char *dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
516{
517 int pos_after_tid;
518 int pos = 0;
519
520 pos += snprintf(buf + pos, remaining(pos), "%s", KERN_DEBUG);
521 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100522 if (in_interrupt())
Jason Baron431625d2011-10-04 14:13:19 -0700523 pos += snprintf(buf + pos, remaining(pos), "%s ",
524 "<intr>");
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100525 else
Jason Baron431625d2011-10-04 14:13:19 -0700526 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
527 task_pid_vnr(current));
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100528 }
Jason Baron431625d2011-10-04 14:13:19 -0700529 pos_after_tid = pos;
530 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
531 pos += snprintf(buf + pos, remaining(pos), "%s:",
532 desc->modname);
533 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
534 pos += snprintf(buf + pos, remaining(pos), "%s:",
535 desc->function);
536 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
Jim Cromie07100be2011-12-19 17:11:09 -0500537 pos += snprintf(buf + pos, remaining(pos), "%d:",
538 desc->lineno);
Jason Baron431625d2011-10-04 14:13:19 -0700539 if (pos - pos_after_tid)
540 pos += snprintf(buf + pos, remaining(pos), " ");
541 if (pos >= PREFIX_SIZE)
542 buf[PREFIX_SIZE - 1] = '\0';
Joe Perches6c2140e2011-08-11 14:36:25 -0400543
Jason Baron431625d2011-10-04 14:13:19 -0700544 return buf;
Joe Perches6c2140e2011-08-11 14:36:25 -0400545}
546
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100547int __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
548{
549 va_list args;
550 int res;
Jason Baron431625d2011-10-04 14:13:19 -0700551 struct va_format vaf;
552 char buf[PREFIX_SIZE];
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100553
554 BUG_ON(!descriptor);
555 BUG_ON(!fmt);
556
557 va_start(args, fmt);
Jason Baron431625d2011-10-04 14:13:19 -0700558 vaf.fmt = fmt;
559 vaf.va = &args;
560 res = printk("%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100561 va_end(args);
562
563 return res;
564}
565EXPORT_SYMBOL(__dynamic_pr_debug);
566
Joe Perchescbc46632011-08-11 14:36:21 -0400567int __dynamic_dev_dbg(struct _ddebug *descriptor,
568 const struct device *dev, const char *fmt, ...)
569{
570 struct va_format vaf;
571 va_list args;
572 int res;
Jason Baron431625d2011-10-04 14:13:19 -0700573 char buf[PREFIX_SIZE];
Joe Perchescbc46632011-08-11 14:36:21 -0400574
575 BUG_ON(!descriptor);
576 BUG_ON(!fmt);
577
578 va_start(args, fmt);
Joe Perchescbc46632011-08-11 14:36:21 -0400579 vaf.fmt = fmt;
580 vaf.va = &args;
Jason Baron431625d2011-10-04 14:13:19 -0700581 res = __dev_printk(dynamic_emit_prefix(descriptor, buf), dev, &vaf);
Joe Perchescbc46632011-08-11 14:36:21 -0400582 va_end(args);
583
584 return res;
585}
586EXPORT_SYMBOL(__dynamic_dev_dbg);
587
Jason Baron0feefd92011-10-04 14:13:22 -0700588#ifdef CONFIG_NET
589
Jason Baronffa10cb2011-08-11 14:36:48 -0400590int __dynamic_netdev_dbg(struct _ddebug *descriptor,
591 const struct net_device *dev, const char *fmt, ...)
592{
593 struct va_format vaf;
594 va_list args;
595 int res;
Jason Baron431625d2011-10-04 14:13:19 -0700596 char buf[PREFIX_SIZE];
Jason Baronffa10cb2011-08-11 14:36:48 -0400597
598 BUG_ON(!descriptor);
599 BUG_ON(!fmt);
600
601 va_start(args, fmt);
Jason Baronffa10cb2011-08-11 14:36:48 -0400602 vaf.fmt = fmt;
603 vaf.va = &args;
Jason Baron431625d2011-10-04 14:13:19 -0700604 res = __netdev_printk(dynamic_emit_prefix(descriptor, buf), dev, &vaf);
Jason Baronffa10cb2011-08-11 14:36:48 -0400605 va_end(args);
606
607 return res;
608}
609EXPORT_SYMBOL(__dynamic_netdev_dbg);
610
Jason Baron0feefd92011-10-04 14:13:22 -0700611#endif
612
Jim Cromiebc757f62011-12-19 17:12:29 -0500613#define DDEBUG_STRING_SIZE 1024
614static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
615
Thomas Renningera648ec02010-08-06 16:11:02 +0200616static __init int ddebug_setup_query(char *str)
617{
Jim Cromiebc757f62011-12-19 17:12:29 -0500618 if (strlen(str) >= DDEBUG_STRING_SIZE) {
Joe Perches4ad275e2011-08-11 14:36:33 -0400619 pr_warn("ddebug boot param string too large\n");
Thomas Renningera648ec02010-08-06 16:11:02 +0200620 return 0;
621 }
Jim Cromiebc757f62011-12-19 17:12:29 -0500622 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
Thomas Renningera648ec02010-08-06 16:11:02 +0200623 return 1;
624}
625
626__setup("ddebug_query=", ddebug_setup_query);
627
Jason Barone9d376f2009-02-05 11:51:38 -0500628/*
629 * File_ops->write method for <debugfs>/dynamic_debug/conrol. Gathers the
630 * command text from userspace, parses and executes it.
631 */
Jim Cromie72814912011-12-19 17:13:07 -0500632#define USER_BUF_PAGE 4096
Jason Barone9d376f2009-02-05 11:51:38 -0500633static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
634 size_t len, loff_t *offp)
635{
Jim Cromie72814912011-12-19 17:13:07 -0500636 char *tmpbuf;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200637 int ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500638
639 if (len == 0)
640 return 0;
Jim Cromie72814912011-12-19 17:13:07 -0500641 if (len > USER_BUF_PAGE - 1) {
642 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
Jason Barone9d376f2009-02-05 11:51:38 -0500643 return -E2BIG;
Jim Cromie72814912011-12-19 17:13:07 -0500644 }
645 tmpbuf = kmalloc(len + 1, GFP_KERNEL);
646 if (!tmpbuf)
647 return -ENOMEM;
648 if (copy_from_user(tmpbuf, ubuf, len)) {
649 kfree(tmpbuf);
Jason Barone9d376f2009-02-05 11:51:38 -0500650 return -EFAULT;
Jim Cromie72814912011-12-19 17:13:07 -0500651 }
Jason Barone9d376f2009-02-05 11:51:38 -0500652 tmpbuf[len] = '\0';
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600653 vpr_info("read %d bytes from userspace\n", (int)len);
Jason Barone9d376f2009-02-05 11:51:38 -0500654
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500655 ret = ddebug_exec_queries(tmpbuf);
Jim Cromie72814912011-12-19 17:13:07 -0500656 kfree(tmpbuf);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500657 if (ret < 0)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200658 return ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500659
660 *offp += len;
661 return len;
662}
663
664/*
665 * Set the iterator to point to the first _ddebug object
666 * and return a pointer to that first object. Returns
667 * NULL if there are no _ddebugs at all.
668 */
669static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
670{
671 if (list_empty(&ddebug_tables)) {
672 iter->table = NULL;
673 iter->idx = 0;
674 return NULL;
675 }
676 iter->table = list_entry(ddebug_tables.next,
677 struct ddebug_table, link);
678 iter->idx = 0;
679 return &iter->table->ddebugs[iter->idx];
680}
681
682/*
683 * Advance the iterator to point to the next _ddebug
684 * object from the one the iterator currently points at,
685 * and returns a pointer to the new _ddebug. Returns
686 * NULL if the iterator has seen all the _ddebugs.
687 */
688static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
689{
690 if (iter->table == NULL)
691 return NULL;
692 if (++iter->idx == iter->table->num_ddebugs) {
693 /* iterate to next table */
694 iter->idx = 0;
695 if (list_is_last(&iter->table->link, &ddebug_tables)) {
696 iter->table = NULL;
697 return NULL;
698 }
699 iter->table = list_entry(iter->table->link.next,
700 struct ddebug_table, link);
701 }
702 return &iter->table->ddebugs[iter->idx];
703}
704
705/*
706 * Seq_ops start method. Called at the start of every
707 * read() call from userspace. Takes the ddebug_lock and
708 * seeks the seq_file's iterator to the given position.
709 */
710static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
711{
712 struct ddebug_iter *iter = m->private;
713 struct _ddebug *dp;
714 int n = *pos;
715
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600716 vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500717
718 mutex_lock(&ddebug_lock);
719
720 if (!n)
721 return SEQ_START_TOKEN;
722 if (n < 0)
723 return NULL;
724 dp = ddebug_iter_first(iter);
725 while (dp != NULL && --n > 0)
726 dp = ddebug_iter_next(iter);
727 return dp;
728}
729
730/*
731 * Seq_ops next method. Called several times within a read()
732 * call from userspace, with ddebug_lock held. Walks to the
733 * next _ddebug object with a special case for the header line.
734 */
735static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
736{
737 struct ddebug_iter *iter = m->private;
738 struct _ddebug *dp;
739
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600740 vpr_info("called m=%p p=%p *pos=%lld\n",
741 m, p, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500742
743 if (p == SEQ_START_TOKEN)
744 dp = ddebug_iter_first(iter);
745 else
746 dp = ddebug_iter_next(iter);
747 ++*pos;
748 return dp;
749}
750
751/*
752 * Seq_ops show method. Called several times within a read()
753 * call from userspace, with ddebug_lock held. Formats the
754 * current _ddebug as a single human-readable line, with a
755 * special case for the header line.
756 */
757static int ddebug_proc_show(struct seq_file *m, void *p)
758{
759 struct ddebug_iter *iter = m->private;
760 struct _ddebug *dp = p;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500761 char flagsbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500762
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600763 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500764
765 if (p == SEQ_START_TOKEN) {
766 seq_puts(m,
767 "# filename:lineno [module]function flags format\n");
768 return 0;
769 }
770
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500771 seq_printf(m, "%s:%u [%s]%s =%s \"",
Jim Cromie2b678312011-12-19 17:13:12 -0500772 trim_prefix(dp->filename), dp->lineno,
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500773 iter->table->mod_name, dp->function,
774 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500775 seq_escape(m, dp->format, "\t\r\n\"");
776 seq_puts(m, "\"\n");
777
778 return 0;
779}
780
781/*
782 * Seq_ops stop method. Called at the end of each read()
783 * call from userspace. Drops ddebug_lock.
784 */
785static void ddebug_proc_stop(struct seq_file *m, void *p)
786{
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600787 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500788 mutex_unlock(&ddebug_lock);
789}
790
791static const struct seq_operations ddebug_proc_seqops = {
792 .start = ddebug_proc_start,
793 .next = ddebug_proc_next,
794 .show = ddebug_proc_show,
795 .stop = ddebug_proc_stop
796};
797
798/*
Jim Cromie07100be2011-12-19 17:11:09 -0500799 * File_ops->open method for <debugfs>/dynamic_debug/control. Does
800 * the seq_file setup dance, and also creates an iterator to walk the
801 * _ddebugs. Note that we create a seq_file always, even for O_WRONLY
802 * files where it's not needed, as doing so simplifies the ->release
803 * method.
Jason Barone9d376f2009-02-05 11:51:38 -0500804 */
805static int ddebug_proc_open(struct inode *inode, struct file *file)
806{
807 struct ddebug_iter *iter;
808 int err;
809
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600810 vpr_info("called\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500811
812 iter = kzalloc(sizeof(*iter), GFP_KERNEL);
813 if (iter == NULL)
814 return -ENOMEM;
815
816 err = seq_open(file, &ddebug_proc_seqops);
817 if (err) {
818 kfree(iter);
819 return err;
820 }
821 ((struct seq_file *) file->private_data)->private = iter;
822 return 0;
823}
824
825static const struct file_operations ddebug_proc_fops = {
826 .owner = THIS_MODULE,
827 .open = ddebug_proc_open,
828 .read = seq_read,
829 .llseek = seq_lseek,
830 .release = seq_release_private,
831 .write = ddebug_proc_write
832};
833
834/*
835 * Allocate a new ddebug_table for the given module
836 * and add it to the global list.
837 */
838int ddebug_add_module(struct _ddebug *tab, unsigned int n,
839 const char *name)
840{
841 struct ddebug_table *dt;
842 char *new_name;
843
844 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
845 if (dt == NULL)
846 return -ENOMEM;
847 new_name = kstrdup(name, GFP_KERNEL);
848 if (new_name == NULL) {
849 kfree(dt);
850 return -ENOMEM;
851 }
852 dt->mod_name = new_name;
853 dt->num_ddebugs = n;
Jason Barone9d376f2009-02-05 11:51:38 -0500854 dt->ddebugs = tab;
855
856 mutex_lock(&ddebug_lock);
857 list_add_tail(&dt->link, &ddebug_tables);
858 mutex_unlock(&ddebug_lock);
859
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600860 vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500861 return 0;
862}
863EXPORT_SYMBOL_GPL(ddebug_add_module);
864
Jim Cromieb48420c2012-04-27 14:30:35 -0600865/* handle both dyndbg=".." and $module.dyndbg=".." params at boot */
866static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
867 const char *unused)
868{
869 const char *modname = NULL;
870 char *sep;
871
872 sep = strchr(param, '.');
873 if (sep) {
874 *sep = '\0';
875 modname = param;
876 param = sep + 1;
877 }
878 if (strcmp(param, "dyndbg"))
879 return 0; /* skip all other params w/o error */
880
881 vpr_info("module: %s %s=\"%s\"\n", modname, param, val);
882
883 ddebug_exec_queries(val ? val : "+p");
884 return 0; /* query failure shouldnt stop module load */
885}
886
887/* handle dyndbg args to modprobe */
888int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *doing)
889{
890 if (strcmp(param, "dyndbg"))
891 return -ENOENT;
892
893 vpr_info("module: %s %s=\"%s\"\n", doing, param, val);
894
895 ddebug_exec_queries((val ? val : "+p"));
896
897 return 0; /* query failure shouldnt stop module load */
898}
899
Jason Barone9d376f2009-02-05 11:51:38 -0500900static void ddebug_table_free(struct ddebug_table *dt)
901{
902 list_del_init(&dt->link);
903 kfree(dt->mod_name);
904 kfree(dt);
905}
906
907/*
908 * Called in response to a module being unloaded. Removes
909 * any ddebug_table's which point at the module.
910 */
Yehuda Sadehff49d742010-07-03 13:07:35 +1000911int ddebug_remove_module(const char *mod_name)
Jason Barone9d376f2009-02-05 11:51:38 -0500912{
913 struct ddebug_table *dt, *nextdt;
914 int ret = -ENOENT;
915
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600916 vpr_info("removing module \"%s\"\n", mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500917
918 mutex_lock(&ddebug_lock);
919 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
920 if (!strcmp(dt->mod_name, mod_name)) {
921 ddebug_table_free(dt);
922 ret = 0;
923 }
924 }
925 mutex_unlock(&ddebug_lock);
926 return ret;
927}
928EXPORT_SYMBOL_GPL(ddebug_remove_module);
929
930static void ddebug_remove_all_tables(void)
931{
932 mutex_lock(&ddebug_lock);
933 while (!list_empty(&ddebug_tables)) {
934 struct ddebug_table *dt = list_entry(ddebug_tables.next,
935 struct ddebug_table,
936 link);
937 ddebug_table_free(dt);
938 }
939 mutex_unlock(&ddebug_lock);
940}
941
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200942static __initdata int ddebug_init_success;
943
944static int __init dynamic_debug_init_debugfs(void)
Jason Barone9d376f2009-02-05 11:51:38 -0500945{
946 struct dentry *dir, *file;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200947
948 if (!ddebug_init_success)
949 return -ENODEV;
Jason Barone9d376f2009-02-05 11:51:38 -0500950
951 dir = debugfs_create_dir("dynamic_debug", NULL);
952 if (!dir)
953 return -ENOMEM;
954 file = debugfs_create_file("control", 0644, dir, NULL,
955 &ddebug_proc_fops);
956 if (!file) {
957 debugfs_remove(dir);
958 return -ENOMEM;
959 }
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200960 return 0;
961}
962
963static int __init dynamic_debug_init(void)
964{
965 struct _ddebug *iter, *iter_start;
966 const char *modname = NULL;
Jim Cromieb48420c2012-04-27 14:30:35 -0600967 char *cmdline;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200968 int ret = 0;
969 int n = 0;
970
Jim Cromieb5b78f82011-12-19 17:12:54 -0500971 if (__start___verbose == __stop___verbose) {
972 pr_warn("_ddebug table is empty in a "
973 "CONFIG_DYNAMIC_DEBUG build");
974 return 1;
Jason Barone9d376f2009-02-05 11:51:38 -0500975 }
Jim Cromieb5b78f82011-12-19 17:12:54 -0500976 iter = __start___verbose;
977 modname = iter->modname;
978 iter_start = iter;
979 for (; iter < __stop___verbose; iter++) {
980 if (strcmp(modname, iter->modname)) {
981 ret = ddebug_add_module(iter_start, n, modname);
982 if (ret)
983 goto out_free;
984 n = 0;
985 modname = iter->modname;
986 iter_start = iter;
987 }
988 n++;
989 }
990 ret = ddebug_add_module(iter_start, n, modname);
991 if (ret)
992 goto out_free;
Thomas Renningera648ec02010-08-06 16:11:02 +0200993
994 /* ddebug_query boot param got passed -> set it up */
995 if (ddebug_setup_string[0] != '\0') {
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500996 ret = ddebug_exec_queries(ddebug_setup_string);
997 if (ret < 0)
Joe Perches4ad275e2011-08-11 14:36:33 -0400998 pr_warn("Invalid ddebug boot param %s",
999 ddebug_setup_string);
Thomas Renningera648ec02010-08-06 16:11:02 +02001000 else
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001001 pr_info("%d changes by ddebug_query\n", ret);
1002
1003 /* keep tables even on ddebug_query parse error */
1004 ret = 0;
Jason Barone9d376f2009-02-05 11:51:38 -05001005 }
Jim Cromieb48420c2012-04-27 14:30:35 -06001006 /* now that ddebug tables are loaded, process all boot args
1007 * again to find and activate queries given in dyndbg params.
1008 * While this has already been done for known boot params, it
1009 * ignored the unknown ones (dyndbg in particular). Reusing
1010 * parse_args avoids ad-hoc parsing. This will also attempt
1011 * to activate queries for not-yet-loaded modules, which is
1012 * slightly noisy if verbose, but harmless.
1013 */
1014 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1015 parse_args("dyndbg params", cmdline, NULL,
1016 0, 0, 0, &ddebug_dyndbg_boot_param_cb);
1017 kfree(cmdline);
Thomas Renningera648ec02010-08-06 16:11:02 +02001018
Jason Barone9d376f2009-02-05 11:51:38 -05001019out_free:
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001020 if (ret)
Jason Barone9d376f2009-02-05 11:51:38 -05001021 ddebug_remove_all_tables();
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001022 else
1023 ddebug_init_success = 1;
Jason Barone9d376f2009-02-05 11:51:38 -05001024 return 0;
1025}
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001026/* Allow early initialization for boot messages via boot param */
1027arch_initcall(dynamic_debug_init);
Jim Cromieb48420c2012-04-27 14:30:35 -06001028
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001029/* Debugfs setup must be done later */
1030module_init(dynamic_debug_init_debugfs);