blob: 5276b99ca650df8fe6e6e07363f2639250418c5a [file] [log] [blame]
Jason Barone9d376f2009-02-05 11:51:38 -05001/*
2 * lib/dynamic_debug.c
3 *
4 * make pr_debug()/dev_dbg() calls runtime configurable based upon their
5 * source module.
6 *
7 * Copyright (C) 2008 Jason Baron <jbaron@redhat.com>
8 * By Greg Banks <gnb@melbourne.sgi.com>
9 * Copyright (c) 2008 Silicon Graphics Inc. All Rights Reserved.
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +010010 * Copyright (C) 2011 Bart Van Assche. All Rights Reserved.
Jason Barone9d376f2009-02-05 11:51:38 -050011 */
12
Joe Perches4ad275e2011-08-11 14:36:33 -040013#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
14
Jason Barone9d376f2009-02-05 11:51:38 -050015#include <linux/kernel.h>
16#include <linux/module.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070017#include <linux/moduleparam.h>
18#include <linux/kallsyms.h>
19#include <linux/types.h>
Jason Barone9d376f2009-02-05 11:51:38 -050020#include <linux/mutex.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070021#include <linux/proc_fs.h>
Jason Barone9d376f2009-02-05 11:51:38 -050022#include <linux/seq_file.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070023#include <linux/list.h>
24#include <linux/sysctl.h>
Jason Barone9d376f2009-02-05 11:51:38 -050025#include <linux/ctype.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070026#include <linux/string.h>
27#include <linux/uaccess.h>
Jason Barone9d376f2009-02-05 11:51:38 -050028#include <linux/dynamic_debug.h>
29#include <linux/debugfs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/slab.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070031#include <linux/jump_label.h>
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +010032#include <linux/hardirq.h>
Greg Kroah-Hartmane8d97922011-02-03 15:59:58 -080033#include <linux/sched.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070034#include <linux/device.h>
Jason Baronffa10cb2011-08-11 14:36:48 -040035#include <linux/netdevice.h>
Jason Barone9d376f2009-02-05 11:51:38 -050036
37extern struct _ddebug __start___verbose[];
38extern struct _ddebug __stop___verbose[];
39
Jason Barone9d376f2009-02-05 11:51:38 -050040struct ddebug_table {
41 struct list_head link;
42 char *mod_name;
43 unsigned int num_ddebugs;
Jason Barone9d376f2009-02-05 11:51:38 -050044 struct _ddebug *ddebugs;
45};
46
47struct ddebug_query {
48 const char *filename;
49 const char *module;
50 const char *function;
51 const char *format;
52 unsigned int first_lineno, last_lineno;
53};
54
55struct ddebug_iter {
56 struct ddebug_table *table;
57 unsigned int idx;
58};
59
60static DEFINE_MUTEX(ddebug_lock);
61static LIST_HEAD(ddebug_tables);
Joe Perchesf657fd22012-12-05 16:48:26 -050062static int verbose;
Jim Cromie74df1382011-12-19 17:12:24 -050063module_param(verbose, int, 0644);
Jason Barone9d376f2009-02-05 11:51:38 -050064
Jim Cromie2b678312011-12-19 17:13:12 -050065/* Return the path relative to source root */
66static inline const char *trim_prefix(const char *path)
67{
68 int skip = strlen(__FILE__) - strlen("lib/dynamic_debug.c");
69
70 if (strncmp(path, __FILE__, skip))
71 skip = 0; /* prefix mismatch, don't skip */
72
73 return path + skip;
74}
75
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +010076static struct { unsigned flag:8; char opt_char; } opt_array[] = {
77 { _DPRINTK_FLAGS_PRINT, 'p' },
78 { _DPRINTK_FLAGS_INCL_MODNAME, 'm' },
79 { _DPRINTK_FLAGS_INCL_FUNCNAME, 'f' },
80 { _DPRINTK_FLAGS_INCL_LINENO, 'l' },
81 { _DPRINTK_FLAGS_INCL_TID, 't' },
Jim Cromie5ca7d2a2011-12-19 17:12:44 -050082 { _DPRINTK_FLAGS_NONE, '_' },
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +010083};
84
Jason Barone9d376f2009-02-05 11:51:38 -050085/* format a string into buf[] which describes the _ddebug's flags */
86static char *ddebug_describe_flags(struct _ddebug *dp, char *buf,
87 size_t maxlen)
88{
89 char *p = buf;
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +010090 int i;
Jason Barone9d376f2009-02-05 11:51:38 -050091
Jim Cromie5ca7d2a2011-12-19 17:12:44 -050092 BUG_ON(maxlen < 6);
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +010093 for (i = 0; i < ARRAY_SIZE(opt_array); ++i)
94 if (dp->flags & opt_array[i].flag)
95 *p++ = opt_array[i].opt_char;
Jason Barone9d376f2009-02-05 11:51:38 -050096 if (p == buf)
Jim Cromie5ca7d2a2011-12-19 17:12:44 -050097 *p++ = '_';
Jason Barone9d376f2009-02-05 11:51:38 -050098 *p = '\0';
99
100 return buf;
101}
102
Joe Perchesf657fd22012-12-05 16:48:26 -0500103#define vpr_info(fmt, ...) \
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600104do { \
Joe Perchesf657fd22012-12-05 16:48:26 -0500105 if (verbose) \
106 pr_info(fmt, ##__VA_ARGS__); \
Jim Cromie574b3722011-12-19 17:13:16 -0500107} while (0)
108
Joe Perchesf657fd22012-12-05 16:48:26 -0500109static void vpr_info_dq(const struct ddebug_query *query, const char *msg)
110{
111 /* trim any trailing newlines */
112 int fmtlen = 0;
113
114 if (query->format) {
115 fmtlen = strlen(query->format);
116 while (fmtlen && query->format[fmtlen - 1] == '\n')
117 fmtlen--;
118 }
119
120 vpr_info("%s: func=\"%s\" file=\"%s\" module=\"%s\" format=\"%.*s\" lineno=%u-%u\n",
121 msg,
122 query->function ? query->function : "",
123 query->filename ? query->filename : "",
124 query->module ? query->module : "",
125 fmtlen, query->format ? query->format : "",
126 query->first_lineno, query->last_lineno);
127}
128
Jason Barone9d376f2009-02-05 11:51:38 -0500129/*
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500130 * Search the tables for _ddebug's which match the given `query' and
131 * apply the `flags' and `mask' to them. Returns number of matching
132 * callsites, normally the same as number of changes. If verbose,
133 * logs the changes. Takes ddebug_lock.
Jason Barone9d376f2009-02-05 11:51:38 -0500134 */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500135static int ddebug_change(const struct ddebug_query *query,
136 unsigned int flags, unsigned int mask)
Jason Barone9d376f2009-02-05 11:51:38 -0500137{
138 int i;
139 struct ddebug_table *dt;
140 unsigned int newflags;
141 unsigned int nfound = 0;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500142 char flagbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500143
144 /* search for matching ddebugs */
145 mutex_lock(&ddebug_lock);
146 list_for_each_entry(dt, &ddebug_tables, link) {
147
148 /* match against the module name */
Jim Cromied6a238d2011-12-19 17:12:39 -0500149 if (query->module && strcmp(query->module, dt->mod_name))
Jason Barone9d376f2009-02-05 11:51:38 -0500150 continue;
151
Joe Perchesf657fd22012-12-05 16:48:26 -0500152 for (i = 0; i < dt->num_ddebugs; i++) {
Jason Barone9d376f2009-02-05 11:51:38 -0500153 struct _ddebug *dp = &dt->ddebugs[i];
154
155 /* match against the source filename */
Jim Cromied6a238d2011-12-19 17:12:39 -0500156 if (query->filename &&
Jason Barone9d376f2009-02-05 11:51:38 -0500157 strcmp(query->filename, dp->filename) &&
Andy Shevchenko35367ab2012-12-17 16:01:21 -0800158 strcmp(query->filename, kbasename(dp->filename)) &&
Jim Cromie2b678312011-12-19 17:13:12 -0500159 strcmp(query->filename, trim_prefix(dp->filename)))
Jason Barone9d376f2009-02-05 11:51:38 -0500160 continue;
161
162 /* match against the function */
Jim Cromied6a238d2011-12-19 17:12:39 -0500163 if (query->function &&
Jason Barone9d376f2009-02-05 11:51:38 -0500164 strcmp(query->function, dp->function))
165 continue;
166
167 /* match against the format */
Jim Cromied6a238d2011-12-19 17:12:39 -0500168 if (query->format &&
169 !strstr(dp->format, query->format))
Jason Barone9d376f2009-02-05 11:51:38 -0500170 continue;
171
172 /* match against the line number range */
173 if (query->first_lineno &&
174 dp->lineno < query->first_lineno)
175 continue;
176 if (query->last_lineno &&
177 dp->lineno > query->last_lineno)
178 continue;
179
180 nfound++;
181
182 newflags = (dp->flags & mask) | flags;
183 if (newflags == dp->flags)
184 continue;
Jason Barone9d376f2009-02-05 11:51:38 -0500185 dp->flags = newflags;
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600186 vpr_info("changed %s:%d [%s]%s =%s\n",
Joe Perchesf657fd22012-12-05 16:48:26 -0500187 trim_prefix(dp->filename), dp->lineno,
188 dt->mod_name, dp->function,
189 ddebug_describe_flags(dp, flagbuf,
190 sizeof(flagbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500191 }
192 }
193 mutex_unlock(&ddebug_lock);
194
195 if (!nfound && verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400196 pr_info("no matches for query\n");
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500197
198 return nfound;
Jason Barone9d376f2009-02-05 11:51:38 -0500199}
200
201/*
Jason Barone9d376f2009-02-05 11:51:38 -0500202 * Split the buffer `buf' into space-separated words.
Greg Banks9898abb2009-02-06 12:54:26 +1100203 * Handles simple " and ' quoting, i.e. without nested,
204 * embedded or escaped \". Return the number of words
205 * or <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500206 */
207static int ddebug_tokenize(char *buf, char *words[], int maxwords)
208{
209 int nwords = 0;
210
Greg Banks9898abb2009-02-06 12:54:26 +1100211 while (*buf) {
212 char *end;
213
214 /* Skip leading whitespace */
André Goddard Rosae7d28602009-12-14 18:01:06 -0800215 buf = skip_spaces(buf);
Greg Banks9898abb2009-02-06 12:54:26 +1100216 if (!*buf)
217 break; /* oh, it was trailing whitespace */
Jim Cromie8bd60262011-12-19 17:13:03 -0500218 if (*buf == '#')
219 break; /* token starts comment, skip rest of line */
Greg Banks9898abb2009-02-06 12:54:26 +1100220
Jim Cromie07100be2011-12-19 17:11:09 -0500221 /* find `end' of word, whitespace separated or quoted */
Greg Banks9898abb2009-02-06 12:54:26 +1100222 if (*buf == '"' || *buf == '\'') {
223 int quote = *buf++;
Joe Perchesf657fd22012-12-05 16:48:26 -0500224 for (end = buf; *end && *end != quote; end++)
Greg Banks9898abb2009-02-06 12:54:26 +1100225 ;
Jim Cromie18c216c2012-12-05 16:48:27 -0500226 if (!*end) {
227 pr_err("unclosed quote: %s\n", buf);
Greg Banks9898abb2009-02-06 12:54:26 +1100228 return -EINVAL; /* unclosed quote */
Jim Cromie18c216c2012-12-05 16:48:27 -0500229 }
Greg Banks9898abb2009-02-06 12:54:26 +1100230 } else {
Joe Perchesf657fd22012-12-05 16:48:26 -0500231 for (end = buf; *end && !isspace(*end); end++)
Greg Banks9898abb2009-02-06 12:54:26 +1100232 ;
233 BUG_ON(end == buf);
234 }
Greg Banks9898abb2009-02-06 12:54:26 +1100235
Jim Cromie07100be2011-12-19 17:11:09 -0500236 /* `buf' is start of word, `end' is one past its end */
Jim Cromie18c216c2012-12-05 16:48:27 -0500237 if (nwords == maxwords) {
238 pr_err("too many words, legal max <=%d\n", maxwords);
Greg Banks9898abb2009-02-06 12:54:26 +1100239 return -EINVAL; /* ran out of words[] before bytes */
Jim Cromie18c216c2012-12-05 16:48:27 -0500240 }
Greg Banks9898abb2009-02-06 12:54:26 +1100241 if (*end)
242 *end++ = '\0'; /* terminate the word */
243 words[nwords++] = buf;
244 buf = end;
245 }
Jason Barone9d376f2009-02-05 11:51:38 -0500246
247 if (verbose) {
248 int i;
Joe Perches4ad275e2011-08-11 14:36:33 -0400249 pr_info("split into words:");
Joe Perchesf657fd22012-12-05 16:48:26 -0500250 for (i = 0; i < nwords; i++)
Joe Perches4ad275e2011-08-11 14:36:33 -0400251 pr_cont(" \"%s\"", words[i]);
252 pr_cont("\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500253 }
254
255 return nwords;
256}
257
258/*
259 * Parse a single line number. Note that the empty string ""
260 * is treated as a special case and converted to zero, which
261 * is later treated as a "don't care" value.
262 */
263static inline int parse_lineno(const char *str, unsigned int *val)
264{
265 char *end = NULL;
266 BUG_ON(str == NULL);
267 if (*str == '\0') {
268 *val = 0;
269 return 0;
270 }
271 *val = simple_strtoul(str, &end, 10);
Jim Cromie18c216c2012-12-05 16:48:27 -0500272 if (end == NULL || end == str || *end != '\0') {
273 pr_err("bad line-number: %s\n", str);
274 return -EINVAL;
275 }
276 return 0;
Jason Barone9d376f2009-02-05 11:51:38 -0500277}
278
279/*
280 * Undo octal escaping in a string, inplace. This is useful to
281 * allow the user to express a query which matches a format
282 * containing embedded spaces.
283 */
284#define isodigit(c) ((c) >= '0' && (c) <= '7')
285static char *unescape(char *str)
286{
287 char *in = str;
288 char *out = str;
289
290 while (*in) {
291 if (*in == '\\') {
292 if (in[1] == '\\') {
293 *out++ = '\\';
294 in += 2;
295 continue;
296 } else if (in[1] == 't') {
297 *out++ = '\t';
298 in += 2;
299 continue;
300 } else if (in[1] == 'n') {
301 *out++ = '\n';
302 in += 2;
303 continue;
304 } else if (isodigit(in[1]) &&
Joe Perchesf657fd22012-12-05 16:48:26 -0500305 isodigit(in[2]) &&
306 isodigit(in[3])) {
307 *out++ = (((in[1] - '0') << 6) |
308 ((in[2] - '0') << 3) |
309 (in[3] - '0'));
Jason Barone9d376f2009-02-05 11:51:38 -0500310 in += 4;
311 continue;
312 }
313 }
314 *out++ = *in++;
315 }
316 *out = '\0';
317
318 return str;
319}
320
Jim Cromie820874c2011-12-19 17:12:49 -0500321static int check_set(const char **dest, char *src, char *name)
322{
323 int rc = 0;
324
325 if (*dest) {
326 rc = -EINVAL;
Joe Perchesf657fd22012-12-05 16:48:26 -0500327 pr_err("match-spec:%s val:%s overridden by %s\n",
328 name, *dest, src);
Jim Cromie820874c2011-12-19 17:12:49 -0500329 }
330 *dest = src;
331 return rc;
332}
333
Jason Barone9d376f2009-02-05 11:51:38 -0500334/*
335 * Parse words[] as a ddebug query specification, which is a series
336 * of (keyword, value) pairs chosen from these possibilities:
337 *
338 * func <function-name>
339 * file <full-pathname>
340 * file <base-filename>
341 * module <module-name>
342 * format <escaped-string-to-find-in-format>
343 * line <lineno>
344 * line <first-lineno>-<last-lineno> // where either may be empty
Jim Cromie820874c2011-12-19 17:12:49 -0500345 *
346 * Only 1 of each type is allowed.
347 * Returns 0 on success, <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500348 */
349static int ddebug_parse_query(char *words[], int nwords,
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600350 struct ddebug_query *query, const char *modname)
Jason Barone9d376f2009-02-05 11:51:38 -0500351{
352 unsigned int i;
Jim Cromie820874c2011-12-19 17:12:49 -0500353 int rc;
Jason Barone9d376f2009-02-05 11:51:38 -0500354
355 /* check we have an even number of words */
Jim Cromie18c216c2012-12-05 16:48:27 -0500356 if (nwords % 2 != 0) {
357 pr_err("expecting pairs of match-spec <value>\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500358 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500359 }
Jason Barone9d376f2009-02-05 11:51:38 -0500360 memset(query, 0, sizeof(*query));
361
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600362 if (modname)
363 /* support $modname.dyndbg=<multiple queries> */
364 query->module = modname;
365
Joe Perchesf657fd22012-12-05 16:48:26 -0500366 for (i = 0; i < nwords; i += 2) {
367 if (!strcmp(words[i], "func")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500368 rc = check_set(&query->function, words[i+1], "func");
Joe Perchesf657fd22012-12-05 16:48:26 -0500369 } else if (!strcmp(words[i], "file")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500370 rc = check_set(&query->filename, words[i+1], "file");
Joe Perchesf657fd22012-12-05 16:48:26 -0500371 } else if (!strcmp(words[i], "module")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500372 rc = check_set(&query->module, words[i+1], "module");
Joe Perchesf657fd22012-12-05 16:48:26 -0500373 } else if (!strcmp(words[i], "format")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500374 rc = check_set(&query->format, unescape(words[i+1]),
Joe Perchesf657fd22012-12-05 16:48:26 -0500375 "format");
376 } else if (!strcmp(words[i], "line")) {
Jason Barone9d376f2009-02-05 11:51:38 -0500377 char *first = words[i+1];
378 char *last = strchr(first, '-');
Jim Cromie820874c2011-12-19 17:12:49 -0500379 if (query->first_lineno || query->last_lineno) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500380 pr_err("match-spec: line used 2x\n");
Jim Cromie820874c2011-12-19 17:12:49 -0500381 return -EINVAL;
382 }
Jason Barone9d376f2009-02-05 11:51:38 -0500383 if (last)
384 *last++ = '\0';
Jim Cromie18c216c2012-12-05 16:48:27 -0500385 if (parse_lineno(first, &query->first_lineno) < 0) {
386 pr_err("line-number is <0\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500387 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500388 }
Jim Cromie820874c2011-12-19 17:12:49 -0500389 if (last) {
Jason Barone9d376f2009-02-05 11:51:38 -0500390 /* range <first>-<last> */
Jim Cromie820874c2011-12-19 17:12:49 -0500391 if (parse_lineno(last, &query->last_lineno)
392 < query->first_lineno) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500393 pr_err("last-line:%d < 1st-line:%d\n",
394 query->last_lineno,
395 query->first_lineno);
Jason Barone9d376f2009-02-05 11:51:38 -0500396 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500397 }
Jason Barone9d376f2009-02-05 11:51:38 -0500398 } else {
399 query->last_lineno = query->first_lineno;
400 }
401 } else {
Jim Cromieae27f862011-12-19 17:12:34 -0500402 pr_err("unknown keyword \"%s\"\n", words[i]);
Jason Barone9d376f2009-02-05 11:51:38 -0500403 return -EINVAL;
404 }
Jim Cromie820874c2011-12-19 17:12:49 -0500405 if (rc)
406 return rc;
Jason Barone9d376f2009-02-05 11:51:38 -0500407 }
Jim Cromie574b3722011-12-19 17:13:16 -0500408 vpr_info_dq(query, "parsed");
Jason Barone9d376f2009-02-05 11:51:38 -0500409 return 0;
410}
411
412/*
413 * Parse `str' as a flags specification, format [-+=][p]+.
414 * Sets up *maskp and *flagsp to be used when changing the
415 * flags fields of matched _ddebug's. Returns 0 on success
416 * or <0 on error.
417 */
418static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
419 unsigned int *maskp)
420{
421 unsigned flags = 0;
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100422 int op = '=', i;
Jason Barone9d376f2009-02-05 11:51:38 -0500423
424 switch (*str) {
425 case '+':
426 case '-':
427 case '=':
428 op = *str++;
429 break;
430 default:
Jim Cromie18c216c2012-12-05 16:48:27 -0500431 pr_err("bad flag-op %c, at start of %s\n", *str, str);
Jason Barone9d376f2009-02-05 11:51:38 -0500432 return -EINVAL;
433 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600434 vpr_info("op='%c'\n", op);
Jason Barone9d376f2009-02-05 11:51:38 -0500435
Joe Perchesf657fd22012-12-05 16:48:26 -0500436 for (; *str ; ++str) {
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100437 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
438 if (*str == opt_array[i].opt_char) {
439 flags |= opt_array[i].flag;
440 break;
441 }
Jason Barone9d376f2009-02-05 11:51:38 -0500442 }
Jim Cromie18c216c2012-12-05 16:48:27 -0500443 if (i < 0) {
444 pr_err("unknown flag '%c' in \"%s\"\n", *str, str);
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100445 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500446 }
Jason Barone9d376f2009-02-05 11:51:38 -0500447 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600448 vpr_info("flags=0x%x\n", flags);
Jason Barone9d376f2009-02-05 11:51:38 -0500449
450 /* calculate final *flagsp, *maskp according to mask and op */
451 switch (op) {
452 case '=':
453 *maskp = 0;
454 *flagsp = flags;
455 break;
456 case '+':
457 *maskp = ~0U;
458 *flagsp = flags;
459 break;
460 case '-':
461 *maskp = ~flags;
462 *flagsp = 0;
463 break;
464 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600465 vpr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
Jason Barone9d376f2009-02-05 11:51:38 -0500466 return 0;
467}
468
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600469static int ddebug_exec_query(char *query_string, const char *modname)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200470{
471 unsigned int flags = 0, mask = 0;
472 struct ddebug_query query;
473#define MAXWORDS 9
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500474 int nwords, nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200475 char *words[MAXWORDS];
476
477 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
Jim Cromie18c216c2012-12-05 16:48:27 -0500478 if (nwords <= 0) {
479 pr_err("tokenize failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200480 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500481 }
482 /* check flags 1st (last arg) so query is pairs of spec,val */
483 if (ddebug_parse_flags(words[nwords-1], &flags, &mask)) {
484 pr_err("flags parse failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200485 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500486 }
487 if (ddebug_parse_query(words, nwords-1, &query, modname)) {
488 pr_err("query parse failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200489 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500490 }
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200491 /* actually go and implement the change */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500492 nfound = ddebug_change(&query, flags, mask);
Joe Perchesf657fd22012-12-05 16:48:26 -0500493 vpr_info_dq(&query, nfound ? "applied" : "no-match");
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500494
495 return nfound;
496}
497
498/* handle multiple queries in query string, continue on error, return
499 last error or number of matching callsites. Module name is either
500 in param (for boot arg) or perhaps in query string.
501*/
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600502static int ddebug_exec_queries(char *query, const char *modname)
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500503{
504 char *split;
505 int i, errs = 0, exitcode = 0, rc, nfound = 0;
506
507 for (i = 0; query; query = split) {
508 split = strpbrk(query, ";\n");
509 if (split)
510 *split++ = '\0';
511
512 query = skip_spaces(query);
513 if (!query || !*query || *query == '#')
514 continue;
515
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600516 vpr_info("query %d: \"%s\"\n", i, query);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500517
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600518 rc = ddebug_exec_query(query, modname);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500519 if (rc < 0) {
520 errs++;
521 exitcode = rc;
Joe Perchesf657fd22012-12-05 16:48:26 -0500522 } else {
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500523 nfound += rc;
Joe Perchesf657fd22012-12-05 16:48:26 -0500524 }
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500525 i++;
526 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600527 vpr_info("processed %d queries, with %d matches, %d errs\n",
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500528 i, nfound, errs);
529
530 if (exitcode)
531 return exitcode;
532 return nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200533}
534
Jason Baron431625d2011-10-04 14:13:19 -0700535#define PREFIX_SIZE 64
536
537static int remaining(int wrote)
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100538{
Jason Baron431625d2011-10-04 14:13:19 -0700539 if (PREFIX_SIZE - wrote > 0)
540 return PREFIX_SIZE - wrote;
541 return 0;
542}
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100543
Jason Baron431625d2011-10-04 14:13:19 -0700544static char *dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
545{
546 int pos_after_tid;
547 int pos = 0;
548
Joe Perches798efc62012-09-12 20:11:29 -0700549 *buf = '\0';
550
Jason Baron431625d2011-10-04 14:13:19 -0700551 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100552 if (in_interrupt())
Joe Perches798efc62012-09-12 20:11:29 -0700553 pos += snprintf(buf + pos, remaining(pos), "<intr> ");
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100554 else
Jason Baron431625d2011-10-04 14:13:19 -0700555 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
Joe Perches798efc62012-09-12 20:11:29 -0700556 task_pid_vnr(current));
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100557 }
Jason Baron431625d2011-10-04 14:13:19 -0700558 pos_after_tid = pos;
559 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
560 pos += snprintf(buf + pos, remaining(pos), "%s:",
Joe Perches798efc62012-09-12 20:11:29 -0700561 desc->modname);
Jason Baron431625d2011-10-04 14:13:19 -0700562 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
563 pos += snprintf(buf + pos, remaining(pos), "%s:",
Joe Perches798efc62012-09-12 20:11:29 -0700564 desc->function);
Jason Baron431625d2011-10-04 14:13:19 -0700565 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
Jim Cromie07100be2011-12-19 17:11:09 -0500566 pos += snprintf(buf + pos, remaining(pos), "%d:",
Joe Perches798efc62012-09-12 20:11:29 -0700567 desc->lineno);
Jason Baron431625d2011-10-04 14:13:19 -0700568 if (pos - pos_after_tid)
569 pos += snprintf(buf + pos, remaining(pos), " ");
570 if (pos >= PREFIX_SIZE)
571 buf[PREFIX_SIZE - 1] = '\0';
Joe Perches6c2140e2011-08-11 14:36:25 -0400572
Jason Baron431625d2011-10-04 14:13:19 -0700573 return buf;
Joe Perches6c2140e2011-08-11 14:36:25 -0400574}
575
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100576int __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
577{
578 va_list args;
579 int res;
Jason Baron431625d2011-10-04 14:13:19 -0700580 struct va_format vaf;
581 char buf[PREFIX_SIZE];
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100582
583 BUG_ON(!descriptor);
584 BUG_ON(!fmt);
585
586 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700587
Jason Baron431625d2011-10-04 14:13:19 -0700588 vaf.fmt = fmt;
589 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700590
591 res = printk(KERN_DEBUG "%s%pV",
592 dynamic_emit_prefix(descriptor, buf), &vaf);
593
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100594 va_end(args);
595
596 return res;
597}
598EXPORT_SYMBOL(__dynamic_pr_debug);
599
Joe Perchescbc46632011-08-11 14:36:21 -0400600int __dynamic_dev_dbg(struct _ddebug *descriptor,
601 const struct device *dev, const char *fmt, ...)
602{
603 struct va_format vaf;
604 va_list args;
605 int res;
606
607 BUG_ON(!descriptor);
608 BUG_ON(!fmt);
609
610 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700611
Joe Perchescbc46632011-08-11 14:36:21 -0400612 vaf.fmt = fmt;
613 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700614
615 if (!dev) {
616 res = printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
617 } else {
618 char buf[PREFIX_SIZE];
Joe Perches798efc62012-09-12 20:11:29 -0700619
Joe Perches666f3552012-09-12 20:14:11 -0700620 res = dev_printk_emit(7, dev, "%s%s %s: %pV",
621 dynamic_emit_prefix(descriptor, buf),
622 dev_driver_string(dev), dev_name(dev),
623 &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700624 }
625
Joe Perchescbc46632011-08-11 14:36:21 -0400626 va_end(args);
627
628 return res;
629}
630EXPORT_SYMBOL(__dynamic_dev_dbg);
631
Jason Baron0feefd92011-10-04 14:13:22 -0700632#ifdef CONFIG_NET
633
Jason Baronffa10cb2011-08-11 14:36:48 -0400634int __dynamic_netdev_dbg(struct _ddebug *descriptor,
Joe Perchesb004ff42012-09-12 20:12:19 -0700635 const struct net_device *dev, const char *fmt, ...)
Jason Baronffa10cb2011-08-11 14:36:48 -0400636{
637 struct va_format vaf;
638 va_list args;
639 int res;
640
641 BUG_ON(!descriptor);
642 BUG_ON(!fmt);
643
644 va_start(args, fmt);
Joe Perchesb004ff42012-09-12 20:12:19 -0700645
Jason Baronffa10cb2011-08-11 14:36:48 -0400646 vaf.fmt = fmt;
647 vaf.va = &args;
Joe Perchesb004ff42012-09-12 20:12:19 -0700648
649 if (dev && dev->dev.parent) {
650 char buf[PREFIX_SIZE];
Joe Perchesb004ff42012-09-12 20:12:19 -0700651
Joe Perches666f3552012-09-12 20:14:11 -0700652 res = dev_printk_emit(7, dev->dev.parent,
653 "%s%s %s %s: %pV",
654 dynamic_emit_prefix(descriptor, buf),
655 dev_driver_string(dev->dev.parent),
656 dev_name(dev->dev.parent),
657 netdev_name(dev), &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700658 } else if (dev) {
659 res = printk(KERN_DEBUG "%s: %pV", netdev_name(dev), &vaf);
660 } else {
661 res = printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
662 }
663
Jason Baronffa10cb2011-08-11 14:36:48 -0400664 va_end(args);
665
666 return res;
667}
668EXPORT_SYMBOL(__dynamic_netdev_dbg);
669
Jason Baron0feefd92011-10-04 14:13:22 -0700670#endif
671
Jim Cromiebc757f62011-12-19 17:12:29 -0500672#define DDEBUG_STRING_SIZE 1024
673static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
674
Thomas Renningera648ec02010-08-06 16:11:02 +0200675static __init int ddebug_setup_query(char *str)
676{
Jim Cromiebc757f62011-12-19 17:12:29 -0500677 if (strlen(str) >= DDEBUG_STRING_SIZE) {
Joe Perches4ad275e2011-08-11 14:36:33 -0400678 pr_warn("ddebug boot param string too large\n");
Thomas Renningera648ec02010-08-06 16:11:02 +0200679 return 0;
680 }
Jim Cromiebc757f62011-12-19 17:12:29 -0500681 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
Thomas Renningera648ec02010-08-06 16:11:02 +0200682 return 1;
683}
684
685__setup("ddebug_query=", ddebug_setup_query);
686
Jason Barone9d376f2009-02-05 11:51:38 -0500687/*
688 * File_ops->write method for <debugfs>/dynamic_debug/conrol. Gathers the
689 * command text from userspace, parses and executes it.
690 */
Jim Cromie72814912011-12-19 17:13:07 -0500691#define USER_BUF_PAGE 4096
Jason Barone9d376f2009-02-05 11:51:38 -0500692static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
693 size_t len, loff_t *offp)
694{
Jim Cromie72814912011-12-19 17:13:07 -0500695 char *tmpbuf;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200696 int ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500697
698 if (len == 0)
699 return 0;
Jim Cromie72814912011-12-19 17:13:07 -0500700 if (len > USER_BUF_PAGE - 1) {
701 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
Jason Barone9d376f2009-02-05 11:51:38 -0500702 return -E2BIG;
Jim Cromie72814912011-12-19 17:13:07 -0500703 }
704 tmpbuf = kmalloc(len + 1, GFP_KERNEL);
705 if (!tmpbuf)
706 return -ENOMEM;
707 if (copy_from_user(tmpbuf, ubuf, len)) {
708 kfree(tmpbuf);
Jason Barone9d376f2009-02-05 11:51:38 -0500709 return -EFAULT;
Jim Cromie72814912011-12-19 17:13:07 -0500710 }
Jason Barone9d376f2009-02-05 11:51:38 -0500711 tmpbuf[len] = '\0';
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600712 vpr_info("read %d bytes from userspace\n", (int)len);
Jason Barone9d376f2009-02-05 11:51:38 -0500713
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600714 ret = ddebug_exec_queries(tmpbuf, NULL);
Jim Cromie72814912011-12-19 17:13:07 -0500715 kfree(tmpbuf);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500716 if (ret < 0)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200717 return ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500718
719 *offp += len;
720 return len;
721}
722
723/*
724 * Set the iterator to point to the first _ddebug object
725 * and return a pointer to that first object. Returns
726 * NULL if there are no _ddebugs at all.
727 */
728static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
729{
730 if (list_empty(&ddebug_tables)) {
731 iter->table = NULL;
732 iter->idx = 0;
733 return NULL;
734 }
735 iter->table = list_entry(ddebug_tables.next,
736 struct ddebug_table, link);
737 iter->idx = 0;
738 return &iter->table->ddebugs[iter->idx];
739}
740
741/*
742 * Advance the iterator to point to the next _ddebug
743 * object from the one the iterator currently points at,
744 * and returns a pointer to the new _ddebug. Returns
745 * NULL if the iterator has seen all the _ddebugs.
746 */
747static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
748{
749 if (iter->table == NULL)
750 return NULL;
751 if (++iter->idx == iter->table->num_ddebugs) {
752 /* iterate to next table */
753 iter->idx = 0;
754 if (list_is_last(&iter->table->link, &ddebug_tables)) {
755 iter->table = NULL;
756 return NULL;
757 }
758 iter->table = list_entry(iter->table->link.next,
759 struct ddebug_table, link);
760 }
761 return &iter->table->ddebugs[iter->idx];
762}
763
764/*
765 * Seq_ops start method. Called at the start of every
766 * read() call from userspace. Takes the ddebug_lock and
767 * seeks the seq_file's iterator to the given position.
768 */
769static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
770{
771 struct ddebug_iter *iter = m->private;
772 struct _ddebug *dp;
773 int n = *pos;
774
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600775 vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500776
777 mutex_lock(&ddebug_lock);
778
779 if (!n)
780 return SEQ_START_TOKEN;
781 if (n < 0)
782 return NULL;
783 dp = ddebug_iter_first(iter);
784 while (dp != NULL && --n > 0)
785 dp = ddebug_iter_next(iter);
786 return dp;
787}
788
789/*
790 * Seq_ops next method. Called several times within a read()
791 * call from userspace, with ddebug_lock held. Walks to the
792 * next _ddebug object with a special case for the header line.
793 */
794static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
795{
796 struct ddebug_iter *iter = m->private;
797 struct _ddebug *dp;
798
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600799 vpr_info("called m=%p p=%p *pos=%lld\n",
Joe Perchesf657fd22012-12-05 16:48:26 -0500800 m, p, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500801
802 if (p == SEQ_START_TOKEN)
803 dp = ddebug_iter_first(iter);
804 else
805 dp = ddebug_iter_next(iter);
806 ++*pos;
807 return dp;
808}
809
810/*
811 * Seq_ops show method. Called several times within a read()
812 * call from userspace, with ddebug_lock held. Formats the
813 * current _ddebug as a single human-readable line, with a
814 * special case for the header line.
815 */
816static int ddebug_proc_show(struct seq_file *m, void *p)
817{
818 struct ddebug_iter *iter = m->private;
819 struct _ddebug *dp = p;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500820 char flagsbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500821
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600822 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500823
824 if (p == SEQ_START_TOKEN) {
825 seq_puts(m,
Joe Perchesf657fd22012-12-05 16:48:26 -0500826 "# filename:lineno [module]function flags format\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500827 return 0;
828 }
829
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500830 seq_printf(m, "%s:%u [%s]%s =%s \"",
Joe Perchesf657fd22012-12-05 16:48:26 -0500831 trim_prefix(dp->filename), dp->lineno,
832 iter->table->mod_name, dp->function,
833 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500834 seq_escape(m, dp->format, "\t\r\n\"");
835 seq_puts(m, "\"\n");
836
837 return 0;
838}
839
840/*
841 * Seq_ops stop method. Called at the end of each read()
842 * call from userspace. Drops ddebug_lock.
843 */
844static void ddebug_proc_stop(struct seq_file *m, void *p)
845{
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600846 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500847 mutex_unlock(&ddebug_lock);
848}
849
850static const struct seq_operations ddebug_proc_seqops = {
851 .start = ddebug_proc_start,
852 .next = ddebug_proc_next,
853 .show = ddebug_proc_show,
854 .stop = ddebug_proc_stop
855};
856
857/*
Jim Cromie07100be2011-12-19 17:11:09 -0500858 * File_ops->open method for <debugfs>/dynamic_debug/control. Does
859 * the seq_file setup dance, and also creates an iterator to walk the
860 * _ddebugs. Note that we create a seq_file always, even for O_WRONLY
861 * files where it's not needed, as doing so simplifies the ->release
862 * method.
Jason Barone9d376f2009-02-05 11:51:38 -0500863 */
864static int ddebug_proc_open(struct inode *inode, struct file *file)
865{
866 struct ddebug_iter *iter;
867 int err;
868
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600869 vpr_info("called\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500870
871 iter = kzalloc(sizeof(*iter), GFP_KERNEL);
872 if (iter == NULL)
873 return -ENOMEM;
874
875 err = seq_open(file, &ddebug_proc_seqops);
876 if (err) {
877 kfree(iter);
878 return err;
879 }
Joe Perchesf657fd22012-12-05 16:48:26 -0500880 ((struct seq_file *)file->private_data)->private = iter;
Jason Barone9d376f2009-02-05 11:51:38 -0500881 return 0;
882}
883
884static const struct file_operations ddebug_proc_fops = {
885 .owner = THIS_MODULE,
886 .open = ddebug_proc_open,
887 .read = seq_read,
888 .llseek = seq_lseek,
889 .release = seq_release_private,
890 .write = ddebug_proc_write
891};
892
893/*
894 * Allocate a new ddebug_table for the given module
895 * and add it to the global list.
896 */
897int ddebug_add_module(struct _ddebug *tab, unsigned int n,
898 const char *name)
899{
900 struct ddebug_table *dt;
901 char *new_name;
902
903 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
904 if (dt == NULL)
905 return -ENOMEM;
906 new_name = kstrdup(name, GFP_KERNEL);
907 if (new_name == NULL) {
908 kfree(dt);
909 return -ENOMEM;
910 }
911 dt->mod_name = new_name;
912 dt->num_ddebugs = n;
Jason Barone9d376f2009-02-05 11:51:38 -0500913 dt->ddebugs = tab;
914
915 mutex_lock(&ddebug_lock);
916 list_add_tail(&dt->link, &ddebug_tables);
917 mutex_unlock(&ddebug_lock);
918
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600919 vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500920 return 0;
921}
922EXPORT_SYMBOL_GPL(ddebug_add_module);
923
Jim Cromie6ab676e2012-04-27 14:30:37 -0600924/* helper for ddebug_dyndbg_(boot|module)_param_cb */
925static int ddebug_dyndbg_param_cb(char *param, char *val,
926 const char *modname, int on_err)
Jim Cromieb48420c2012-04-27 14:30:35 -0600927{
Jim Cromieb48420c2012-04-27 14:30:35 -0600928 char *sep;
929
930 sep = strchr(param, '.');
931 if (sep) {
Jim Cromie6ab676e2012-04-27 14:30:37 -0600932 /* needed only for ddebug_dyndbg_boot_param_cb */
Jim Cromieb48420c2012-04-27 14:30:35 -0600933 *sep = '\0';
934 modname = param;
935 param = sep + 1;
936 }
937 if (strcmp(param, "dyndbg"))
Jim Cromie6ab676e2012-04-27 14:30:37 -0600938 return on_err; /* determined by caller */
Jim Cromieb48420c2012-04-27 14:30:35 -0600939
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600940 ddebug_exec_queries((val ? val : "+p"), modname);
941
Jim Cromieb48420c2012-04-27 14:30:35 -0600942 return 0; /* query failure shouldnt stop module load */
943}
944
Jim Cromie6ab676e2012-04-27 14:30:37 -0600945/* handle both dyndbg and $module.dyndbg params at boot */
946static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
947 const char *unused)
Jim Cromieb48420c2012-04-27 14:30:35 -0600948{
Jim Cromie6ab676e2012-04-27 14:30:37 -0600949 vpr_info("%s=\"%s\"\n", param, val);
950 return ddebug_dyndbg_param_cb(param, val, NULL, 0);
951}
Jim Cromieb48420c2012-04-27 14:30:35 -0600952
Jim Cromie6ab676e2012-04-27 14:30:37 -0600953/*
954 * modprobe foo finds foo.params in boot-args, strips "foo.", and
955 * passes them to load_module(). This callback gets unknown params,
956 * processes dyndbg params, rejects others.
957 */
958int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
959{
960 vpr_info("module: %s %s=\"%s\"\n", module, param, val);
961 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
Jim Cromieb48420c2012-04-27 14:30:35 -0600962}
963
Jason Barone9d376f2009-02-05 11:51:38 -0500964static void ddebug_table_free(struct ddebug_table *dt)
965{
966 list_del_init(&dt->link);
967 kfree(dt->mod_name);
968 kfree(dt);
969}
970
971/*
972 * Called in response to a module being unloaded. Removes
973 * any ddebug_table's which point at the module.
974 */
Yehuda Sadehff49d742010-07-03 13:07:35 +1000975int ddebug_remove_module(const char *mod_name)
Jason Barone9d376f2009-02-05 11:51:38 -0500976{
977 struct ddebug_table *dt, *nextdt;
978 int ret = -ENOENT;
979
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600980 vpr_info("removing module \"%s\"\n", mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500981
982 mutex_lock(&ddebug_lock);
983 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
984 if (!strcmp(dt->mod_name, mod_name)) {
985 ddebug_table_free(dt);
986 ret = 0;
987 }
988 }
989 mutex_unlock(&ddebug_lock);
990 return ret;
991}
992EXPORT_SYMBOL_GPL(ddebug_remove_module);
993
994static void ddebug_remove_all_tables(void)
995{
996 mutex_lock(&ddebug_lock);
997 while (!list_empty(&ddebug_tables)) {
998 struct ddebug_table *dt = list_entry(ddebug_tables.next,
999 struct ddebug_table,
1000 link);
1001 ddebug_table_free(dt);
1002 }
1003 mutex_unlock(&ddebug_lock);
1004}
1005
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001006static __initdata int ddebug_init_success;
1007
1008static int __init dynamic_debug_init_debugfs(void)
Jason Barone9d376f2009-02-05 11:51:38 -05001009{
1010 struct dentry *dir, *file;
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001011
1012 if (!ddebug_init_success)
1013 return -ENODEV;
Jason Barone9d376f2009-02-05 11:51:38 -05001014
1015 dir = debugfs_create_dir("dynamic_debug", NULL);
1016 if (!dir)
1017 return -ENOMEM;
1018 file = debugfs_create_file("control", 0644, dir, NULL,
1019 &ddebug_proc_fops);
1020 if (!file) {
1021 debugfs_remove(dir);
1022 return -ENOMEM;
1023 }
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001024 return 0;
1025}
1026
1027static int __init dynamic_debug_init(void)
1028{
1029 struct _ddebug *iter, *iter_start;
1030 const char *modname = NULL;
Jim Cromieb48420c2012-04-27 14:30:35 -06001031 char *cmdline;
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001032 int ret = 0;
Jim Cromie41076922012-04-27 14:30:39 -06001033 int n = 0, entries = 0, modct = 0;
1034 int verbose_bytes = 0;
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001035
Jim Cromieb5b78f82011-12-19 17:12:54 -05001036 if (__start___verbose == __stop___verbose) {
Joe Perchesf657fd22012-12-05 16:48:26 -05001037 pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
Jim Cromieb5b78f82011-12-19 17:12:54 -05001038 return 1;
Jason Barone9d376f2009-02-05 11:51:38 -05001039 }
Jim Cromieb5b78f82011-12-19 17:12:54 -05001040 iter = __start___verbose;
1041 modname = iter->modname;
1042 iter_start = iter;
1043 for (; iter < __stop___verbose; iter++) {
Jim Cromie41076922012-04-27 14:30:39 -06001044 entries++;
1045 verbose_bytes += strlen(iter->modname) + strlen(iter->function)
1046 + strlen(iter->filename) + strlen(iter->format);
1047
Jim Cromieb5b78f82011-12-19 17:12:54 -05001048 if (strcmp(modname, iter->modname)) {
Jim Cromie41076922012-04-27 14:30:39 -06001049 modct++;
Jim Cromieb5b78f82011-12-19 17:12:54 -05001050 ret = ddebug_add_module(iter_start, n, modname);
1051 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -06001052 goto out_err;
Jim Cromieb5b78f82011-12-19 17:12:54 -05001053 n = 0;
1054 modname = iter->modname;
1055 iter_start = iter;
1056 }
1057 n++;
1058 }
1059 ret = ddebug_add_module(iter_start, n, modname);
1060 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -06001061 goto out_err;
Thomas Renningera648ec02010-08-06 16:11:02 +02001062
Jim Cromieaf442392012-04-27 14:30:38 -06001063 ddebug_init_success = 1;
Joe Perchesf657fd22012-12-05 16:48:26 -05001064 vpr_info("%d modules, %d entries and %d bytes in ddebug tables, %d bytes in (readonly) verbose section\n",
1065 modct, entries, (int)(modct * sizeof(struct ddebug_table)),
1066 verbose_bytes + (int)(__stop___verbose - __start___verbose));
Jim Cromieaf442392012-04-27 14:30:38 -06001067
1068 /* apply ddebug_query boot param, dont unload tables on err */
Thomas Renningera648ec02010-08-06 16:11:02 +02001069 if (ddebug_setup_string[0] != '\0') {
Joe Perchesf657fd22012-12-05 16:48:26 -05001070 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
Jim Cromie8e59b5cf2012-04-27 14:30:40 -06001071 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001072 if (ret < 0)
Joe Perchesf657fd22012-12-05 16:48:26 -05001073 pr_warn("Invalid ddebug boot param %s\n",
Joe Perches4ad275e2011-08-11 14:36:33 -04001074 ddebug_setup_string);
Thomas Renningera648ec02010-08-06 16:11:02 +02001075 else
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001076 pr_info("%d changes by ddebug_query\n", ret);
Jason Barone9d376f2009-02-05 11:51:38 -05001077 }
Jim Cromieb48420c2012-04-27 14:30:35 -06001078 /* now that ddebug tables are loaded, process all boot args
1079 * again to find and activate queries given in dyndbg params.
1080 * While this has already been done for known boot params, it
1081 * ignored the unknown ones (dyndbg in particular). Reusing
1082 * parse_args avoids ad-hoc parsing. This will also attempt
1083 * to activate queries for not-yet-loaded modules, which is
1084 * slightly noisy if verbose, but harmless.
1085 */
1086 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1087 parse_args("dyndbg params", cmdline, NULL,
1088 0, 0, 0, &ddebug_dyndbg_boot_param_cb);
1089 kfree(cmdline);
Jim Cromieaf442392012-04-27 14:30:38 -06001090 return 0;
Thomas Renningera648ec02010-08-06 16:11:02 +02001091
Jim Cromieaf442392012-04-27 14:30:38 -06001092out_err:
1093 ddebug_remove_all_tables();
Jason Barone9d376f2009-02-05 11:51:38 -05001094 return 0;
1095}
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001096/* Allow early initialization for boot messages via boot param */
Jim Cromie3ec56522012-04-27 14:30:42 -06001097early_initcall(dynamic_debug_init);
Jim Cromieb48420c2012-04-27 14:30:35 -06001098
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001099/* Debugfs setup must be done later */
Jim Cromie3ec56522012-04-27 14:30:42 -06001100fs_initcall(dynamic_debug_init_debugfs);