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/irqflags.h>
10 #include <linux/debugfs.h>
11 #include <linux/uaccess.h>
12 #include <linux/module.h>
13 #include <linux/ftrace.h>
14 #include <linux/hash.h>
16 #include <asm/local.h>
19 #include "trace_stat.h"
20 #include "trace_output.h"
22 #ifdef CONFIG_BRANCH_TRACER
24 static struct tracer branch_trace;
25 static int branch_tracing_enabled __read_mostly;
26 static DEFINE_MUTEX(branch_tracing_mutex);
28 static struct trace_array *branch_tracer;
31 probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
33 struct trace_array *tr = branch_tracer;
34 struct ring_buffer_event *event;
35 struct trace_branch *entry;
41 * I would love to save just the ftrace_likely_data pointer, but
42 * this code can also be used by modules. Ugly things can happen
43 * if the module is unloaded, and then we go and read the
44 * pointer. This is slower, but much safer.
50 local_irq_save(flags);
51 cpu = raw_smp_processor_id();
52 if (atomic_inc_return(&tr->data[cpu]->disabled) != 1)
55 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
60 entry = ring_buffer_event_data(event);
61 tracing_generic_entry_update(&entry->ent, flags, pc);
62 entry->ent.type = TRACE_BRANCH;
64 /* Strip off the path, only save the file */
65 p = f->file + strlen(f->file);
66 while (p >= f->file && *p != '/')
70 strncpy(entry->func, f->func, TRACE_FUNC_SIZE);
71 strncpy(entry->file, p, TRACE_FILE_SIZE);
72 entry->func[TRACE_FUNC_SIZE] = 0;
73 entry->file[TRACE_FILE_SIZE] = 0;
74 entry->line = f->line;
75 entry->correct = val == expect;
77 ring_buffer_unlock_commit(tr->buffer, event);
80 atomic_dec(&tr->data[cpu]->disabled);
81 local_irq_restore(flags);
85 void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
87 if (!branch_tracing_enabled)
90 probe_likely_condition(f, val, expect);
93 int enable_branch_tracing(struct trace_array *tr)
97 mutex_lock(&branch_tracing_mutex);
100 * Must be seen before enabling. The reader is a condition
101 * where we do not need a matching rmb()
104 branch_tracing_enabled++;
105 mutex_unlock(&branch_tracing_mutex);
110 void disable_branch_tracing(void)
112 mutex_lock(&branch_tracing_mutex);
114 if (!branch_tracing_enabled)
117 branch_tracing_enabled--;
120 mutex_unlock(&branch_tracing_mutex);
123 static void start_branch_trace(struct trace_array *tr)
125 enable_branch_tracing(tr);
128 static void stop_branch_trace(struct trace_array *tr)
130 disable_branch_tracing();
133 static int branch_trace_init(struct trace_array *tr)
135 tracing_reset_online_cpus(tr);
136 start_branch_trace(tr);
140 static void branch_trace_reset(struct trace_array *tr)
142 stop_branch_trace(tr);
145 static enum print_line_t trace_branch_print(struct trace_iterator *iter,
148 struct trace_branch *field;
150 trace_assign_type(field, iter->ent);
152 if (trace_seq_printf(&iter->seq, "[%s] %s:%s:%d\n",
153 field->correct ? " ok " : " MISS ",
157 return TRACE_TYPE_PARTIAL_LINE;
159 return TRACE_TYPE_HANDLED;
163 static struct trace_event trace_branch_event = {
164 .type = TRACE_BRANCH,
165 .trace = trace_branch_print,
166 .latency_trace = trace_branch_print,
169 static struct tracer branch_trace __read_mostly =
172 .init = branch_trace_init,
173 .reset = branch_trace_reset,
174 #ifdef CONFIG_FTRACE_SELFTEST
175 .selftest = trace_selftest_startup_branch,
176 #endif /* CONFIG_FTRACE_SELFTEST */
179 __init static int init_branch_tracer(void)
183 ret = register_ftrace_event(&trace_branch_event);
185 printk(KERN_WARNING "Warning: could not register "
189 return register_tracer(&branch_trace);
191 device_initcall(init_branch_tracer);
195 void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
198 #endif /* CONFIG_BRANCH_TRACER */
200 void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect)
203 * I would love to have a trace point here instead, but the
204 * trace point code is so inundated with unlikely and likely
205 * conditions that the recursive nightmare that exists is too
206 * much to try to get working. At least for now.
208 trace_likely_condition(f, val, expect);
210 /* FIXME: Make this atomic! */
216 EXPORT_SYMBOL(ftrace_likely_update);
218 extern unsigned long __start_annotated_branch_profile[];
219 extern unsigned long __stop_annotated_branch_profile[];
221 static int annotated_branch_stat_headers(struct seq_file *m)
223 seq_printf(m, " correct incorrect %% ");
224 seq_printf(m, " Function "
226 " ------- --------- - "
232 static inline long get_incorrect_percent(struct ftrace_branch_data *p)
237 percent = p->incorrect * 100;
238 percent /= p->correct + p->incorrect;
240 percent = p->incorrect ? 100 : -1;
245 static int branch_stat_show(struct seq_file *m, void *v)
247 struct ftrace_branch_data *p = v;
251 /* Only print the file, not the path */
252 f = p->file + strlen(p->file);
253 while (f >= p->file && *f != '/')
258 * The miss is overlayed on correct, and hit on incorrect.
260 percent = get_incorrect_percent(p);
262 seq_printf(m, "%8lu %8lu ", p->correct, p->incorrect);
264 seq_printf(m, " X ");
266 seq_printf(m, "%3ld ", percent);
267 seq_printf(m, "%-30.30s %-20.20s %d\n", p->func, f, p->line);
271 static void *annotated_branch_stat_start(void)
273 return __start_annotated_branch_profile;
277 annotated_branch_stat_next(void *v, int idx)
279 struct ftrace_branch_data *p = v;
283 if ((void *)p >= (void *)__stop_annotated_branch_profile)
289 static int annotated_branch_stat_cmp(void *p1, void *p2)
291 struct ftrace_branch_data *a = p1;
292 struct ftrace_branch_data *b = p2;
294 long percent_a, percent_b;
296 percent_a = get_incorrect_percent(a);
297 percent_b = get_incorrect_percent(b);
299 if (percent_a < percent_b)
301 if (percent_a > percent_b)
307 static struct tracer_stat annotated_branch_stats = {
308 .name = "branch_annotated",
309 .stat_start = annotated_branch_stat_start,
310 .stat_next = annotated_branch_stat_next,
311 .stat_cmp = annotated_branch_stat_cmp,
312 .stat_headers = annotated_branch_stat_headers,
313 .stat_show = branch_stat_show
316 __init static int init_annotated_branch_stats(void)
320 ret = register_stat_tracer(&annotated_branch_stats);
322 printk(KERN_WARNING "Warning: could not register "
323 "annotated branches stats\n");
328 fs_initcall(init_annotated_branch_stats);
330 #ifdef CONFIG_PROFILE_ALL_BRANCHES
332 extern unsigned long __start_branch_profile[];
333 extern unsigned long __stop_branch_profile[];
335 static int all_branch_stat_headers(struct seq_file *m)
337 seq_printf(m, " miss hit %% ");
338 seq_printf(m, " Function "
340 " ------- --------- - "
346 static void *all_branch_stat_start(void)
348 return __start_branch_profile;
352 all_branch_stat_next(void *v, int idx)
354 struct ftrace_branch_data *p = v;
358 if ((void *)p >= (void *)__stop_branch_profile)
364 static struct tracer_stat all_branch_stats = {
365 .name = "branch_all",
366 .stat_start = all_branch_stat_start,
367 .stat_next = all_branch_stat_next,
368 .stat_headers = all_branch_stat_headers,
369 .stat_show = branch_stat_show
372 __init static int all_annotated_branch_stats(void)
376 ret = register_stat_tracer(&all_branch_stats);
378 printk(KERN_WARNING "Warning: could not register "
379 "all branches stats\n");
384 fs_initcall(all_annotated_branch_stats);
385 #endif /* CONFIG_PROFILE_ALL_BRANCHES */