4 * Copyright (C) 2008 Lai Jiangshan <laijs@cn.fujitsu.com>
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>
25 * modules trace_printk()'s formats are autosaved in struct trace_bprintk_fmt
26 * which are queued on trace_bprintk_fmt_list.
28 static LIST_HEAD(trace_bprintk_fmt_list);
30 /* serialize accesses to trace_bprintk_fmt_list */
31 static DEFINE_MUTEX(btrace_mutex);
33 struct trace_bprintk_fmt {
34 struct list_head list;
38 static inline struct trace_bprintk_fmt *lookup_format(const char *fmt)
40 struct trace_bprintk_fmt *pos;
41 list_for_each_entry(pos, &trace_bprintk_fmt_list, list) {
42 if (!strcmp(pos->fmt, fmt))
49 void hold_module_trace_bprintk_format(const char **start, const char **end)
54 mutex_lock(&btrace_mutex);
55 for (iter = start; iter < end; iter++) {
56 struct trace_bprintk_fmt *tb_fmt = lookup_format(*iter);
63 tb_fmt = kmalloc(sizeof(*tb_fmt), GFP_KERNEL);
65 fmt = kmalloc(strlen(*iter) + 1, GFP_KERNEL);
67 list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
76 mutex_unlock(&btrace_mutex);
79 static int module_trace_bprintk_format_notify(struct notifier_block *self,
80 unsigned long val, void *data)
82 struct module *mod = data;
83 if (mod->num_trace_bprintk_fmt) {
84 const char **start = mod->trace_bprintk_fmt_start;
85 const char **end = start + mod->num_trace_bprintk_fmt;
87 if (val == MODULE_STATE_COMING)
88 hold_module_trace_bprintk_format(start, end);
94 * The debugfs/tracing/printk_formats file maps the addresses with
95 * the ASCII formats that are used in the bprintk events in the
96 * buffer. For userspace tools to be able to decode the events from
97 * the buffer, they need to be able to map the address with the format.
99 * The addresses of the bprintk formats are in their own section
100 * __trace_printk_fmt. But for modules we copy them into a link list.
101 * The code to print the formats and their addresses passes around the
102 * address of the fmt string. If the fmt address passed into the seq
103 * functions is within the kernel core __trace_printk_fmt section, then
104 * it simply uses the next pointer in the list.
106 * When the fmt pointer is outside the kernel core __trace_printk_fmt
107 * section, then we need to read the link list pointers. The trick is
108 * we pass the address of the string to the seq function just like
109 * we do for the kernel core formats. To get back the structure that
110 * holds the format, we simply use containerof() and then go to the
111 * next format in the list.
114 find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
116 struct trace_bprintk_fmt *mod_fmt;
118 if (list_empty(&trace_bprintk_fmt_list))
122 * v will point to the address of the fmt record from t_next
123 * v will be NULL from t_start.
124 * If this is the first pointer or called from start
125 * then we need to walk the list.
127 if (!v || start_index == *pos) {
128 struct trace_bprintk_fmt *p;
130 /* search the module list */
131 list_for_each_entry(p, &trace_bprintk_fmt_list, list) {
132 if (start_index == *pos)
141 * v points to the address of the fmt field in the mod list
142 * structure that holds the module print format.
144 mod_fmt = container_of(v, typeof(*mod_fmt), fmt);
145 if (mod_fmt->list.next == &trace_bprintk_fmt_list)
148 mod_fmt = container_of(mod_fmt->list.next, typeof(*mod_fmt), list);
150 return &mod_fmt->fmt;
153 static void format_mod_start(void)
155 mutex_lock(&btrace_mutex);
158 static void format_mod_stop(void)
160 mutex_unlock(&btrace_mutex);
163 #else /* !CONFIG_MODULES */
165 module_trace_bprintk_format_notify(struct notifier_block *self,
166 unsigned long val, void *data)
170 static inline const char **
171 find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
175 static inline void format_mod_start(void) { }
176 static inline void format_mod_stop(void) { }
177 #endif /* CONFIG_MODULES */
180 __initdata_or_module static
181 struct notifier_block module_trace_bprintk_format_nb = {
182 .notifier_call = module_trace_bprintk_format_notify,
185 int __trace_bprintk(unsigned long ip, const char *fmt, ...)
193 if (!(trace_flags & TRACE_ITER_PRINTK))
197 ret = trace_vbprintk(ip, fmt, ap);
201 EXPORT_SYMBOL_GPL(__trace_bprintk);
203 int __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap)
208 if (!(trace_flags & TRACE_ITER_PRINTK))
211 return trace_vbprintk(ip, fmt, ap);
213 EXPORT_SYMBOL_GPL(__ftrace_vbprintk);
215 int __trace_printk(unsigned long ip, const char *fmt, ...)
220 if (!(trace_flags & TRACE_ITER_PRINTK))
224 ret = trace_vprintk(ip, fmt, ap);
228 EXPORT_SYMBOL_GPL(__trace_printk);
230 int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
232 if (!(trace_flags & TRACE_ITER_PRINTK))
235 return trace_vprintk(ip, fmt, ap);
237 EXPORT_SYMBOL_GPL(__ftrace_vprintk);
239 static const char **find_next(void *v, loff_t *pos)
241 const char **fmt = v;
244 start_index = __stop___trace_bprintk_fmt - __start___trace_bprintk_fmt;
246 if (*pos < start_index)
247 return __start___trace_bprintk_fmt + *pos;
249 return find_next_mod_format(start_index, v, fmt, pos);
253 t_start(struct seq_file *m, loff_t *pos)
256 return find_next(NULL, pos);
259 static void *t_next(struct seq_file *m, void * v, loff_t *pos)
262 return find_next(v, pos);
265 static int t_show(struct seq_file *m, void *v)
267 const char **fmt = v;
268 const char *str = *fmt;
271 seq_printf(m, "0x%lx : \"", *(unsigned long *)fmt);
274 * Tabs and new lines need to be converted.
276 for (i = 0; str[i]; i++) {
299 static void t_stop(struct seq_file *m, void *p)
304 static const struct seq_operations show_format_seq_ops = {
312 ftrace_formats_open(struct inode *inode, struct file *file)
314 return seq_open(file, &show_format_seq_ops);
317 static const struct file_operations ftrace_formats_fops = {
318 .open = ftrace_formats_open,
321 .release = seq_release,
324 static __init int init_trace_printk_function_export(void)
326 struct dentry *d_tracer;
328 d_tracer = tracing_init_dentry();
332 trace_create_file("printk_formats", 0444, d_tracer,
333 NULL, &ftrace_formats_fops);
338 fs_initcall(init_trace_printk_function_export);
340 static __init int init_trace_printk(void)
342 return register_module_notifier(&module_trace_bprintk_format_nb);
345 early_initcall(init_trace_printk);