4 * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
6 #include <linux/kallsyms.h>
7 #include <linux/seq_file.h>
8 #include <linux/spinlock.h>
9 #include <linux/debugfs.h>
10 #include <linux/uaccess.h>
11 #include <linux/module.h>
12 #include <linux/ftrace.h>
13 #include <linux/hash.h>
15 #include <asm/local.h>
18 #ifdef CONFIG_UNLIKELY_TRACER
20 static int unlikely_tracing_enabled __read_mostly;
21 static DEFINE_MUTEX(unlikely_tracing_mutex);
22 static struct trace_array *unlikely_tracer;
25 probe_likely_condition(struct ftrace_likely_data *f, int val, int expect)
27 struct trace_array *tr = unlikely_tracer;
28 struct ring_buffer_event *event;
29 struct trace_unlikely *entry;
30 unsigned long flags, irq_flags;
35 * I would love to save just the ftrace_likely_data pointer, but
36 * this code can also be used by modules. Ugly things can happen
37 * if the module is unloaded, and then we go and read the
38 * pointer. This is slower, but much safer.
44 local_irq_save(flags);
45 cpu = raw_smp_processor_id();
46 if (atomic_inc_return(&tr->data[cpu]->disabled) != 1)
49 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
55 entry = ring_buffer_event_data(event);
56 tracing_generic_entry_update(&entry->ent, flags, pc);
57 entry->ent.type = TRACE_UNLIKELY;
59 /* Strip off the path, only save the file */
60 p = f->file + strlen(f->file);
61 while (p >= f->file && *p != '/')
65 strncpy(entry->func, f->func, TRACE_FUNC_SIZE);
66 strncpy(entry->file, p, TRACE_FILE_SIZE);
67 entry->func[TRACE_FUNC_SIZE] = 0;
68 entry->file[TRACE_FILE_SIZE] = 0;
69 entry->line = f->line;
70 entry->correct = val == expect;
72 ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
75 atomic_dec(&tr->data[cpu]->disabled);
76 local_irq_restore(flags);
80 void trace_likely_condition(struct ftrace_likely_data *f, int val, int expect)
82 if (!unlikely_tracing_enabled)
85 probe_likely_condition(f, val, expect);
88 int enable_unlikely_tracing(struct trace_array *tr)
92 mutex_lock(&unlikely_tracing_mutex);
95 * Must be seen before enabling. The reader is a condition
96 * where we do not need a matching rmb()
99 unlikely_tracing_enabled++;
100 mutex_unlock(&unlikely_tracing_mutex);
105 void disable_unlikely_tracing(void)
107 mutex_lock(&unlikely_tracing_mutex);
109 if (!unlikely_tracing_enabled)
112 unlikely_tracing_enabled--;
115 mutex_unlock(&unlikely_tracing_mutex);
119 void trace_likely_condition(struct ftrace_likely_data *f, int val, int expect)
122 #endif /* CONFIG_UNLIKELY_TRACER */
124 void ftrace_likely_update(struct ftrace_likely_data *f, int val, int expect)
127 * I would love to have a trace point here instead, but the
128 * trace point code is so inundated with unlikely and likely
129 * conditions that the recursive nightmare that exists is too
130 * much to try to get working. At least for now.
132 trace_likely_condition(f, val, expect);
134 /* FIXME: Make this atomic! */
140 EXPORT_SYMBOL(ftrace_likely_update);
142 struct ftrace_pointer {
148 t_next(struct seq_file *m, void *v, loff_t *pos)
150 struct ftrace_pointer *f = m->private;
151 struct ftrace_likely_data *p = v;
160 if ((void *)p >= (void *)f->stop)
166 static void *t_start(struct seq_file *m, loff_t *pos)
171 for (; t && l < *pos; t = t_next(m, t, &l))
177 static void t_stop(struct seq_file *m, void *p)
181 static int t_show(struct seq_file *m, void *v)
183 struct ftrace_likely_data *p = v;
185 unsigned long percent;
187 if (v == (void *)1) {
188 seq_printf(m, " correct incorrect %% "
191 " ------- --------- - "
197 /* Only print the file, not the path */
198 f = p->file + strlen(p->file);
199 while (f >= p->file && *f != '/')
204 percent = p->incorrect * 100;
205 percent /= p->correct + p->incorrect;
207 percent = p->incorrect ? 100 : 0;
209 seq_printf(m, "%8lu %8lu %3lu ", p->correct, p->incorrect, percent);
210 seq_printf(m, "%-30.30s %-20.20s %d\n", p->func, f, p->line);
214 static struct seq_operations tracing_likely_seq_ops = {
221 static int tracing_likely_open(struct inode *inode, struct file *file)
225 ret = seq_open(file, &tracing_likely_seq_ops);
227 struct seq_file *m = file->private_data;
228 m->private = (void *)inode->i_private;
234 static struct file_operations tracing_likely_fops = {
235 .open = tracing_likely_open,
240 extern unsigned long __start_likely_profile[];
241 extern unsigned long __stop_likely_profile[];
242 extern unsigned long __start_unlikely_profile[];
243 extern unsigned long __stop_unlikely_profile[];
245 static struct ftrace_pointer ftrace_likely_pos = {
246 .start = __start_likely_profile,
247 .stop = __stop_likely_profile,
250 static struct ftrace_pointer ftrace_unlikely_pos = {
251 .start = __start_unlikely_profile,
252 .stop = __stop_unlikely_profile,
255 static __init int ftrace_unlikely_init(void)
257 struct dentry *d_tracer;
258 struct dentry *entry;
260 d_tracer = tracing_init_dentry();
262 entry = debugfs_create_file("profile_likely", 0444, d_tracer,
264 &tracing_likely_fops);
266 pr_warning("Could not create debugfs 'profile_likely' entry\n");
268 entry = debugfs_create_file("profile_unlikely", 0444, d_tracer,
269 &ftrace_unlikely_pos,
270 &tracing_likely_fops);
272 pr_warning("Could not create debugfs"
273 " 'profile_unlikely' entry\n");
278 device_initcall(ftrace_unlikely_init);