Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447// SPDX-License-Identifier: GPL-2.0/* * unlikely profiler * * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com> */#include <linux/kallsyms.h>#include <linux/seq_file.h>#include <linux/spinlock.h>#include <linux/irqflags.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>
#include "trace.h"#include "trace_stat.h"#include "trace_output.h"
#ifdef CONFIG_BRANCH_TRACER
static struct tracer branch_trace;static int branch_tracing_enabled __read_mostly;static DEFINE_MUTEX(branch_tracing_mutex);
static struct trace_array *branch_tracer;
static voidprobe_likely_condition(struct ftrace_likely_data *f, int val, int expect){ struct trace_array *tr = branch_tracer; struct trace_buffer *buffer; struct ring_buffer_event *event; struct trace_branch *entry; unsigned long flags; unsigned int trace_ctx; const char *p;
if (current->trace_recursion & TRACE_BRANCH_BIT) return;
/* * 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;
raw_local_irq_save(flags); current->trace_recursion |= TRACE_BRANCH_BIT; if (!tracer_tracing_is_on_cpu(tr, raw_smp_processor_id())) goto out;
trace_ctx = tracing_gen_ctx_flags(flags); buffer = tr->array_buffer.buffer; event = trace_buffer_lock_reserve(buffer, TRACE_BRANCH, sizeof(*entry), trace_ctx); if (!event) goto out;
entry = ring_buffer_event_data(event);
/* Strip off the path, only save the file */ p = f->data.file + strlen(f->data.file); while (p >= f->data.file && *p != '/') p--; p++;
strscpy(entry->func, f->data.func); strscpy(entry->file, p); entry->constant = f->constant; entry->line = f->data.line; entry->correct = val == expect;
trace_buffer_unlock_commit_nostack(buffer, event);
out: current->trace_recursion &= ~TRACE_BRANCH_BIT; raw_local_irq_restore(flags);}
static inlinevoid trace_likely_condition(struct ftrace_likely_data *f, int val, int expect){ if (!branch_tracing_enabled) return;
probe_likely_condition(f, val, expect);}
int enable_branch_tracing(struct trace_array *tr){ mutex_lock(&branch_tracing_mutex); branch_tracer = tr; /* * Must be seen before enabling. The reader is a condition * where we do not need a matching rmb() */ smp_wmb(); branch_tracing_enabled++; mutex_unlock(&branch_tracing_mutex);
return 0;}
void disable_branch_tracing(void){ mutex_lock(&branch_tracing_mutex);
if (!branch_tracing_enabled) goto out_unlock;
branch_tracing_enabled--;
out_unlock: mutex_unlock(&branch_tracing_mutex);}
static int branch_trace_init(struct trace_array *tr){ return enable_branch_tracing(tr);}
static void branch_trace_reset(struct trace_array *tr){ disable_branch_tracing();}
static enum print_line_t trace_branch_print(struct trace_iterator *iter, int flags, struct trace_event *event){ struct trace_branch *field;
trace_assign_type(field, iter->ent);
trace_seq_printf(&iter->seq, "[%s] %s:%s:%d\n", field->correct ? " ok " : " MISS ", field->func, field->file, field->line);
return trace_handle_return(&iter->seq);}
static void branch_print_header(struct seq_file *s){ seq_puts(s, "# TASK-PID CPU# TIMESTAMP CORRECT" " FUNC:FILE:LINE\n" "# | | | | | " " |\n");}
static struct trace_event_functions trace_branch_funcs = { .trace = trace_branch_print,};
static struct trace_event trace_branch_event = { .type = TRACE_BRANCH, .funcs = &trace_branch_funcs,};
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 */ .print_header = branch_print_header,};
__init static int init_branch_tracer(void){ int ret;
ret = register_trace_event(&trace_branch_event); if (!ret) { pr_warn("Warning: could not register branch events\n"); return 1; } return register_tracer(&branch_trace);}core_initcall(init_branch_tracer);
#elsestatic inlinevoid trace_likely_condition(struct ftrace_likely_data *f, int val, int expect){}#endif /* CONFIG_BRANCH_TRACER */
void ftrace_likely_update(struct ftrace_likely_data *f, int val, int expect, int is_constant){ unsigned long flags = user_access_save();
/* A constant is always correct */ if (is_constant) { f->constant++; val = expect; } /* * 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);
/* FIXME: Make this atomic! */ if (val == expect) f->data.correct++; else f->data.incorrect++;
user_access_restore(flags);}EXPORT_SYMBOL(ftrace_likely_update);
extern unsigned long __start_annotated_branch_profile[];extern unsigned long __stop_annotated_branch_profile[];
static int annotated_branch_stat_headers(struct seq_file *m){ seq_puts(m, " correct incorrect % " " Function " " File Line\n" " ------- --------- - " " -------- " " ---- ----\n"); return 0;}
static inline long get_incorrect_percent(const struct ftrace_branch_data *p){ long percent;
if (p->correct) { percent = p->incorrect * 100; percent /= p->correct + p->incorrect; } else percent = p->incorrect ? 100 : -1;
return percent;}
static const char *branch_stat_process_file(struct ftrace_branch_data *p){ const char *f;
/* Only print the file, not the path */ f = p->file + strlen(p->file); while (f >= p->file && *f != '/') f--; return ++f;}
static void branch_stat_show(struct seq_file *m, struct ftrace_branch_data *p, const char *f){ long percent;
/* * The miss is overlayed on correct, and hit on incorrect. */ percent = get_incorrect_percent(p);
if (percent < 0) seq_puts(m, " X "); else seq_printf(m, "%3ld ", percent);
seq_printf(m, "%-30.30s %-20.20s %d\n", p->func, f, p->line);}
static int branch_stat_show_normal(struct seq_file *m, struct ftrace_branch_data *p, const char *f){ seq_printf(m, "%8lu %8lu ", p->correct, p->incorrect); branch_stat_show(m, p, f); return 0;}
static int annotate_branch_stat_show(struct seq_file *m, void *v){ struct ftrace_likely_data *p = v; const char *f; int l;
f = branch_stat_process_file(&p->data);
if (!p->constant) return branch_stat_show_normal(m, &p->data, f);
l = snprintf(NULL, 0, "/%lu", p->constant); l = l > 8 ? 0 : 8 - l;
seq_printf(m, "%8lu/%lu %*lu ", p->data.correct, p->constant, l, p->data.incorrect); branch_stat_show(m, &p->data, f); return 0;}
static void *annotated_branch_stat_start(struct tracer_stat *trace){ return __start_annotated_branch_profile;}
static void *annotated_branch_stat_next(void *v, int idx){ struct ftrace_likely_data *p = v;
++p;
if ((void *)p >= (void *)__stop_annotated_branch_profile) return NULL;
return p;}
static int annotated_branch_stat_cmp(const void *p1, const void *p2){ const struct ftrace_branch_data *a = p1; const 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;
if (a->incorrect < b->incorrect) return -1; if (a->incorrect > b->incorrect) return 1;
/* * Since the above shows worse (incorrect) cases * first, we continue that by showing best (correct) * cases last. */ if (a->correct > b->correct) return -1; if (a->correct < b->correct) return 1;
return 0;}
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 = annotate_branch_stat_show};
__init static int init_annotated_branch_stats(void){ int ret;
ret = register_stat_tracer(&annotated_branch_stats); if (ret) { pr_warn("Warning: could not register annotated branches stats\n"); return ret; } return 0;}fs_initcall(init_annotated_branch_stats);
#ifdef CONFIG_PROFILE_ALL_BRANCHES
extern unsigned long __start_branch_profile[];extern unsigned long __stop_branch_profile[];
static int all_branch_stat_headers(struct seq_file *m){ seq_puts(m, " miss hit % " " Function " " File Line\n" " ------- --------- - " " -------- " " ---- ----\n"); return 0;}
static void *all_branch_stat_start(struct tracer_stat *trace){ return __start_branch_profile;}
static void *all_branch_stat_next(void *v, int idx){ struct ftrace_branch_data *p = v;
++p;
if ((void *)p >= (void *)__stop_branch_profile) return NULL;
return p;}
static int all_branch_stat_show(struct seq_file *m, void *v){ struct ftrace_branch_data *p = v; const char *f;
f = branch_stat_process_file(p); return branch_stat_show_normal(m, p, f);}
static struct tracer_stat all_branch_stats = { .name = "branch_all", .stat_start = all_branch_stat_start, .stat_next = all_branch_stat_next, .stat_headers = all_branch_stat_headers, .stat_show = all_branch_stat_show};
__init static int all_annotated_branch_stats(void){ int ret;
ret = register_stat_tracer(&all_branch_stats); if (ret) { pr_warn("Warning: could not register all branches stats\n"); return ret; } return 0;}fs_initcall(all_annotated_branch_stats);#endif /* CONFIG_PROFILE_ALL_BRANCHES */