2008-11-12 00:14:39 -05:00
|
|
|
/*
|
|
|
|
* unlikely profiler
|
|
|
|
*
|
|
|
|
* Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
|
|
|
|
*/
|
|
|
|
#include <linux/kallsyms.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/spinlock.h>
|
2008-11-28 22:12:46 -05:00
|
|
|
#include <linux/irqflags.h>
|
2008-11-12 00:14:39 -05:00
|
|
|
#include <linux/debugfs.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/ftrace.h>
|
|
|
|
#include <linux/hash.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <asm/local.h>
|
2008-12-23 23:24:13 -05:00
|
|
|
|
2008-11-12 00:14:39 -05:00
|
|
|
#include "trace.h"
|
2009-01-10 14:34:13 -05:00
|
|
|
#include "trace_stat.h"
|
2008-12-23 23:24:13 -05:00
|
|
|
#include "trace_output.h"
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-11-12 15:24:24 -05:00
|
|
|
#ifdef CONFIG_BRANCH_TRACER
|
2008-11-12 00:14:40 -05:00
|
|
|
|
2009-01-10 14:34:13 -05:00
|
|
|
static struct tracer branch_trace;
|
2008-11-12 15:24:24 -05:00
|
|
|
static int branch_tracing_enabled __read_mostly;
|
|
|
|
static DEFINE_MUTEX(branch_tracing_mutex);
|
2008-12-27 17:25:38 -05:00
|
|
|
|
2008-11-12 15:24:24 -05:00
|
|
|
static struct trace_array *branch_tracer;
|
2008-11-12 00:14:40 -05:00
|
|
|
|
|
|
|
static void
|
2008-11-12 15:24:24 -05:00
|
|
|
probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
|
2008-11-12 00:14:40 -05:00
|
|
|
{
|
2008-11-12 15:24:24 -05:00
|
|
|
struct trace_array *tr = branch_tracer;
|
2008-11-12 00:14:40 -05:00
|
|
|
struct ring_buffer_event *event;
|
2008-11-12 15:24:24 -05:00
|
|
|
struct trace_branch *entry;
|
2009-02-05 13:12:56 -05:00
|
|
|
unsigned long flags;
|
2008-11-12 00:14:40 -05:00
|
|
|
int cpu, pc;
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* I would love to save just the ftrace_likely_data pointer, but
|
|
|
|
* this code can also be used by modules. Ugly things can happen
|
|
|
|
* if the module is unloaded, and then we go and read the
|
|
|
|
* pointer. This is slower, but much safer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (unlikely(!tr))
|
|
|
|
return;
|
|
|
|
|
2008-12-02 15:34:05 -05:00
|
|
|
local_irq_save(flags);
|
2008-11-12 00:14:40 -05:00
|
|
|
cpu = raw_smp_processor_id();
|
|
|
|
if (atomic_inc_return(&tr->data[cpu]->disabled) != 1)
|
|
|
|
goto out;
|
|
|
|
|
tracing: Introduce trace_buffer_{lock_reserve,unlock_commit}
Impact: new API
These new functions do what previously was being open coded, reducing
the number of details ftrace plugin writers have to worry about.
It also standardizes the handling of stacktrace, userstacktrace and
other trace options we may introduce in the future.
With this patch, for instance, the blk tracer (and some others already
in the tree) can use the "userstacktrace" /d/tracing/trace_options
facility.
$ codiff /tmp/vmlinux.before /tmp/vmlinux.after
linux-2.6-tip/kernel/trace/trace.c:
trace_vprintk | -5
trace_graph_return | -22
trace_graph_entry | -26
trace_function | -45
__ftrace_trace_stack | -27
ftrace_trace_userstack | -29
tracing_sched_switch_trace | -66
tracing_stop | +1
trace_seq_to_user | -1
ftrace_trace_special | -63
ftrace_special | +1
tracing_sched_wakeup_trace | -70
tracing_reset_online_cpus | -1
13 functions changed, 2 bytes added, 355 bytes removed, diff: -353
linux-2.6-tip/block/blktrace.c:
__blk_add_trace | -58
1 function changed, 58 bytes removed, diff: -58
linux-2.6-tip/kernel/trace/trace.c:
trace_buffer_lock_reserve | +88
trace_buffer_unlock_commit | +86
2 functions changed, 174 bytes added, diff: +174
/tmp/vmlinux.after:
16 functions changed, 176 bytes added, 413 bytes removed, diff: -237
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Acked-by: Frédéric Weisbecker <fweisbec@gmail.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-02-05 13:14:13 -05:00
|
|
|
pc = preempt_count();
|
|
|
|
event = trace_buffer_lock_reserve(tr, TRACE_BRANCH,
|
|
|
|
sizeof(*entry), flags, pc);
|
2008-11-12 00:14:40 -05:00
|
|
|
if (!event)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
entry = ring_buffer_event_data(event);
|
|
|
|
|
|
|
|
/* Strip off the path, only save the file */
|
|
|
|
p = f->file + strlen(f->file);
|
|
|
|
while (p >= f->file && *p != '/')
|
|
|
|
p--;
|
|
|
|
p++;
|
|
|
|
|
|
|
|
strncpy(entry->func, f->func, TRACE_FUNC_SIZE);
|
|
|
|
strncpy(entry->file, p, TRACE_FILE_SIZE);
|
|
|
|
entry->func[TRACE_FUNC_SIZE] = 0;
|
|
|
|
entry->file[TRACE_FILE_SIZE] = 0;
|
|
|
|
entry->line = f->line;
|
|
|
|
entry->correct = val == expect;
|
|
|
|
|
2009-02-05 13:12:56 -05:00
|
|
|
ring_buffer_unlock_commit(tr->buffer, event);
|
2008-11-12 00:14:40 -05:00
|
|
|
|
|
|
|
out:
|
|
|
|
atomic_dec(&tr->data[cpu]->disabled);
|
2008-12-02 15:34:05 -05:00
|
|
|
local_irq_restore(flags);
|
2008-11-12 00:14:40 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline
|
2008-11-12 15:24:24 -05:00
|
|
|
void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
|
2008-11-12 00:14:40 -05:00
|
|
|
{
|
2008-11-12 15:24:24 -05:00
|
|
|
if (!branch_tracing_enabled)
|
2008-11-12 00:14:40 -05:00
|
|
|
return;
|
|
|
|
|
|
|
|
probe_likely_condition(f, val, expect);
|
|
|
|
}
|
|
|
|
|
2008-11-12 15:24:24 -05:00
|
|
|
int enable_branch_tracing(struct trace_array *tr)
|
2008-11-12 00:14:40 -05:00
|
|
|
{
|
2008-11-12 15:24:24 -05:00
|
|
|
mutex_lock(&branch_tracing_mutex);
|
|
|
|
branch_tracer = tr;
|
2008-11-12 00:14:40 -05:00
|
|
|
/*
|
|
|
|
* Must be seen before enabling. The reader is a condition
|
|
|
|
* where we do not need a matching rmb()
|
|
|
|
*/
|
|
|
|
smp_wmb();
|
2008-11-12 15:24:24 -05:00
|
|
|
branch_tracing_enabled++;
|
|
|
|
mutex_unlock(&branch_tracing_mutex);
|
2008-11-12 00:14:40 -05:00
|
|
|
|
2009-02-10 01:02:46 -05:00
|
|
|
return 0;
|
2008-11-12 00:14:40 -05:00
|
|
|
}
|
|
|
|
|
2008-11-12 15:24:24 -05:00
|
|
|
void disable_branch_tracing(void)
|
2008-11-12 00:14:40 -05:00
|
|
|
{
|
2008-11-12 15:24:24 -05:00
|
|
|
mutex_lock(&branch_tracing_mutex);
|
2008-11-12 00:14:40 -05:00
|
|
|
|
2008-11-12 15:24:24 -05:00
|
|
|
if (!branch_tracing_enabled)
|
2008-11-12 00:14:40 -05:00
|
|
|
goto out_unlock;
|
|
|
|
|
2008-11-12 15:24:24 -05:00
|
|
|
branch_tracing_enabled--;
|
2008-11-12 00:14:40 -05:00
|
|
|
|
|
|
|
out_unlock:
|
2008-11-12 15:24:24 -05:00
|
|
|
mutex_unlock(&branch_tracing_mutex);
|
2008-11-12 00:14:40 -05:00
|
|
|
}
|
2008-11-12 15:24:24 -05:00
|
|
|
|
|
|
|
static void start_branch_trace(struct trace_array *tr)
|
|
|
|
{
|
|
|
|
enable_branch_tracing(tr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void stop_branch_trace(struct trace_array *tr)
|
|
|
|
{
|
|
|
|
disable_branch_tracing();
|
|
|
|
}
|
|
|
|
|
2008-11-15 23:57:26 -05:00
|
|
|
static int branch_trace_init(struct trace_array *tr)
|
2008-11-12 15:24:24 -05:00
|
|
|
{
|
|
|
|
start_branch_trace(tr);
|
2008-11-15 23:57:26 -05:00
|
|
|
return 0;
|
2008-11-12 15:24:24 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void branch_trace_reset(struct trace_array *tr)
|
|
|
|
{
|
|
|
|
stop_branch_trace(tr);
|
|
|
|
}
|
|
|
|
|
2009-02-03 19:05:50 -05:00
|
|
|
static enum print_line_t trace_branch_print(struct trace_iterator *iter,
|
|
|
|
int flags)
|
2008-12-23 23:24:13 -05:00
|
|
|
{
|
|
|
|
struct trace_branch *field;
|
|
|
|
|
2009-02-02 17:30:12 -05:00
|
|
|
trace_assign_type(field, iter->ent);
|
2008-12-23 23:24:13 -05:00
|
|
|
|
2009-02-02 17:30:12 -05:00
|
|
|
if (trace_seq_printf(&iter->seq, "[%s] %s:%s:%d\n",
|
2008-12-23 23:24:13 -05:00
|
|
|
field->correct ? " ok " : " MISS ",
|
|
|
|
field->func,
|
|
|
|
field->file,
|
|
|
|
field->line))
|
|
|
|
return TRACE_TYPE_PARTIAL_LINE;
|
|
|
|
|
2009-02-03 17:20:41 -05:00
|
|
|
return TRACE_TYPE_HANDLED;
|
2008-12-23 23:24:13 -05:00
|
|
|
}
|
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
|
2008-12-23 23:24:13 -05:00
|
|
|
static struct trace_event trace_branch_event = {
|
2009-03-10 14:10:56 -04:00
|
|
|
.type = TRACE_BRANCH,
|
2008-12-23 23:24:13 -05:00
|
|
|
.trace = trace_branch_print,
|
|
|
|
};
|
|
|
|
|
2009-01-10 14:34:13 -05:00
|
|
|
static struct tracer branch_trace __read_mostly =
|
|
|
|
{
|
|
|
|
.name = "branch",
|
|
|
|
.init = branch_trace_init,
|
|
|
|
.reset = branch_trace_reset,
|
|
|
|
#ifdef CONFIG_FTRACE_SELFTEST
|
|
|
|
.selftest = trace_selftest_startup_branch,
|
|
|
|
#endif /* CONFIG_FTRACE_SELFTEST */
|
|
|
|
};
|
|
|
|
|
|
|
|
__init static int init_branch_tracer(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = register_ftrace_event(&trace_branch_event);
|
|
|
|
if (!ret) {
|
|
|
|
printk(KERN_WARNING "Warning: could not register "
|
|
|
|
"branch events\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return register_tracer(&branch_trace);
|
|
|
|
}
|
|
|
|
device_initcall(init_branch_tracer);
|
|
|
|
|
2008-11-12 00:14:40 -05:00
|
|
|
#else
|
|
|
|
static inline
|
2008-11-12 15:24:24 -05:00
|
|
|
void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
|
2008-11-12 00:14:40 -05:00
|
|
|
{
|
|
|
|
}
|
2008-11-12 15:24:24 -05:00
|
|
|
#endif /* CONFIG_BRANCH_TRACER */
|
2008-11-12 00:14:40 -05:00
|
|
|
|
2008-11-12 15:24:24 -05:00
|
|
|
void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect)
|
2008-11-12 00:14:39 -05:00
|
|
|
{
|
2008-11-12 00:14:40 -05:00
|
|
|
/*
|
|
|
|
* I would love to have a trace point here instead, but the
|
|
|
|
* trace point code is so inundated with unlikely and likely
|
|
|
|
* conditions that the recursive nightmare that exists is too
|
|
|
|
* much to try to get working. At least for now.
|
|
|
|
*/
|
|
|
|
trace_likely_condition(f, val, expect);
|
|
|
|
|
2008-11-12 00:14:39 -05:00
|
|
|
/* FIXME: Make this atomic! */
|
|
|
|
if (val == expect)
|
|
|
|
f->correct++;
|
|
|
|
else
|
|
|
|
f->incorrect++;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ftrace_likely_update);
|
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
extern unsigned long __start_annotated_branch_profile[];
|
|
|
|
extern unsigned long __stop_annotated_branch_profile[];
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
static int annotated_branch_stat_headers(struct seq_file *m)
|
2008-11-12 00:14:39 -05:00
|
|
|
{
|
2008-12-27 17:25:38 -05:00
|
|
|
seq_printf(m, " correct incorrect %% ");
|
|
|
|
seq_printf(m, " Function "
|
|
|
|
" File Line\n"
|
|
|
|
" ------- --------- - "
|
|
|
|
" -------- "
|
|
|
|
" ---- ----\n");
|
|
|
|
return 0;
|
2008-11-12 00:14:39 -05:00
|
|
|
}
|
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
static inline long get_incorrect_percent(struct ftrace_branch_data *p)
|
2008-11-12 00:14:39 -05:00
|
|
|
{
|
2008-12-27 17:25:38 -05:00
|
|
|
long percent;
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
if (p->correct) {
|
|
|
|
percent = p->incorrect * 100;
|
|
|
|
percent /= p->correct + p->incorrect;
|
|
|
|
} else
|
|
|
|
percent = p->incorrect ? 100 : -1;
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
return percent;
|
2008-11-12 00:14:39 -05:00
|
|
|
}
|
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
static int branch_stat_show(struct seq_file *m, void *v)
|
2008-11-12 00:14:39 -05:00
|
|
|
{
|
2008-11-12 15:24:24 -05:00
|
|
|
struct ftrace_branch_data *p = v;
|
2008-11-12 00:14:39 -05:00
|
|
|
const char *f;
|
2008-11-21 01:51:53 -05:00
|
|
|
long percent;
|
2008-11-12 00:14:39 -05:00
|
|
|
|
|
|
|
/* Only print the file, not the path */
|
|
|
|
f = p->file + strlen(p->file);
|
|
|
|
while (f >= p->file && *f != '/')
|
|
|
|
f--;
|
|
|
|
f++;
|
|
|
|
|
2008-11-21 01:30:54 -05:00
|
|
|
/*
|
|
|
|
* The miss is overlayed on correct, and hit on incorrect.
|
|
|
|
*/
|
2008-12-27 17:25:38 -05:00
|
|
|
percent = get_incorrect_percent(p);
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-11-21 01:51:53 -05:00
|
|
|
seq_printf(m, "%8lu %8lu ", p->correct, p->incorrect);
|
|
|
|
if (percent < 0)
|
|
|
|
seq_printf(m, " X ");
|
|
|
|
else
|
|
|
|
seq_printf(m, "%3ld ", percent);
|
2008-11-12 00:14:39 -05:00
|
|
|
seq_printf(m, "%-30.30s %-20.20s %d\n", p->func, f, p->line);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
static void *annotated_branch_stat_start(void)
|
|
|
|
{
|
|
|
|
return __start_annotated_branch_profile;
|
|
|
|
}
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
static void *
|
|
|
|
annotated_branch_stat_next(void *v, int idx)
|
2008-11-12 00:14:39 -05:00
|
|
|
{
|
2008-12-27 17:25:38 -05:00
|
|
|
struct ftrace_branch_data *p = v;
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
++p;
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
if ((void *)p >= (void *)__stop_annotated_branch_profile)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return p;
|
2008-11-12 00:14:39 -05:00
|
|
|
}
|
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
static int annotated_branch_stat_cmp(void *p1, void *p2)
|
|
|
|
{
|
|
|
|
struct ftrace_branch_data *a = p1;
|
|
|
|
struct ftrace_branch_data *b = p2;
|
|
|
|
|
|
|
|
long percent_a, percent_b;
|
|
|
|
|
|
|
|
percent_a = get_incorrect_percent(a);
|
|
|
|
percent_b = get_incorrect_percent(b);
|
|
|
|
|
|
|
|
if (percent_a < percent_b)
|
|
|
|
return -1;
|
|
|
|
if (percent_a > percent_b)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2009-01-10 14:34:13 -05:00
|
|
|
static struct tracer_stat annotated_branch_stats = {
|
|
|
|
.name = "branch_annotated",
|
|
|
|
.stat_start = annotated_branch_stat_start,
|
|
|
|
.stat_next = annotated_branch_stat_next,
|
|
|
|
.stat_cmp = annotated_branch_stat_cmp,
|
|
|
|
.stat_headers = annotated_branch_stat_headers,
|
|
|
|
.stat_show = branch_stat_show
|
|
|
|
};
|
|
|
|
|
|
|
|
__init static int init_annotated_branch_stats(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = register_stat_tracer(&annotated_branch_stats);
|
|
|
|
if (!ret) {
|
|
|
|
printk(KERN_WARNING "Warning: could not register "
|
|
|
|
"annotated branches stats\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
fs_initcall(init_annotated_branch_stats);
|
|
|
|
|
2008-11-21 01:30:54 -05:00
|
|
|
#ifdef CONFIG_PROFILE_ALL_BRANCHES
|
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
extern unsigned long __start_branch_profile[];
|
|
|
|
extern unsigned long __stop_branch_profile[];
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
static int all_branch_stat_headers(struct seq_file *m)
|
|
|
|
{
|
|
|
|
seq_printf(m, " miss hit %% ");
|
|
|
|
seq_printf(m, " Function "
|
|
|
|
" File Line\n"
|
|
|
|
" ------- --------- - "
|
|
|
|
" -------- "
|
|
|
|
" ---- ----\n");
|
|
|
|
return 0;
|
|
|
|
}
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
static void *all_branch_stat_start(void)
|
2008-11-12 00:14:39 -05:00
|
|
|
{
|
2008-12-27 17:25:38 -05:00
|
|
|
return __start_branch_profile;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
|
|
|
all_branch_stat_next(void *v, int idx)
|
|
|
|
{
|
|
|
|
struct ftrace_branch_data *p = v;
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
++p;
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
if ((void *)p >= (void *)__stop_branch_profile)
|
|
|
|
return NULL;
|
2008-11-12 00:14:39 -05:00
|
|
|
|
2008-12-27 17:25:38 -05:00
|
|
|
return p;
|
|
|
|
}
|
2008-11-21 01:30:54 -05:00
|
|
|
|
2009-01-10 14:34:13 -05:00
|
|
|
static struct tracer_stat all_branch_stats = {
|
|
|
|
.name = "branch_all",
|
2009-01-08 13:03:56 -05:00
|
|
|
.stat_start = all_branch_stat_start,
|
|
|
|
.stat_next = all_branch_stat_next,
|
|
|
|
.stat_headers = all_branch_stat_headers,
|
2009-01-10 14:34:13 -05:00
|
|
|
.stat_show = branch_stat_show
|
2009-01-08 13:03:56 -05:00
|
|
|
};
|
2008-12-27 17:25:38 -05:00
|
|
|
|
2009-01-10 14:34:13 -05:00
|
|
|
__init static int all_annotated_branch_stats(void)
|
2008-12-27 17:25:38 -05:00
|
|
|
{
|
|
|
|
int ret;
|
2009-01-10 14:34:13 -05:00
|
|
|
|
|
|
|
ret = register_stat_tracer(&all_branch_stats);
|
2008-12-27 17:25:38 -05:00
|
|
|
if (!ret) {
|
2009-01-10 14:34:13 -05:00
|
|
|
printk(KERN_WARNING "Warning: could not register "
|
|
|
|
"all branches stats\n");
|
2008-12-27 17:25:38 -05:00
|
|
|
return 1;
|
|
|
|
}
|
2009-01-10 14:34:13 -05:00
|
|
|
return 0;
|
2008-12-27 17:25:38 -05:00
|
|
|
}
|
2009-01-10 14:34:13 -05:00
|
|
|
fs_initcall(all_annotated_branch_stats);
|
|
|
|
#endif /* CONFIG_PROFILE_ALL_BRANCHES */
|