git.oblomov.eu Git - linux-2.6/blob - kernel/trace/trace_branch.c

   1 /*
   2  * unlikely profiler
   3  *
   4  * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
   5  */
   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>
  15 #include <linux/fs.h>
  16 #include <asm/local.h>
  17
  18 #include "trace.h"
  19 #include "trace_stat.h"
  20 #include "trace_output.h"
  21
  22 #ifdef CONFIG_BRANCH_TRACER
  23
  24 static struct tracer branch_trace;
  25 static int branch_tracing_enabled __read_mostly;
  26 static DEFINE_MUTEX(branch_tracing_mutex);
  27
  28 static struct trace_array *branch_tracer;
  29
  30 static void
  31 probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
  32 {
  33         struct trace_array *tr = branch_tracer;
  34         struct ring_buffer_event *event;
  35         struct trace_branch *entry;
  36         unsigned long flags, irq_flags;
  37         int cpu, pc;
  38         const char *p;
  39
  40         /*
  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.
  45          */
  46
  47         if (unlikely(!tr))
  48                 return;
  49
  50         local_irq_save(flags);
  51         cpu = raw_smp_processor_id();
  52         if (atomic_inc_return(&tr->data[cpu]->disabled) != 1)
  53                 goto out;
  54
  55         event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
  56                                          &irq_flags);
  57         if (!event)
  58                 goto out;
  59
  60         pc = preempt_count();
  61         entry   = ring_buffer_event_data(event);
  62         tracing_generic_entry_update(&entry->ent, flags, pc);
  63         entry->ent.type         = TRACE_BRANCH;
  64
  65         /* Strip off the path, only save the file */
  66         p = f->file + strlen(f->file);
  67         while (p >= f->file && *p != '/')
  68                 p--;
  69         p++;
  70
  71         strncpy(entry->func, f->func, TRACE_FUNC_SIZE);
  72         strncpy(entry->file, p, TRACE_FILE_SIZE);
  73         entry->func[TRACE_FUNC_SIZE] = 0;
  74         entry->file[TRACE_FILE_SIZE] = 0;
  75         entry->line = f->line;
  76         entry->correct = val == expect;
  77
  78         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
  79
  80  out:
  81         atomic_dec(&tr->data[cpu]->disabled);
  82         local_irq_restore(flags);
  83 }
  84
  85 static inline
  86 void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
  87 {
  88         if (!branch_tracing_enabled)
  89                 return;
  90
  91         probe_likely_condition(f, val, expect);
  92 }
  93
  94 int enable_branch_tracing(struct trace_array *tr)
  95 {
  96         int ret = 0;
  97
  98         mutex_lock(&branch_tracing_mutex);
  99         branch_tracer = tr;
 100         /*
 101          * Must be seen before enabling. The reader is a condition
 102          * where we do not need a matching rmb()
 103          */
 104         smp_wmb();
 105         branch_tracing_enabled++;
 106         mutex_unlock(&branch_tracing_mutex);
 107
 108         return ret;
 109 }
 110
 111 void disable_branch_tracing(void)
 112 {
 113         mutex_lock(&branch_tracing_mutex);
 114
 115         if (!branch_tracing_enabled)
 116                 goto out_unlock;
 117
 118         branch_tracing_enabled--;
 119
 120  out_unlock:
 121         mutex_unlock(&branch_tracing_mutex);
 122 }
 123
 124 static void start_branch_trace(struct trace_array *tr)
 125 {
 126         enable_branch_tracing(tr);
 127 }
 128
 129 static void stop_branch_trace(struct trace_array *tr)
 130 {
 131         disable_branch_tracing();
 132 }
 133
 134 static int branch_trace_init(struct trace_array *tr)
 135 {
 136         int cpu;
 137
 138         for_each_online_cpu(cpu)
 139                 tracing_reset(tr, cpu);
 140
 141         start_branch_trace(tr);
 142         return 0;
 143 }
 144
 145 static void branch_trace_reset(struct trace_array *tr)
 146 {
 147         stop_branch_trace(tr);
 148 }
 149
 150 static int
 151 trace_print_print(struct trace_seq *s, struct trace_entry *entry, int flags)
 152 {
 153         struct print_entry *field;
 154
 155         trace_assign_type(field, entry);
 156
 157         if (seq_print_ip_sym(s, field->ip, flags))
 158                 goto partial;
 159
 160         if (trace_seq_printf(s, ": %s", field->buf))
 161                 goto partial;
 162
 163  partial:
 164         return TRACE_TYPE_PARTIAL_LINE;
 165 }
 166
 167 static int
 168 trace_branch_print(struct trace_seq *s, struct trace_entry *entry, int flags)
 169 {
 170         struct trace_branch *field;
 171
 172         trace_assign_type(field, entry);
 173
 174         if (trace_seq_printf(s, "[%s] %s:%s:%d\n",
 175                              field->correct ? "  ok  " : " MISS ",
 176                              field->func,
 177                              field->file,
 178                              field->line))
 179                 return TRACE_TYPE_PARTIAL_LINE;
 180
 181         return 0;
 182 }
 183
 184
 185 static struct trace_event trace_branch_event = {
 186         .type           = TRACE_BRANCH,
 187         .trace          = trace_branch_print,
 188         .latency_trace  = trace_branch_print,
 189         .raw            = trace_nop_print,
 190         .hex            = trace_nop_print,
 191         .binary         = trace_nop_print,
 192 };
 193
 194 static struct tracer branch_trace __read_mostly =
 195 {
 196         .name           = "branch",
 197         .init           = branch_trace_init,
 198         .reset          = branch_trace_reset,
 199 #ifdef CONFIG_FTRACE_SELFTEST
 200         .selftest       = trace_selftest_startup_branch,
 201 #endif /* CONFIG_FTRACE_SELFTEST */
 202 };
 203
 204 __init static int init_branch_tracer(void)
 205 {
 206         int ret;
 207
 208         ret = register_ftrace_event(&trace_branch_event);
 209         if (!ret) {
 210                 printk(KERN_WARNING "Warning: could not register "
 211                                     "branch events\n");
 212                 return 1;
 213         }
 214         return register_tracer(&branch_trace);
 215 }
 216 device_initcall(init_branch_tracer);
 217
 218 #else
 219 static inline
 220 void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
 221 {
 222 }
 223 #endif /* CONFIG_BRANCH_TRACER */
 224
 225 void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect)
 226 {
 227         /*
 228          * I would love to have a trace point here instead, but the
 229          * trace point code is so inundated with unlikely and likely
 230          * conditions that the recursive nightmare that exists is too
 231          * much to try to get working. At least for now.
 232          */
 233         trace_likely_condition(f, val, expect);
 234
 235         /* FIXME: Make this atomic! */
 236         if (val == expect)
 237                 f->correct++;
 238         else
 239                 f->incorrect++;
 240 }
 241 EXPORT_SYMBOL(ftrace_likely_update);
 242
 243 extern unsigned long __start_annotated_branch_profile[];
 244 extern unsigned long __stop_annotated_branch_profile[];
 245
 246 static int annotated_branch_stat_headers(struct seq_file *m)
 247 {
 248         seq_printf(m, " correct incorrect  %% ");
 249         seq_printf(m, "       Function                "
 250                               "  File              Line\n"
 251                               " ------- ---------  - "
 252                               "       --------                "
 253                               "  ----              ----\n");
 254         return 0;
 255 }
 256
 257 static inline long get_incorrect_percent(struct ftrace_branch_data *p)
 258 {
 259         long percent;
 260
 261         if (p->correct) {
 262                 percent = p->incorrect * 100;
 263                 percent /= p->correct + p->incorrect;
 264         } else
 265                 percent = p->incorrect ? 100 : -1;
 266
 267         return percent;
 268 }
 269
 270 static int branch_stat_show(struct seq_file *m, void *v)
 271 {
 272         struct ftrace_branch_data *p = v;
 273         const char *f;
 274         long percent;
 275
 276         /* Only print the file, not the path */
 277         f = p->file + strlen(p->file);
 278         while (f >= p->file && *f != '/')
 279                 f--;
 280         f++;
 281
 282         /*
 283          * The miss is overlayed on correct, and hit on incorrect.
 284          */
 285         percent = get_incorrect_percent(p);
 286
 287         seq_printf(m, "%8lu %8lu ",  p->correct, p->incorrect);
 288         if (percent < 0)
 289                 seq_printf(m, "  X ");
 290         else
 291                 seq_printf(m, "%3ld ", percent);
 292         seq_printf(m, "%-30.30s %-20.20s %d\n", p->func, f, p->line);
 293         return 0;
 294 }
 295
 296 static void *annotated_branch_stat_start(void)
 297 {
 298         return __start_annotated_branch_profile;
 299 }
 300
 301 static void *
 302 annotated_branch_stat_next(void *v, int idx)
 303 {
 304         struct ftrace_branch_data *p = v;
 305
 306         ++p;
 307
 308         if ((void *)p >= (void *)__stop_annotated_branch_profile)
 309                 return NULL;
 310
 311         return p;
 312 }
 313
 314 static int annotated_branch_stat_cmp(void *p1, void *p2)
 315 {
 316         struct ftrace_branch_data *a = p1;
 317         struct ftrace_branch_data *b = p2;
 318
 319         long percent_a, percent_b;
 320
 321         percent_a = get_incorrect_percent(a);
 322         percent_b = get_incorrect_percent(b);
 323
 324         if (percent_a < percent_b)
 325                 return -1;
 326         if (percent_a > percent_b)
 327                 return 1;
 328         else
 329                 return 0;
 330 }
 331
 332 static struct tracer_stat annotated_branch_stats = {
 333         .name = "branch_annotated",
 334         .stat_start = annotated_branch_stat_start,
 335         .stat_next = annotated_branch_stat_next,
 336         .stat_cmp = annotated_branch_stat_cmp,
 337         .stat_headers = annotated_branch_stat_headers,
 338         .stat_show = branch_stat_show
 339 };
 340
 341 __init static int init_annotated_branch_stats(void)
 342 {
 343         int ret;
 344
 345         ret = register_stat_tracer(&annotated_branch_stats);
 346         if (!ret) {
 347                 printk(KERN_WARNING "Warning: could not register "
 348                                     "annotated branches stats\n");
 349                 return 1;
 350         }
 351         return 0;
 352 }
 353 fs_initcall(init_annotated_branch_stats);
 354
 355 #ifdef CONFIG_PROFILE_ALL_BRANCHES
 356
 357 extern unsigned long __start_branch_profile[];
 358 extern unsigned long __stop_branch_profile[];
 359
 360 static int all_branch_stat_headers(struct seq_file *m)
 361 {
 362         seq_printf(m, "   miss      hit    %% ");
 363         seq_printf(m, "       Function                "
 364                               "  File              Line\n"
 365                               " ------- ---------  - "
 366                               "       --------                "
 367                               "  ----              ----\n");
 368         return 0;
 369 }
 370
 371 static void *all_branch_stat_start(void)
 372 {
 373         return __start_branch_profile;
 374 }
 375
 376 static void *
 377 all_branch_stat_next(void *v, int idx)
 378 {
 379         struct ftrace_branch_data *p = v;
 380
 381         ++p;
 382
 383         if ((void *)p >= (void *)__stop_branch_profile)
 384                 return NULL;
 385
 386         return p;
 387 }
 388
 389 static struct tracer_stat all_branch_stats = {
 390         .name = "branch_all",
 391         .stat_start = all_branch_stat_start,
 392         .stat_next = all_branch_stat_next,
 393         .stat_headers = all_branch_stat_headers,
 394         .stat_show = branch_stat_show
 395 };
 396
 397 __init static int all_annotated_branch_stats(void)
 398 {
 399         int ret;
 400
 401         ret = register_stat_tracer(&all_branch_stats);
 402         if (!ret) {
 403                 printk(KERN_WARNING "Warning: could not register "
 404                                     "all branches stats\n");
 405                 return 1;
 406         }
 407         return 0;
 408 }
 409 fs_initcall(all_annotated_branch_stats);
 410 #endif /* CONFIG_PROFILE_ALL_BRANCHES */