3 files changed, 181 insertions, 0 deletions

diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index d986216c8327..a604f24c755f 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -159,6 +159,22 @@ config BOOT_TRACER
             selected, because the self-tests are an initcall as well and that
             would invalidate the boot trace. )
 
+config TRACE_UNLIKELY_PROFILE
+        bool "Trace likely/unlikely profiler"
+        depends on DEBUG_KERNEL
+        select TRACING
+        help
+          This tracer profiles all the the likely and unlikely macros
+          in the kernel. It will display the results in:
+
+          /debugfs/tracing/profile_likely
+          /debugfs/tracing/profile_unlikely
+
+          Note: this will add a significant overhead, only turn this
+          on if you need to profile the system's use of these macros.
+
+          Say N if unsure.
+
 config STACK_TRACER
         bool "Trace max stack"
         depends on HAVE_FUNCTION_TRACER
diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
index 3e1f361bbc17..98e70ee27986 100644
--- a/kernel/trace/Makefile
+++ b/kernel/trace/Makefile
@@ -25,5 +25,6 @@ obj-$(CONFIG_STACK_TRACER) += trace_stack.o
 obj-$(CONFIG_MMIOTRACE) += trace_mmiotrace.o
 obj-$(CONFIG_BOOT_TRACER) += trace_boot.o
 obj-$(CONFIG_FUNCTION_RET_TRACER) += trace_functions_return.o
+obj-$(CONFIG_TRACE_UNLIKELY_PROFILE) += trace_unlikely.o
 
 libftrace-y := ftrace.o
diff --git a/kernel/trace/trace_unlikely.c b/kernel/trace/trace_unlikely.c
new file mode 100644
index 000000000000..94932696069f
--- /dev/null
+++ b/kernel/trace/trace_unlikely.c
@@ -0,0 +1,164 @@
+/*
+ * 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/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>
+#include "trace.h"
+
+void ftrace_likely_update(struct ftrace_likely_data *f, int val, int expect)
+{
+        /* FIXME: Make this atomic! */
+        if (val == expect)
+                f->correct++;
+        else
+                f->incorrect++;
+}
+EXPORT_SYMBOL(ftrace_likely_update);
+
+struct ftrace_pointer {
+        void            *start;
+        void            *stop;
+};
+
+static void *
+t_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        struct ftrace_pointer *f = m->private;
+        struct ftrace_likely_data *p = v;
+
+        (*pos)++;
+
+        if (v == (void *)1)
+                return f->start;
+
+        ++p;
+
+        if ((void *)p >= (void *)f->stop)
+                return NULL;
+
+        return p;
+}
+
+static void *t_start(struct seq_file *m, loff_t *pos)
+{
+        void *t = (void *)1;
+        loff_t l = 0;
+
+        for (; t && l < *pos; t = t_next(m, t, &l))
+                ;
+
+        return t;
+}
+
+static void t_stop(struct seq_file *m, void *p)
+{
+}
+
+static int t_show(struct seq_file *m, void *v)
+{
+        struct ftrace_likely_data *p = v;
+        const char *f;
+        unsigned long percent;
+
+        if (v == (void *)1) {
+                seq_printf(m, " correct incorrect  %% "
+                              "       Function                "
+                              "  File              Line\n"
+                              " ------- ---------  - "
+                              "       --------                "
+                              "  ----              ----\n");
+                return 0;
+        }
+
+        /* Only print the file, not the path */
+        f = p->file + strlen(p->file);
+        while (f >= p->file && *f != '/')
+                f--;
+        f++;
+
+        if (p->correct) {
+                percent = p->incorrect * 100;
+                percent /= p->correct + p->incorrect;
+        } else
+                percent = p->incorrect ? 100 : 0;
+
+        seq_printf(m, "%8lu %8lu %3lu ", p->correct, p->incorrect, percent);
+        seq_printf(m, "%-30.30s %-20.20s %d\n", p->func, f, p->line);
+        return 0;
+}
+
+static struct seq_operations tracing_likely_seq_ops = {
+        .start          = t_start,
+        .next           = t_next,
+        .stop           = t_stop,
+        .show           = t_show,
+};
+
+static int tracing_likely_open(struct inode *inode, struct file *file)
+{
+        int ret;
+
+        ret = seq_open(file, &tracing_likely_seq_ops);
+        if (!ret) {
+                struct seq_file *m = file->private_data;
+                m->private = (void *)inode->i_private;
+        }
+
+        return ret;
+}
+
+static struct file_operations tracing_likely_fops = {
+        .open           = tracing_likely_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+};
+
+extern unsigned long __start_likely_profile[];
+extern unsigned long __stop_likely_profile[];
+extern unsigned long __start_unlikely_profile[];
+extern unsigned long __stop_unlikely_profile[];
+
+static struct ftrace_pointer ftrace_likely_pos = {
+        .start                  = __start_likely_profile,
+        .stop                   = __stop_likely_profile,
+};
+
+static struct ftrace_pointer ftrace_unlikely_pos = {
+        .start                  = __start_unlikely_profile,
+        .stop                   = __stop_unlikely_profile,
+};
+
+static __init int ftrace_unlikely_init(void)
+{
+        struct dentry *d_tracer;
+        struct dentry *entry;
+
+        d_tracer = tracing_init_dentry();
+
+        entry = debugfs_create_file("profile_likely", 0444, d_tracer,
+                                    &ftrace_likely_pos,
+                                    &tracing_likely_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs 'profile_likely' entry\n");
+
+        entry = debugfs_create_file("profile_unlikely", 0444, d_tracer,
+                                    &ftrace_unlikely_pos,
+                                    &tracing_likely_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs"
+                           " 'profile_unlikely' entry\n");
+
+        return 0;
+}
+
+device_initcall(ftrace_unlikely_init);