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/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 */
 28static LIST_HEAD(trace_bprintk_fmt_list);
 29
 30/* serialize accesses to trace_bprintk_fmt_list */
 31static DEFINE_MUTEX(btrace_mutex);
 32
 33struct trace_bprintk_fmt {
 34	struct list_head list;
 35	const char *fmt;
 36};
 37
 38static 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
 48static
 49void 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
 78static 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 */
112static const char **
113find_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
152static void format_mod_start(void)
153{
154	mutex_lock(&btrace_mutex);
155}
156
157static void format_mod_stop(void)
158{
159	mutex_unlock(&btrace_mutex);
160}
161
162#else /* !CONFIG_MODULES */
163__init static int
164module_trace_bprintk_format_notify(struct notifier_block *self,
165		unsigned long val, void *data)
166{
167	return 0;
168}
169static inline const char **
170find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
171{
172	return NULL;
173}
174static inline void format_mod_start(void) { }
175static inline void format_mod_stop(void) { }
176#endif /* CONFIG_MODULES */
177
 
 
 
 
 
 
178
179__initdata_or_module static
180struct notifier_block module_trace_bprintk_format_nb = {
181	.notifier_call = module_trace_bprintk_format_notify,
182};
183
184int __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}
200EXPORT_SYMBOL_GPL(__trace_bprintk);
201
202int __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}
212EXPORT_SYMBOL_GPL(__ftrace_vbprintk);
213
214int __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}
227EXPORT_SYMBOL_GPL(__trace_printk);
228
229int __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}
236EXPORT_SYMBOL_GPL(__ftrace_vprintk);
237
238static 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
251static void *
252t_start(struct seq_file *m, loff_t *pos)
253{
254	format_mod_start();
255	return find_next(NULL, pos);
256}
257
258static void *t_next(struct seq_file *m, void * v, loff_t *pos)
259{
260	(*pos)++;
261	return find_next(v, pos);
262}
263
264static 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
298static void t_stop(struct seq_file *m, void *p)
299{
300	format_mod_stop();
301}
302
303static 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
310static int
311ftrace_formats_open(struct inode *inode, struct file *file)
312{
313	return seq_open(file, &show_format_seq_ops);
314}
315
316static 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
323static __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
337fs_initcall(init_trace_printk_function_export);
338
339static __init int init_trace_printk(void)
340{
341	return register_module_notifier(&module_trace_bprintk_format_nb);
342}
343
344early_initcall(init_trace_printk);