blob: d8f3d3150603cc0d2abd06e415f0c9a35521e2fa [file] [log] [blame]
Jason Barone9d376f2009-02-05 11:51:38 -05001/*
2 * lib/dynamic_debug.c
3 *
4 * make pr_debug()/dev_dbg() calls runtime configurable based upon their
5 * source module.
6 *
7 * Copyright (C) 2008 Jason Baron <jbaron@redhat.com>
8 * By Greg Banks <gnb@melbourne.sgi.com>
9 * Copyright (c) 2008 Silicon Graphics Inc. All Rights Reserved.
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010010 * Copyright (C) 2011 Bart Van Assche. All Rights Reserved.
Du, Changbin578b1e02014-01-23 15:54:14 -080011 * Copyright (C) 2013 Du, Changbin <changbin.du@gmail.com>
Jason Barone9d376f2009-02-05 11:51:38 -050012 */
13
Joe Perches4ad275e2011-08-11 14:36:33 -040014#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
15
Jason Barone9d376f2009-02-05 11:51:38 -050016#include <linux/kernel.h>
17#include <linux/module.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070018#include <linux/moduleparam.h>
19#include <linux/kallsyms.h>
20#include <linux/types.h>
Jason Barone9d376f2009-02-05 11:51:38 -050021#include <linux/mutex.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070022#include <linux/proc_fs.h>
Jason Barone9d376f2009-02-05 11:51:38 -050023#include <linux/seq_file.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070024#include <linux/list.h>
25#include <linux/sysctl.h>
Jason Barone9d376f2009-02-05 11:51:38 -050026#include <linux/ctype.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070027#include <linux/string.h>
Du, Changbin578b1e02014-01-23 15:54:14 -080028#include <linux/parser.h>
Andy Shevchenkod338b132013-04-30 15:27:32 -070029#include <linux/string_helpers.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070030#include <linux/uaccess.h>
Jason Barone9d376f2009-02-05 11:51:38 -050031#include <linux/dynamic_debug.h>
32#include <linux/debugfs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/slab.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070034#include <linux/jump_label.h>
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010035#include <linux/hardirq.h>
Greg Kroah-Hartmane8d97922011-02-03 15:59:58 -080036#include <linux/sched.h>
Greg Kroah-Hartmanfef15d22012-05-07 16:47:32 -070037#include <linux/device.h>
Jason Baronffa10cb2011-08-11 14:36:48 -040038#include <linux/netdevice.h>
Jason Barone9d376f2009-02-05 11:51:38 -050039
40extern struct _ddebug __start___verbose[];
41extern struct _ddebug __stop___verbose[];
42
Jason Barone9d376f2009-02-05 11:51:38 -050043struct ddebug_table {
44 struct list_head link;
45 char *mod_name;
46 unsigned int num_ddebugs;
Jason Barone9d376f2009-02-05 11:51:38 -050047 struct _ddebug *ddebugs;
48};
49
50struct ddebug_query {
51 const char *filename;
52 const char *module;
53 const char *function;
54 const char *format;
55 unsigned int first_lineno, last_lineno;
56};
57
58struct ddebug_iter {
59 struct ddebug_table *table;
60 unsigned int idx;
61};
62
63static DEFINE_MUTEX(ddebug_lock);
64static LIST_HEAD(ddebug_tables);
Joe Perchesf657fd22012-12-05 16:48:26 -050065static int verbose;
Jim Cromie74df1382011-12-19 17:12:24 -050066module_param(verbose, int, 0644);
Jason Barone9d376f2009-02-05 11:51:38 -050067
Jim Cromie2b678312011-12-19 17:13:12 -050068/* Return the path relative to source root */
69static inline const char *trim_prefix(const char *path)
70{
71 int skip = strlen(__FILE__) - strlen("lib/dynamic_debug.c");
72
73 if (strncmp(path, __FILE__, skip))
74 skip = 0; /* prefix mismatch, don't skip */
75
76 return path + skip;
77}
78
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010079static struct { unsigned flag:8; char opt_char; } opt_array[] = {
80 { _DPRINTK_FLAGS_PRINT, 'p' },
81 { _DPRINTK_FLAGS_INCL_MODNAME, 'm' },
82 { _DPRINTK_FLAGS_INCL_FUNCNAME, 'f' },
83 { _DPRINTK_FLAGS_INCL_LINENO, 'l' },
84 { _DPRINTK_FLAGS_INCL_TID, 't' },
Jim Cromie5ca7d2a2011-12-19 17:12:44 -050085 { _DPRINTK_FLAGS_NONE, '_' },
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010086};
87
Jason Barone9d376f2009-02-05 11:51:38 -050088/* format a string into buf[] which describes the _ddebug's flags */
89static char *ddebug_describe_flags(struct _ddebug *dp, char *buf,
90 size_t maxlen)
91{
92 char *p = buf;
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010093 int i;
Jason Barone9d376f2009-02-05 11:51:38 -050094
Jim Cromie5ca7d2a2011-12-19 17:12:44 -050095 BUG_ON(maxlen < 6);
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +010096 for (i = 0; i < ARRAY_SIZE(opt_array); ++i)
97 if (dp->flags & opt_array[i].flag)
98 *p++ = opt_array[i].opt_char;
Jason Barone9d376f2009-02-05 11:51:38 -050099 if (p == buf)
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500100 *p++ = '_';
Jason Barone9d376f2009-02-05 11:51:38 -0500101 *p = '\0';
102
103 return buf;
104}
105
Joe Perchesf657fd22012-12-05 16:48:26 -0500106#define vpr_info(fmt, ...) \
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600107do { \
Joe Perchesf657fd22012-12-05 16:48:26 -0500108 if (verbose) \
109 pr_info(fmt, ##__VA_ARGS__); \
Jim Cromie574b3722011-12-19 17:13:16 -0500110} while (0)
111
Joe Perchesf657fd22012-12-05 16:48:26 -0500112static void vpr_info_dq(const struct ddebug_query *query, const char *msg)
113{
114 /* trim any trailing newlines */
115 int fmtlen = 0;
116
117 if (query->format) {
118 fmtlen = strlen(query->format);
119 while (fmtlen && query->format[fmtlen - 1] == '\n')
120 fmtlen--;
121 }
122
123 vpr_info("%s: func=\"%s\" file=\"%s\" module=\"%s\" format=\"%.*s\" lineno=%u-%u\n",
124 msg,
125 query->function ? query->function : "",
126 query->filename ? query->filename : "",
127 query->module ? query->module : "",
128 fmtlen, query->format ? query->format : "",
129 query->first_lineno, query->last_lineno);
130}
131
Jason Barone9d376f2009-02-05 11:51:38 -0500132/*
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500133 * Search the tables for _ddebug's which match the given `query' and
134 * apply the `flags' and `mask' to them. Returns number of matching
135 * callsites, normally the same as number of changes. If verbose,
136 * logs the changes. Takes ddebug_lock.
Jason Barone9d376f2009-02-05 11:51:38 -0500137 */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500138static int ddebug_change(const struct ddebug_query *query,
139 unsigned int flags, unsigned int mask)
Jason Barone9d376f2009-02-05 11:51:38 -0500140{
141 int i;
142 struct ddebug_table *dt;
143 unsigned int newflags;
144 unsigned int nfound = 0;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500145 char flagbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500146
147 /* search for matching ddebugs */
148 mutex_lock(&ddebug_lock);
149 list_for_each_entry(dt, &ddebug_tables, link) {
150
151 /* match against the module name */
Du, Changbin578b1e02014-01-23 15:54:14 -0800152 if (query->module &&
153 !match_wildcard(query->module, dt->mod_name))
Jason Barone9d376f2009-02-05 11:51:38 -0500154 continue;
155
Joe Perchesf657fd22012-12-05 16:48:26 -0500156 for (i = 0; i < dt->num_ddebugs; i++) {
Jason Barone9d376f2009-02-05 11:51:38 -0500157 struct _ddebug *dp = &dt->ddebugs[i];
158
159 /* match against the source filename */
Jim Cromied6a238d2011-12-19 17:12:39 -0500160 if (query->filename &&
Du, Changbin578b1e02014-01-23 15:54:14 -0800161 !match_wildcard(query->filename, dp->filename) &&
162 !match_wildcard(query->filename,
163 kbasename(dp->filename)) &&
164 !match_wildcard(query->filename,
165 trim_prefix(dp->filename)))
Jason Barone9d376f2009-02-05 11:51:38 -0500166 continue;
167
168 /* match against the function */
Jim Cromied6a238d2011-12-19 17:12:39 -0500169 if (query->function &&
Du, Changbin578b1e02014-01-23 15:54:14 -0800170 !match_wildcard(query->function, dp->function))
Jason Barone9d376f2009-02-05 11:51:38 -0500171 continue;
172
173 /* match against the format */
Jim Cromied6a238d2011-12-19 17:12:39 -0500174 if (query->format &&
175 !strstr(dp->format, query->format))
Jason Barone9d376f2009-02-05 11:51:38 -0500176 continue;
177
178 /* match against the line number range */
179 if (query->first_lineno &&
180 dp->lineno < query->first_lineno)
181 continue;
182 if (query->last_lineno &&
183 dp->lineno > query->last_lineno)
184 continue;
185
186 nfound++;
187
188 newflags = (dp->flags & mask) | flags;
189 if (newflags == dp->flags)
190 continue;
Jason Barone9d376f2009-02-05 11:51:38 -0500191 dp->flags = newflags;
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600192 vpr_info("changed %s:%d [%s]%s =%s\n",
Joe Perchesf657fd22012-12-05 16:48:26 -0500193 trim_prefix(dp->filename), dp->lineno,
194 dt->mod_name, dp->function,
195 ddebug_describe_flags(dp, flagbuf,
196 sizeof(flagbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500197 }
198 }
199 mutex_unlock(&ddebug_lock);
200
201 if (!nfound && verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400202 pr_info("no matches for query\n");
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500203
204 return nfound;
Jason Barone9d376f2009-02-05 11:51:38 -0500205}
206
207/*
Jason Barone9d376f2009-02-05 11:51:38 -0500208 * Split the buffer `buf' into space-separated words.
Greg Banks9898abb2009-02-06 12:54:26 +1100209 * Handles simple " and ' quoting, i.e. without nested,
210 * embedded or escaped \". Return the number of words
211 * or <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500212 */
213static int ddebug_tokenize(char *buf, char *words[], int maxwords)
214{
215 int nwords = 0;
216
Greg Banks9898abb2009-02-06 12:54:26 +1100217 while (*buf) {
218 char *end;
219
220 /* Skip leading whitespace */
André Goddard Rosae7d28602009-12-14 18:01:06 -0800221 buf = skip_spaces(buf);
Greg Banks9898abb2009-02-06 12:54:26 +1100222 if (!*buf)
223 break; /* oh, it was trailing whitespace */
Jim Cromie8bd60262011-12-19 17:13:03 -0500224 if (*buf == '#')
225 break; /* token starts comment, skip rest of line */
Greg Banks9898abb2009-02-06 12:54:26 +1100226
Jim Cromie07100be2011-12-19 17:11:09 -0500227 /* find `end' of word, whitespace separated or quoted */
Greg Banks9898abb2009-02-06 12:54:26 +1100228 if (*buf == '"' || *buf == '\'') {
229 int quote = *buf++;
Joe Perchesf657fd22012-12-05 16:48:26 -0500230 for (end = buf; *end && *end != quote; end++)
Greg Banks9898abb2009-02-06 12:54:26 +1100231 ;
Jim Cromie18c216c2012-12-05 16:48:27 -0500232 if (!*end) {
233 pr_err("unclosed quote: %s\n", buf);
Greg Banks9898abb2009-02-06 12:54:26 +1100234 return -EINVAL; /* unclosed quote */
Jim Cromie18c216c2012-12-05 16:48:27 -0500235 }
Greg Banks9898abb2009-02-06 12:54:26 +1100236 } else {
Joe Perchesf657fd22012-12-05 16:48:26 -0500237 for (end = buf; *end && !isspace(*end); end++)
Greg Banks9898abb2009-02-06 12:54:26 +1100238 ;
239 BUG_ON(end == buf);
240 }
Greg Banks9898abb2009-02-06 12:54:26 +1100241
Jim Cromie07100be2011-12-19 17:11:09 -0500242 /* `buf' is start of word, `end' is one past its end */
Jim Cromie18c216c2012-12-05 16:48:27 -0500243 if (nwords == maxwords) {
244 pr_err("too many words, legal max <=%d\n", maxwords);
Greg Banks9898abb2009-02-06 12:54:26 +1100245 return -EINVAL; /* ran out of words[] before bytes */
Jim Cromie18c216c2012-12-05 16:48:27 -0500246 }
Greg Banks9898abb2009-02-06 12:54:26 +1100247 if (*end)
248 *end++ = '\0'; /* terminate the word */
249 words[nwords++] = buf;
250 buf = end;
251 }
Jason Barone9d376f2009-02-05 11:51:38 -0500252
253 if (verbose) {
254 int i;
Joe Perches4ad275e2011-08-11 14:36:33 -0400255 pr_info("split into words:");
Joe Perchesf657fd22012-12-05 16:48:26 -0500256 for (i = 0; i < nwords; i++)
Joe Perches4ad275e2011-08-11 14:36:33 -0400257 pr_cont(" \"%s\"", words[i]);
258 pr_cont("\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500259 }
260
261 return nwords;
262}
263
264/*
265 * Parse a single line number. Note that the empty string ""
266 * is treated as a special case and converted to zero, which
267 * is later treated as a "don't care" value.
268 */
269static inline int parse_lineno(const char *str, unsigned int *val)
270{
Jason Barone9d376f2009-02-05 11:51:38 -0500271 BUG_ON(str == NULL);
272 if (*str == '\0') {
273 *val = 0;
274 return 0;
275 }
Andrey Ryabinin45925992014-01-27 17:06:59 -0800276 if (kstrtouint(str, 10, val) < 0) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500277 pr_err("bad line-number: %s\n", str);
278 return -EINVAL;
279 }
280 return 0;
Jason Barone9d376f2009-02-05 11:51:38 -0500281}
282
Jim Cromie820874c2011-12-19 17:12:49 -0500283static int check_set(const char **dest, char *src, char *name)
284{
285 int rc = 0;
286
287 if (*dest) {
288 rc = -EINVAL;
Joe Perchesf657fd22012-12-05 16:48:26 -0500289 pr_err("match-spec:%s val:%s overridden by %s\n",
290 name, *dest, src);
Jim Cromie820874c2011-12-19 17:12:49 -0500291 }
292 *dest = src;
293 return rc;
294}
295
Jason Barone9d376f2009-02-05 11:51:38 -0500296/*
297 * Parse words[] as a ddebug query specification, which is a series
298 * of (keyword, value) pairs chosen from these possibilities:
299 *
300 * func <function-name>
301 * file <full-pathname>
302 * file <base-filename>
303 * module <module-name>
304 * format <escaped-string-to-find-in-format>
305 * line <lineno>
306 * line <first-lineno>-<last-lineno> // where either may be empty
Jim Cromie820874c2011-12-19 17:12:49 -0500307 *
308 * Only 1 of each type is allowed.
309 * Returns 0 on success, <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500310 */
311static int ddebug_parse_query(char *words[], int nwords,
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600312 struct ddebug_query *query, const char *modname)
Jason Barone9d376f2009-02-05 11:51:38 -0500313{
314 unsigned int i;
jbaron@akamai.combd8c154a2013-08-27 16:50:03 +0000315 int rc = 0;
Jason Barone9d376f2009-02-05 11:51:38 -0500316
317 /* check we have an even number of words */
Jim Cromie18c216c2012-12-05 16:48:27 -0500318 if (nwords % 2 != 0) {
319 pr_err("expecting pairs of match-spec <value>\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500320 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500321 }
Jason Barone9d376f2009-02-05 11:51:38 -0500322 memset(query, 0, sizeof(*query));
323
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600324 if (modname)
325 /* support $modname.dyndbg=<multiple queries> */
326 query->module = modname;
327
Joe Perchesf657fd22012-12-05 16:48:26 -0500328 for (i = 0; i < nwords; i += 2) {
329 if (!strcmp(words[i], "func")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500330 rc = check_set(&query->function, words[i+1], "func");
Joe Perchesf657fd22012-12-05 16:48:26 -0500331 } else if (!strcmp(words[i], "file")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500332 rc = check_set(&query->filename, words[i+1], "file");
Joe Perchesf657fd22012-12-05 16:48:26 -0500333 } else if (!strcmp(words[i], "module")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500334 rc = check_set(&query->module, words[i+1], "module");
Joe Perchesf657fd22012-12-05 16:48:26 -0500335 } else if (!strcmp(words[i], "format")) {
Andy Shevchenkod338b132013-04-30 15:27:32 -0700336 string_unescape_inplace(words[i+1], UNESCAPE_SPACE |
337 UNESCAPE_OCTAL |
338 UNESCAPE_SPECIAL);
339 rc = check_set(&query->format, words[i+1], "format");
Joe Perchesf657fd22012-12-05 16:48:26 -0500340 } else if (!strcmp(words[i], "line")) {
Jason Barone9d376f2009-02-05 11:51:38 -0500341 char *first = words[i+1];
342 char *last = strchr(first, '-');
Jim Cromie820874c2011-12-19 17:12:49 -0500343 if (query->first_lineno || query->last_lineno) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500344 pr_err("match-spec: line used 2x\n");
Jim Cromie820874c2011-12-19 17:12:49 -0500345 return -EINVAL;
346 }
Jason Barone9d376f2009-02-05 11:51:38 -0500347 if (last)
348 *last++ = '\0';
Andrey Ryabinind9e133e2014-01-27 17:06:57 -0800349 if (parse_lineno(first, &query->first_lineno) < 0)
Jason Barone9d376f2009-02-05 11:51:38 -0500350 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500351 if (last) {
Jason Barone9d376f2009-02-05 11:51:38 -0500352 /* range <first>-<last> */
Andrey Ryabinin3ace6782014-01-27 17:06:58 -0800353 if (parse_lineno(last, &query->last_lineno) < 0)
354 return -EINVAL;
355
356 if (query->last_lineno < query->first_lineno) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500357 pr_err("last-line:%d < 1st-line:%d\n",
358 query->last_lineno,
359 query->first_lineno);
Jason Barone9d376f2009-02-05 11:51:38 -0500360 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500361 }
Jason Barone9d376f2009-02-05 11:51:38 -0500362 } else {
363 query->last_lineno = query->first_lineno;
364 }
365 } else {
Jim Cromieae27f862011-12-19 17:12:34 -0500366 pr_err("unknown keyword \"%s\"\n", words[i]);
Jason Barone9d376f2009-02-05 11:51:38 -0500367 return -EINVAL;
368 }
Jim Cromie820874c2011-12-19 17:12:49 -0500369 if (rc)
370 return rc;
Jason Barone9d376f2009-02-05 11:51:38 -0500371 }
Jim Cromie574b3722011-12-19 17:13:16 -0500372 vpr_info_dq(query, "parsed");
Jason Barone9d376f2009-02-05 11:51:38 -0500373 return 0;
374}
375
376/*
377 * Parse `str' as a flags specification, format [-+=][p]+.
378 * Sets up *maskp and *flagsp to be used when changing the
379 * flags fields of matched _ddebug's. Returns 0 on success
380 * or <0 on error.
381 */
382static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
383 unsigned int *maskp)
384{
385 unsigned flags = 0;
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100386 int op = '=', i;
Jason Barone9d376f2009-02-05 11:51:38 -0500387
388 switch (*str) {
389 case '+':
390 case '-':
391 case '=':
392 op = *str++;
393 break;
394 default:
Jim Cromie18c216c2012-12-05 16:48:27 -0500395 pr_err("bad flag-op %c, at start of %s\n", *str, str);
Jason Barone9d376f2009-02-05 11:51:38 -0500396 return -EINVAL;
397 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600398 vpr_info("op='%c'\n", op);
Jason Barone9d376f2009-02-05 11:51:38 -0500399
Joe Perchesf657fd22012-12-05 16:48:26 -0500400 for (; *str ; ++str) {
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100401 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
402 if (*str == opt_array[i].opt_char) {
403 flags |= opt_array[i].flag;
404 break;
405 }
Jason Barone9d376f2009-02-05 11:51:38 -0500406 }
Jim Cromie18c216c2012-12-05 16:48:27 -0500407 if (i < 0) {
408 pr_err("unknown flag '%c' in \"%s\"\n", *str, str);
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100409 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500410 }
Jason Barone9d376f2009-02-05 11:51:38 -0500411 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600412 vpr_info("flags=0x%x\n", flags);
Jason Barone9d376f2009-02-05 11:51:38 -0500413
414 /* calculate final *flagsp, *maskp according to mask and op */
415 switch (op) {
416 case '=':
417 *maskp = 0;
418 *flagsp = flags;
419 break;
420 case '+':
421 *maskp = ~0U;
422 *flagsp = flags;
423 break;
424 case '-':
425 *maskp = ~flags;
426 *flagsp = 0;
427 break;
428 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600429 vpr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
Jason Barone9d376f2009-02-05 11:51:38 -0500430 return 0;
431}
432
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600433static int ddebug_exec_query(char *query_string, const char *modname)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200434{
435 unsigned int flags = 0, mask = 0;
436 struct ddebug_query query;
437#define MAXWORDS 9
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500438 int nwords, nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200439 char *words[MAXWORDS];
440
441 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
Jim Cromie18c216c2012-12-05 16:48:27 -0500442 if (nwords <= 0) {
443 pr_err("tokenize failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200444 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500445 }
446 /* check flags 1st (last arg) so query is pairs of spec,val */
447 if (ddebug_parse_flags(words[nwords-1], &flags, &mask)) {
448 pr_err("flags parse failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200449 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500450 }
451 if (ddebug_parse_query(words, nwords-1, &query, modname)) {
452 pr_err("query parse failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200453 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500454 }
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200455 /* actually go and implement the change */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500456 nfound = ddebug_change(&query, flags, mask);
Joe Perchesf657fd22012-12-05 16:48:26 -0500457 vpr_info_dq(&query, nfound ? "applied" : "no-match");
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500458
459 return nfound;
460}
461
462/* handle multiple queries in query string, continue on error, return
463 last error or number of matching callsites. Module name is either
464 in param (for boot arg) or perhaps in query string.
465*/
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600466static int ddebug_exec_queries(char *query, const char *modname)
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500467{
468 char *split;
469 int i, errs = 0, exitcode = 0, rc, nfound = 0;
470
471 for (i = 0; query; query = split) {
472 split = strpbrk(query, ";\n");
473 if (split)
474 *split++ = '\0';
475
476 query = skip_spaces(query);
477 if (!query || !*query || *query == '#')
478 continue;
479
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600480 vpr_info("query %d: \"%s\"\n", i, query);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500481
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600482 rc = ddebug_exec_query(query, modname);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500483 if (rc < 0) {
484 errs++;
485 exitcode = rc;
Joe Perchesf657fd22012-12-05 16:48:26 -0500486 } else {
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500487 nfound += rc;
Joe Perchesf657fd22012-12-05 16:48:26 -0500488 }
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500489 i++;
490 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600491 vpr_info("processed %d queries, with %d matches, %d errs\n",
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500492 i, nfound, errs);
493
494 if (exitcode)
495 return exitcode;
496 return nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200497}
498
Jason Baron431625d2011-10-04 14:13:19 -0700499#define PREFIX_SIZE 64
500
501static int remaining(int wrote)
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100502{
Jason Baron431625d2011-10-04 14:13:19 -0700503 if (PREFIX_SIZE - wrote > 0)
504 return PREFIX_SIZE - wrote;
505 return 0;
506}
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100507
Jason Baron431625d2011-10-04 14:13:19 -0700508static char *dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
509{
510 int pos_after_tid;
511 int pos = 0;
512
Joe Perches798efc62012-09-12 20:11:29 -0700513 *buf = '\0';
514
Jason Baron431625d2011-10-04 14:13:19 -0700515 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100516 if (in_interrupt())
Joe Perches798efc62012-09-12 20:11:29 -0700517 pos += snprintf(buf + pos, remaining(pos), "<intr> ");
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100518 else
Jason Baron431625d2011-10-04 14:13:19 -0700519 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
Joe Perches798efc62012-09-12 20:11:29 -0700520 task_pid_vnr(current));
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100521 }
Jason Baron431625d2011-10-04 14:13:19 -0700522 pos_after_tid = pos;
523 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
524 pos += snprintf(buf + pos, remaining(pos), "%s:",
Joe Perches798efc62012-09-12 20:11:29 -0700525 desc->modname);
Jason Baron431625d2011-10-04 14:13:19 -0700526 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
527 pos += snprintf(buf + pos, remaining(pos), "%s:",
Joe Perches798efc62012-09-12 20:11:29 -0700528 desc->function);
Jason Baron431625d2011-10-04 14:13:19 -0700529 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
Jim Cromie07100be2011-12-19 17:11:09 -0500530 pos += snprintf(buf + pos, remaining(pos), "%d:",
Joe Perches798efc62012-09-12 20:11:29 -0700531 desc->lineno);
Jason Baron431625d2011-10-04 14:13:19 -0700532 if (pos - pos_after_tid)
533 pos += snprintf(buf + pos, remaining(pos), " ");
534 if (pos >= PREFIX_SIZE)
535 buf[PREFIX_SIZE - 1] = '\0';
Joe Perches6c2140e2011-08-11 14:36:25 -0400536
Jason Baron431625d2011-10-04 14:13:19 -0700537 return buf;
Joe Perches6c2140e2011-08-11 14:36:25 -0400538}
539
Joe Perches906d2012014-09-24 11:17:56 -0700540void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100541{
542 va_list args;
Jason Baron431625d2011-10-04 14:13:19 -0700543 struct va_format vaf;
544 char buf[PREFIX_SIZE];
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100545
546 BUG_ON(!descriptor);
547 BUG_ON(!fmt);
548
549 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700550
Jason Baron431625d2011-10-04 14:13:19 -0700551 vaf.fmt = fmt;
552 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700553
Joe Perches906d2012014-09-24 11:17:56 -0700554 printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700555
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100556 va_end(args);
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100557}
558EXPORT_SYMBOL(__dynamic_pr_debug);
559
Joe Perches906d2012014-09-24 11:17:56 -0700560void __dynamic_dev_dbg(struct _ddebug *descriptor,
Joe Perchescbc46632011-08-11 14:36:21 -0400561 const struct device *dev, const char *fmt, ...)
562{
563 struct va_format vaf;
564 va_list args;
Joe Perchescbc46632011-08-11 14:36:21 -0400565
566 BUG_ON(!descriptor);
567 BUG_ON(!fmt);
568
569 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700570
Joe Perchescbc46632011-08-11 14:36:21 -0400571 vaf.fmt = fmt;
572 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700573
574 if (!dev) {
Joe Perches906d2012014-09-24 11:17:56 -0700575 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700576 } else {
577 char buf[PREFIX_SIZE];
Joe Perches798efc62012-09-12 20:11:29 -0700578
Joe Perchesa39d4a82014-12-10 15:50:15 -0800579 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
Joe Perches906d2012014-09-24 11:17:56 -0700580 dynamic_emit_prefix(descriptor, buf),
581 dev_driver_string(dev), dev_name(dev),
582 &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700583 }
584
Joe Perchescbc46632011-08-11 14:36:21 -0400585 va_end(args);
Joe Perchescbc46632011-08-11 14:36:21 -0400586}
587EXPORT_SYMBOL(__dynamic_dev_dbg);
588
Jason Baron0feefd92011-10-04 14:13:22 -0700589#ifdef CONFIG_NET
590
Joe Perches906d2012014-09-24 11:17:56 -0700591void __dynamic_netdev_dbg(struct _ddebug *descriptor,
592 const struct net_device *dev, const char *fmt, ...)
Jason Baronffa10cb2011-08-11 14:36:48 -0400593{
594 struct va_format vaf;
595 va_list args;
Jason Baronffa10cb2011-08-11 14:36:48 -0400596
597 BUG_ON(!descriptor);
598 BUG_ON(!fmt);
599
600 va_start(args, fmt);
Joe Perchesb004ff42012-09-12 20:12:19 -0700601
Jason Baronffa10cb2011-08-11 14:36:48 -0400602 vaf.fmt = fmt;
603 vaf.va = &args;
Joe Perchesb004ff42012-09-12 20:12:19 -0700604
605 if (dev && dev->dev.parent) {
606 char buf[PREFIX_SIZE];
Joe Perchesb004ff42012-09-12 20:12:19 -0700607
Joe Perchesa39d4a82014-12-10 15:50:15 -0800608 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
Joe Perches906d2012014-09-24 11:17:56 -0700609 "%s%s %s %s%s: %pV",
610 dynamic_emit_prefix(descriptor, buf),
611 dev_driver_string(dev->dev.parent),
612 dev_name(dev->dev.parent),
613 netdev_name(dev), netdev_reg_state(dev),
614 &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700615 } else if (dev) {
Joe Perches906d2012014-09-24 11:17:56 -0700616 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
617 netdev_reg_state(dev), &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700618 } else {
Joe Perches906d2012014-09-24 11:17:56 -0700619 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700620 }
621
Jason Baronffa10cb2011-08-11 14:36:48 -0400622 va_end(args);
Jason Baronffa10cb2011-08-11 14:36:48 -0400623}
624EXPORT_SYMBOL(__dynamic_netdev_dbg);
625
Jason Baron0feefd92011-10-04 14:13:22 -0700626#endif
627
Jim Cromiebc757f62011-12-19 17:12:29 -0500628#define DDEBUG_STRING_SIZE 1024
629static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
630
Thomas Renningera648ec02010-08-06 16:11:02 +0200631static __init int ddebug_setup_query(char *str)
632{
Jim Cromiebc757f62011-12-19 17:12:29 -0500633 if (strlen(str) >= DDEBUG_STRING_SIZE) {
Joe Perches4ad275e2011-08-11 14:36:33 -0400634 pr_warn("ddebug boot param string too large\n");
Thomas Renningera648ec02010-08-06 16:11:02 +0200635 return 0;
636 }
Jim Cromiebc757f62011-12-19 17:12:29 -0500637 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
Thomas Renningera648ec02010-08-06 16:11:02 +0200638 return 1;
639}
640
641__setup("ddebug_query=", ddebug_setup_query);
642
Jason Barone9d376f2009-02-05 11:51:38 -0500643/*
Masatake YAMATO231821d2014-12-15 12:04:16 +0900644 * File_ops->write method for <debugfs>/dynamic_debug/control. Gathers the
Jason Barone9d376f2009-02-05 11:51:38 -0500645 * command text from userspace, parses and executes it.
646 */
Jim Cromie72814912011-12-19 17:13:07 -0500647#define USER_BUF_PAGE 4096
Jason Barone9d376f2009-02-05 11:51:38 -0500648static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
649 size_t len, loff_t *offp)
650{
Jim Cromie72814912011-12-19 17:13:07 -0500651 char *tmpbuf;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200652 int ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500653
654 if (len == 0)
655 return 0;
Jim Cromie72814912011-12-19 17:13:07 -0500656 if (len > USER_BUF_PAGE - 1) {
657 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
Jason Barone9d376f2009-02-05 11:51:38 -0500658 return -E2BIG;
Jim Cromie72814912011-12-19 17:13:07 -0500659 }
660 tmpbuf = kmalloc(len + 1, GFP_KERNEL);
661 if (!tmpbuf)
662 return -ENOMEM;
663 if (copy_from_user(tmpbuf, ubuf, len)) {
664 kfree(tmpbuf);
Jason Barone9d376f2009-02-05 11:51:38 -0500665 return -EFAULT;
Jim Cromie72814912011-12-19 17:13:07 -0500666 }
Jason Barone9d376f2009-02-05 11:51:38 -0500667 tmpbuf[len] = '\0';
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600668 vpr_info("read %d bytes from userspace\n", (int)len);
Jason Barone9d376f2009-02-05 11:51:38 -0500669
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600670 ret = ddebug_exec_queries(tmpbuf, NULL);
Jim Cromie72814912011-12-19 17:13:07 -0500671 kfree(tmpbuf);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500672 if (ret < 0)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200673 return ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500674
675 *offp += len;
676 return len;
677}
678
679/*
680 * Set the iterator to point to the first _ddebug object
681 * and return a pointer to that first object. Returns
682 * NULL if there are no _ddebugs at all.
683 */
684static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
685{
686 if (list_empty(&ddebug_tables)) {
687 iter->table = NULL;
688 iter->idx = 0;
689 return NULL;
690 }
691 iter->table = list_entry(ddebug_tables.next,
692 struct ddebug_table, link);
693 iter->idx = 0;
694 return &iter->table->ddebugs[iter->idx];
695}
696
697/*
698 * Advance the iterator to point to the next _ddebug
699 * object from the one the iterator currently points at,
700 * and returns a pointer to the new _ddebug. Returns
701 * NULL if the iterator has seen all the _ddebugs.
702 */
703static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
704{
705 if (iter->table == NULL)
706 return NULL;
707 if (++iter->idx == iter->table->num_ddebugs) {
708 /* iterate to next table */
709 iter->idx = 0;
710 if (list_is_last(&iter->table->link, &ddebug_tables)) {
711 iter->table = NULL;
712 return NULL;
713 }
714 iter->table = list_entry(iter->table->link.next,
715 struct ddebug_table, link);
716 }
717 return &iter->table->ddebugs[iter->idx];
718}
719
720/*
721 * Seq_ops start method. Called at the start of every
722 * read() call from userspace. Takes the ddebug_lock and
723 * seeks the seq_file's iterator to the given position.
724 */
725static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
726{
727 struct ddebug_iter *iter = m->private;
728 struct _ddebug *dp;
729 int n = *pos;
730
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600731 vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500732
733 mutex_lock(&ddebug_lock);
734
735 if (!n)
736 return SEQ_START_TOKEN;
737 if (n < 0)
738 return NULL;
739 dp = ddebug_iter_first(iter);
740 while (dp != NULL && --n > 0)
741 dp = ddebug_iter_next(iter);
742 return dp;
743}
744
745/*
746 * Seq_ops next method. Called several times within a read()
747 * call from userspace, with ddebug_lock held. Walks to the
748 * next _ddebug object with a special case for the header line.
749 */
750static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
751{
752 struct ddebug_iter *iter = m->private;
753 struct _ddebug *dp;
754
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600755 vpr_info("called m=%p p=%p *pos=%lld\n",
Joe Perchesf657fd22012-12-05 16:48:26 -0500756 m, p, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500757
758 if (p == SEQ_START_TOKEN)
759 dp = ddebug_iter_first(iter);
760 else
761 dp = ddebug_iter_next(iter);
762 ++*pos;
763 return dp;
764}
765
766/*
767 * Seq_ops show method. Called several times within a read()
768 * call from userspace, with ddebug_lock held. Formats the
769 * current _ddebug as a single human-readable line, with a
770 * special case for the header line.
771 */
772static int ddebug_proc_show(struct seq_file *m, void *p)
773{
774 struct ddebug_iter *iter = m->private;
775 struct _ddebug *dp = p;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500776 char flagsbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500777
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600778 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500779
780 if (p == SEQ_START_TOKEN) {
781 seq_puts(m,
Joe Perchesf657fd22012-12-05 16:48:26 -0500782 "# filename:lineno [module]function flags format\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500783 return 0;
784 }
785
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500786 seq_printf(m, "%s:%u [%s]%s =%s \"",
Joe Perchesf657fd22012-12-05 16:48:26 -0500787 trim_prefix(dp->filename), dp->lineno,
788 iter->table->mod_name, dp->function,
789 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500790 seq_escape(m, dp->format, "\t\r\n\"");
791 seq_puts(m, "\"\n");
792
793 return 0;
794}
795
796/*
797 * Seq_ops stop method. Called at the end of each read()
798 * call from userspace. Drops ddebug_lock.
799 */
800static void ddebug_proc_stop(struct seq_file *m, void *p)
801{
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600802 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500803 mutex_unlock(&ddebug_lock);
804}
805
806static const struct seq_operations ddebug_proc_seqops = {
807 .start = ddebug_proc_start,
808 .next = ddebug_proc_next,
809 .show = ddebug_proc_show,
810 .stop = ddebug_proc_stop
811};
812
813/*
Jim Cromie07100be2011-12-19 17:11:09 -0500814 * File_ops->open method for <debugfs>/dynamic_debug/control. Does
815 * the seq_file setup dance, and also creates an iterator to walk the
816 * _ddebugs. Note that we create a seq_file always, even for O_WRONLY
817 * files where it's not needed, as doing so simplifies the ->release
818 * method.
Jason Barone9d376f2009-02-05 11:51:38 -0500819 */
820static int ddebug_proc_open(struct inode *inode, struct file *file)
821{
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600822 vpr_info("called\n");
Rob Jones4bad78c2014-10-13 15:51:32 -0700823 return seq_open_private(file, &ddebug_proc_seqops,
824 sizeof(struct ddebug_iter));
Jason Barone9d376f2009-02-05 11:51:38 -0500825}
826
827static const struct file_operations ddebug_proc_fops = {
828 .owner = THIS_MODULE,
829 .open = ddebug_proc_open,
830 .read = seq_read,
831 .llseek = seq_lseek,
832 .release = seq_release_private,
833 .write = ddebug_proc_write
834};
835
836/*
837 * Allocate a new ddebug_table for the given module
838 * and add it to the global list.
839 */
840int ddebug_add_module(struct _ddebug *tab, unsigned int n,
841 const char *name)
842{
843 struct ddebug_table *dt;
844 char *new_name;
845
846 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
847 if (dt == NULL)
848 return -ENOMEM;
849 new_name = kstrdup(name, GFP_KERNEL);
850 if (new_name == NULL) {
851 kfree(dt);
852 return -ENOMEM;
853 }
854 dt->mod_name = new_name;
855 dt->num_ddebugs = n;
Jason Barone9d376f2009-02-05 11:51:38 -0500856 dt->ddebugs = tab;
857
858 mutex_lock(&ddebug_lock);
859 list_add_tail(&dt->link, &ddebug_tables);
860 mutex_unlock(&ddebug_lock);
861
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600862 vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500863 return 0;
864}
865EXPORT_SYMBOL_GPL(ddebug_add_module);
866
Jim Cromie6ab676e2012-04-27 14:30:37 -0600867/* helper for ddebug_dyndbg_(boot|module)_param_cb */
868static int ddebug_dyndbg_param_cb(char *param, char *val,
869 const char *modname, int on_err)
Jim Cromieb48420c2012-04-27 14:30:35 -0600870{
Jim Cromieb48420c2012-04-27 14:30:35 -0600871 char *sep;
872
873 sep = strchr(param, '.');
874 if (sep) {
Jim Cromie6ab676e2012-04-27 14:30:37 -0600875 /* needed only for ddebug_dyndbg_boot_param_cb */
Jim Cromieb48420c2012-04-27 14:30:35 -0600876 *sep = '\0';
877 modname = param;
878 param = sep + 1;
879 }
880 if (strcmp(param, "dyndbg"))
Jim Cromie6ab676e2012-04-27 14:30:37 -0600881 return on_err; /* determined by caller */
Jim Cromieb48420c2012-04-27 14:30:35 -0600882
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600883 ddebug_exec_queries((val ? val : "+p"), modname);
884
Jim Cromieb48420c2012-04-27 14:30:35 -0600885 return 0; /* query failure shouldnt stop module load */
886}
887
Jim Cromie6ab676e2012-04-27 14:30:37 -0600888/* handle both dyndbg and $module.dyndbg params at boot */
889static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
890 const char *unused)
Jim Cromieb48420c2012-04-27 14:30:35 -0600891{
Jim Cromie6ab676e2012-04-27 14:30:37 -0600892 vpr_info("%s=\"%s\"\n", param, val);
893 return ddebug_dyndbg_param_cb(param, val, NULL, 0);
894}
Jim Cromieb48420c2012-04-27 14:30:35 -0600895
Jim Cromie6ab676e2012-04-27 14:30:37 -0600896/*
897 * modprobe foo finds foo.params in boot-args, strips "foo.", and
898 * passes them to load_module(). This callback gets unknown params,
899 * processes dyndbg params, rejects others.
900 */
901int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
902{
903 vpr_info("module: %s %s=\"%s\"\n", module, param, val);
904 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
Jim Cromieb48420c2012-04-27 14:30:35 -0600905}
906
Jason Barone9d376f2009-02-05 11:51:38 -0500907static void ddebug_table_free(struct ddebug_table *dt)
908{
909 list_del_init(&dt->link);
910 kfree(dt->mod_name);
911 kfree(dt);
912}
913
914/*
915 * Called in response to a module being unloaded. Removes
916 * any ddebug_table's which point at the module.
917 */
Yehuda Sadehff49d742010-07-03 13:07:35 +1000918int ddebug_remove_module(const char *mod_name)
Jason Barone9d376f2009-02-05 11:51:38 -0500919{
920 struct ddebug_table *dt, *nextdt;
921 int ret = -ENOENT;
922
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600923 vpr_info("removing module \"%s\"\n", mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500924
925 mutex_lock(&ddebug_lock);
926 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
927 if (!strcmp(dt->mod_name, mod_name)) {
928 ddebug_table_free(dt);
929 ret = 0;
930 }
931 }
932 mutex_unlock(&ddebug_lock);
933 return ret;
934}
935EXPORT_SYMBOL_GPL(ddebug_remove_module);
936
937static void ddebug_remove_all_tables(void)
938{
939 mutex_lock(&ddebug_lock);
940 while (!list_empty(&ddebug_tables)) {
941 struct ddebug_table *dt = list_entry(ddebug_tables.next,
942 struct ddebug_table,
943 link);
944 ddebug_table_free(dt);
945 }
946 mutex_unlock(&ddebug_lock);
947}
948
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200949static __initdata int ddebug_init_success;
950
951static int __init dynamic_debug_init_debugfs(void)
Jason Barone9d376f2009-02-05 11:51:38 -0500952{
953 struct dentry *dir, *file;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200954
955 if (!ddebug_init_success)
956 return -ENODEV;
Jason Barone9d376f2009-02-05 11:51:38 -0500957
958 dir = debugfs_create_dir("dynamic_debug", NULL);
959 if (!dir)
960 return -ENOMEM;
961 file = debugfs_create_file("control", 0644, dir, NULL,
962 &ddebug_proc_fops);
963 if (!file) {
964 debugfs_remove(dir);
965 return -ENOMEM;
966 }
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200967 return 0;
968}
969
970static int __init dynamic_debug_init(void)
971{
972 struct _ddebug *iter, *iter_start;
973 const char *modname = NULL;
Jim Cromieb48420c2012-04-27 14:30:35 -0600974 char *cmdline;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200975 int ret = 0;
Jim Cromie41076922012-04-27 14:30:39 -0600976 int n = 0, entries = 0, modct = 0;
977 int verbose_bytes = 0;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200978
Jim Cromieb5b78f82011-12-19 17:12:54 -0500979 if (__start___verbose == __stop___verbose) {
Joe Perchesf657fd22012-12-05 16:48:26 -0500980 pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
Jim Cromieb5b78f82011-12-19 17:12:54 -0500981 return 1;
Jason Barone9d376f2009-02-05 11:51:38 -0500982 }
Jim Cromieb5b78f82011-12-19 17:12:54 -0500983 iter = __start___verbose;
984 modname = iter->modname;
985 iter_start = iter;
986 for (; iter < __stop___verbose; iter++) {
Jim Cromie41076922012-04-27 14:30:39 -0600987 entries++;
988 verbose_bytes += strlen(iter->modname) + strlen(iter->function)
989 + strlen(iter->filename) + strlen(iter->format);
990
Jim Cromieb5b78f82011-12-19 17:12:54 -0500991 if (strcmp(modname, iter->modname)) {
Jim Cromie41076922012-04-27 14:30:39 -0600992 modct++;
Jim Cromieb5b78f82011-12-19 17:12:54 -0500993 ret = ddebug_add_module(iter_start, n, modname);
994 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -0600995 goto out_err;
Jim Cromieb5b78f82011-12-19 17:12:54 -0500996 n = 0;
997 modname = iter->modname;
998 iter_start = iter;
999 }
1000 n++;
1001 }
1002 ret = ddebug_add_module(iter_start, n, modname);
1003 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -06001004 goto out_err;
Thomas Renningera648ec02010-08-06 16:11:02 +02001005
Jim Cromieaf442392012-04-27 14:30:38 -06001006 ddebug_init_success = 1;
Joe Perchesf657fd22012-12-05 16:48:26 -05001007 vpr_info("%d modules, %d entries and %d bytes in ddebug tables, %d bytes in (readonly) verbose section\n",
1008 modct, entries, (int)(modct * sizeof(struct ddebug_table)),
1009 verbose_bytes + (int)(__stop___verbose - __start___verbose));
Jim Cromieaf442392012-04-27 14:30:38 -06001010
1011 /* apply ddebug_query boot param, dont unload tables on err */
Thomas Renningera648ec02010-08-06 16:11:02 +02001012 if (ddebug_setup_string[0] != '\0') {
Joe Perchesf657fd22012-12-05 16:48:26 -05001013 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
Jim Cromie8e59b5cf2012-04-27 14:30:40 -06001014 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001015 if (ret < 0)
Joe Perchesf657fd22012-12-05 16:48:26 -05001016 pr_warn("Invalid ddebug boot param %s\n",
Joe Perches4ad275e2011-08-11 14:36:33 -04001017 ddebug_setup_string);
Thomas Renningera648ec02010-08-06 16:11:02 +02001018 else
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001019 pr_info("%d changes by ddebug_query\n", ret);
Jason Barone9d376f2009-02-05 11:51:38 -05001020 }
Jim Cromieb48420c2012-04-27 14:30:35 -06001021 /* now that ddebug tables are loaded, process all boot args
1022 * again to find and activate queries given in dyndbg params.
1023 * While this has already been done for known boot params, it
1024 * ignored the unknown ones (dyndbg in particular). Reusing
1025 * parse_args avoids ad-hoc parsing. This will also attempt
1026 * to activate queries for not-yet-loaded modules, which is
1027 * slightly noisy if verbose, but harmless.
1028 */
1029 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1030 parse_args("dyndbg params", cmdline, NULL,
1031 0, 0, 0, &ddebug_dyndbg_boot_param_cb);
1032 kfree(cmdline);
Jim Cromieaf442392012-04-27 14:30:38 -06001033 return 0;
Thomas Renningera648ec02010-08-06 16:11:02 +02001034
Jim Cromieaf442392012-04-27 14:30:38 -06001035out_err:
1036 ddebug_remove_all_tables();
Jason Barone9d376f2009-02-05 11:51:38 -05001037 return 0;
1038}
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001039/* Allow early initialization for boot messages via boot param */
Jim Cromie3ec56522012-04-27 14:30:42 -06001040early_initcall(dynamic_debug_init);
Jim Cromieb48420c2012-04-27 14:30:35 -06001041
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001042/* Debugfs setup must be done later */
Jim Cromie3ec56522012-04-27 14:30:42 -06001043fs_initcall(dynamic_debug_init_debugfs);