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