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 ftrace_event_call *call = &event_branch;
34 struct trace_array *tr = branch_tracer;
35 struct trace_array_cpu *data;
36 struct ring_buffer_event *event;
37 struct trace_branch *entry;
38 struct ring_buffer *buffer;
44 * I would love to save just the ftrace_likely_data pointer, but
45 * this code can also be used by modules. Ugly things can happen
46 * if the module is unloaded, and then we go and read the
47 * pointer. This is slower, but much safer.
53 local_irq_save(flags);
54 cpu = raw_smp_processor_id();
55 data = per_cpu_ptr(tr->trace_buffer.data, cpu);
56 if (atomic_inc_return(&data->disabled) != 1)
60 buffer = tr->trace_buffer.buffer;
61 event = trace_buffer_lock_reserve(buffer, TRACE_BRANCH,
62 sizeof(*entry), flags, pc);
66 entry = ring_buffer_event_data(event);
68 /* Strip off the path, only save the file */
69 p = f->file + strlen(f->file);
70 while (p >= f->file && *p != '/')
74 strncpy(entry->func, f->func, TRACE_FUNC_SIZE);
75 strncpy(entry->file, p, TRACE_FILE_SIZE);
76 entry->func[TRACE_FUNC_SIZE] = 0;
77 entry->file[TRACE_FILE_SIZE] = 0;
78 entry->line = f->line;
79 entry->correct = val == expect;
81 if (!call_filter_check_discard(call, entry, buffer, event))
82 __buffer_unlock_commit(buffer, event);
85 atomic_dec(&data->disabled);
86 local_irq_restore(flags);
90 void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
92 if (!branch_tracing_enabled)
95 probe_likely_condition(f, val, expect);
98 int enable_branch_tracing(struct trace_array *tr)
100 mutex_lock(&branch_tracing_mutex);
103 * Must be seen before enabling. The reader is a condition
104 * where we do not need a matching rmb()
107 branch_tracing_enabled++;
108 mutex_unlock(&branch_tracing_mutex);
113 void disable_branch_tracing(void)
115 mutex_lock(&branch_tracing_mutex);
117 if (!branch_tracing_enabled)
120 branch_tracing_enabled--;
123 mutex_unlock(&branch_tracing_mutex);
126 static void start_branch_trace(struct trace_array *tr)
128 enable_branch_tracing(tr);
131 static void stop_branch_trace(struct trace_array *tr)
133 disable_branch_tracing();
136 static int branch_trace_init(struct trace_array *tr)
138 start_branch_trace(tr);
142 static void branch_trace_reset(struct trace_array *tr)
144 stop_branch_trace(tr);
147 static enum print_line_t trace_branch_print(struct trace_iterator *iter,
148 int flags, struct trace_event *event)
150 struct trace_branch *field;
152 trace_assign_type(field, iter->ent);
154 trace_seq_printf(&iter->seq, "[%s] %s:%s:%d\n",
155 field->correct ? " ok " : " MISS ",
160 return trace_handle_return(&iter->seq);
163 static void branch_print_header(struct seq_file *s)
165 seq_puts(s, "# TASK-PID CPU# TIMESTAMP CORRECT"
171 static struct trace_event_functions trace_branch_funcs = {
172 .trace = trace_branch_print,
175 static struct trace_event trace_branch_event = {
176 .type = TRACE_BRANCH,
177 .funcs = &trace_branch_funcs,
180 static struct tracer branch_trace __read_mostly =
183 .init = branch_trace_init,
184 .reset = branch_trace_reset,
185 #ifdef CONFIG_FTRACE_SELFTEST
186 .selftest = trace_selftest_startup_branch,
187 #endif /* CONFIG_FTRACE_SELFTEST */
188 .print_header = branch_print_header,
191 __init static int init_branch_tracer(void)
195 ret = register_ftrace_event(&trace_branch_event);
197 printk(KERN_WARNING "Warning: could not register "
201 return register_tracer(&branch_trace);
203 core_initcall(init_branch_tracer);
207 void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
210 #endif /* CONFIG_BRANCH_TRACER */
212 void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect)
215 * I would love to have a trace point here instead, but the
216 * trace point code is so inundated with unlikely and likely
217 * conditions that the recursive nightmare that exists is too
218 * much to try to get working. At least for now.
220 trace_likely_condition(f, val, expect);
222 /* FIXME: Make this atomic! */
228 EXPORT_SYMBOL(ftrace_likely_update);
230 extern unsigned long __start_annotated_branch_profile[];
231 extern unsigned long __stop_annotated_branch_profile[];
233 static int annotated_branch_stat_headers(struct seq_file *m)
235 seq_puts(m, " correct incorrect % "
238 " ------- --------- - "
244 static inline long get_incorrect_percent(struct ftrace_branch_data *p)
249 percent = p->incorrect * 100;
250 percent /= p->correct + p->incorrect;
252 percent = p->incorrect ? 100 : -1;
257 static int branch_stat_show(struct seq_file *m, void *v)
259 struct ftrace_branch_data *p = v;
263 /* Only print the file, not the path */
264 f = p->file + strlen(p->file);
265 while (f >= p->file && *f != '/')
270 * The miss is overlayed on correct, and hit on incorrect.
272 percent = get_incorrect_percent(p);
274 seq_printf(m, "%8lu %8lu ", p->correct, p->incorrect);
278 seq_printf(m, "%3ld ", percent);
279 seq_printf(m, "%-30.30s %-20.20s %d\n", p->func, f, p->line);
283 static void *annotated_branch_stat_start(struct tracer_stat *trace)
285 return __start_annotated_branch_profile;
289 annotated_branch_stat_next(void *v, int idx)
291 struct ftrace_branch_data *p = v;
295 if ((void *)p >= (void *)__stop_annotated_branch_profile)
301 static int annotated_branch_stat_cmp(void *p1, void *p2)
303 struct ftrace_branch_data *a = p1;
304 struct ftrace_branch_data *b = p2;
306 long percent_a, percent_b;
308 percent_a = get_incorrect_percent(a);
309 percent_b = get_incorrect_percent(b);
311 if (percent_a < percent_b)
313 if (percent_a > percent_b)
316 if (a->incorrect < b->incorrect)
318 if (a->incorrect > b->incorrect)
322 * Since the above shows worse (incorrect) cases
323 * first, we continue that by showing best (correct)
326 if (a->correct > b->correct)
328 if (a->correct < b->correct)
334 static struct tracer_stat annotated_branch_stats = {
335 .name = "branch_annotated",
336 .stat_start = annotated_branch_stat_start,
337 .stat_next = annotated_branch_stat_next,
338 .stat_cmp = annotated_branch_stat_cmp,
339 .stat_headers = annotated_branch_stat_headers,
340 .stat_show = branch_stat_show
343 __init static int init_annotated_branch_stats(void)
347 ret = register_stat_tracer(&annotated_branch_stats);
349 printk(KERN_WARNING "Warning: could not register "
350 "annotated branches stats\n");
355 fs_initcall(init_annotated_branch_stats);
357 #ifdef CONFIG_PROFILE_ALL_BRANCHES
359 extern unsigned long __start_branch_profile[];
360 extern unsigned long __stop_branch_profile[];
362 static int all_branch_stat_headers(struct seq_file *m)
364 seq_puts(m, " miss hit % "
367 " ------- --------- - "
373 static void *all_branch_stat_start(struct tracer_stat *trace)
375 return __start_branch_profile;
379 all_branch_stat_next(void *v, int idx)
381 struct ftrace_branch_data *p = v;
385 if ((void *)p >= (void *)__stop_branch_profile)
391 static struct tracer_stat all_branch_stats = {
392 .name = "branch_all",
393 .stat_start = all_branch_stat_start,
394 .stat_next = all_branch_stat_next,
395 .stat_headers = all_branch_stat_headers,
396 .stat_show = branch_stat_show
399 __init static int all_annotated_branch_stats(void)
403 ret = register_stat_tracer(&all_branch_stats);
405 printk(KERN_WARNING "Warning: could not register "
406 "all branches stats\n");
411 fs_initcall(all_annotated_branch_stats);
412 #endif /* CONFIG_PROFILE_ALL_BRANCHES */