Loading...
1/*
2 * trace binary printk
3 *
4 * Copyright (C) 2008 Lai Jiangshan <laijs@cn.fujitsu.com>
5 *
6 */
7#include <linux/seq_file.h>
8#include <linux/debugfs.h>
9#include <linux/uaccess.h>
10#include <linux/kernel.h>
11#include <linux/ftrace.h>
12#include <linux/string.h>
13#include <linux/module.h>
14#include <linux/mutex.h>
15#include <linux/ctype.h>
16#include <linux/list.h>
17#include <linux/slab.h>
18#include <linux/fs.h>
19
20#include "trace.h"
21
22#ifdef CONFIG_MODULES
23
24/*
25 * modules trace_printk()'s formats are autosaved in struct trace_bprintk_fmt
26 * which are queued on trace_bprintk_fmt_list.
27 */
28static LIST_HEAD(trace_bprintk_fmt_list);
29
30/* serialize accesses to trace_bprintk_fmt_list */
31static DEFINE_MUTEX(btrace_mutex);
32
33struct trace_bprintk_fmt {
34 struct list_head list;
35 const char *fmt;
36};
37
38static inline struct trace_bprintk_fmt *lookup_format(const char *fmt)
39{
40 struct trace_bprintk_fmt *pos;
41 list_for_each_entry(pos, &trace_bprintk_fmt_list, list) {
42 if (!strcmp(pos->fmt, fmt))
43 return pos;
44 }
45 return NULL;
46}
47
48static
49void hold_module_trace_bprintk_format(const char **start, const char **end)
50{
51 const char **iter;
52 char *fmt;
53
54 /* allocate the trace_printk per cpu buffers */
55 if (start != end)
56 trace_printk_init_buffers();
57
58 mutex_lock(&btrace_mutex);
59 for (iter = start; iter < end; iter++) {
60 struct trace_bprintk_fmt *tb_fmt = lookup_format(*iter);
61 if (tb_fmt) {
62 *iter = tb_fmt->fmt;
63 continue;
64 }
65
66 fmt = NULL;
67 tb_fmt = kmalloc(sizeof(*tb_fmt), GFP_KERNEL);
68 if (tb_fmt) {
69 fmt = kmalloc(strlen(*iter) + 1, GFP_KERNEL);
70 if (fmt) {
71 list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
72 strcpy(fmt, *iter);
73 tb_fmt->fmt = fmt;
74 } else
75 kfree(tb_fmt);
76 }
77 *iter = fmt;
78
79 }
80 mutex_unlock(&btrace_mutex);
81}
82
83static int module_trace_bprintk_format_notify(struct notifier_block *self,
84 unsigned long val, void *data)
85{
86 struct module *mod = data;
87 if (mod->num_trace_bprintk_fmt) {
88 const char **start = mod->trace_bprintk_fmt_start;
89 const char **end = start + mod->num_trace_bprintk_fmt;
90
91 if (val == MODULE_STATE_COMING)
92 hold_module_trace_bprintk_format(start, end);
93 }
94 return 0;
95}
96
97/*
98 * The debugfs/tracing/printk_formats file maps the addresses with
99 * the ASCII formats that are used in the bprintk events in the
100 * buffer. For userspace tools to be able to decode the events from
101 * the buffer, they need to be able to map the address with the format.
102 *
103 * The addresses of the bprintk formats are in their own section
104 * __trace_printk_fmt. But for modules we copy them into a link list.
105 * The code to print the formats and their addresses passes around the
106 * address of the fmt string. If the fmt address passed into the seq
107 * functions is within the kernel core __trace_printk_fmt section, then
108 * it simply uses the next pointer in the list.
109 *
110 * When the fmt pointer is outside the kernel core __trace_printk_fmt
111 * section, then we need to read the link list pointers. The trick is
112 * we pass the address of the string to the seq function just like
113 * we do for the kernel core formats. To get back the structure that
114 * holds the format, we simply use containerof() and then go to the
115 * next format in the list.
116 */
117static const char **
118find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
119{
120 struct trace_bprintk_fmt *mod_fmt;
121
122 if (list_empty(&trace_bprintk_fmt_list))
123 return NULL;
124
125 /*
126 * v will point to the address of the fmt record from t_next
127 * v will be NULL from t_start.
128 * If this is the first pointer or called from start
129 * then we need to walk the list.
130 */
131 if (!v || start_index == *pos) {
132 struct trace_bprintk_fmt *p;
133
134 /* search the module list */
135 list_for_each_entry(p, &trace_bprintk_fmt_list, list) {
136 if (start_index == *pos)
137 return &p->fmt;
138 start_index++;
139 }
140 /* pos > index */
141 return NULL;
142 }
143
144 /*
145 * v points to the address of the fmt field in the mod list
146 * structure that holds the module print format.
147 */
148 mod_fmt = container_of(v, typeof(*mod_fmt), fmt);
149 if (mod_fmt->list.next == &trace_bprintk_fmt_list)
150 return NULL;
151
152 mod_fmt = container_of(mod_fmt->list.next, typeof(*mod_fmt), list);
153
154 return &mod_fmt->fmt;
155}
156
157static void format_mod_start(void)
158{
159 mutex_lock(&btrace_mutex);
160}
161
162static void format_mod_stop(void)
163{
164 mutex_unlock(&btrace_mutex);
165}
166
167#else /* !CONFIG_MODULES */
168__init static int
169module_trace_bprintk_format_notify(struct notifier_block *self,
170 unsigned long val, void *data)
171{
172 return 0;
173}
174static inline const char **
175find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
176{
177 return NULL;
178}
179static inline void format_mod_start(void) { }
180static inline void format_mod_stop(void) { }
181#endif /* CONFIG_MODULES */
182
183
184__initdata_or_module static
185struct notifier_block module_trace_bprintk_format_nb = {
186 .notifier_call = module_trace_bprintk_format_notify,
187};
188
189int __trace_bprintk(unsigned long ip, const char *fmt, ...)
190 {
191 int ret;
192 va_list ap;
193
194 if (unlikely(!fmt))
195 return 0;
196
197 if (!(trace_flags & TRACE_ITER_PRINTK))
198 return 0;
199
200 va_start(ap, fmt);
201 ret = trace_vbprintk(ip, fmt, ap);
202 va_end(ap);
203 return ret;
204}
205EXPORT_SYMBOL_GPL(__trace_bprintk);
206
207int __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap)
208 {
209 if (unlikely(!fmt))
210 return 0;
211
212 if (!(trace_flags & TRACE_ITER_PRINTK))
213 return 0;
214
215 return trace_vbprintk(ip, fmt, ap);
216}
217EXPORT_SYMBOL_GPL(__ftrace_vbprintk);
218
219int __trace_printk(unsigned long ip, const char *fmt, ...)
220{
221 int ret;
222 va_list ap;
223
224 if (!(trace_flags & TRACE_ITER_PRINTK))
225 return 0;
226
227 va_start(ap, fmt);
228 ret = trace_vprintk(ip, fmt, ap);
229 va_end(ap);
230 return ret;
231}
232EXPORT_SYMBOL_GPL(__trace_printk);
233
234int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
235{
236 if (!(trace_flags & TRACE_ITER_PRINTK))
237 return 0;
238
239 return trace_vprintk(ip, fmt, ap);
240}
241EXPORT_SYMBOL_GPL(__ftrace_vprintk);
242
243static const char **find_next(void *v, loff_t *pos)
244{
245 const char **fmt = v;
246 int start_index;
247 int last_index;
248
249 start_index = __stop___trace_bprintk_fmt - __start___trace_bprintk_fmt;
250
251 if (*pos < start_index)
252 return __start___trace_bprintk_fmt + *pos;
253
254 /*
255 * The __tracepoint_str section is treated the same as the
256 * __trace_printk_fmt section. The difference is that the
257 * __trace_printk_fmt section should only be used by trace_printk()
258 * in a debugging environment, as if anything exists in that section
259 * the trace_prink() helper buffers are allocated, which would just
260 * waste space in a production environment.
261 *
262 * The __tracepoint_str sections on the other hand are used by
263 * tracepoints which need to map pointers to their strings to
264 * the ASCII text for userspace.
265 */
266 last_index = start_index;
267 start_index = __stop___tracepoint_str - __start___tracepoint_str;
268
269 if (*pos < last_index + start_index)
270 return __start___tracepoint_str + (*pos - last_index);
271
272 return find_next_mod_format(start_index, v, fmt, pos);
273}
274
275static void *
276t_start(struct seq_file *m, loff_t *pos)
277{
278 format_mod_start();
279 return find_next(NULL, pos);
280}
281
282static void *t_next(struct seq_file *m, void * v, loff_t *pos)
283{
284 (*pos)++;
285 return find_next(v, pos);
286}
287
288static int t_show(struct seq_file *m, void *v)
289{
290 const char **fmt = v;
291 const char *str = *fmt;
292 int i;
293
294 seq_printf(m, "0x%lx : \"", *(unsigned long *)fmt);
295
296 /*
297 * Tabs and new lines need to be converted.
298 */
299 for (i = 0; str[i]; i++) {
300 switch (str[i]) {
301 case '\n':
302 seq_puts(m, "\\n");
303 break;
304 case '\t':
305 seq_puts(m, "\\t");
306 break;
307 case '\\':
308 seq_puts(m, "\\");
309 break;
310 case '"':
311 seq_puts(m, "\\\"");
312 break;
313 default:
314 seq_putc(m, str[i]);
315 }
316 }
317 seq_puts(m, "\"\n");
318
319 return 0;
320}
321
322static void t_stop(struct seq_file *m, void *p)
323{
324 format_mod_stop();
325}
326
327static const struct seq_operations show_format_seq_ops = {
328 .start = t_start,
329 .next = t_next,
330 .show = t_show,
331 .stop = t_stop,
332};
333
334static int
335ftrace_formats_open(struct inode *inode, struct file *file)
336{
337 return seq_open(file, &show_format_seq_ops);
338}
339
340static const struct file_operations ftrace_formats_fops = {
341 .open = ftrace_formats_open,
342 .read = seq_read,
343 .llseek = seq_lseek,
344 .release = seq_release,
345};
346
347static __init int init_trace_printk_function_export(void)
348{
349 struct dentry *d_tracer;
350
351 d_tracer = tracing_init_dentry();
352 if (!d_tracer)
353 return 0;
354
355 trace_create_file("printk_formats", 0444, d_tracer,
356 NULL, &ftrace_formats_fops);
357
358 return 0;
359}
360
361fs_initcall(init_trace_printk_function_export);
362
363static __init int init_trace_printk(void)
364{
365 return register_module_notifier(&module_trace_bprintk_format_nb);
366}
367
368early_initcall(init_trace_printk);
1/*
2 * trace binary printk
3 *
4 * Copyright (C) 2008 Lai Jiangshan <laijs@cn.fujitsu.com>
5 *
6 */
7#include <linux/seq_file.h>
8#include <linux/uaccess.h>
9#include <linux/kernel.h>
10#include <linux/ftrace.h>
11#include <linux/string.h>
12#include <linux/module.h>
13#include <linux/mutex.h>
14#include <linux/ctype.h>
15#include <linux/list.h>
16#include <linux/slab.h>
17
18#include "trace.h"
19
20#ifdef CONFIG_MODULES
21
22/*
23 * modules trace_printk()'s formats are autosaved in struct trace_bprintk_fmt
24 * which are queued on trace_bprintk_fmt_list.
25 */
26static LIST_HEAD(trace_bprintk_fmt_list);
27
28/* serialize accesses to trace_bprintk_fmt_list */
29static DEFINE_MUTEX(btrace_mutex);
30
31struct trace_bprintk_fmt {
32 struct list_head list;
33 const char *fmt;
34};
35
36static inline struct trace_bprintk_fmt *lookup_format(const char *fmt)
37{
38 struct trace_bprintk_fmt *pos;
39 list_for_each_entry(pos, &trace_bprintk_fmt_list, list) {
40 if (!strcmp(pos->fmt, fmt))
41 return pos;
42 }
43 return NULL;
44}
45
46static
47void hold_module_trace_bprintk_format(const char **start, const char **end)
48{
49 const char **iter;
50 char *fmt;
51
52 /* allocate the trace_printk per cpu buffers */
53 if (start != end)
54 trace_printk_init_buffers();
55
56 mutex_lock(&btrace_mutex);
57 for (iter = start; iter < end; iter++) {
58 struct trace_bprintk_fmt *tb_fmt = lookup_format(*iter);
59 if (tb_fmt) {
60 *iter = tb_fmt->fmt;
61 continue;
62 }
63
64 fmt = NULL;
65 tb_fmt = kmalloc(sizeof(*tb_fmt), GFP_KERNEL);
66 if (tb_fmt) {
67 fmt = kmalloc(strlen(*iter) + 1, GFP_KERNEL);
68 if (fmt) {
69 list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
70 strcpy(fmt, *iter);
71 tb_fmt->fmt = fmt;
72 } else
73 kfree(tb_fmt);
74 }
75 *iter = fmt;
76
77 }
78 mutex_unlock(&btrace_mutex);
79}
80
81static int module_trace_bprintk_format_notify(struct notifier_block *self,
82 unsigned long val, void *data)
83{
84 struct module *mod = data;
85 if (mod->num_trace_bprintk_fmt) {
86 const char **start = mod->trace_bprintk_fmt_start;
87 const char **end = start + mod->num_trace_bprintk_fmt;
88
89 if (val == MODULE_STATE_COMING)
90 hold_module_trace_bprintk_format(start, end);
91 }
92 return 0;
93}
94
95/*
96 * The debugfs/tracing/printk_formats file maps the addresses with
97 * the ASCII formats that are used in the bprintk events in the
98 * buffer. For userspace tools to be able to decode the events from
99 * the buffer, they need to be able to map the address with the format.
100 *
101 * The addresses of the bprintk formats are in their own section
102 * __trace_printk_fmt. But for modules we copy them into a link list.
103 * The code to print the formats and their addresses passes around the
104 * address of the fmt string. If the fmt address passed into the seq
105 * functions is within the kernel core __trace_printk_fmt section, then
106 * it simply uses the next pointer in the list.
107 *
108 * When the fmt pointer is outside the kernel core __trace_printk_fmt
109 * section, then we need to read the link list pointers. The trick is
110 * we pass the address of the string to the seq function just like
111 * we do for the kernel core formats. To get back the structure that
112 * holds the format, we simply use containerof() and then go to the
113 * next format in the list.
114 */
115static const char **
116find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
117{
118 struct trace_bprintk_fmt *mod_fmt;
119
120 if (list_empty(&trace_bprintk_fmt_list))
121 return NULL;
122
123 /*
124 * v will point to the address of the fmt record from t_next
125 * v will be NULL from t_start.
126 * If this is the first pointer or called from start
127 * then we need to walk the list.
128 */
129 if (!v || start_index == *pos) {
130 struct trace_bprintk_fmt *p;
131
132 /* search the module list */
133 list_for_each_entry(p, &trace_bprintk_fmt_list, list) {
134 if (start_index == *pos)
135 return &p->fmt;
136 start_index++;
137 }
138 /* pos > index */
139 return NULL;
140 }
141
142 /*
143 * v points to the address of the fmt field in the mod list
144 * structure that holds the module print format.
145 */
146 mod_fmt = container_of(v, typeof(*mod_fmt), fmt);
147 if (mod_fmt->list.next == &trace_bprintk_fmt_list)
148 return NULL;
149
150 mod_fmt = container_of(mod_fmt->list.next, typeof(*mod_fmt), list);
151
152 return &mod_fmt->fmt;
153}
154
155static void format_mod_start(void)
156{
157 mutex_lock(&btrace_mutex);
158}
159
160static void format_mod_stop(void)
161{
162 mutex_unlock(&btrace_mutex);
163}
164
165#else /* !CONFIG_MODULES */
166__init static int
167module_trace_bprintk_format_notify(struct notifier_block *self,
168 unsigned long val, void *data)
169{
170 return 0;
171}
172static inline const char **
173find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
174{
175 return NULL;
176}
177static inline void format_mod_start(void) { }
178static inline void format_mod_stop(void) { }
179#endif /* CONFIG_MODULES */
180
181static bool __read_mostly trace_printk_enabled = true;
182
183void trace_printk_control(bool enabled)
184{
185 trace_printk_enabled = enabled;
186}
187
188__initdata_or_module static
189struct notifier_block module_trace_bprintk_format_nb = {
190 .notifier_call = module_trace_bprintk_format_notify,
191};
192
193int __trace_bprintk(unsigned long ip, const char *fmt, ...)
194 {
195 int ret;
196 va_list ap;
197
198 if (unlikely(!fmt))
199 return 0;
200
201 if (!trace_printk_enabled)
202 return 0;
203
204 va_start(ap, fmt);
205 ret = trace_vbprintk(ip, fmt, ap);
206 va_end(ap);
207 return ret;
208}
209EXPORT_SYMBOL_GPL(__trace_bprintk);
210
211int __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap)
212 {
213 if (unlikely(!fmt))
214 return 0;
215
216 if (!trace_printk_enabled)
217 return 0;
218
219 return trace_vbprintk(ip, fmt, ap);
220}
221EXPORT_SYMBOL_GPL(__ftrace_vbprintk);
222
223int __trace_printk(unsigned long ip, const char *fmt, ...)
224{
225 int ret;
226 va_list ap;
227
228 if (!trace_printk_enabled)
229 return 0;
230
231 va_start(ap, fmt);
232 ret = trace_vprintk(ip, fmt, ap);
233 va_end(ap);
234 return ret;
235}
236EXPORT_SYMBOL_GPL(__trace_printk);
237
238int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
239{
240 if (!trace_printk_enabled)
241 return 0;
242
243 return trace_vprintk(ip, fmt, ap);
244}
245EXPORT_SYMBOL_GPL(__ftrace_vprintk);
246
247static const char **find_next(void *v, loff_t *pos)
248{
249 const char **fmt = v;
250 int start_index;
251 int last_index;
252
253 start_index = __stop___trace_bprintk_fmt - __start___trace_bprintk_fmt;
254
255 if (*pos < start_index)
256 return __start___trace_bprintk_fmt + *pos;
257
258 /*
259 * The __tracepoint_str section is treated the same as the
260 * __trace_printk_fmt section. The difference is that the
261 * __trace_printk_fmt section should only be used by trace_printk()
262 * in a debugging environment, as if anything exists in that section
263 * the trace_prink() helper buffers are allocated, which would just
264 * waste space in a production environment.
265 *
266 * The __tracepoint_str sections on the other hand are used by
267 * tracepoints which need to map pointers to their strings to
268 * the ASCII text for userspace.
269 */
270 last_index = start_index;
271 start_index = __stop___tracepoint_str - __start___tracepoint_str;
272
273 if (*pos < last_index + start_index)
274 return __start___tracepoint_str + (*pos - last_index);
275
276 start_index += last_index;
277 return find_next_mod_format(start_index, v, fmt, pos);
278}
279
280static void *
281t_start(struct seq_file *m, loff_t *pos)
282{
283 format_mod_start();
284 return find_next(NULL, pos);
285}
286
287static void *t_next(struct seq_file *m, void * v, loff_t *pos)
288{
289 (*pos)++;
290 return find_next(v, pos);
291}
292
293static int t_show(struct seq_file *m, void *v)
294{
295 const char **fmt = v;
296 const char *str = *fmt;
297 int i;
298
299 if (!*fmt)
300 return 0;
301
302 seq_printf(m, "0x%lx : \"", *(unsigned long *)fmt);
303
304 /*
305 * Tabs and new lines need to be converted.
306 */
307 for (i = 0; str[i]; i++) {
308 switch (str[i]) {
309 case '\n':
310 seq_puts(m, "\\n");
311 break;
312 case '\t':
313 seq_puts(m, "\\t");
314 break;
315 case '\\':
316 seq_putc(m, '\\');
317 break;
318 case '"':
319 seq_puts(m, "\\\"");
320 break;
321 default:
322 seq_putc(m, str[i]);
323 }
324 }
325 seq_puts(m, "\"\n");
326
327 return 0;
328}
329
330static void t_stop(struct seq_file *m, void *p)
331{
332 format_mod_stop();
333}
334
335static const struct seq_operations show_format_seq_ops = {
336 .start = t_start,
337 .next = t_next,
338 .show = t_show,
339 .stop = t_stop,
340};
341
342static int
343ftrace_formats_open(struct inode *inode, struct file *file)
344{
345 return seq_open(file, &show_format_seq_ops);
346}
347
348static const struct file_operations ftrace_formats_fops = {
349 .open = ftrace_formats_open,
350 .read = seq_read,
351 .llseek = seq_lseek,
352 .release = seq_release,
353};
354
355static __init int init_trace_printk_function_export(void)
356{
357 struct dentry *d_tracer;
358
359 d_tracer = tracing_init_dentry();
360 if (IS_ERR(d_tracer))
361 return 0;
362
363 trace_create_file("printk_formats", 0444, d_tracer,
364 NULL, &ftrace_formats_fops);
365
366 return 0;
367}
368
369fs_initcall(init_trace_printk_function_export);
370
371static __init int init_trace_printk(void)
372{
373 return register_module_notifier(&module_trace_bprintk_format_nb);
374}
375
376early_initcall(init_trace_printk);