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