Release 4.15 kernel/trace/trace_printk.c

/*
 * trace binary printk
 *
 * Copyright (C) 2008 Lai Jiangshan <laijs@cn.fujitsu.com>
 *
 */
#include <linux/seq_file.h>
#include <linux/uaccess.h>
#include <linux/kernel.h>
#include <linux/ftrace.h>
#include <linux/string.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/ctype.h>
#include <linux/list.h>
#include <linux/slab.h>

#include "trace.h"

#ifdef CONFIG_MODULES

/*
 * modules trace_printk()'s formats are autosaved in struct trace_bprintk_fmt
 * which are queued on trace_bprintk_fmt_list.
 */
static LIST_HEAD(trace_bprintk_fmt_list);

/* serialize accesses to trace_bprintk_fmt_list */
static DEFINE_MUTEX(btrace_mutex);


struct trace_bprintk_fmt {
	
struct list_head list;
	
const char *fmt;
};



static inline struct trace_bprintk_fmt *lookup_format(const char *fmt)
{
	struct trace_bprintk_fmt *pos;

	if (!fmt)
		return ERR_PTR(-EINVAL);

	list_for_each_entry(pos, &trace_bprintk_fmt_list, list) {
		if (!strcmp(pos->fmt, fmt))
			return pos;
	}
	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lai Jiangshan
47
79.66%
2
66.67%
Steven Rostedt
12
20.34%
1
33.33%
Total
59
100.00%
3
100.00%


static

void hold_module_trace_bprintk_format(const char **start, const char **end)
{
	const char **iter;
	char *fmt;

	/* allocate the trace_printk per cpu buffers */
	if (start != end)
		trace_printk_init_buffers();

	mutex_lock(&btrace_mutex);
	for (iter = start; iter < end; iter++) {
		struct trace_bprintk_fmt *tb_fmt = lookup_format(*iter);
		if (tb_fmt) {
			if (!IS_ERR(tb_fmt))
				*iter = tb_fmt->fmt;
			continue;
		}

		fmt = NULL;
		tb_fmt = kmalloc(sizeof(*tb_fmt), GFP_KERNEL);
		if (tb_fmt) {
			fmt = kmalloc(strlen(*iter) + 1, GFP_KERNEL);
			if (fmt) {
				list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
				strcpy(fmt, *iter);
				tb_fmt->fmt = fmt;
			} else
				kfree(tb_fmt);
		}
		*iter = fmt;

	}
	mutex_unlock(&btrace_mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lai Jiangshan
113
63.48%
2
28.57%
Steven Rostedt
55
30.90%
4
57.14%
Frédéric Weisbecker
10
5.62%
1
14.29%
Total
178
100.00%
7
100.00%



static int module_trace_bprintk_format_notify(struct notifier_block *self,
		unsigned long val, void *data)
{
	struct module *mod = data;
	if (mod->num_trace_bprintk_fmt) {
		const char **start = mod->trace_bprintk_fmt_start;
		const char **end = start + mod->num_trace_bprintk_fmt;

		if (val == MODULE_STATE_COMING)
			hold_module_trace_bprintk_format(start, end);
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lai Jiangshan
72
100.00%
2
100.00%
Total
72
100.00%
2
100.00%

/*
 * The debugfs/tracing/printk_formats file maps the addresses with
 * the ASCII formats that are used in the bprintk events in the
 * buffer. For userspace tools to be able to decode the events from
 * the buffer, they need to be able to map the address with the format.
 *
 * The addresses of the bprintk formats are in their own section
 * __trace_printk_fmt. But for modules we copy them into a link list.
 * The code to print the formats and their addresses passes around the
 * address of the fmt string. If the fmt address passed into the seq
 * functions is within the kernel core __trace_printk_fmt section, then
 * it simply uses the next pointer in the list.
 *
 * When the fmt pointer is outside the kernel core __trace_printk_fmt
 * section, then we need to read the link list pointers. The trick is
 * we pass the address of the string to the seq function just like
 * we do for the kernel core formats. To get back the structure that
 * holds the format, we simply use containerof() and then go to the
 * next format in the list.
 */

static const char **

find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
{
	struct trace_bprintk_fmt *mod_fmt;

	if (list_empty(&trace_bprintk_fmt_list))
		return NULL;

	/*
         * v will point to the address of the fmt record from t_next
         * v will be NULL from t_start.
         * If this is the first pointer or called from start
         * then we need to walk the list.
         */
	if (!v || start_index == *pos) {
		struct trace_bprintk_fmt *p;

		/* search the module list */
		list_for_each_entry(p, &trace_bprintk_fmt_list, list) {
			if (start_index == *pos)
				return &p->fmt;
			start_index++;
		}
		/* pos > index */
		return NULL;
	}

	/*
         * v points to the address of the fmt field in the mod list
         * structure that holds the module print format.
         */
	mod_fmt = container_of(v, typeof(*mod_fmt), fmt);
	if (mod_fmt->list.next == &trace_bprintk_fmt_list)
		return NULL;

	mod_fmt = container_of(mod_fmt->list.next, typeof(*mod_fmt), list);

	return &mod_fmt->fmt;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
146
100.00%
1
100.00%
Total
146
100.00%
1
100.00%



static void format_mod_start(void)
{
	mutex_lock(&btrace_mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
14
100.00%
1
100.00%
Total
14
100.00%
1
100.00%



static void format_mod_stop(void)
{
	mutex_unlock(&btrace_mutex);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
14
100.00%
1
100.00%
Total
14
100.00%
1
100.00%

#else /* !CONFIG_MODULES */

__init static int

module_trace_bprintk_format_notify(struct notifier_block *self,
		unsigned long val, void *data)
{
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Lai Jiangshan
23
100.00%
1
100.00%
Total
23
100.00%
1
100.00%


static inline const char **

find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
{
	return NULL;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%



static inline void format_mod_start(void) { }
Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
8
100.00%
1
100.00%
Total
8
100.00%
1
100.00%



static inline void format_mod_stop(void) { }
Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
8
100.00%
1
100.00%
Total
8
100.00%
1
100.00%

#endif /* CONFIG_MODULES */


static bool __read_mostly trace_printk_enabled = true;



void trace_printk_control(bool enabled)
{
	trace_printk_enabled = enabled;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
12
100.00%
1
100.00%
Total
12
100.00%
1
100.00%

__initdata_or_module static

struct notifier_block module_trace_bprintk_format_nb = {
	.notifier_call = module_trace_bprintk_format_notify,
};



int __trace_bprintk(unsigned long ip, const char *fmt, ...)
 {
	int ret;
	va_list ap;

	if (unlikely(!fmt))
		return 0;

	if (!trace_printk_enabled)
		return 0;

	va_start(ap, fmt);
	ret = trace_vbprintk(ip, fmt, ap);
	va_end(ap);
	return ret;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Frédéric Weisbecker
56
83.58%
2
50.00%
Lai Jiangshan
10
14.93%
1
25.00%
Steven Rostedt
1
1.49%
1
25.00%
Total
67
100.00%
4
100.00%


EXPORT_SYMBOL_GPL(__trace_bprintk);



int __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap)
 {
	if (unlikely(!fmt))
		return 0;

	if (!trace_printk_enabled)
		return 0;

	return trace_vbprintk(ip, fmt, ap);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Frédéric Weisbecker
35
76.09%
2
50.00%
Lai Jiangshan
10
21.74%
1
25.00%
Steven Rostedt
1
2.17%
1
25.00%
Total
46
100.00%
4
100.00%


EXPORT_SYMBOL_GPL(__ftrace_vbprintk);



int __trace_printk(unsigned long ip, const char *fmt, ...)
{
	int ret;
	va_list ap;

	if (!trace_printk_enabled)
		return 0;

	va_start(ap, fmt);
	ret = trace_vprintk(ip, fmt, ap);
	va_end(ap);
	return ret;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Frédéric Weisbecker
55
98.21%
1
50.00%
Steven Rostedt
1
1.79%
1
50.00%
Total
56
100.00%
2
100.00%


EXPORT_SYMBOL_GPL(__trace_printk);



int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
{
	if (!trace_printk_enabled)
		return 0;

	return trace_vprintk(ip, fmt, ap);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Frédéric Weisbecker
33
94.29%
2
50.00%
Steven Rostedt
1
2.86%
1
25.00%
Lai Jiangshan
1
2.86%
1
25.00%
Total
35
100.00%
4
100.00%


EXPORT_SYMBOL_GPL(__ftrace_vprintk);



static const char **find_next(void *v, loff_t *pos)
{
	const char **fmt = v;
	int start_index;
	int last_index;

	start_index = __stop___trace_bprintk_fmt - __start___trace_bprintk_fmt;

	if (*pos < start_index)
		return __start___trace_bprintk_fmt + *pos;

	/*
         * The __tracepoint_str section is treated the same as the
         * __trace_printk_fmt section. The difference is that the
         * __trace_printk_fmt section should only be used by trace_printk()
         * in a debugging environment, as if anything exists in that section
         * the trace_prink() helper buffers are allocated, which would just
         * waste space in a production environment.
         *
         * The __tracepoint_str sections on the other hand are used by
         * tracepoints which need to map pointers to their strings to
         * the ASCII text for userspace.
         */
	last_index = start_index;
	start_index = __stop___tracepoint_str - __start___tracepoint_str;

	if (*pos < last_index + start_index)
		return __start___tracepoint_str + (*pos - last_index);

	start_index += last_index;
	return find_next_mod_format(start_index, v, fmt, pos);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
92
95.83%
4
80.00%
Qiu Peiyang
4
4.17%
1
20.00%
Total
96
100.00%
5
100.00%


static void *

t_start(struct seq_file *m, loff_t *pos)
{
	format_mod_start();
	return find_next(NULL, pos);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
27
100.00%
2
100.00%
Total
27
100.00%
2
100.00%



static void *t_next(struct seq_file *m, void * v, loff_t *pos)
{
	(*pos)++;
	return find_next(v, pos);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
23
67.65%
2
66.67%
Li Zefan
11
32.35%
1
33.33%
Total
34
100.00%
3
100.00%



static int t_show(struct seq_file *m, void *v)
{
	const char **fmt = v;
	const char *str = *fmt;
	int i;

	if (!*fmt)
		return 0;

	seq_printf(m, "0x%lx : \"", *(unsigned long *)fmt);

	/*
         * Tabs and new lines need to be converted.
         */
	for (i = 0; str[i]; i++) {
		switch (str[i]) {
		case '\n':
			seq_puts(m, "\\n");
			break;
		case '\t':
			seq_puts(m, "\\t");
			break;
		case '\\':
			seq_putc(m, '\\');
			break;
		case '"':
			seq_puts(m, "\\\"");
			break;
		default:
			seq_putc(m, str[i]);
		}
	}
	seq_puts(m, "\"\n");

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
147
98.66%
3
75.00%
Rasmus Villemoes
2
1.34%
1
25.00%
Total
149
100.00%
4
100.00%



static void t_stop(struct seq_file *m, void *p)
{
	format_mod_stop();
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
18
100.00%
2
100.00%
Total
18
100.00%
2
100.00%


static const struct seq_operations show_format_seq_ops = {
	.start = t_start,
	.next = t_next,
	.show = t_show,
	.stop = t_stop,
};


static int

ftrace_formats_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &show_format_seq_ops);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
24
96.00%
1
50.00%
Li Zefan
1
4.00%
1
50.00%
Total
25
100.00%
2
100.00%


static const struct file_operations ftrace_formats_fops = {
	.open = ftrace_formats_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release,
};



static __init int init_trace_printk_function_export(void)
{
	struct dentry *d_tracer;

	d_tracer = tracing_init_dentry();
	if (IS_ERR(d_tracer))
		return 0;

	trace_create_file("printk_formats", 0444, d_tracer,
				    NULL, &ftrace_formats_fops);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
45
97.83%
2
66.67%
Frédéric Weisbecker
1
2.17%
1
33.33%
Total
46
100.00%
3
100.00%


fs_initcall(init_trace_printk_function_export);



static __init int init_trace_printk(void)
{
	return register_module_notifier(&module_trace_bprintk_format_nb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Lai Jiangshan
14
87.50%
2
66.67%
Frédéric Weisbecker
2
12.50%
1
33.33%
Total
16
100.00%
3
100.00%


early_initcall(init_trace_printk);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Steven Rostedt
762
56.15%
12
60.00%
Lai Jiangshan
360
26.53%
2
10.00%
Frédéric Weisbecker
217
15.99%
3
15.00%
Li Zefan
12
0.88%
1
5.00%
Qiu Peiyang
4
0.29%
1
5.00%
Rasmus Villemoes
2
0.15%
1
5.00%
Total
1357
100.00%
20
100.00%
Directory: kernel/trace

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.