687699d365aeb328eddaf619f04ccf10b1cc6b6c
[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/marker.h>
15 #include <linux/mutex.h>
16 #include <linux/ctype.h>
17 #include <linux/list.h>
18 #include <linux/slab.h>
19 #include <linux/fs.h>
20
21 #include "trace.h"
22
23 #ifdef CONFIG_MODULES
24
25 /*
26  * modules trace_printk()'s formats are autosaved in struct trace_bprintk_fmt
27  * which are queued on trace_bprintk_fmt_list.
28  */
29 static LIST_HEAD(trace_bprintk_fmt_list);
30
31 /* serialize accesses to trace_bprintk_fmt_list */
32 static DEFINE_MUTEX(btrace_mutex);
33
34 struct trace_bprintk_fmt {
35         struct list_head list;
36         char fmt[0];
37 };
38
39 static inline struct trace_bprintk_fmt *lookup_format(const char *fmt)
40 {
41         struct trace_bprintk_fmt *pos;
42         list_for_each_entry(pos, &trace_bprintk_fmt_list, list) {
43                 if (!strcmp(pos->fmt, fmt))
44                         return pos;
45         }
46         return NULL;
47 }
48
49 static
50 void hold_module_trace_bprintk_format(const char **start, const char **end)
51 {
52         const char **iter;
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(offsetof(struct trace_bprintk_fmt, fmt)
63                                 + strlen(*iter) + 1, GFP_KERNEL);
64                 if (tb_fmt) {
65                         list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
66                         strcpy(tb_fmt->fmt, *iter);
67                         *iter = tb_fmt->fmt;
68                 } else
69                         *iter = NULL;
70         }
71         mutex_unlock(&btrace_mutex);
72 }
73
74 static int module_trace_bprintk_format_notify(struct notifier_block *self,
75                 unsigned long val, void *data)
76 {
77         struct module *mod = data;
78         if (mod->num_trace_bprintk_fmt) {
79                 const char **start = mod->trace_bprintk_fmt_start;
80                 const char **end = start + mod->num_trace_bprintk_fmt;
81
82                 if (val == MODULE_STATE_COMING)
83                         hold_module_trace_bprintk_format(start, end);
84         }
85         return 0;
86 }
87
88 #else /* !CONFIG_MODULES */
89 __init static int
90 module_trace_bprintk_format_notify(struct notifier_block *self,
91                 unsigned long val, void *data)
92 {
93         return 0;
94 }
95 #endif /* CONFIG_MODULES */
96
97
98 __initdata_or_module static
99 struct notifier_block module_trace_bprintk_format_nb = {
100         .notifier_call = module_trace_bprintk_format_notify,
101 };
102
103 int __trace_bprintk(unsigned long ip, const char *fmt, ...)
104  {
105         int ret;
106         va_list ap;
107
108         if (unlikely(!fmt))
109                 return 0;
110
111         if (!(trace_flags & TRACE_ITER_PRINTK))
112                 return 0;
113
114         va_start(ap, fmt);
115         ret = trace_vbprintk(ip, fmt, ap);
116         va_end(ap);
117         return ret;
118 }
119 EXPORT_SYMBOL_GPL(__trace_bprintk);
120
121 int __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap)
122  {
123         if (unlikely(!fmt))
124                 return 0;
125
126         if (!(trace_flags & TRACE_ITER_PRINTK))
127                 return 0;
128
129         return trace_vbprintk(ip, fmt, ap);
130 }
131 EXPORT_SYMBOL_GPL(__ftrace_vbprintk);
132
133 int __trace_printk(unsigned long ip, const char *fmt, ...)
134 {
135         int ret;
136         va_list ap;
137
138         if (!(trace_flags & TRACE_ITER_PRINTK))
139                 return 0;
140
141         va_start(ap, fmt);
142         ret = trace_vprintk(ip, fmt, ap);
143         va_end(ap);
144         return ret;
145 }
146 EXPORT_SYMBOL_GPL(__trace_printk);
147
148 int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
149 {
150         if (!(trace_flags & TRACE_ITER_PRINTK))
151                 return 0;
152
153         return trace_vprintk(ip, fmt, ap);
154 }
155 EXPORT_SYMBOL_GPL(__ftrace_vprintk);
156
157 static void *
158 t_start(struct seq_file *m, loff_t *pos)
159 {
160         const char **fmt = __start___trace_bprintk_fmt + *pos;
161
162         if ((unsigned long)fmt >= (unsigned long)__stop___trace_bprintk_fmt)
163                 return NULL;
164         return fmt;
165 }
166
167 static void *t_next(struct seq_file *m, void * v, loff_t *pos)
168 {
169         (*pos)++;
170         return t_start(m, pos);
171 }
172
173 static int t_show(struct seq_file *m, void *v)
174 {
175         const char **fmt = v;
176         const char *str = *fmt;
177         int i;
178
179         seq_printf(m, "0x%lx : \"", *(unsigned long *)fmt);
180
181         /*
182          * Tabs and new lines need to be converted.
183          */
184         for (i = 0; str[i]; i++) {
185                 switch (str[i]) {
186                 case '\n':
187                         seq_puts(m, "\\n");
188                         break;
189                 case '\t':
190                         seq_puts(m, "\\t");
191                         break;
192                 case '\\':
193                         seq_puts(m, "\\");
194                         break;
195                 case '"':
196                         seq_puts(m, "\\\"");
197                         break;
198                 default:
199                         seq_putc(m, str[i]);
200                 }
201         }
202         seq_puts(m, "\"\n");
203
204         return 0;
205 }
206
207 static void t_stop(struct seq_file *m, void *p)
208 {
209 }
210
211 static const struct seq_operations show_format_seq_ops = {
212         .start = t_start,
213         .next = t_next,
214         .show = t_show,
215         .stop = t_stop,
216 };
217
218 static int
219 ftrace_formats_open(struct inode *inode, struct file *file)
220 {
221         return seq_open(file, &show_format_seq_ops);
222 }
223
224 static const struct file_operations ftrace_formats_fops = {
225         .open = ftrace_formats_open,
226         .read = seq_read,
227         .llseek = seq_lseek,
228         .release = seq_release,
229 };
230
231 static __init int init_trace_printk_function_export(void)
232 {
233         struct dentry *d_tracer;
234
235         d_tracer = tracing_init_dentry();
236         if (!d_tracer)
237                 return 0;
238
239         trace_create_file("printk_formats", 0444, d_tracer,
240                                     NULL, &ftrace_formats_fops);
241
242         return 0;
243 }
244
245 fs_initcall(init_trace_printk_function_export);
246
247 static __init int init_trace_printk(void)
248 {
249         return register_module_notifier(&module_trace_bprintk_format_nb);
250 }
251
252 early_initcall(init_trace_printk);