1
2
3
4
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
24
25
26static LIST_HEAD(trace_bprintk_fmt_list);
27
28
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
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
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
125
126
127
128
129 if (!v || start_index == *pos) {
130 struct trace_bprintk_fmt *p;
131
132
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
139 return NULL;
140 }
141
142
143
144
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
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
180
181
182__initdata_or_module static
183struct notifier_block module_trace_bprintk_format_nb = {
184 .notifier_call = module_trace_bprintk_format_notify,
185};
186
187int __trace_bprintk(unsigned long ip, const char *fmt, ...)
188 {
189 int ret;
190 va_list ap;
191
192 if (unlikely(!fmt))
193 return 0;
194
195 if (!(trace_flags & TRACE_ITER_PRINTK))
196 return 0;
197
198 va_start(ap, fmt);
199 ret = trace_vbprintk(ip, fmt, ap);
200 va_end(ap);
201 return ret;
202}
203EXPORT_SYMBOL_GPL(__trace_bprintk);
204
205int __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap)
206 {
207 if (unlikely(!fmt))
208 return 0;
209
210 if (!(trace_flags & TRACE_ITER_PRINTK))
211 return 0;
212
213 return trace_vbprintk(ip, fmt, ap);
214}
215EXPORT_SYMBOL_GPL(__ftrace_vbprintk);
216
217int __trace_printk(unsigned long ip, const char *fmt, ...)
218{
219 int ret;
220 va_list ap;
221
222 if (!(trace_flags & TRACE_ITER_PRINTK))
223 return 0;
224
225 va_start(ap, fmt);
226 ret = trace_vprintk(ip, fmt, ap);
227 va_end(ap);
228 return ret;
229}
230EXPORT_SYMBOL_GPL(__trace_printk);
231
232int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
233{
234 if (!(trace_flags & TRACE_ITER_PRINTK))
235 return 0;
236
237 return trace_vprintk(ip, fmt, ap);
238}
239EXPORT_SYMBOL_GPL(__ftrace_vprintk);
240
241static const char **find_next(void *v, loff_t *pos)
242{
243 const char **fmt = v;
244 int start_index;
245 int last_index;
246
247 start_index = __stop___trace_bprintk_fmt - __start___trace_bprintk_fmt;
248
249 if (*pos < start_index)
250 return __start___trace_bprintk_fmt + *pos;
251
252
253
254
255
256
257
258
259
260
261
262
263
264 last_index = start_index;
265 start_index = __stop___tracepoint_str - __start___tracepoint_str;
266
267 if (*pos < last_index + start_index)
268 return __start___tracepoint_str + (*pos - last_index);
269
270 return find_next_mod_format(start_index, v, fmt, pos);
271}
272
273static void *
274t_start(struct seq_file *m, loff_t *pos)
275{
276 format_mod_start();
277 return find_next(NULL, pos);
278}
279
280static void *t_next(struct seq_file *m, void * v, loff_t *pos)
281{
282 (*pos)++;
283 return find_next(v, pos);
284}
285
286static int t_show(struct seq_file *m, void *v)
287{
288 const char **fmt = v;
289 const char *str = *fmt;
290 int i;
291
292 seq_printf(m, "0x%lx : \"", *(unsigned long *)fmt);
293
294
295
296
297 for (i = 0; str[i]; i++) {
298 switch (str[i]) {
299 case '\n':
300 seq_puts(m, "\\n");
301 break;
302 case '\t':
303 seq_puts(m, "\\t");
304 break;
305 case '\\':
306 seq_putc(m, '\\');
307 break;
308 case '"':
309 seq_puts(m, "\\\"");
310 break;
311 default:
312 seq_putc(m, str[i]);
313 }
314 }
315 seq_puts(m, "\"\n");
316
317 return 0;
318}
319
320static void t_stop(struct seq_file *m, void *p)
321{
322 format_mod_stop();
323}
324
325static const struct seq_operations show_format_seq_ops = {
326 .start = t_start,
327 .next = t_next,
328 .show = t_show,
329 .stop = t_stop,
330};
331
332static int
333ftrace_formats_open(struct inode *inode, struct file *file)
334{
335 return seq_open(file, &show_format_seq_ops);
336}
337
338static const struct file_operations ftrace_formats_fops = {
339 .open = ftrace_formats_open,
340 .read = seq_read,
341 .llseek = seq_lseek,
342 .release = seq_release,
343};
344
345static __init int init_trace_printk_function_export(void)
346{
347 struct dentry *d_tracer;
348
349 d_tracer = tracing_init_dentry();
350 if (IS_ERR(d_tracer))
351 return 0;
352
353 trace_create_file("printk_formats", 0444, d_tracer,
354 NULL, &ftrace_formats_fops);
355
356 return 0;
357}
358
359fs_initcall(init_trace_printk_function_export);
360
361static __init int init_trace_printk(void)
362{
363 return register_module_notifier(&module_trace_bprintk_format_nb);
364}
365
366early_initcall(init_trace_printk);
367