blob: da796e2dc4f506dc63db68b132180acff00c291f [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;
Rasmus Villemoes3e406b12015-11-06 16:30:15 -080045 const char *mod_name;
Jason Barone9d376f2009-02-05 11:51:38 -050046 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 Baron9049fc72016-08-03 13:46:39 -0700191#ifdef HAVE_JUMP_LABEL
192 if (dp->flags & _DPRINTK_FLAGS_PRINT) {
193 if (!(flags & _DPRINTK_FLAGS_PRINT))
194 static_branch_disable(&dp->key.dd_key_true);
195 } else if (flags & _DPRINTK_FLAGS_PRINT)
196 static_branch_enable(&dp->key.dd_key_true);
197#endif
Jason Barone9d376f2009-02-05 11:51:38 -0500198 dp->flags = newflags;
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600199 vpr_info("changed %s:%d [%s]%s =%s\n",
Joe Perchesf657fd22012-12-05 16:48:26 -0500200 trim_prefix(dp->filename), dp->lineno,
201 dt->mod_name, dp->function,
202 ddebug_describe_flags(dp, flagbuf,
203 sizeof(flagbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500204 }
205 }
206 mutex_unlock(&ddebug_lock);
207
208 if (!nfound && verbose)
Joe Perches4ad275e2011-08-11 14:36:33 -0400209 pr_info("no matches for query\n");
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500210
211 return nfound;
Jason Barone9d376f2009-02-05 11:51:38 -0500212}
213
214/*
Jason Barone9d376f2009-02-05 11:51:38 -0500215 * Split the buffer `buf' into space-separated words.
Greg Banks9898abb2009-02-06 12:54:26 +1100216 * Handles simple " and ' quoting, i.e. without nested,
217 * embedded or escaped \". Return the number of words
218 * or <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500219 */
220static int ddebug_tokenize(char *buf, char *words[], int maxwords)
221{
222 int nwords = 0;
223
Greg Banks9898abb2009-02-06 12:54:26 +1100224 while (*buf) {
225 char *end;
226
227 /* Skip leading whitespace */
André Goddard Rosae7d28602009-12-14 18:01:06 -0800228 buf = skip_spaces(buf);
Greg Banks9898abb2009-02-06 12:54:26 +1100229 if (!*buf)
230 break; /* oh, it was trailing whitespace */
Jim Cromie8bd60262011-12-19 17:13:03 -0500231 if (*buf == '#')
232 break; /* token starts comment, skip rest of line */
Greg Banks9898abb2009-02-06 12:54:26 +1100233
Jim Cromie07100be2011-12-19 17:11:09 -0500234 /* find `end' of word, whitespace separated or quoted */
Greg Banks9898abb2009-02-06 12:54:26 +1100235 if (*buf == '"' || *buf == '\'') {
236 int quote = *buf++;
Joe Perchesf657fd22012-12-05 16:48:26 -0500237 for (end = buf; *end && *end != quote; end++)
Greg Banks9898abb2009-02-06 12:54:26 +1100238 ;
Jim Cromie18c216c2012-12-05 16:48:27 -0500239 if (!*end) {
240 pr_err("unclosed quote: %s\n", buf);
Greg Banks9898abb2009-02-06 12:54:26 +1100241 return -EINVAL; /* unclosed quote */
Jim Cromie18c216c2012-12-05 16:48:27 -0500242 }
Greg Banks9898abb2009-02-06 12:54:26 +1100243 } else {
Joe Perchesf657fd22012-12-05 16:48:26 -0500244 for (end = buf; *end && !isspace(*end); end++)
Greg Banks9898abb2009-02-06 12:54:26 +1100245 ;
246 BUG_ON(end == buf);
247 }
Greg Banks9898abb2009-02-06 12:54:26 +1100248
Jim Cromie07100be2011-12-19 17:11:09 -0500249 /* `buf' is start of word, `end' is one past its end */
Jim Cromie18c216c2012-12-05 16:48:27 -0500250 if (nwords == maxwords) {
251 pr_err("too many words, legal max <=%d\n", maxwords);
Greg Banks9898abb2009-02-06 12:54:26 +1100252 return -EINVAL; /* ran out of words[] before bytes */
Jim Cromie18c216c2012-12-05 16:48:27 -0500253 }
Greg Banks9898abb2009-02-06 12:54:26 +1100254 if (*end)
255 *end++ = '\0'; /* terminate the word */
256 words[nwords++] = buf;
257 buf = end;
258 }
Jason Barone9d376f2009-02-05 11:51:38 -0500259
260 if (verbose) {
261 int i;
Joe Perches4ad275e2011-08-11 14:36:33 -0400262 pr_info("split into words:");
Joe Perchesf657fd22012-12-05 16:48:26 -0500263 for (i = 0; i < nwords; i++)
Joe Perches4ad275e2011-08-11 14:36:33 -0400264 pr_cont(" \"%s\"", words[i]);
265 pr_cont("\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500266 }
267
268 return nwords;
269}
270
271/*
272 * Parse a single line number. Note that the empty string ""
273 * is treated as a special case and converted to zero, which
274 * is later treated as a "don't care" value.
275 */
276static inline int parse_lineno(const char *str, unsigned int *val)
277{
Jason Barone9d376f2009-02-05 11:51:38 -0500278 BUG_ON(str == NULL);
279 if (*str == '\0') {
280 *val = 0;
281 return 0;
282 }
Andrey Ryabinin45925992014-01-27 17:06:59 -0800283 if (kstrtouint(str, 10, val) < 0) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500284 pr_err("bad line-number: %s\n", str);
285 return -EINVAL;
286 }
287 return 0;
Jason Barone9d376f2009-02-05 11:51:38 -0500288}
289
Jim Cromie820874c2011-12-19 17:12:49 -0500290static int check_set(const char **dest, char *src, char *name)
291{
292 int rc = 0;
293
294 if (*dest) {
295 rc = -EINVAL;
Joe Perchesf657fd22012-12-05 16:48:26 -0500296 pr_err("match-spec:%s val:%s overridden by %s\n",
297 name, *dest, src);
Jim Cromie820874c2011-12-19 17:12:49 -0500298 }
299 *dest = src;
300 return rc;
301}
302
Jason Barone9d376f2009-02-05 11:51:38 -0500303/*
304 * Parse words[] as a ddebug query specification, which is a series
305 * of (keyword, value) pairs chosen from these possibilities:
306 *
307 * func <function-name>
308 * file <full-pathname>
309 * file <base-filename>
310 * module <module-name>
311 * format <escaped-string-to-find-in-format>
312 * line <lineno>
313 * line <first-lineno>-<last-lineno> // where either may be empty
Jim Cromie820874c2011-12-19 17:12:49 -0500314 *
315 * Only 1 of each type is allowed.
316 * Returns 0 on success, <0 on error.
Jason Barone9d376f2009-02-05 11:51:38 -0500317 */
318static int ddebug_parse_query(char *words[], int nwords,
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600319 struct ddebug_query *query, const char *modname)
Jason Barone9d376f2009-02-05 11:51:38 -0500320{
321 unsigned int i;
jbaron@akamai.combd8c154a2013-08-27 16:50:03 +0000322 int rc = 0;
Jason Barone9d376f2009-02-05 11:51:38 -0500323
324 /* check we have an even number of words */
Jim Cromie18c216c2012-12-05 16:48:27 -0500325 if (nwords % 2 != 0) {
326 pr_err("expecting pairs of match-spec <value>\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500327 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500328 }
Jason Barone9d376f2009-02-05 11:51:38 -0500329 memset(query, 0, sizeof(*query));
330
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600331 if (modname)
332 /* support $modname.dyndbg=<multiple queries> */
333 query->module = modname;
334
Joe Perchesf657fd22012-12-05 16:48:26 -0500335 for (i = 0; i < nwords; i += 2) {
336 if (!strcmp(words[i], "func")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500337 rc = check_set(&query->function, words[i+1], "func");
Joe Perchesf657fd22012-12-05 16:48:26 -0500338 } else if (!strcmp(words[i], "file")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500339 rc = check_set(&query->filename, words[i+1], "file");
Joe Perchesf657fd22012-12-05 16:48:26 -0500340 } else if (!strcmp(words[i], "module")) {
Jim Cromie820874c2011-12-19 17:12:49 -0500341 rc = check_set(&query->module, words[i+1], "module");
Joe Perchesf657fd22012-12-05 16:48:26 -0500342 } else if (!strcmp(words[i], "format")) {
Andy Shevchenkod338b132013-04-30 15:27:32 -0700343 string_unescape_inplace(words[i+1], UNESCAPE_SPACE |
344 UNESCAPE_OCTAL |
345 UNESCAPE_SPECIAL);
346 rc = check_set(&query->format, words[i+1], "format");
Joe Perchesf657fd22012-12-05 16:48:26 -0500347 } else if (!strcmp(words[i], "line")) {
Jason Barone9d376f2009-02-05 11:51:38 -0500348 char *first = words[i+1];
349 char *last = strchr(first, '-');
Jim Cromie820874c2011-12-19 17:12:49 -0500350 if (query->first_lineno || query->last_lineno) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500351 pr_err("match-spec: line used 2x\n");
Jim Cromie820874c2011-12-19 17:12:49 -0500352 return -EINVAL;
353 }
Jason Barone9d376f2009-02-05 11:51:38 -0500354 if (last)
355 *last++ = '\0';
Andrey Ryabinind9e133e2014-01-27 17:06:57 -0800356 if (parse_lineno(first, &query->first_lineno) < 0)
Jason Barone9d376f2009-02-05 11:51:38 -0500357 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500358 if (last) {
Jason Barone9d376f2009-02-05 11:51:38 -0500359 /* range <first>-<last> */
Andrey Ryabinin3ace6782014-01-27 17:06:58 -0800360 if (parse_lineno(last, &query->last_lineno) < 0)
361 return -EINVAL;
362
363 if (query->last_lineno < query->first_lineno) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500364 pr_err("last-line:%d < 1st-line:%d\n",
365 query->last_lineno,
366 query->first_lineno);
Jason Barone9d376f2009-02-05 11:51:38 -0500367 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500368 }
Jason Barone9d376f2009-02-05 11:51:38 -0500369 } else {
370 query->last_lineno = query->first_lineno;
371 }
372 } else {
Jim Cromieae27f862011-12-19 17:12:34 -0500373 pr_err("unknown keyword \"%s\"\n", words[i]);
Jason Barone9d376f2009-02-05 11:51:38 -0500374 return -EINVAL;
375 }
Jim Cromie820874c2011-12-19 17:12:49 -0500376 if (rc)
377 return rc;
Jason Barone9d376f2009-02-05 11:51:38 -0500378 }
Jim Cromie574b3722011-12-19 17:13:16 -0500379 vpr_info_dq(query, "parsed");
Jason Barone9d376f2009-02-05 11:51:38 -0500380 return 0;
381}
382
383/*
384 * Parse `str' as a flags specification, format [-+=][p]+.
385 * Sets up *maskp and *flagsp to be used when changing the
386 * flags fields of matched _ddebug's. Returns 0 on success
387 * or <0 on error.
388 */
389static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
390 unsigned int *maskp)
391{
392 unsigned flags = 0;
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100393 int op = '=', i;
Jason Barone9d376f2009-02-05 11:51:38 -0500394
395 switch (*str) {
396 case '+':
397 case '-':
398 case '=':
399 op = *str++;
400 break;
401 default:
Jim Cromie18c216c2012-12-05 16:48:27 -0500402 pr_err("bad flag-op %c, at start of %s\n", *str, str);
Jason Barone9d376f2009-02-05 11:51:38 -0500403 return -EINVAL;
404 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600405 vpr_info("op='%c'\n", op);
Jason Barone9d376f2009-02-05 11:51:38 -0500406
Joe Perchesf657fd22012-12-05 16:48:26 -0500407 for (; *str ; ++str) {
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100408 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
409 if (*str == opt_array[i].opt_char) {
410 flags |= opt_array[i].flag;
411 break;
412 }
Jason Barone9d376f2009-02-05 11:51:38 -0500413 }
Jim Cromie18c216c2012-12-05 16:48:27 -0500414 if (i < 0) {
415 pr_err("unknown flag '%c' in \"%s\"\n", *str, str);
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100416 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500417 }
Jason Barone9d376f2009-02-05 11:51:38 -0500418 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600419 vpr_info("flags=0x%x\n", flags);
Jason Barone9d376f2009-02-05 11:51:38 -0500420
421 /* calculate final *flagsp, *maskp according to mask and op */
422 switch (op) {
423 case '=':
424 *maskp = 0;
425 *flagsp = flags;
426 break;
427 case '+':
428 *maskp = ~0U;
429 *flagsp = flags;
430 break;
431 case '-':
432 *maskp = ~flags;
433 *flagsp = 0;
434 break;
435 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600436 vpr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
Jason Barone9d376f2009-02-05 11:51:38 -0500437 return 0;
438}
439
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600440static int ddebug_exec_query(char *query_string, const char *modname)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200441{
442 unsigned int flags = 0, mask = 0;
443 struct ddebug_query query;
444#define MAXWORDS 9
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500445 int nwords, nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200446 char *words[MAXWORDS];
447
448 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
Jim Cromie18c216c2012-12-05 16:48:27 -0500449 if (nwords <= 0) {
450 pr_err("tokenize failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200451 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500452 }
453 /* check flags 1st (last arg) so query is pairs of spec,val */
454 if (ddebug_parse_flags(words[nwords-1], &flags, &mask)) {
455 pr_err("flags parse failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200456 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500457 }
458 if (ddebug_parse_query(words, nwords-1, &query, modname)) {
459 pr_err("query parse failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200460 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500461 }
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200462 /* actually go and implement the change */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500463 nfound = ddebug_change(&query, flags, mask);
Joe Perchesf657fd22012-12-05 16:48:26 -0500464 vpr_info_dq(&query, nfound ? "applied" : "no-match");
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500465
466 return nfound;
467}
468
469/* handle multiple queries in query string, continue on error, return
470 last error or number of matching callsites. Module name is either
471 in param (for boot arg) or perhaps in query string.
472*/
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600473static int ddebug_exec_queries(char *query, const char *modname)
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500474{
475 char *split;
476 int i, errs = 0, exitcode = 0, rc, nfound = 0;
477
478 for (i = 0; query; query = split) {
479 split = strpbrk(query, ";\n");
480 if (split)
481 *split++ = '\0';
482
483 query = skip_spaces(query);
484 if (!query || !*query || *query == '#')
485 continue;
486
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600487 vpr_info("query %d: \"%s\"\n", i, query);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500488
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600489 rc = ddebug_exec_query(query, modname);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500490 if (rc < 0) {
491 errs++;
492 exitcode = rc;
Joe Perchesf657fd22012-12-05 16:48:26 -0500493 } else {
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500494 nfound += rc;
Joe Perchesf657fd22012-12-05 16:48:26 -0500495 }
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500496 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 Assche8ba6ebf2011-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 Assche8ba6ebf2011-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
Joe Perches798efc62012-09-12 20:11:29 -0700520 *buf = '\0';
521
Jason Baron431625d2011-10-04 14:13:19 -0700522 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100523 if (in_interrupt())
Joe Perches798efc62012-09-12 20:11:29 -0700524 pos += snprintf(buf + pos, remaining(pos), "<intr> ");
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100525 else
Jason Baron431625d2011-10-04 14:13:19 -0700526 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
Joe Perches798efc62012-09-12 20:11:29 -0700527 task_pid_vnr(current));
Bart Van Assche8ba6ebf2011-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:",
Joe Perches798efc62012-09-12 20:11:29 -0700532 desc->modname);
Jason Baron431625d2011-10-04 14:13:19 -0700533 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
534 pos += snprintf(buf + pos, remaining(pos), "%s:",
Joe Perches798efc62012-09-12 20:11:29 -0700535 desc->function);
Jason Baron431625d2011-10-04 14:13:19 -0700536 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
Jim Cromie07100be2011-12-19 17:11:09 -0500537 pos += snprintf(buf + pos, remaining(pos), "%d:",
Joe Perches798efc62012-09-12 20:11:29 -0700538 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
Joe Perches906d2012014-09-24 11:17:56 -0700547void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100548{
549 va_list args;
Jason Baron431625d2011-10-04 14:13:19 -0700550 struct va_format vaf;
551 char buf[PREFIX_SIZE];
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100552
553 BUG_ON(!descriptor);
554 BUG_ON(!fmt);
555
556 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700557
Jason Baron431625d2011-10-04 14:13:19 -0700558 vaf.fmt = fmt;
559 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700560
Joe Perches906d2012014-09-24 11:17:56 -0700561 printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700562
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100563 va_end(args);
Bart Van Assche8ba6ebf2011-01-23 17:17:24 +0100564}
565EXPORT_SYMBOL(__dynamic_pr_debug);
566
Joe Perches906d2012014-09-24 11:17:56 -0700567void __dynamic_dev_dbg(struct _ddebug *descriptor,
Joe Perchescbc46632011-08-11 14:36:21 -0400568 const struct device *dev, const char *fmt, ...)
569{
570 struct va_format vaf;
571 va_list args;
Joe Perchescbc46632011-08-11 14:36:21 -0400572
573 BUG_ON(!descriptor);
574 BUG_ON(!fmt);
575
576 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700577
Joe Perchescbc46632011-08-11 14:36:21 -0400578 vaf.fmt = fmt;
579 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700580
581 if (!dev) {
Joe Perches906d2012014-09-24 11:17:56 -0700582 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700583 } else {
584 char buf[PREFIX_SIZE];
Joe Perches798efc62012-09-12 20:11:29 -0700585
Joe Perchesa39d4a82014-12-10 15:50:15 -0800586 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
Joe Perches906d2012014-09-24 11:17:56 -0700587 dynamic_emit_prefix(descriptor, buf),
588 dev_driver_string(dev), dev_name(dev),
589 &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700590 }
591
Joe Perchescbc46632011-08-11 14:36:21 -0400592 va_end(args);
Joe Perchescbc46632011-08-11 14:36:21 -0400593}
594EXPORT_SYMBOL(__dynamic_dev_dbg);
595
Jason Baron0feefd92011-10-04 14:13:22 -0700596#ifdef CONFIG_NET
597
Joe Perches906d2012014-09-24 11:17:56 -0700598void __dynamic_netdev_dbg(struct _ddebug *descriptor,
599 const struct net_device *dev, const char *fmt, ...)
Jason Baronffa10cb2011-08-11 14:36:48 -0400600{
601 struct va_format vaf;
602 va_list args;
Jason Baronffa10cb2011-08-11 14:36:48 -0400603
604 BUG_ON(!descriptor);
605 BUG_ON(!fmt);
606
607 va_start(args, fmt);
Joe Perchesb004ff42012-09-12 20:12:19 -0700608
Jason Baronffa10cb2011-08-11 14:36:48 -0400609 vaf.fmt = fmt;
610 vaf.va = &args;
Joe Perchesb004ff42012-09-12 20:12:19 -0700611
612 if (dev && dev->dev.parent) {
613 char buf[PREFIX_SIZE];
Joe Perchesb004ff42012-09-12 20:12:19 -0700614
Joe Perchesa39d4a82014-12-10 15:50:15 -0800615 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
Joe Perches906d2012014-09-24 11:17:56 -0700616 "%s%s %s %s%s: %pV",
617 dynamic_emit_prefix(descriptor, buf),
618 dev_driver_string(dev->dev.parent),
619 dev_name(dev->dev.parent),
620 netdev_name(dev), netdev_reg_state(dev),
621 &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700622 } else if (dev) {
Joe Perches906d2012014-09-24 11:17:56 -0700623 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
624 netdev_reg_state(dev), &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700625 } else {
Joe Perches906d2012014-09-24 11:17:56 -0700626 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700627 }
628
Jason Baronffa10cb2011-08-11 14:36:48 -0400629 va_end(args);
Jason Baronffa10cb2011-08-11 14:36:48 -0400630}
631EXPORT_SYMBOL(__dynamic_netdev_dbg);
632
Jason Baron0feefd92011-10-04 14:13:22 -0700633#endif
634
Jim Cromiebc757f62011-12-19 17:12:29 -0500635#define DDEBUG_STRING_SIZE 1024
636static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
637
Thomas Renningera648ec02010-08-06 16:11:02 +0200638static __init int ddebug_setup_query(char *str)
639{
Jim Cromiebc757f62011-12-19 17:12:29 -0500640 if (strlen(str) >= DDEBUG_STRING_SIZE) {
Joe Perches4ad275e2011-08-11 14:36:33 -0400641 pr_warn("ddebug boot param string too large\n");
Thomas Renningera648ec02010-08-06 16:11:02 +0200642 return 0;
643 }
Jim Cromiebc757f62011-12-19 17:12:29 -0500644 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
Thomas Renningera648ec02010-08-06 16:11:02 +0200645 return 1;
646}
647
648__setup("ddebug_query=", ddebug_setup_query);
649
Jason Barone9d376f2009-02-05 11:51:38 -0500650/*
Masatake YAMATO231821d2014-12-15 12:04:16 +0900651 * File_ops->write method for <debugfs>/dynamic_debug/control. Gathers the
Jason Barone9d376f2009-02-05 11:51:38 -0500652 * command text from userspace, parses and executes it.
653 */
Jim Cromie72814912011-12-19 17:13:07 -0500654#define USER_BUF_PAGE 4096
Jason Barone9d376f2009-02-05 11:51:38 -0500655static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
656 size_t len, loff_t *offp)
657{
Jim Cromie72814912011-12-19 17:13:07 -0500658 char *tmpbuf;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200659 int ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500660
661 if (len == 0)
662 return 0;
Jim Cromie72814912011-12-19 17:13:07 -0500663 if (len > USER_BUF_PAGE - 1) {
664 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
Jason Barone9d376f2009-02-05 11:51:38 -0500665 return -E2BIG;
Jim Cromie72814912011-12-19 17:13:07 -0500666 }
Al Viro16e5c1f2015-12-24 00:06:05 -0500667 tmpbuf = memdup_user_nul(ubuf, len);
668 if (IS_ERR(tmpbuf))
669 return PTR_ERR(tmpbuf);
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600670 vpr_info("read %d bytes from userspace\n", (int)len);
Jason Barone9d376f2009-02-05 11:51:38 -0500671
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600672 ret = ddebug_exec_queries(tmpbuf, NULL);
Jim Cromie72814912011-12-19 17:13:07 -0500673 kfree(tmpbuf);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500674 if (ret < 0)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200675 return ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500676
677 *offp += len;
678 return len;
679}
680
681/*
682 * Set the iterator to point to the first _ddebug object
683 * and return a pointer to that first object. Returns
684 * NULL if there are no _ddebugs at all.
685 */
686static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
687{
688 if (list_empty(&ddebug_tables)) {
689 iter->table = NULL;
690 iter->idx = 0;
691 return NULL;
692 }
693 iter->table = list_entry(ddebug_tables.next,
694 struct ddebug_table, link);
695 iter->idx = 0;
696 return &iter->table->ddebugs[iter->idx];
697}
698
699/*
700 * Advance the iterator to point to the next _ddebug
701 * object from the one the iterator currently points at,
702 * and returns a pointer to the new _ddebug. Returns
703 * NULL if the iterator has seen all the _ddebugs.
704 */
705static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
706{
707 if (iter->table == NULL)
708 return NULL;
709 if (++iter->idx == iter->table->num_ddebugs) {
710 /* iterate to next table */
711 iter->idx = 0;
712 if (list_is_last(&iter->table->link, &ddebug_tables)) {
713 iter->table = NULL;
714 return NULL;
715 }
716 iter->table = list_entry(iter->table->link.next,
717 struct ddebug_table, link);
718 }
719 return &iter->table->ddebugs[iter->idx];
720}
721
722/*
723 * Seq_ops start method. Called at the start of every
724 * read() call from userspace. Takes the ddebug_lock and
725 * seeks the seq_file's iterator to the given position.
726 */
727static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
728{
729 struct ddebug_iter *iter = m->private;
730 struct _ddebug *dp;
731 int n = *pos;
732
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600733 vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500734
735 mutex_lock(&ddebug_lock);
736
737 if (!n)
738 return SEQ_START_TOKEN;
739 if (n < 0)
740 return NULL;
741 dp = ddebug_iter_first(iter);
742 while (dp != NULL && --n > 0)
743 dp = ddebug_iter_next(iter);
744 return dp;
745}
746
747/*
748 * Seq_ops next method. Called several times within a read()
749 * call from userspace, with ddebug_lock held. Walks to the
750 * next _ddebug object with a special case for the header line.
751 */
752static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
753{
754 struct ddebug_iter *iter = m->private;
755 struct _ddebug *dp;
756
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600757 vpr_info("called m=%p p=%p *pos=%lld\n",
Joe Perchesf657fd22012-12-05 16:48:26 -0500758 m, p, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500759
760 if (p == SEQ_START_TOKEN)
761 dp = ddebug_iter_first(iter);
762 else
763 dp = ddebug_iter_next(iter);
764 ++*pos;
765 return dp;
766}
767
768/*
769 * Seq_ops show method. Called several times within a read()
770 * call from userspace, with ddebug_lock held. Formats the
771 * current _ddebug as a single human-readable line, with a
772 * special case for the header line.
773 */
774static int ddebug_proc_show(struct seq_file *m, void *p)
775{
776 struct ddebug_iter *iter = m->private;
777 struct _ddebug *dp = p;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500778 char flagsbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500779
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600780 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500781
782 if (p == SEQ_START_TOKEN) {
783 seq_puts(m,
Joe Perchesf657fd22012-12-05 16:48:26 -0500784 "# filename:lineno [module]function flags format\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500785 return 0;
786 }
787
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500788 seq_printf(m, "%s:%u [%s]%s =%s \"",
Joe Perchesf657fd22012-12-05 16:48:26 -0500789 trim_prefix(dp->filename), dp->lineno,
790 iter->table->mod_name, dp->function,
791 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500792 seq_escape(m, dp->format, "\t\r\n\"");
793 seq_puts(m, "\"\n");
794
795 return 0;
796}
797
798/*
799 * Seq_ops stop method. Called at the end of each read()
800 * call from userspace. Drops ddebug_lock.
801 */
802static void ddebug_proc_stop(struct seq_file *m, void *p)
803{
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600804 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500805 mutex_unlock(&ddebug_lock);
806}
807
808static const struct seq_operations ddebug_proc_seqops = {
809 .start = ddebug_proc_start,
810 .next = ddebug_proc_next,
811 .show = ddebug_proc_show,
812 .stop = ddebug_proc_stop
813};
814
815/*
Jim Cromie07100be2011-12-19 17:11:09 -0500816 * File_ops->open method for <debugfs>/dynamic_debug/control. Does
817 * the seq_file setup dance, and also creates an iterator to walk the
818 * _ddebugs. Note that we create a seq_file always, even for O_WRONLY
819 * files where it's not needed, as doing so simplifies the ->release
820 * method.
Jason Barone9d376f2009-02-05 11:51:38 -0500821 */
822static int ddebug_proc_open(struct inode *inode, struct file *file)
823{
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600824 vpr_info("called\n");
Rob Jones4bad78c2014-10-13 15:51:32 -0700825 return seq_open_private(file, &ddebug_proc_seqops,
826 sizeof(struct ddebug_iter));
Jason Barone9d376f2009-02-05 11:51:38 -0500827}
828
829static const struct file_operations ddebug_proc_fops = {
830 .owner = THIS_MODULE,
831 .open = ddebug_proc_open,
832 .read = seq_read,
833 .llseek = seq_lseek,
834 .release = seq_release_private,
835 .write = ddebug_proc_write
836};
837
838/*
839 * Allocate a new ddebug_table for the given module
840 * and add it to the global list.
841 */
842int ddebug_add_module(struct _ddebug *tab, unsigned int n,
843 const char *name)
844{
845 struct ddebug_table *dt;
Rasmus Villemoes3e406b12015-11-06 16:30:15 -0800846 const char *new_name;
Jason Barone9d376f2009-02-05 11:51:38 -0500847
848 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
849 if (dt == NULL)
850 return -ENOMEM;
Rasmus Villemoes3e406b12015-11-06 16:30:15 -0800851 new_name = kstrdup_const(name, GFP_KERNEL);
Jason Barone9d376f2009-02-05 11:51:38 -0500852 if (new_name == NULL) {
853 kfree(dt);
854 return -ENOMEM;
855 }
856 dt->mod_name = new_name;
857 dt->num_ddebugs = n;
Jason Barone9d376f2009-02-05 11:51:38 -0500858 dt->ddebugs = tab;
859
860 mutex_lock(&ddebug_lock);
861 list_add_tail(&dt->link, &ddebug_tables);
862 mutex_unlock(&ddebug_lock);
863
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600864 vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500865 return 0;
866}
867EXPORT_SYMBOL_GPL(ddebug_add_module);
868
Jim Cromie6ab676e2012-04-27 14:30:37 -0600869/* helper for ddebug_dyndbg_(boot|module)_param_cb */
870static int ddebug_dyndbg_param_cb(char *param, char *val,
871 const char *modname, int on_err)
Jim Cromieb48420c2012-04-27 14:30:35 -0600872{
Jim Cromieb48420c2012-04-27 14:30:35 -0600873 char *sep;
874
875 sep = strchr(param, '.');
876 if (sep) {
Jim Cromie6ab676e2012-04-27 14:30:37 -0600877 /* needed only for ddebug_dyndbg_boot_param_cb */
Jim Cromieb48420c2012-04-27 14:30:35 -0600878 *sep = '\0';
879 modname = param;
880 param = sep + 1;
881 }
882 if (strcmp(param, "dyndbg"))
Jim Cromie6ab676e2012-04-27 14:30:37 -0600883 return on_err; /* determined by caller */
Jim Cromieb48420c2012-04-27 14:30:35 -0600884
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600885 ddebug_exec_queries((val ? val : "+p"), modname);
886
Jim Cromieb48420c2012-04-27 14:30:35 -0600887 return 0; /* query failure shouldnt stop module load */
888}
889
Jim Cromie6ab676e2012-04-27 14:30:37 -0600890/* handle both dyndbg and $module.dyndbg params at boot */
891static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
Luis R. Rodriguezecc86172015-03-30 16:20:03 -0700892 const char *unused, void *arg)
Jim Cromieb48420c2012-04-27 14:30:35 -0600893{
Jim Cromie6ab676e2012-04-27 14:30:37 -0600894 vpr_info("%s=\"%s\"\n", param, val);
895 return ddebug_dyndbg_param_cb(param, val, NULL, 0);
896}
Jim Cromieb48420c2012-04-27 14:30:35 -0600897
Jim Cromie6ab676e2012-04-27 14:30:37 -0600898/*
899 * modprobe foo finds foo.params in boot-args, strips "foo.", and
900 * passes them to load_module(). This callback gets unknown params,
901 * processes dyndbg params, rejects others.
902 */
903int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
904{
905 vpr_info("module: %s %s=\"%s\"\n", module, param, val);
906 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
Jim Cromieb48420c2012-04-27 14:30:35 -0600907}
908
Jason Barone9d376f2009-02-05 11:51:38 -0500909static void ddebug_table_free(struct ddebug_table *dt)
910{
911 list_del_init(&dt->link);
Rasmus Villemoes3e406b12015-11-06 16:30:15 -0800912 kfree_const(dt->mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500913 kfree(dt);
914}
915
916/*
917 * Called in response to a module being unloaded. Removes
918 * any ddebug_table's which point at the module.
919 */
Yehuda Sadehff49d742010-07-03 13:07:35 +1000920int ddebug_remove_module(const char *mod_name)
Jason Barone9d376f2009-02-05 11:51:38 -0500921{
922 struct ddebug_table *dt, *nextdt;
923 int ret = -ENOENT;
924
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600925 vpr_info("removing module \"%s\"\n", mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500926
927 mutex_lock(&ddebug_lock);
928 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
929 if (!strcmp(dt->mod_name, mod_name)) {
930 ddebug_table_free(dt);
931 ret = 0;
932 }
933 }
934 mutex_unlock(&ddebug_lock);
935 return ret;
936}
937EXPORT_SYMBOL_GPL(ddebug_remove_module);
938
939static void ddebug_remove_all_tables(void)
940{
941 mutex_lock(&ddebug_lock);
942 while (!list_empty(&ddebug_tables)) {
943 struct ddebug_table *dt = list_entry(ddebug_tables.next,
944 struct ddebug_table,
945 link);
946 ddebug_table_free(dt);
947 }
948 mutex_unlock(&ddebug_lock);
949}
950
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200951static __initdata int ddebug_init_success;
952
953static int __init dynamic_debug_init_debugfs(void)
Jason Barone9d376f2009-02-05 11:51:38 -0500954{
955 struct dentry *dir, *file;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200956
957 if (!ddebug_init_success)
958 return -ENODEV;
Jason Barone9d376f2009-02-05 11:51:38 -0500959
960 dir = debugfs_create_dir("dynamic_debug", NULL);
961 if (!dir)
962 return -ENOMEM;
963 file = debugfs_create_file("control", 0644, dir, NULL,
964 &ddebug_proc_fops);
965 if (!file) {
966 debugfs_remove(dir);
967 return -ENOMEM;
968 }
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200969 return 0;
970}
971
972static int __init dynamic_debug_init(void)
973{
974 struct _ddebug *iter, *iter_start;
975 const char *modname = NULL;
Jim Cromieb48420c2012-04-27 14:30:35 -0600976 char *cmdline;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200977 int ret = 0;
Jim Cromie41076922012-04-27 14:30:39 -0600978 int n = 0, entries = 0, modct = 0;
979 int verbose_bytes = 0;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200980
Jim Cromieb5b78f82011-12-19 17:12:54 -0500981 if (__start___verbose == __stop___verbose) {
Joe Perchesf657fd22012-12-05 16:48:26 -0500982 pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
Jim Cromieb5b78f82011-12-19 17:12:54 -0500983 return 1;
Jason Barone9d376f2009-02-05 11:51:38 -0500984 }
Jim Cromieb5b78f82011-12-19 17:12:54 -0500985 iter = __start___verbose;
986 modname = iter->modname;
987 iter_start = iter;
988 for (; iter < __stop___verbose; iter++) {
Jim Cromie41076922012-04-27 14:30:39 -0600989 entries++;
990 verbose_bytes += strlen(iter->modname) + strlen(iter->function)
991 + strlen(iter->filename) + strlen(iter->format);
992
Jim Cromieb5b78f82011-12-19 17:12:54 -0500993 if (strcmp(modname, iter->modname)) {
Jim Cromie41076922012-04-27 14:30:39 -0600994 modct++;
Jim Cromieb5b78f82011-12-19 17:12:54 -0500995 ret = ddebug_add_module(iter_start, n, modname);
996 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -0600997 goto out_err;
Jim Cromieb5b78f82011-12-19 17:12:54 -0500998 n = 0;
999 modname = iter->modname;
1000 iter_start = iter;
1001 }
1002 n++;
1003 }
1004 ret = ddebug_add_module(iter_start, n, modname);
1005 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -06001006 goto out_err;
Thomas Renningera648ec02010-08-06 16:11:02 +02001007
Jim Cromieaf442392012-04-27 14:30:38 -06001008 ddebug_init_success = 1;
Joe Perchesf657fd22012-12-05 16:48:26 -05001009 vpr_info("%d modules, %d entries and %d bytes in ddebug tables, %d bytes in (readonly) verbose section\n",
1010 modct, entries, (int)(modct * sizeof(struct ddebug_table)),
1011 verbose_bytes + (int)(__stop___verbose - __start___verbose));
Jim Cromieaf442392012-04-27 14:30:38 -06001012
1013 /* apply ddebug_query boot param, dont unload tables on err */
Thomas Renningera648ec02010-08-06 16:11:02 +02001014 if (ddebug_setup_string[0] != '\0') {
Joe Perchesf657fd22012-12-05 16:48:26 -05001015 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
Jim Cromie8e59b5cf2012-04-27 14:30:40 -06001016 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001017 if (ret < 0)
Joe Perchesf657fd22012-12-05 16:48:26 -05001018 pr_warn("Invalid ddebug boot param %s\n",
Joe Perches4ad275e2011-08-11 14:36:33 -04001019 ddebug_setup_string);
Thomas Renningera648ec02010-08-06 16:11:02 +02001020 else
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001021 pr_info("%d changes by ddebug_query\n", ret);
Jason Barone9d376f2009-02-05 11:51:38 -05001022 }
Jim Cromieb48420c2012-04-27 14:30:35 -06001023 /* now that ddebug tables are loaded, process all boot args
1024 * again to find and activate queries given in dyndbg params.
1025 * While this has already been done for known boot params, it
1026 * ignored the unknown ones (dyndbg in particular). Reusing
1027 * parse_args avoids ad-hoc parsing. This will also attempt
1028 * to activate queries for not-yet-loaded modules, which is
1029 * slightly noisy if verbose, but harmless.
1030 */
1031 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1032 parse_args("dyndbg params", cmdline, NULL,
Luis R. Rodriguezecc86172015-03-30 16:20:03 -07001033 0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
Jim Cromieb48420c2012-04-27 14:30:35 -06001034 kfree(cmdline);
Jim Cromieaf442392012-04-27 14:30:38 -06001035 return 0;
Thomas Renningera648ec02010-08-06 16:11:02 +02001036
Jim Cromieaf442392012-04-27 14:30:38 -06001037out_err:
1038 ddebug_remove_all_tables();
Jason Barone9d376f2009-02-05 11:51:38 -05001039 return 0;
1040}
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001041/* Allow early initialization for boot messages via boot param */
Jim Cromie3ec56522012-04-27 14:30:42 -06001042early_initcall(dynamic_debug_init);
Jim Cromieb48420c2012-04-27 14:30:35 -06001043
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001044/* Debugfs setup must be done later */
Jim Cromie3ec56522012-04-27 14:30:42 -06001045fs_initcall(dynamic_debug_init_debugfs);