blob: c7c96bc7654af7c4d5f3c8bbf595989f9b3d0ebf [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.
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 Assche8ba6ebf52011-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 Assche8ba6ebf52011-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 Assche8ba6ebf52011-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 Assche8ba6ebf52011-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 Assche8ba6ebf52011-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.combd8c1542013-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
Randy Dunlap1f3c7902017-11-17 15:27:35 -0800363 /* special case for last lineno not specified */
364 if (query->last_lineno == 0)
365 query->last_lineno = UINT_MAX;
366
Andrey Ryabinin3ace6782014-01-27 17:06:58 -0800367 if (query->last_lineno < query->first_lineno) {
Jim Cromie18c216c2012-12-05 16:48:27 -0500368 pr_err("last-line:%d < 1st-line:%d\n",
369 query->last_lineno,
370 query->first_lineno);
Jason Barone9d376f2009-02-05 11:51:38 -0500371 return -EINVAL;
Jim Cromie820874c2011-12-19 17:12:49 -0500372 }
Jason Barone9d376f2009-02-05 11:51:38 -0500373 } else {
374 query->last_lineno = query->first_lineno;
375 }
376 } else {
Jim Cromieae27f862011-12-19 17:12:34 -0500377 pr_err("unknown keyword \"%s\"\n", words[i]);
Jason Barone9d376f2009-02-05 11:51:38 -0500378 return -EINVAL;
379 }
Jim Cromie820874c2011-12-19 17:12:49 -0500380 if (rc)
381 return rc;
Jason Barone9d376f2009-02-05 11:51:38 -0500382 }
Jim Cromie574b3722011-12-19 17:13:16 -0500383 vpr_info_dq(query, "parsed");
Jason Barone9d376f2009-02-05 11:51:38 -0500384 return 0;
385}
386
387/*
388 * Parse `str' as a flags specification, format [-+=][p]+.
389 * Sets up *maskp and *flagsp to be used when changing the
390 * flags fields of matched _ddebug's. Returns 0 on success
391 * or <0 on error.
392 */
393static int ddebug_parse_flags(const char *str, unsigned int *flagsp,
394 unsigned int *maskp)
395{
396 unsigned flags = 0;
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100397 int op = '=', i;
Jason Barone9d376f2009-02-05 11:51:38 -0500398
399 switch (*str) {
400 case '+':
401 case '-':
402 case '=':
403 op = *str++;
404 break;
405 default:
Jim Cromie18c216c2012-12-05 16:48:27 -0500406 pr_err("bad flag-op %c, at start of %s\n", *str, str);
Jason Barone9d376f2009-02-05 11:51:38 -0500407 return -EINVAL;
408 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600409 vpr_info("op='%c'\n", op);
Jason Barone9d376f2009-02-05 11:51:38 -0500410
Joe Perchesf657fd22012-12-05 16:48:26 -0500411 for (; *str ; ++str) {
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100412 for (i = ARRAY_SIZE(opt_array) - 1; i >= 0; i--) {
413 if (*str == opt_array[i].opt_char) {
414 flags |= opt_array[i].flag;
415 break;
416 }
Jason Barone9d376f2009-02-05 11:51:38 -0500417 }
Jim Cromie18c216c2012-12-05 16:48:27 -0500418 if (i < 0) {
419 pr_err("unknown flag '%c' in \"%s\"\n", *str, str);
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100420 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500421 }
Jason Barone9d376f2009-02-05 11:51:38 -0500422 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600423 vpr_info("flags=0x%x\n", flags);
Jason Barone9d376f2009-02-05 11:51:38 -0500424
425 /* calculate final *flagsp, *maskp according to mask and op */
426 switch (op) {
427 case '=':
428 *maskp = 0;
429 *flagsp = flags;
430 break;
431 case '+':
432 *maskp = ~0U;
433 *flagsp = flags;
434 break;
435 case '-':
436 *maskp = ~flags;
437 *flagsp = 0;
438 break;
439 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600440 vpr_info("*flagsp=0x%x *maskp=0x%x\n", *flagsp, *maskp);
Jason Barone9d376f2009-02-05 11:51:38 -0500441 return 0;
442}
443
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600444static int ddebug_exec_query(char *query_string, const char *modname)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200445{
446 unsigned int flags = 0, mask = 0;
447 struct ddebug_query query;
448#define MAXWORDS 9
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500449 int nwords, nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200450 char *words[MAXWORDS];
451
452 nwords = ddebug_tokenize(query_string, words, MAXWORDS);
Jim Cromie18c216c2012-12-05 16:48:27 -0500453 if (nwords <= 0) {
454 pr_err("tokenize failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200455 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500456 }
457 /* check flags 1st (last arg) so query is pairs of spec,val */
458 if (ddebug_parse_flags(words[nwords-1], &flags, &mask)) {
459 pr_err("flags parse failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200460 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500461 }
462 if (ddebug_parse_query(words, nwords-1, &query, modname)) {
463 pr_err("query parse failed\n");
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200464 return -EINVAL;
Jim Cromie18c216c2012-12-05 16:48:27 -0500465 }
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200466 /* actually go and implement the change */
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500467 nfound = ddebug_change(&query, flags, mask);
Joe Perchesf657fd22012-12-05 16:48:26 -0500468 vpr_info_dq(&query, nfound ? "applied" : "no-match");
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500469
470 return nfound;
471}
472
473/* handle multiple queries in query string, continue on error, return
474 last error or number of matching callsites. Module name is either
475 in param (for boot arg) or perhaps in query string.
476*/
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600477static int ddebug_exec_queries(char *query, const char *modname)
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500478{
479 char *split;
480 int i, errs = 0, exitcode = 0, rc, nfound = 0;
481
482 for (i = 0; query; query = split) {
483 split = strpbrk(query, ";\n");
484 if (split)
485 *split++ = '\0';
486
487 query = skip_spaces(query);
488 if (!query || !*query || *query == '#')
489 continue;
490
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600491 vpr_info("query %d: \"%s\"\n", i, query);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500492
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600493 rc = ddebug_exec_query(query, modname);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500494 if (rc < 0) {
495 errs++;
496 exitcode = rc;
Joe Perchesf657fd22012-12-05 16:48:26 -0500497 } else {
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500498 nfound += rc;
Joe Perchesf657fd22012-12-05 16:48:26 -0500499 }
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500500 i++;
501 }
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600502 vpr_info("processed %d queries, with %d matches, %d errs\n",
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500503 i, nfound, errs);
504
505 if (exitcode)
506 return exitcode;
507 return nfound;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200508}
509
Jason Baron431625d2011-10-04 14:13:19 -0700510#define PREFIX_SIZE 64
511
512static int remaining(int wrote)
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100513{
Jason Baron431625d2011-10-04 14:13:19 -0700514 if (PREFIX_SIZE - wrote > 0)
515 return PREFIX_SIZE - wrote;
516 return 0;
517}
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100518
Jason Baron431625d2011-10-04 14:13:19 -0700519static char *dynamic_emit_prefix(const struct _ddebug *desc, char *buf)
520{
521 int pos_after_tid;
522 int pos = 0;
523
Joe Perches798efc62012-09-12 20:11:29 -0700524 *buf = '\0';
525
Jason Baron431625d2011-10-04 14:13:19 -0700526 if (desc->flags & _DPRINTK_FLAGS_INCL_TID) {
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100527 if (in_interrupt())
Joe Perches798efc62012-09-12 20:11:29 -0700528 pos += snprintf(buf + pos, remaining(pos), "<intr> ");
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100529 else
Jason Baron431625d2011-10-04 14:13:19 -0700530 pos += snprintf(buf + pos, remaining(pos), "[%d] ",
Joe Perches798efc62012-09-12 20:11:29 -0700531 task_pid_vnr(current));
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100532 }
Jason Baron431625d2011-10-04 14:13:19 -0700533 pos_after_tid = pos;
534 if (desc->flags & _DPRINTK_FLAGS_INCL_MODNAME)
535 pos += snprintf(buf + pos, remaining(pos), "%s:",
Joe Perches798efc62012-09-12 20:11:29 -0700536 desc->modname);
Jason Baron431625d2011-10-04 14:13:19 -0700537 if (desc->flags & _DPRINTK_FLAGS_INCL_FUNCNAME)
538 pos += snprintf(buf + pos, remaining(pos), "%s:",
Joe Perches798efc62012-09-12 20:11:29 -0700539 desc->function);
Jason Baron431625d2011-10-04 14:13:19 -0700540 if (desc->flags & _DPRINTK_FLAGS_INCL_LINENO)
Jim Cromie07100be2011-12-19 17:11:09 -0500541 pos += snprintf(buf + pos, remaining(pos), "%d:",
Joe Perches798efc62012-09-12 20:11:29 -0700542 desc->lineno);
Jason Baron431625d2011-10-04 14:13:19 -0700543 if (pos - pos_after_tid)
544 pos += snprintf(buf + pos, remaining(pos), " ");
545 if (pos >= PREFIX_SIZE)
546 buf[PREFIX_SIZE - 1] = '\0';
Joe Perches6c2140e2011-08-11 14:36:25 -0400547
Jason Baron431625d2011-10-04 14:13:19 -0700548 return buf;
Joe Perches6c2140e2011-08-11 14:36:25 -0400549}
550
Joe Perches906d2012014-09-24 11:17:56 -0700551void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...)
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100552{
553 va_list args;
Jason Baron431625d2011-10-04 14:13:19 -0700554 struct va_format vaf;
555 char buf[PREFIX_SIZE];
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100556
557 BUG_ON(!descriptor);
558 BUG_ON(!fmt);
559
560 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700561
Jason Baron431625d2011-10-04 14:13:19 -0700562 vaf.fmt = fmt;
563 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700564
Joe Perches906d2012014-09-24 11:17:56 -0700565 printk(KERN_DEBUG "%s%pV", dynamic_emit_prefix(descriptor, buf), &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700566
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100567 va_end(args);
Bart Van Assche8ba6ebf52011-01-23 17:17:24 +0100568}
569EXPORT_SYMBOL(__dynamic_pr_debug);
570
Joe Perches906d2012014-09-24 11:17:56 -0700571void __dynamic_dev_dbg(struct _ddebug *descriptor,
Joe Perchescbc46632011-08-11 14:36:21 -0400572 const struct device *dev, const char *fmt, ...)
573{
574 struct va_format vaf;
575 va_list args;
Joe Perchescbc46632011-08-11 14:36:21 -0400576
577 BUG_ON(!descriptor);
578 BUG_ON(!fmt);
579
580 va_start(args, fmt);
Joe Perches798efc62012-09-12 20:11:29 -0700581
Joe Perchescbc46632011-08-11 14:36:21 -0400582 vaf.fmt = fmt;
583 vaf.va = &args;
Joe Perches798efc62012-09-12 20:11:29 -0700584
585 if (!dev) {
Joe Perches906d2012014-09-24 11:17:56 -0700586 printk(KERN_DEBUG "(NULL device *): %pV", &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700587 } else {
588 char buf[PREFIX_SIZE];
Joe Perches798efc62012-09-12 20:11:29 -0700589
Joe Perchesa39d4a82014-12-10 15:50:15 -0800590 dev_printk_emit(LOGLEVEL_DEBUG, dev, "%s%s %s: %pV",
Joe Perches906d2012014-09-24 11:17:56 -0700591 dynamic_emit_prefix(descriptor, buf),
592 dev_driver_string(dev), dev_name(dev),
593 &vaf);
Joe Perches798efc62012-09-12 20:11:29 -0700594 }
595
Joe Perchescbc46632011-08-11 14:36:21 -0400596 va_end(args);
Joe Perchescbc46632011-08-11 14:36:21 -0400597}
598EXPORT_SYMBOL(__dynamic_dev_dbg);
599
Jason Baron0feefd92011-10-04 14:13:22 -0700600#ifdef CONFIG_NET
601
Joe Perches906d2012014-09-24 11:17:56 -0700602void __dynamic_netdev_dbg(struct _ddebug *descriptor,
603 const struct net_device *dev, const char *fmt, ...)
Jason Baronffa10cb2011-08-11 14:36:48 -0400604{
605 struct va_format vaf;
606 va_list args;
Jason Baronffa10cb2011-08-11 14:36:48 -0400607
608 BUG_ON(!descriptor);
609 BUG_ON(!fmt);
610
611 va_start(args, fmt);
Joe Perchesb004ff42012-09-12 20:12:19 -0700612
Jason Baronffa10cb2011-08-11 14:36:48 -0400613 vaf.fmt = fmt;
614 vaf.va = &args;
Joe Perchesb004ff42012-09-12 20:12:19 -0700615
616 if (dev && dev->dev.parent) {
617 char buf[PREFIX_SIZE];
Joe Perchesb004ff42012-09-12 20:12:19 -0700618
Joe Perchesa39d4a82014-12-10 15:50:15 -0800619 dev_printk_emit(LOGLEVEL_DEBUG, dev->dev.parent,
Joe Perches906d2012014-09-24 11:17:56 -0700620 "%s%s %s %s%s: %pV",
621 dynamic_emit_prefix(descriptor, buf),
622 dev_driver_string(dev->dev.parent),
623 dev_name(dev->dev.parent),
624 netdev_name(dev), netdev_reg_state(dev),
625 &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700626 } else if (dev) {
Joe Perches906d2012014-09-24 11:17:56 -0700627 printk(KERN_DEBUG "%s%s: %pV", netdev_name(dev),
628 netdev_reg_state(dev), &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700629 } else {
Joe Perches906d2012014-09-24 11:17:56 -0700630 printk(KERN_DEBUG "(NULL net_device): %pV", &vaf);
Joe Perchesb004ff42012-09-12 20:12:19 -0700631 }
632
Jason Baronffa10cb2011-08-11 14:36:48 -0400633 va_end(args);
Jason Baronffa10cb2011-08-11 14:36:48 -0400634}
635EXPORT_SYMBOL(__dynamic_netdev_dbg);
636
Jason Baron0feefd92011-10-04 14:13:22 -0700637#endif
638
Jim Cromiebc757f62011-12-19 17:12:29 -0500639#define DDEBUG_STRING_SIZE 1024
640static __initdata char ddebug_setup_string[DDEBUG_STRING_SIZE];
641
Thomas Renningera648ec02010-08-06 16:11:02 +0200642static __init int ddebug_setup_query(char *str)
643{
Jim Cromiebc757f62011-12-19 17:12:29 -0500644 if (strlen(str) >= DDEBUG_STRING_SIZE) {
Joe Perches4ad275e2011-08-11 14:36:33 -0400645 pr_warn("ddebug boot param string too large\n");
Thomas Renningera648ec02010-08-06 16:11:02 +0200646 return 0;
647 }
Jim Cromiebc757f62011-12-19 17:12:29 -0500648 strlcpy(ddebug_setup_string, str, DDEBUG_STRING_SIZE);
Thomas Renningera648ec02010-08-06 16:11:02 +0200649 return 1;
650}
651
652__setup("ddebug_query=", ddebug_setup_query);
653
Jason Barone9d376f2009-02-05 11:51:38 -0500654/*
Masatake YAMATO231821d2014-12-15 12:04:16 +0900655 * File_ops->write method for <debugfs>/dynamic_debug/control. Gathers the
Jason Barone9d376f2009-02-05 11:51:38 -0500656 * command text from userspace, parses and executes it.
657 */
Jim Cromie72814912011-12-19 17:13:07 -0500658#define USER_BUF_PAGE 4096
Jason Barone9d376f2009-02-05 11:51:38 -0500659static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf,
660 size_t len, loff_t *offp)
661{
Jim Cromie72814912011-12-19 17:13:07 -0500662 char *tmpbuf;
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200663 int ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500664
665 if (len == 0)
666 return 0;
Jim Cromie72814912011-12-19 17:13:07 -0500667 if (len > USER_BUF_PAGE - 1) {
668 pr_warn("expected <%d bytes into control\n", USER_BUF_PAGE);
Jason Barone9d376f2009-02-05 11:51:38 -0500669 return -E2BIG;
Jim Cromie72814912011-12-19 17:13:07 -0500670 }
Al Viro16e5c1f2015-12-24 00:06:05 -0500671 tmpbuf = memdup_user_nul(ubuf, len);
672 if (IS_ERR(tmpbuf))
673 return PTR_ERR(tmpbuf);
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600674 vpr_info("read %d bytes from userspace\n", (int)len);
Jason Barone9d376f2009-02-05 11:51:38 -0500675
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600676 ret = ddebug_exec_queries(tmpbuf, NULL);
Jim Cromie72814912011-12-19 17:13:07 -0500677 kfree(tmpbuf);
Jim Cromie85f7f6c2011-12-19 17:13:21 -0500678 if (ret < 0)
Thomas Renningerfd89cfb2010-08-06 16:11:01 +0200679 return ret;
Jason Barone9d376f2009-02-05 11:51:38 -0500680
681 *offp += len;
682 return len;
683}
684
685/*
686 * Set the iterator to point to the first _ddebug object
687 * and return a pointer to that first object. Returns
688 * NULL if there are no _ddebugs at all.
689 */
690static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter)
691{
692 if (list_empty(&ddebug_tables)) {
693 iter->table = NULL;
694 iter->idx = 0;
695 return NULL;
696 }
697 iter->table = list_entry(ddebug_tables.next,
698 struct ddebug_table, link);
699 iter->idx = 0;
700 return &iter->table->ddebugs[iter->idx];
701}
702
703/*
704 * Advance the iterator to point to the next _ddebug
705 * object from the one the iterator currently points at,
706 * and returns a pointer to the new _ddebug. Returns
707 * NULL if the iterator has seen all the _ddebugs.
708 */
709static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter)
710{
711 if (iter->table == NULL)
712 return NULL;
713 if (++iter->idx == iter->table->num_ddebugs) {
714 /* iterate to next table */
715 iter->idx = 0;
716 if (list_is_last(&iter->table->link, &ddebug_tables)) {
717 iter->table = NULL;
718 return NULL;
719 }
720 iter->table = list_entry(iter->table->link.next,
721 struct ddebug_table, link);
722 }
723 return &iter->table->ddebugs[iter->idx];
724}
725
726/*
727 * Seq_ops start method. Called at the start of every
728 * read() call from userspace. Takes the ddebug_lock and
729 * seeks the seq_file's iterator to the given position.
730 */
731static void *ddebug_proc_start(struct seq_file *m, loff_t *pos)
732{
733 struct ddebug_iter *iter = m->private;
734 struct _ddebug *dp;
735 int n = *pos;
736
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600737 vpr_info("called m=%p *pos=%lld\n", m, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500738
739 mutex_lock(&ddebug_lock);
740
741 if (!n)
742 return SEQ_START_TOKEN;
743 if (n < 0)
744 return NULL;
745 dp = ddebug_iter_first(iter);
746 while (dp != NULL && --n > 0)
747 dp = ddebug_iter_next(iter);
748 return dp;
749}
750
751/*
752 * Seq_ops next method. Called several times within a read()
753 * call from userspace, with ddebug_lock held. Walks to the
754 * next _ddebug object with a special case for the header line.
755 */
756static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos)
757{
758 struct ddebug_iter *iter = m->private;
759 struct _ddebug *dp;
760
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600761 vpr_info("called m=%p p=%p *pos=%lld\n",
Joe Perchesf657fd22012-12-05 16:48:26 -0500762 m, p, (unsigned long long)*pos);
Jason Barone9d376f2009-02-05 11:51:38 -0500763
764 if (p == SEQ_START_TOKEN)
765 dp = ddebug_iter_first(iter);
766 else
767 dp = ddebug_iter_next(iter);
768 ++*pos;
769 return dp;
770}
771
772/*
773 * Seq_ops show method. Called several times within a read()
774 * call from userspace, with ddebug_lock held. Formats the
775 * current _ddebug as a single human-readable line, with a
776 * special case for the header line.
777 */
778static int ddebug_proc_show(struct seq_file *m, void *p)
779{
780 struct ddebug_iter *iter = m->private;
781 struct _ddebug *dp = p;
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500782 char flagsbuf[10];
Jason Barone9d376f2009-02-05 11:51:38 -0500783
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600784 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500785
786 if (p == SEQ_START_TOKEN) {
787 seq_puts(m,
Joe Perchesf657fd22012-12-05 16:48:26 -0500788 "# filename:lineno [module]function flags format\n");
Jason Barone9d376f2009-02-05 11:51:38 -0500789 return 0;
790 }
791
Jim Cromie5ca7d2a2011-12-19 17:12:44 -0500792 seq_printf(m, "%s:%u [%s]%s =%s \"",
Joe Perchesf657fd22012-12-05 16:48:26 -0500793 trim_prefix(dp->filename), dp->lineno,
794 iter->table->mod_name, dp->function,
795 ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf)));
Jason Barone9d376f2009-02-05 11:51:38 -0500796 seq_escape(m, dp->format, "\t\r\n\"");
797 seq_puts(m, "\"\n");
798
799 return 0;
800}
801
802/*
803 * Seq_ops stop method. Called at the end of each read()
804 * call from userspace. Drops ddebug_lock.
805 */
806static void ddebug_proc_stop(struct seq_file *m, void *p)
807{
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600808 vpr_info("called m=%p p=%p\n", m, p);
Jason Barone9d376f2009-02-05 11:51:38 -0500809 mutex_unlock(&ddebug_lock);
810}
811
812static const struct seq_operations ddebug_proc_seqops = {
813 .start = ddebug_proc_start,
814 .next = ddebug_proc_next,
815 .show = ddebug_proc_show,
816 .stop = ddebug_proc_stop
817};
818
819/*
Jim Cromie07100be2011-12-19 17:11:09 -0500820 * File_ops->open method for <debugfs>/dynamic_debug/control. Does
821 * the seq_file setup dance, and also creates an iterator to walk the
822 * _ddebugs. Note that we create a seq_file always, even for O_WRONLY
823 * files where it's not needed, as doing so simplifies the ->release
824 * method.
Jason Barone9d376f2009-02-05 11:51:38 -0500825 */
826static int ddebug_proc_open(struct inode *inode, struct file *file)
827{
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600828 vpr_info("called\n");
Rob Jones4bad78c2014-10-13 15:51:32 -0700829 return seq_open_private(file, &ddebug_proc_seqops,
830 sizeof(struct ddebug_iter));
Jason Barone9d376f2009-02-05 11:51:38 -0500831}
832
833static const struct file_operations ddebug_proc_fops = {
834 .owner = THIS_MODULE,
835 .open = ddebug_proc_open,
836 .read = seq_read,
837 .llseek = seq_lseek,
838 .release = seq_release_private,
839 .write = ddebug_proc_write
840};
841
842/*
843 * Allocate a new ddebug_table for the given module
844 * and add it to the global list.
845 */
846int ddebug_add_module(struct _ddebug *tab, unsigned int n,
847 const char *name)
848{
849 struct ddebug_table *dt;
Rasmus Villemoes3e406b12015-11-06 16:30:15 -0800850 const char *new_name;
Jason Barone9d376f2009-02-05 11:51:38 -0500851
852 dt = kzalloc(sizeof(*dt), GFP_KERNEL);
853 if (dt == NULL)
854 return -ENOMEM;
Rasmus Villemoes3e406b12015-11-06 16:30:15 -0800855 new_name = kstrdup_const(name, GFP_KERNEL);
Jason Barone9d376f2009-02-05 11:51:38 -0500856 if (new_name == NULL) {
857 kfree(dt);
858 return -ENOMEM;
859 }
860 dt->mod_name = new_name;
861 dt->num_ddebugs = n;
Jason Barone9d376f2009-02-05 11:51:38 -0500862 dt->ddebugs = tab;
863
864 mutex_lock(&ddebug_lock);
865 list_add_tail(&dt->link, &ddebug_tables);
866 mutex_unlock(&ddebug_lock);
867
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600868 vpr_info("%u debug prints in module %s\n", n, dt->mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500869 return 0;
870}
871EXPORT_SYMBOL_GPL(ddebug_add_module);
872
Jim Cromie6ab676e2012-04-27 14:30:37 -0600873/* helper for ddebug_dyndbg_(boot|module)_param_cb */
874static int ddebug_dyndbg_param_cb(char *param, char *val,
875 const char *modname, int on_err)
Jim Cromieb48420c2012-04-27 14:30:35 -0600876{
Jim Cromieb48420c2012-04-27 14:30:35 -0600877 char *sep;
878
879 sep = strchr(param, '.');
880 if (sep) {
Jim Cromie6ab676e2012-04-27 14:30:37 -0600881 /* needed only for ddebug_dyndbg_boot_param_cb */
Jim Cromieb48420c2012-04-27 14:30:35 -0600882 *sep = '\0';
883 modname = param;
884 param = sep + 1;
885 }
886 if (strcmp(param, "dyndbg"))
Jim Cromie6ab676e2012-04-27 14:30:37 -0600887 return on_err; /* determined by caller */
Jim Cromieb48420c2012-04-27 14:30:35 -0600888
Jim Cromie8e59b5cf2012-04-27 14:30:40 -0600889 ddebug_exec_queries((val ? val : "+p"), modname);
890
Jim Cromieb48420c2012-04-27 14:30:35 -0600891 return 0; /* query failure shouldnt stop module load */
892}
893
Jim Cromie6ab676e2012-04-27 14:30:37 -0600894/* handle both dyndbg and $module.dyndbg params at boot */
895static int ddebug_dyndbg_boot_param_cb(char *param, char *val,
Luis R. Rodriguezecc86172015-03-30 16:20:03 -0700896 const char *unused, void *arg)
Jim Cromieb48420c2012-04-27 14:30:35 -0600897{
Jim Cromie6ab676e2012-04-27 14:30:37 -0600898 vpr_info("%s=\"%s\"\n", param, val);
899 return ddebug_dyndbg_param_cb(param, val, NULL, 0);
900}
Jim Cromieb48420c2012-04-27 14:30:35 -0600901
Jim Cromie6ab676e2012-04-27 14:30:37 -0600902/*
903 * modprobe foo finds foo.params in boot-args, strips "foo.", and
904 * passes them to load_module(). This callback gets unknown params,
905 * processes dyndbg params, rejects others.
906 */
907int ddebug_dyndbg_module_param_cb(char *param, char *val, const char *module)
908{
909 vpr_info("module: %s %s=\"%s\"\n", module, param, val);
910 return ddebug_dyndbg_param_cb(param, val, module, -ENOENT);
Jim Cromieb48420c2012-04-27 14:30:35 -0600911}
912
Jason Barone9d376f2009-02-05 11:51:38 -0500913static void ddebug_table_free(struct ddebug_table *dt)
914{
915 list_del_init(&dt->link);
Rasmus Villemoes3e406b12015-11-06 16:30:15 -0800916 kfree_const(dt->mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500917 kfree(dt);
918}
919
920/*
921 * Called in response to a module being unloaded. Removes
922 * any ddebug_table's which point at the module.
923 */
Yehuda Sadehff49d742010-07-03 13:07:35 +1000924int ddebug_remove_module(const char *mod_name)
Jason Barone9d376f2009-02-05 11:51:38 -0500925{
926 struct ddebug_table *dt, *nextdt;
927 int ret = -ENOENT;
928
Jim Cromieb8ccd5d2012-04-27 14:30:32 -0600929 vpr_info("removing module \"%s\"\n", mod_name);
Jason Barone9d376f2009-02-05 11:51:38 -0500930
931 mutex_lock(&ddebug_lock);
932 list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) {
933 if (!strcmp(dt->mod_name, mod_name)) {
934 ddebug_table_free(dt);
935 ret = 0;
936 }
937 }
938 mutex_unlock(&ddebug_lock);
939 return ret;
940}
941EXPORT_SYMBOL_GPL(ddebug_remove_module);
942
943static void ddebug_remove_all_tables(void)
944{
945 mutex_lock(&ddebug_lock);
946 while (!list_empty(&ddebug_tables)) {
947 struct ddebug_table *dt = list_entry(ddebug_tables.next,
948 struct ddebug_table,
949 link);
950 ddebug_table_free(dt);
951 }
952 mutex_unlock(&ddebug_lock);
953}
954
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200955static __initdata int ddebug_init_success;
956
957static int __init dynamic_debug_init_debugfs(void)
Jason Barone9d376f2009-02-05 11:51:38 -0500958{
959 struct dentry *dir, *file;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200960
961 if (!ddebug_init_success)
962 return -ENODEV;
Jason Barone9d376f2009-02-05 11:51:38 -0500963
964 dir = debugfs_create_dir("dynamic_debug", NULL);
965 if (!dir)
966 return -ENOMEM;
967 file = debugfs_create_file("control", 0644, dir, NULL,
968 &ddebug_proc_fops);
969 if (!file) {
970 debugfs_remove(dir);
971 return -ENOMEM;
972 }
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200973 return 0;
974}
975
976static int __init dynamic_debug_init(void)
977{
978 struct _ddebug *iter, *iter_start;
979 const char *modname = NULL;
Jim Cromieb48420c2012-04-27 14:30:35 -0600980 char *cmdline;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200981 int ret = 0;
Jim Cromie41076922012-04-27 14:30:39 -0600982 int n = 0, entries = 0, modct = 0;
983 int verbose_bytes = 0;
Thomas Renninger6a5c0832010-08-06 16:11:03 +0200984
Jim Cromieb5b78f82011-12-19 17:12:54 -0500985 if (__start___verbose == __stop___verbose) {
Joe Perchesf657fd22012-12-05 16:48:26 -0500986 pr_warn("_ddebug table is empty in a CONFIG_DYNAMIC_DEBUG build\n");
Jim Cromieb5b78f82011-12-19 17:12:54 -0500987 return 1;
Jason Barone9d376f2009-02-05 11:51:38 -0500988 }
Jim Cromieb5b78f82011-12-19 17:12:54 -0500989 iter = __start___verbose;
990 modname = iter->modname;
991 iter_start = iter;
992 for (; iter < __stop___verbose; iter++) {
Jim Cromie41076922012-04-27 14:30:39 -0600993 entries++;
994 verbose_bytes += strlen(iter->modname) + strlen(iter->function)
995 + strlen(iter->filename) + strlen(iter->format);
996
Jim Cromieb5b78f82011-12-19 17:12:54 -0500997 if (strcmp(modname, iter->modname)) {
Jim Cromie41076922012-04-27 14:30:39 -0600998 modct++;
Jim Cromieb5b78f82011-12-19 17:12:54 -0500999 ret = ddebug_add_module(iter_start, n, modname);
1000 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -06001001 goto out_err;
Jim Cromieb5b78f82011-12-19 17:12:54 -05001002 n = 0;
1003 modname = iter->modname;
1004 iter_start = iter;
1005 }
1006 n++;
1007 }
1008 ret = ddebug_add_module(iter_start, n, modname);
1009 if (ret)
Jim Cromieaf442392012-04-27 14:30:38 -06001010 goto out_err;
Thomas Renningera648ec02010-08-06 16:11:02 +02001011
Jim Cromieaf442392012-04-27 14:30:38 -06001012 ddebug_init_success = 1;
Joe Perchesf657fd22012-12-05 16:48:26 -05001013 vpr_info("%d modules, %d entries and %d bytes in ddebug tables, %d bytes in (readonly) verbose section\n",
1014 modct, entries, (int)(modct * sizeof(struct ddebug_table)),
1015 verbose_bytes + (int)(__stop___verbose - __start___verbose));
Jim Cromieaf442392012-04-27 14:30:38 -06001016
1017 /* apply ddebug_query boot param, dont unload tables on err */
Thomas Renningera648ec02010-08-06 16:11:02 +02001018 if (ddebug_setup_string[0] != '\0') {
Joe Perchesf657fd22012-12-05 16:48:26 -05001019 pr_warn("ddebug_query param name is deprecated, change it to dyndbg\n");
Jim Cromie8e59b5cf2012-04-27 14:30:40 -06001020 ret = ddebug_exec_queries(ddebug_setup_string, NULL);
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001021 if (ret < 0)
Joe Perchesf657fd22012-12-05 16:48:26 -05001022 pr_warn("Invalid ddebug boot param %s\n",
Joe Perches4ad275e2011-08-11 14:36:33 -04001023 ddebug_setup_string);
Thomas Renningera648ec02010-08-06 16:11:02 +02001024 else
Jim Cromie85f7f6c2011-12-19 17:13:21 -05001025 pr_info("%d changes by ddebug_query\n", ret);
Jason Barone9d376f2009-02-05 11:51:38 -05001026 }
Jim Cromieb48420c2012-04-27 14:30:35 -06001027 /* now that ddebug tables are loaded, process all boot args
1028 * again to find and activate queries given in dyndbg params.
1029 * While this has already been done for known boot params, it
1030 * ignored the unknown ones (dyndbg in particular). Reusing
1031 * parse_args avoids ad-hoc parsing. This will also attempt
1032 * to activate queries for not-yet-loaded modules, which is
1033 * slightly noisy if verbose, but harmless.
1034 */
1035 cmdline = kstrdup(saved_command_line, GFP_KERNEL);
1036 parse_args("dyndbg params", cmdline, NULL,
Luis R. Rodriguezecc86172015-03-30 16:20:03 -07001037 0, 0, 0, NULL, &ddebug_dyndbg_boot_param_cb);
Jim Cromieb48420c2012-04-27 14:30:35 -06001038 kfree(cmdline);
Jim Cromieaf442392012-04-27 14:30:38 -06001039 return 0;
Thomas Renningera648ec02010-08-06 16:11:02 +02001040
Jim Cromieaf442392012-04-27 14:30:38 -06001041out_err:
1042 ddebug_remove_all_tables();
Jason Barone9d376f2009-02-05 11:51:38 -05001043 return 0;
1044}
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001045/* Allow early initialization for boot messages via boot param */
Jim Cromie3ec56522012-04-27 14:30:42 -06001046early_initcall(dynamic_debug_init);
Jim Cromieb48420c2012-04-27 14:30:35 -06001047
Thomas Renninger6a5c0832010-08-06 16:11:03 +02001048/* Debugfs setup must be done later */
Jim Cromie3ec56522012-04-27 14:30:42 -06001049fs_initcall(dynamic_debug_init_debugfs);