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
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	 * The __tracepoint_str section is treated the same as the
254	 * __trace_printk_fmt section. The difference is that the
255	 * __trace_printk_fmt section should only be used by trace_printk()
256	 * in a debugging environment, as if anything exists in that section
257	 * the trace_prink() helper buffers are allocated, which would just
258	 * waste space in a production environment.
259	 *
260	 * The __tracepoint_str sections on the other hand are used by
261	 * tracepoints which need to map pointers to their strings to
262	 * the ASCII text for userspace.
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	if (!*fmt)
293		return 0;
294
295	seq_printf(m, "0x%lx : \"", *(unsigned long *)fmt);
296
297	/*
298	 * Tabs and new lines need to be converted.
299	 */
300	for (i = 0; str[i]; i++) {
301		switch (str[i]) {
302		case '\n':
303			seq_puts(m, "\\n");
304			break;
305		case '\t':
306			seq_puts(m, "\\t");
307			break;
308		case '\\':
309			seq_putc(m, '\\');
310			break;
311		case '"':
312			seq_puts(m, "\\\"");
313			break;
314		default:
315			seq_putc(m, str[i]);
316		}
317	}
318	seq_puts(m, "\"\n");
319
320	return 0;
321}
322
323static void t_stop(struct seq_file *m, void *p)
324{
325	format_mod_stop();
326}
327
328static const struct seq_operations show_format_seq_ops = {
329	.start = t_start,
330	.next = t_next,
331	.show = t_show,
332	.stop = t_stop,
333};
334
335static int
336ftrace_formats_open(struct inode *inode, struct file *file)
337{
338	return seq_open(file, &show_format_seq_ops);
339}
340
341static const struct file_operations ftrace_formats_fops = {
342	.open = ftrace_formats_open,
343	.read = seq_read,
344	.llseek = seq_lseek,
345	.release = seq_release,
346};
347
348static __init int init_trace_printk_function_export(void)
349{
350	struct dentry *d_tracer;
351
352	d_tracer = tracing_init_dentry();
353	if (IS_ERR(d_tracer))
354		return 0;
355
356	trace_create_file("printk_formats", 0444, d_tracer,
357				    NULL, &ftrace_formats_fops);
358
359	return 0;
360}
361
362fs_initcall(init_trace_printk_function_export);
363
364static __init int init_trace_printk(void)
365{
366	return register_module_notifier(&module_trace_bprintk_format_nb);
367}
368
369early_initcall(init_trace_printk);
370