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