Merge commit 'v2.6.28-rc4' into timers/rtc

Conflicts:
	drivers/rtc/rtc-cmos.c

16 files changed, 4216 insertions, 1788 deletions

diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index 263e9e6bbd60..33dbefd471e8 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -1,23 +1,40 @@
 #
-# Architectures that offer an FTRACE implementation should select HAVE_FTRACE:
+# Architectures that offer an FUNCTION_TRACER implementation should
+#  select HAVE_FUNCTION_TRACER:
 #
-config HAVE_FTRACE
+
+config NOP_TRACER
+        bool
+
+config HAVE_FUNCTION_TRACER
         bool
 
 config HAVE_DYNAMIC_FTRACE
         bool
 
+config HAVE_FTRACE_MCOUNT_RECORD
+        bool
+
 config TRACER_MAX_TRACE
         bool
 
+config RING_BUFFER
+        bool
+
 config TRACING
         bool
         select DEBUG_FS
-        select STACKTRACE
+        select RING_BUFFER
+        select STACKTRACE if STACKTRACE_SUPPORT
+        select TRACEPOINTS
+        select NOP_TRACER
 
-config FTRACE
+menu "Tracers"
+
+config FUNCTION_TRACER
         bool "Kernel Function Tracer"
-        depends on HAVE_FTRACE
+        depends on HAVE_FUNCTION_TRACER
+        depends on DEBUG_KERNEL
         select FRAME_POINTER
         select TRACING
         select CONTEXT_SWITCH_TRACER
@@ -35,7 +52,7 @@ config IRQSOFF_TRACER
         default n
         depends on TRACE_IRQFLAGS_SUPPORT
         depends on GENERIC_TIME
-        depends on HAVE_FTRACE
+        depends on DEBUG_KERNEL
         select TRACE_IRQFLAGS
         select TRACING
         select TRACER_MAX_TRACE
@@ -58,7 +75,7 @@ config PREEMPT_TRACER
         default n
         depends on GENERIC_TIME
         depends on PREEMPT
-        depends on HAVE_FTRACE
+        depends on DEBUG_KERNEL
         select TRACING
         select TRACER_MAX_TRACE
         help
@@ -85,7 +102,7 @@ config SYSPROF_TRACER
 
 config SCHED_TRACER
         bool "Scheduling Latency Tracer"
-        depends on HAVE_FTRACE
+        depends on DEBUG_KERNEL
         select TRACING
         select CONTEXT_SWITCH_TRACER
         select TRACER_MAX_TRACE
@@ -95,17 +112,56 @@ config SCHED_TRACER
 
 config CONTEXT_SWITCH_TRACER
         bool "Trace process context switches"
-        depends on HAVE_FTRACE
+        depends on DEBUG_KERNEL
         select TRACING
         select MARKERS
         help
           This tracer gets called from the context switch and records
           all switching of tasks.
 
+config BOOT_TRACER
+        bool "Trace boot initcalls"
+        depends on DEBUG_KERNEL
+        select TRACING
+        select CONTEXT_SWITCH_TRACER
+        help
+          This tracer helps developers to optimize boot times: it records
+          the timings of the initcalls and traces key events and the identity
+          of tasks that can cause boot delays, such as context-switches.
+
+          Its aim is to be parsed by the /scripts/bootgraph.pl tool to
+          produce pretty graphics about boot inefficiencies, giving a visual
+          representation of the delays during initcalls - but the raw
+          /debug/tracing/trace text output is readable too.
+
+          ( Note that tracing self tests can't be enabled if this tracer is
+            selected, because the self-tests are an initcall as well and that
+            would invalidate the boot trace. )
+
+config STACK_TRACER
+        bool "Trace max stack"
+        depends on HAVE_FUNCTION_TRACER
+        depends on DEBUG_KERNEL
+        select FUNCTION_TRACER
+        select STACKTRACE
+        help
+          This special tracer records the maximum stack footprint of the
+          kernel and displays it in debugfs/tracing/stack_trace.
+
+          This tracer works by hooking into every function call that the
+          kernel executes, and keeping a maximum stack depth value and
+          stack-trace saved. Because this logic has to execute in every
+          kernel function, all the time, this option can slow down the
+          kernel measurably and is generally intended for kernel
+          developers only.
+
+          Say N if unsure.
+
 config DYNAMIC_FTRACE
         bool "enable/disable ftrace tracepoints dynamically"
-        depends on FTRACE
+        depends on FUNCTION_TRACER
         depends on HAVE_DYNAMIC_FTRACE
+        depends on DEBUG_KERNEL
         default y
         help
          This option will modify all the calls to ftrace dynamically
@@ -113,7 +169,7 @@ config DYNAMIC_FTRACE
          with a No-Op instruction) as they are called. A table is
          created to dynamically enable them again.
 
-         This way a CONFIG_FTRACE kernel is slightly larger, but otherwise
+         This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but otherwise
          has native performance as long as no tracing is active.
 
          The changes to the code are done by a kernel thread that
@@ -121,15 +177,22 @@ config DYNAMIC_FTRACE
          were made. If so, it runs stop_machine (stops all CPUS)
          and modifies the code to jump over the call to ftrace.
 
+config FTRACE_MCOUNT_RECORD
+        def_bool y
+        depends on DYNAMIC_FTRACE
+        depends on HAVE_FTRACE_MCOUNT_RECORD
+
 config FTRACE_SELFTEST
         bool
 
 config FTRACE_STARTUP_TEST
         bool "Perform a startup test on ftrace"
-        depends on TRACING
+        depends on TRACING && DEBUG_KERNEL && !BOOT_TRACER
         select FTRACE_SELFTEST
         help
           This option performs a series of startup tests on ftrace. On bootup
           a series of tests are made to verify that the tracer is
           functioning properly. It will do tests on all the configured
           tracers of ftrace.
+
+endmenu
diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
index 71d17de17288..c8228b1a49e9 100644
--- a/kernel/trace/Makefile
+++ b/kernel/trace/Makefile
@@ -1,7 +1,7 @@
 
 # Do not instrument the tracer itself:
 
-ifdef CONFIG_FTRACE
+ifdef CONFIG_FUNCTION_TRACER
 ORIG_CFLAGS := $(KBUILD_CFLAGS)
 KBUILD_CFLAGS = $(subst -pg,,$(ORIG_CFLAGS))
 
@@ -10,15 +10,19 @@ CFLAGS_trace_selftest_dynamic.o = -pg
 obj-y += trace_selftest_dynamic.o
 endif
 
-obj-$(CONFIG_FTRACE) += libftrace.o
+obj-$(CONFIG_FUNCTION_TRACER) += libftrace.o
+obj-$(CONFIG_RING_BUFFER) += ring_buffer.o
 
 obj-$(CONFIG_TRACING) += trace.o
 obj-$(CONFIG_CONTEXT_SWITCH_TRACER) += trace_sched_switch.o
 obj-$(CONFIG_SYSPROF_TRACER) += trace_sysprof.o
-obj-$(CONFIG_FTRACE) += trace_functions.o
+obj-$(CONFIG_FUNCTION_TRACER) += trace_functions.o
 obj-$(CONFIG_IRQSOFF_TRACER) += trace_irqsoff.o
 obj-$(CONFIG_PREEMPT_TRACER) += trace_irqsoff.o
 obj-$(CONFIG_SCHED_TRACER) += trace_sched_wakeup.o
+obj-$(CONFIG_NOP_TRACER) += trace_nop.o
+obj-$(CONFIG_STACK_TRACER) += trace_stack.o
 obj-$(CONFIG_MMIOTRACE) += trace_mmiotrace.o
+obj-$(CONFIG_BOOT_TRACER) += trace_boot.o
 
 libftrace-y := ftrace.o
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index f6e3af31b403..4a39d24568c8 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -25,13 +25,24 @@
 #include <linux/ftrace.h>
 #include <linux/sysctl.h>
 #include <linux/ctype.h>
-#include <linux/hash.h>
 #include <linux/list.h>
 
 #include <asm/ftrace.h>
 
 #include "trace.h"
 
+#define FTRACE_WARN_ON(cond)                    \
+        do {                                    \
+                if (WARN_ON(cond))              \
+                        ftrace_kill();          \
+        } while (0)
+
+#define FTRACE_WARN_ON_ONCE(cond)               \
+        do {                                    \
+                if (WARN_ON_ONCE(cond))         \
+                        ftrace_kill();          \
+        } while (0)
+
 /* ftrace_enabled is a method to turn ftrace on or off */
 int ftrace_enabled __read_mostly;
 static int last_ftrace_enabled;
@@ -81,7 +92,7 @@ void clear_ftrace_function(void)
 
 static int __register_ftrace_function(struct ftrace_ops *ops)
 {
-        /* Should never be called by interrupts */
+        /* should not be called from interrupt context */
         spin_lock(&ftrace_lock);
 
         ops->next = ftrace_list;
@@ -115,6 +126,7 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
         struct ftrace_ops **p;
         int ret = 0;
 
+        /* should not be called from interrupt context */
         spin_lock(&ftrace_lock);
 
         /*
@@ -152,8 +164,17 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
 }
 
 #ifdef CONFIG_DYNAMIC_FTRACE
+#ifndef CONFIG_FTRACE_MCOUNT_RECORD
+# error Dynamic ftrace depends on MCOUNT_RECORD
+#endif
 
-static struct task_struct *ftraced_task;
+/*
+ * Since MCOUNT_ADDR may point to mcount itself, we do not want
+ * to get it confused by reading a reference in the code as we
+ * are parsing on objcopy output of text. Use a variable for
+ * it instead.
+ */
+static unsigned long mcount_addr = MCOUNT_ADDR;
 
 enum {
         FTRACE_ENABLE_CALLS             = (1 << 0),
@@ -165,14 +186,9 @@ enum {
 
 static int ftrace_filtered;
 static int tracing_on;
-static int frozen_record_count;
 
-static struct hlist_head ftrace_hash[FTRACE_HASHSIZE];
+static LIST_HEAD(ftrace_new_addrs);
 
-static DEFINE_PER_CPU(int, ftrace_shutdown_disable_cpu);
-
-static DEFINE_SPINLOCK(ftrace_shutdown_lock);
-static DEFINE_MUTEX(ftraced_lock);
 static DEFINE_MUTEX(ftrace_regex_lock);
 
 struct ftrace_page {
@@ -190,16 +206,13 @@ struct ftrace_page {
 static struct ftrace_page       *ftrace_pages_start;
 static struct ftrace_page       *ftrace_pages;
 
-static int ftraced_trigger;
-static int ftraced_suspend;
-static int ftraced_stop;
-
-static int ftrace_record_suspend;
-
 static struct dyn_ftrace *ftrace_free_records;
 
 
 #ifdef CONFIG_KPROBES
+
+static int frozen_record_count;
+
 static inline void freeze_record(struct dyn_ftrace *rec)
 {
         if (!(rec->flags & FTRACE_FL_FROZEN)) {
@@ -226,79 +239,36 @@ static inline int record_frozen(struct dyn_ftrace *rec)
 # define record_frozen(rec)                     ({ 0; })
 #endif /* CONFIG_KPROBES */
 
-int skip_trace(unsigned long ip)
+static void ftrace_free_rec(struct dyn_ftrace *rec)
 {
-        unsigned long fl;
-        struct dyn_ftrace *rec;
-        struct hlist_node *t;
-        struct hlist_head *head;
-
-        if (frozen_record_count == 0)
-                return 0;
-
-        head = &ftrace_hash[hash_long(ip, FTRACE_HASHBITS)];
-        hlist_for_each_entry_rcu(rec, t, head, node) {
-                if (rec->ip == ip) {
-                        if (record_frozen(rec)) {
-                                if (rec->flags & FTRACE_FL_FAILED)
-                                        return 1;
-
-                                if (!(rec->flags & FTRACE_FL_CONVERTED))
-                                        return 1;
-
-                                if (!tracing_on || !ftrace_enabled)
-                                        return 1;
-
-                                if (ftrace_filtered) {
-                                        fl = rec->flags & (FTRACE_FL_FILTER |
-                                                           FTRACE_FL_NOTRACE);
-                                        if (!fl || (fl & FTRACE_FL_NOTRACE))
-                                                return 1;
-                                }
-                        }
-                        break;
-                }
-        }
-
-        return 0;
+        rec->ip = (unsigned long)ftrace_free_records;
+        ftrace_free_records = rec;
+        rec->flags |= FTRACE_FL_FREE;
 }
 
-static inline int
-ftrace_ip_in_hash(unsigned long ip, unsigned long key)
+void ftrace_release(void *start, unsigned long size)
 {
-        struct dyn_ftrace *p;
-        struct hlist_node *t;
-        int found = 0;
-
-        hlist_for_each_entry_rcu(p, t, &ftrace_hash[key], node) {
-                if (p->ip == ip) {
-                        found = 1;
-                        break;
-                }
-        }
-
-        return found;
-}
+        struct dyn_ftrace *rec;
+        struct ftrace_page *pg;
+        unsigned long s = (unsigned long)start;
+        unsigned long e = s + size;
+        int i;
 
-static inline void
-ftrace_add_hash(struct dyn_ftrace *node, unsigned long key)
-{
-        hlist_add_head_rcu(&node->node, &ftrace_hash[key]);
-}
+        if (ftrace_disabled || !start)
+                return;
 
-/* called from kstop_machine */
-static inline void ftrace_del_hash(struct dyn_ftrace *node)
-{
-        hlist_del(&node->node);
-}
+        /* should not be called from interrupt context */
+        spin_lock(&ftrace_lock);
 
-static void ftrace_free_rec(struct dyn_ftrace *rec)
-{
-        /* no locking, only called from kstop_machine */
+        for (pg = ftrace_pages_start; pg; pg = pg->next) {
+                for (i = 0; i < pg->index; i++) {
+                        rec = &pg->records[i];
 
-        rec->ip = (unsigned long)ftrace_free_records;
-        ftrace_free_records = rec;
-        rec->flags |= FTRACE_FL_FREE;
+                        if ((rec->ip >= s) && (rec->ip < e))
+                                ftrace_free_rec(rec);
+                }
+        }
+        spin_unlock(&ftrace_lock);
 }
 
 static struct dyn_ftrace *ftrace_alloc_dyn_node(unsigned long ip)
@@ -310,10 +280,8 @@ static struct dyn_ftrace *ftrace_alloc_dyn_node(unsigned long ip)
                 rec = ftrace_free_records;
 
                 if (unlikely(!(rec->flags & FTRACE_FL_FREE))) {
-                        WARN_ON_ONCE(1);
+                        FTRACE_WARN_ON_ONCE(1);
                         ftrace_free_records = NULL;
-                        ftrace_disabled = 1;
-                        ftrace_enabled = 0;
                         return NULL;
                 }
 
@@ -323,79 +291,36 @@ static struct dyn_ftrace *ftrace_alloc_dyn_node(unsigned long ip)
         }
 
         if (ftrace_pages->index == ENTRIES_PER_PAGE) {
-                if (!ftrace_pages->next)
-                        return NULL;
+                if (!ftrace_pages->next) {
+                        /* allocate another page */
+                        ftrace_pages->next =
+                                (void *)get_zeroed_page(GFP_KERNEL);
+                        if (!ftrace_pages->next)
+                                return NULL;
+                }
                 ftrace_pages = ftrace_pages->next;
         }
 
         return &ftrace_pages->records[ftrace_pages->index++];
 }
 
-static void
+static struct dyn_ftrace *
 ftrace_record_ip(unsigned long ip)
 {
-        struct dyn_ftrace *node;
-        unsigned long flags;
-        unsigned long key;
-        int resched;
-        int atomic;
-        int cpu;
+        struct dyn_ftrace *rec;
 
         if (!ftrace_enabled || ftrace_disabled)
-                return;
-
-        resched = need_resched();
-        preempt_disable_notrace();
-
-        /*
-         * We simply need to protect against recursion.
-         * Use the the raw version of smp_processor_id and not
-         * __get_cpu_var which can call debug hooks that can
-         * cause a recursive crash here.
-         */
-        cpu = raw_smp_processor_id();
-        per_cpu(ftrace_shutdown_disable_cpu, cpu)++;
-        if (per_cpu(ftrace_shutdown_disable_cpu, cpu) != 1)
-                goto out;
-
-        if (unlikely(ftrace_record_suspend))
-                goto out;
-
-        key = hash_long(ip, FTRACE_HASHBITS);
-
-        WARN_ON_ONCE(key >= FTRACE_HASHSIZE);
-
-        if (ftrace_ip_in_hash(ip, key))
-                goto out;
-
-        atomic = irqs_disabled();
-
-        spin_lock_irqsave(&ftrace_shutdown_lock, flags);
-
-        /* This ip may have hit the hash before the lock */
-        if (ftrace_ip_in_hash(ip, key))
-                goto out_unlock;
-
-        node = ftrace_alloc_dyn_node(ip);
-        if (!node)
-                goto out_unlock;
+                return NULL;
 
-        node->ip = ip;
-
-        ftrace_add_hash(node, key);
+        rec = ftrace_alloc_dyn_node(ip);
+        if (!rec)
+                return NULL;
 
-        ftraced_trigger = 1;
+        rec->ip = ip;
 
- out_unlock:
-        spin_unlock_irqrestore(&ftrace_shutdown_lock, flags);
- out:
-        per_cpu(ftrace_shutdown_disable_cpu, cpu)--;
+        list_add(&rec->list, &ftrace_new_addrs);
 
-        /* prevent recursion with scheduler */
-        if (resched)
-                preempt_enable_no_resched_notrace();
-        else
-                preempt_enable_notrace();
+        return rec;
 }
 
 #define FTRACE_ADDR ((long)(ftrace_caller))
@@ -514,7 +439,6 @@ static void ftrace_replace_code(int enable)
                                 rec->flags |= FTRACE_FL_FAILED;
                                 if ((system_state == SYSTEM_BOOTING) ||
                                     !core_kernel_text(rec->ip)) {
-                                        ftrace_del_hash(rec);
                                         ftrace_free_rec(rec);
                                 }
                         }
@@ -522,13 +446,14 @@ static void ftrace_replace_code(int enable)
         }
 }
 
-static void ftrace_shutdown_replenish(void)
+static void print_ip_ins(const char *fmt, unsigned char *p)
 {
-        if (ftrace_pages->next)
-                return;
+        int i;
+
+        printk(KERN_CONT "%s", fmt);
 
-        /* allocate another page */
-        ftrace_pages->next = (void *)get_zeroed_page(GFP_KERNEL);
+        for (i = 0; i < MCOUNT_INSN_SIZE; i++)
+                printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
 }
 
 static int
@@ -536,34 +461,52 @@ ftrace_code_disable(struct dyn_ftrace *rec)
 {
         unsigned long ip;
         unsigned char *nop, *call;
-        int failed;
+        int ret;
 
         ip = rec->ip;
 
         nop = ftrace_nop_replace();
-        call = ftrace_call_replace(ip, MCOUNT_ADDR);
+        call = ftrace_call_replace(ip, mcount_addr);
+
+        ret = ftrace_modify_code(ip, call, nop);
+        if (ret) {
+                switch (ret) {
+                case -EFAULT:
+                        FTRACE_WARN_ON_ONCE(1);
+                        pr_info("ftrace faulted on modifying ");
+                        print_ip_sym(ip);
+                        break;
+                case -EINVAL:
+                        FTRACE_WARN_ON_ONCE(1);
+                        pr_info("ftrace failed to modify ");
+                        print_ip_sym(ip);
+                        print_ip_ins(" expected: ", call);
+                        print_ip_ins(" actual: ", (unsigned char *)ip);
+                        print_ip_ins(" replace: ", nop);
+                        printk(KERN_CONT "\n");
+                        break;
+                case -EPERM:
+                        FTRACE_WARN_ON_ONCE(1);
+                        pr_info("ftrace faulted on writing ");
+                        print_ip_sym(ip);
+                        break;
+                default:
+                        FTRACE_WARN_ON_ONCE(1);
+                        pr_info("ftrace faulted on unknown error ");
+                        print_ip_sym(ip);
+                }
 
-        failed = ftrace_modify_code(ip, call, nop);
-        if (failed) {
                 rec->flags |= FTRACE_FL_FAILED;
                 return 0;
         }
         return 1;
 }
 
-static int __ftrace_update_code(void *ignore);
-
 static int __ftrace_modify_code(void *data)
 {
-        unsigned long addr;
         int *command = data;
 
         if (*command & FTRACE_ENABLE_CALLS) {
-                /*
-                 * Update any recorded ips now that we have the
-                 * machine stopped
-                 */
-                __ftrace_update_code(NULL);
                 ftrace_replace_code(1);
                 tracing_on = 1;
         } else if (*command & FTRACE_DISABLE_CALLS) {
@@ -574,14 +517,6 @@ static int __ftrace_modify_code(void *data)
         if (*command & FTRACE_UPDATE_TRACE_FUNC)
                 ftrace_update_ftrace_func(ftrace_trace_function);
 
-        if (*command & FTRACE_ENABLE_MCOUNT) {
-                addr = (unsigned long)ftrace_record_ip;
-                ftrace_mcount_set(&addr);
-        } else if (*command & FTRACE_DISABLE_MCOUNT) {
-                addr = (unsigned long)ftrace_stub;
-                ftrace_mcount_set(&addr);
-        }
-
         return 0;
 }
 
@@ -590,26 +525,9 @@ static void ftrace_run_update_code(int command)
         stop_machine(__ftrace_modify_code, &command, NULL);
 }
 
-void ftrace_disable_daemon(void)
-{
-        /* Stop the daemon from calling kstop_machine */
-        mutex_lock(&ftraced_lock);
-        ftraced_stop = 1;
-        mutex_unlock(&ftraced_lock);
-
-        ftrace_force_update();
-}
-
-void ftrace_enable_daemon(void)
-{
-        mutex_lock(&ftraced_lock);
-        ftraced_stop = 0;
-        mutex_unlock(&ftraced_lock);
-
-        ftrace_force_update();
-}
-
 static ftrace_func_t saved_ftrace_func;
+static int ftrace_start;
+static DEFINE_MUTEX(ftrace_start_lock);
 
 static void ftrace_startup(void)
 {
@@ -618,9 +536,9 @@ static void ftrace_startup(void)
         if (unlikely(ftrace_disabled))
                 return;
 
-        mutex_lock(&ftraced_lock);
-        ftraced_suspend++;
-        if (ftraced_suspend == 1)
+        mutex_lock(&ftrace_start_lock);
+        ftrace_start++;
+        if (ftrace_start == 1)
                 command |= FTRACE_ENABLE_CALLS;
 
         if (saved_ftrace_func != ftrace_trace_function) {
@@ -633,7 +551,7 @@ static void ftrace_startup(void)
 
         ftrace_run_update_code(command);
  out:
-        mutex_unlock(&ftraced_lock);
+        mutex_unlock(&ftrace_start_lock);
 }
 
 static void ftrace_shutdown(void)
@@ -643,9 +561,9 @@ static void ftrace_shutdown(void)
         if (unlikely(ftrace_disabled))
                 return;
 
-        mutex_lock(&ftraced_lock);
-        ftraced_suspend--;
-        if (!ftraced_suspend)
+        mutex_lock(&ftrace_start_lock);
+        ftrace_start--;
+        if (!ftrace_start)
                 command |= FTRACE_DISABLE_CALLS;
 
         if (saved_ftrace_func != ftrace_trace_function) {
@@ -658,7 +576,7 @@ static void ftrace_shutdown(void)
 
         ftrace_run_update_code(command);
  out:
-        mutex_unlock(&ftraced_lock);
+        mutex_unlock(&ftrace_start_lock);
 }
 
 static void ftrace_startup_sysctl(void)
@@ -668,15 +586,15 @@ static void ftrace_startup_sysctl(void)
         if (unlikely(ftrace_disabled))
                 return;
 
-        mutex_lock(&ftraced_lock);
+        mutex_lock(&ftrace_start_lock);
         /* Force update next time */
         saved_ftrace_func = NULL;
-        /* ftraced_suspend is true if we want ftrace running */
-        if (ftraced_suspend)
+        /* ftrace_start is true if we want ftrace running */
+        if (ftrace_start)
                 command |= FTRACE_ENABLE_CALLS;
 
         ftrace_run_update_code(command);
-        mutex_unlock(&ftraced_lock);
+        mutex_unlock(&ftrace_start_lock);
 }
 
 static void ftrace_shutdown_sysctl(void)
@@ -686,153 +604,51 @@ static void ftrace_shutdown_sysctl(void)
         if (unlikely(ftrace_disabled))
                 return;
 
-        mutex_lock(&ftraced_lock);
-        /* ftraced_suspend is true if ftrace is running */
-        if (ftraced_suspend)
+        mutex_lock(&ftrace_start_lock);
+        /* ftrace_start is true if ftrace is running */
+        if (ftrace_start)
                 command |= FTRACE_DISABLE_CALLS;
 
         ftrace_run_update_code(command);
-        mutex_unlock(&ftraced_lock);
+        mutex_unlock(&ftrace_start_lock);
 }
 
 static cycle_t          ftrace_update_time;
 static unsigned long    ftrace_update_cnt;
 unsigned long           ftrace_update_tot_cnt;
 
-static int __ftrace_update_code(void *ignore)
+static int ftrace_update_code(void)
 {
-        int i, save_ftrace_enabled;
+        struct dyn_ftrace *p, *t;
         cycle_t start, stop;
-        struct dyn_ftrace *p;
-        struct hlist_node *t, *n;
-        struct hlist_head *head, temp_list;
-
-        /* Don't be recording funcs now */
-        ftrace_record_suspend++;
-        save_ftrace_enabled = ftrace_enabled;
-        ftrace_enabled = 0;
 
         start = ftrace_now(raw_smp_processor_id());
         ftrace_update_cnt = 0;
 
-        /* No locks needed, the machine is stopped! */
-        for (i = 0; i < FTRACE_HASHSIZE; i++) {
-                INIT_HLIST_HEAD(&temp_list);
-                head = &ftrace_hash[i];
+        list_for_each_entry_safe(p, t, &ftrace_new_addrs, list) {
 
-                /* all CPUS are stopped, we are safe to modify code */
-                hlist_for_each_entry_safe(p, t, n, head, node) {
-                        /* Skip over failed records which have not been
-                         * freed. */
-                        if (p->flags & FTRACE_FL_FAILED)
-                                continue;
-
-                        /* Unconverted records are always at the head of the
-                         * hash bucket. Once we encounter a converted record,
-                         * simply skip over to the next bucket. Saves ftraced
-                         * some processor cycles (ftrace does its bid for
-                         * global warming :-p ). */
-                        if (p->flags & (FTRACE_FL_CONVERTED))
-                                break;
+                /* If something went wrong, bail without enabling anything */
+                if (unlikely(ftrace_disabled))
+                        return -1;
 
-                        /* Ignore updates to this record's mcount site.
-                         * Reintroduce this record at the head of this
-                         * bucket to attempt to "convert" it again if
-                         * the kprobe on it is unregistered before the
-                         * next run. */
-                        if (get_kprobe((void *)p->ip)) {
-                                ftrace_del_hash(p);
-                                INIT_HLIST_NODE(&p->node);
-                                hlist_add_head(&p->node, &temp_list);
-                                freeze_record(p);
-                                continue;
-                        } else {
-                                unfreeze_record(p);
-                        }
+                list_del_init(&p->list);
 
-                        /* convert record (i.e, patch mcount-call with NOP) */
-                        if (ftrace_code_disable(p)) {
-                                p->flags |= FTRACE_FL_CONVERTED;
-                                ftrace_update_cnt++;
-                        } else {
-                                if ((system_state == SYSTEM_BOOTING) ||
-                                    !core_kernel_text(p->ip)) {
-                                        ftrace_del_hash(p);
-                                        ftrace_free_rec(p);
-                                }
-                        }
-                }
-
-                hlist_for_each_entry_safe(p, t, n, &temp_list, node) {
-                        hlist_del(&p->node);
-                        INIT_HLIST_NODE(&p->node);
-                        hlist_add_head(&p->node, head);
-                }
+                /* convert record (i.e, patch mcount-call with NOP) */
+                if (ftrace_code_disable(p)) {
+                        p->flags |= FTRACE_FL_CONVERTED;
+                        ftrace_update_cnt++;
+                } else
+                        ftrace_free_rec(p);
         }
 
         stop = ftrace_now(raw_smp_processor_id());
         ftrace_update_time = stop - start;
         ftrace_update_tot_cnt += ftrace_update_cnt;
-        ftraced_trigger = 0;
-
-        ftrace_enabled = save_ftrace_enabled;
-        ftrace_record_suspend--;
 
         return 0;
 }
 
-static int ftrace_update_code(void)
-{
-        if (unlikely(ftrace_disabled) ||
-            !ftrace_enabled || !ftraced_trigger)
-                return 0;
-
-        stop_machine(__ftrace_update_code, NULL, NULL);
-
-        return 1;
-}
-
-static int ftraced(void *ignore)
-{
-        unsigned long usecs;
-
-        while (!kthread_should_stop()) {
-
-                set_current_state(TASK_INTERRUPTIBLE);
-
-                /* check once a second */
-                schedule_timeout(HZ);
-
-                if (unlikely(ftrace_disabled))
-                        continue;
-
-                mutex_lock(&ftrace_sysctl_lock);
-                mutex_lock(&ftraced_lock);
-                if (!ftraced_suspend && !ftraced_stop &&
-                    ftrace_update_code()) {
-                        usecs = nsecs_to_usecs(ftrace_update_time);
-                        if (ftrace_update_tot_cnt > 100000) {
-                                ftrace_update_tot_cnt = 0;
-                                pr_info("hm, dftrace overflow: %lu change%s"
-                                        " (%lu total) in %lu usec%s\n",
-                                        ftrace_update_cnt,
-                                        ftrace_update_cnt != 1 ? "s" : "",
-                                        ftrace_update_tot_cnt,
-                                        usecs, usecs != 1 ? "s" : "");
-                                ftrace_disabled = 1;
-                                WARN_ON_ONCE(1);
-                        }
-                }
-                mutex_unlock(&ftraced_lock);
-                mutex_unlock(&ftrace_sysctl_lock);
-
-                ftrace_shutdown_replenish();
-        }
-        __set_current_state(TASK_RUNNING);
-        return 0;
-}
-
-static int __init ftrace_dyn_table_alloc(void)
+static int __init ftrace_dyn_table_alloc(unsigned long num_to_init)
 {
         struct ftrace_page *pg;
         int cnt;
@@ -859,7 +675,9 @@ static int __init ftrace_dyn_table_alloc(void)
 
         pg = ftrace_pages = ftrace_pages_start;
 
-        cnt = NR_TO_INIT / ENTRIES_PER_PAGE;
+        cnt = num_to_init / ENTRIES_PER_PAGE;
+        pr_info("ftrace: allocating %ld entries in %d pages\n",
+                num_to_init, cnt);
 
         for (i = 0; i < cnt; i++) {
                 pg->next = (void *)get_zeroed_page(GFP_KERNEL);
@@ -901,6 +719,8 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
 
         (*pos)++;
 
+        /* should not be called from interrupt context */
+        spin_lock(&ftrace_lock);
  retry:
         if (iter->idx >= iter->pg->index) {
                 if (iter->pg->next) {
@@ -910,15 +730,13 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                 }
         } else {
                 rec = &iter->pg->records[iter->idx++];
-                if ((!(iter->flags & FTRACE_ITER_FAILURES) &&
+                if ((rec->flags & FTRACE_FL_FREE) ||
+
+                    (!(iter->flags & FTRACE_ITER_FAILURES) &&
                      (rec->flags & FTRACE_FL_FAILED)) ||
 
                     ((iter->flags & FTRACE_ITER_FAILURES) &&
-                     (!(rec->flags & FTRACE_FL_FAILED) ||
-                      (rec->flags & FTRACE_FL_FREE))) ||
-
-                    ((iter->flags & FTRACE_ITER_FILTER) &&
-                     !(rec->flags & FTRACE_FL_FILTER)) ||
+                     !(rec->flags & FTRACE_FL_FAILED)) ||
 
                     ((iter->flags & FTRACE_ITER_NOTRACE) &&
                      !(rec->flags & FTRACE_FL_NOTRACE))) {
@@ -926,6 +744,7 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                         goto retry;
                 }
         }
+        spin_unlock(&ftrace_lock);
 
         iter->pos = *pos;
 
@@ -1039,8 +858,8 @@ static void ftrace_filter_reset(int enable)
         unsigned long type = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
         unsigned i;
 
-        /* keep kstop machine from running */
-        preempt_disable();
+        /* should not be called from interrupt context */
+        spin_lock(&ftrace_lock);
         if (enable)
                 ftrace_filtered = 0;
         pg = ftrace_pages_start;
@@ -1053,7 +872,7 @@ static void ftrace_filter_reset(int enable)
                 }
                 pg = pg->next;
         }
-        preempt_enable();
+        spin_unlock(&ftrace_lock);
 }
 
 static int
@@ -1165,8 +984,8 @@ ftrace_match(unsigned char *buff, int len, int enable)
                 }
         }
 
-        /* keep kstop machine from running */
-        preempt_disable();
+        /* should not be called from interrupt context */
+        spin_lock(&ftrace_lock);
         if (enable)
                 ftrace_filtered = 1;
         pg = ftrace_pages_start;
@@ -1203,7 +1022,7 @@ ftrace_match(unsigned char *buff, int len, int enable)
                 }
                 pg = pg->next;
         }
-        preempt_enable();
+        spin_unlock(&ftrace_lock);
 }
 
 static ssize_t
@@ -1366,10 +1185,10 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
         }
 
         mutex_lock(&ftrace_sysctl_lock);
-        mutex_lock(&ftraced_lock);
-        if (iter->filtered && ftraced_suspend && ftrace_enabled)
+        mutex_lock(&ftrace_start_lock);
+        if (iter->filtered && ftrace_start && ftrace_enabled)
                 ftrace_run_update_code(FTRACE_ENABLE_CALLS);
-        mutex_unlock(&ftraced_lock);
+        mutex_unlock(&ftrace_start_lock);
         mutex_unlock(&ftrace_sysctl_lock);
 
         kfree(iter);
@@ -1389,55 +1208,6 @@ ftrace_notrace_release(struct inode *inode, struct file *file)
         return ftrace_regex_release(inode, file, 0);
 }
 
-static ssize_t
-ftraced_read(struct file *filp, char __user *ubuf,
-                     size_t cnt, loff_t *ppos)
-{
-        /* don't worry about races */
-        char *buf = ftraced_stop ? "disabled\n" : "enabled\n";
-        int r = strlen(buf);
-
-        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
-}
-
-static ssize_t
-ftraced_write(struct file *filp, const char __user *ubuf,
-                      size_t cnt, loff_t *ppos)
-{
-        char buf[64];
-        long val;
-        int ret;
-
-        if (cnt >= sizeof(buf))
-                return -EINVAL;
-
-        if (copy_from_user(&buf, ubuf, cnt))
-                return -EFAULT;
-
-        if (strncmp(buf, "enable", 6) == 0)
-                val = 1;
-        else if (strncmp(buf, "disable", 7) == 0)
-                val = 0;
-        else {
-                buf[cnt] = 0;
-
-                ret = strict_strtoul(buf, 10, &val);
-                if (ret < 0)
-                        return ret;
-
-                val = !!val;
-        }
-
-        if (val)
-                ftrace_enable_daemon();
-        else
-                ftrace_disable_daemon();
-
-        filp->f_pos += cnt;
-
-        return cnt;
-}
-
 static struct file_operations ftrace_avail_fops = {
         .open = ftrace_avail_open,
         .read = seq_read,
@@ -1468,54 +1238,6 @@ static struct file_operations ftrace_notrace_fops = {
         .release = ftrace_notrace_release,
 };
 
-static struct file_operations ftraced_fops = {
-        .open = tracing_open_generic,
-        .read = ftraced_read,
-        .write = ftraced_write,
-};
-
-/**
- * ftrace_force_update - force an update to all recording ftrace functions
- */
-int ftrace_force_update(void)
-{
-        int ret = 0;
-
-        if (unlikely(ftrace_disabled))
-                return -ENODEV;
-
-        mutex_lock(&ftrace_sysctl_lock);
-        mutex_lock(&ftraced_lock);
-
-        /*
-         * If ftraced_trigger is not set, then there is nothing
-         * to update.
-         */
-        if (ftraced_trigger && !ftrace_update_code())
-                ret = -EBUSY;
-
-        mutex_unlock(&ftraced_lock);
-        mutex_unlock(&ftrace_sysctl_lock);
-
-        return ret;
-}
-
-static void ftrace_force_shutdown(void)
-{
-        struct task_struct *task;
-        int command = FTRACE_DISABLE_CALLS | FTRACE_UPDATE_TRACE_FUNC;
-
-        mutex_lock(&ftraced_lock);
-        task = ftraced_task;
-        ftraced_task = NULL;
-        ftraced_suspend = -1;
-        ftrace_run_update_code(command);
-        mutex_unlock(&ftraced_lock);
-
-        if (task)
-                kthread_stop(task);
-}
-
 static __init int ftrace_init_debugfs(void)
 {
         struct dentry *d_tracer;
@@ -1546,97 +1268,103 @@ static __init int ftrace_init_debugfs(void)
                 pr_warning("Could not create debugfs "
                            "'set_ftrace_notrace' entry\n");
 
-        entry = debugfs_create_file("ftraced_enabled", 0644, d_tracer,
-                                    NULL, &ftraced_fops);
-        if (!entry)
-                pr_warning("Could not create debugfs "
-                           "'ftraced_enabled' entry\n");
         return 0;
 }
 
 fs_initcall(ftrace_init_debugfs);
 
-static int __init ftrace_dynamic_init(void)
+static int ftrace_convert_nops(unsigned long *start,
+                               unsigned long *end)
 {
-        struct task_struct *p;
+        unsigned long *p;
         unsigned long addr;
+        unsigned long flags;
+
+        mutex_lock(&ftrace_start_lock);
+        p = start;
+        while (p < end) {
+                addr = ftrace_call_adjust(*p++);
+                ftrace_record_ip(addr);
+        }
+
+        /* disable interrupts to prevent kstop machine */
+        local_irq_save(flags);
+        ftrace_update_code();
+        local_irq_restore(flags);
+        mutex_unlock(&ftrace_start_lock);
+
+        return 0;
+}
+
+void ftrace_init_module(unsigned long *start, unsigned long *end)
+{
+        if (ftrace_disabled || start == end)
+                return;
+        ftrace_convert_nops(start, end);
+}
+
+extern unsigned long __start_mcount_loc[];
+extern unsigned long __stop_mcount_loc[];
+
+void __init ftrace_init(void)
+{
+        unsigned long count, addr, flags;
         int ret;
 
-        addr = (unsigned long)ftrace_record_ip;
+        /* Keep the ftrace pointer to the stub */
+        addr = (unsigned long)ftrace_stub;
 
-        stop_machine(ftrace_dyn_arch_init, &addr, NULL);
+        local_irq_save(flags);
+        ftrace_dyn_arch_init(&addr);
+        local_irq_restore(flags);
 
         /* ftrace_dyn_arch_init places the return code in addr */
-        if (addr) {
-                ret = (int)addr;
+        if (addr)
                 goto failed;
-        }
 
-        ret = ftrace_dyn_table_alloc();
-        if (ret)
-                goto failed;
+        count = __stop_mcount_loc - __start_mcount_loc;
 
-        p = kthread_run(ftraced, NULL, "ftraced");
-        if (IS_ERR(p)) {
-                ret = -1;
+        ret = ftrace_dyn_table_alloc(count);
+        if (ret)
                 goto failed;
-        }
 
         last_ftrace_enabled = ftrace_enabled = 1;
-        ftraced_task = p;
 
-        return 0;
+        ret = ftrace_convert_nops(__start_mcount_loc,
+                                  __stop_mcount_loc);
 
+        return;
  failed:
         ftrace_disabled = 1;
-        return ret;
 }
 
-core_initcall(ftrace_dynamic_init);
 #else
+
+static int __init ftrace_nodyn_init(void)
+{
+        ftrace_enabled = 1;
+        return 0;
+}
+device_initcall(ftrace_nodyn_init);
+
 # define ftrace_startup()               do { } while (0)
 # define ftrace_shutdown()              do { } while (0)
 # define ftrace_startup_sysctl()        do { } while (0)
 # define ftrace_shutdown_sysctl()       do { } while (0)
-# define ftrace_force_shutdown()        do { } while (0)
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
 /**
- * ftrace_kill_atomic - kill ftrace from critical sections
+ * ftrace_kill - kill ftrace
  *
  * This function should be used by panic code. It stops ftrace
  * but in a not so nice way. If you need to simply kill ftrace
  * from a non-atomic section, use ftrace_kill.
  */
-void ftrace_kill_atomic(void)
-{
-        ftrace_disabled = 1;
-        ftrace_enabled = 0;
-#ifdef CONFIG_DYNAMIC_FTRACE
-        ftraced_suspend = -1;
-#endif
-        clear_ftrace_function();
-}
-
-/**
- * ftrace_kill - totally shutdown ftrace
- *
- * This is a safety measure. If something was detected that seems
- * wrong, calling this function will keep ftrace from doing
- * any more modifications, and updates.
- * used when something went wrong.
- */
 void ftrace_kill(void)
 {
-        mutex_lock(&ftrace_sysctl_lock);
         ftrace_disabled = 1;
         ftrace_enabled = 0;
-
         clear_ftrace_function();
-        mutex_unlock(&ftrace_sysctl_lock);
-
-        /* Try to totally disable ftrace */
-        ftrace_force_shutdown();
 }
 
 /**
@@ -1725,3 +1453,4 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
         mutex_unlock(&ftrace_sysctl_lock);
         return ret;
 }
+
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
new file mode 100644
index 000000000000..3f3380638646
--- /dev/null
+++ b/kernel/trace/ring_buffer.c
@@ -0,0 +1,2072 @@
+/*
+ * Generic ring buffer
+ *
+ * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
+ */
+#include <linux/ring_buffer.h>
+#include <linux/spinlock.h>
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <linux/percpu.h>
+#include <linux/mutex.h>
+#include <linux/sched.h>        /* used for sched_clock() (for now) */
+#include <linux/init.h>
+#include <linux/hash.h>
+#include <linux/list.h>
+#include <linux/fs.h>
+
+/* Up this if you want to test the TIME_EXTENTS and normalization */
+#define DEBUG_SHIFT 0
+
+/* FIXME!!! */
+u64 ring_buffer_time_stamp(int cpu)
+{
+        /* shift to debug/test normalization and TIME_EXTENTS */
+        return sched_clock() << DEBUG_SHIFT;
+}
+
+void ring_buffer_normalize_time_stamp(int cpu, u64 *ts)
+{
+        /* Just stupid testing the normalize function and deltas */
+        *ts >>= DEBUG_SHIFT;
+}
+
+#define RB_EVNT_HDR_SIZE (sizeof(struct ring_buffer_event))
+#define RB_ALIGNMENT_SHIFT      2
+#define RB_ALIGNMENT            (1 << RB_ALIGNMENT_SHIFT)
+#define RB_MAX_SMALL_DATA       28
+
+enum {
+        RB_LEN_TIME_EXTEND = 8,
+        RB_LEN_TIME_STAMP = 16,
+};
+
+/* inline for ring buffer fast paths */
+static inline unsigned
+rb_event_length(struct ring_buffer_event *event)
+{
+        unsigned length;
+
+        switch (event->type) {
+        case RINGBUF_TYPE_PADDING:
+                /* undefined */
+                return -1;
+
+        case RINGBUF_TYPE_TIME_EXTEND:
+                return RB_LEN_TIME_EXTEND;
+
+        case RINGBUF_TYPE_TIME_STAMP:
+                return RB_LEN_TIME_STAMP;
+
+        case RINGBUF_TYPE_DATA:
+                if (event->len)
+                        length = event->len << RB_ALIGNMENT_SHIFT;
+                else
+                        length = event->array[0];
+                return length + RB_EVNT_HDR_SIZE;
+        default:
+                BUG();
+        }
+        /* not hit */
+        return 0;
+}
+
+/**
+ * ring_buffer_event_length - return the length of the event
+ * @event: the event to get the length of
+ */
+unsigned ring_buffer_event_length(struct ring_buffer_event *event)
+{
+        return rb_event_length(event);
+}
+
+/* inline for ring buffer fast paths */
+static inline void *
+rb_event_data(struct ring_buffer_event *event)
+{
+        BUG_ON(event->type != RINGBUF_TYPE_DATA);
+        /* If length is in len field, then array[0] has the data */
+        if (event->len)
+                return (void *)&event->array[0];
+        /* Otherwise length is in array[0] and array[1] has the data */
+        return (void *)&event->array[1];
+}
+
+/**
+ * ring_buffer_event_data - return the data of the event
+ * @event: the event to get the data from
+ */
+void *ring_buffer_event_data(struct ring_buffer_event *event)
+{
+        return rb_event_data(event);
+}
+
+#define for_each_buffer_cpu(buffer, cpu)                \
+        for_each_cpu_mask(cpu, buffer->cpumask)
+
+#define TS_SHIFT        27
+#define TS_MASK         ((1ULL << TS_SHIFT) - 1)
+#define TS_DELTA_TEST   (~TS_MASK)
+
+/*
+ * This hack stolen from mm/slob.c.
+ * We can store per page timing information in the page frame of the page.
+ * Thanks to Peter Zijlstra for suggesting this idea.
+ */
+struct buffer_page {
+        u64              time_stamp;    /* page time stamp */
+        local_t          write;         /* index for next write */
+        local_t          commit;        /* write commited index */
+        unsigned         read;          /* index for next read */
+        struct list_head list;          /* list of free pages */
+        void *page;                     /* Actual data page */
+};
+
+/*
+ * Also stolen from mm/slob.c. Thanks to Mathieu Desnoyers for pointing
+ * this issue out.
+ */
+static inline void free_buffer_page(struct buffer_page *bpage)
+{
+        if (bpage->page)
+                free_page((unsigned long)bpage->page);
+        kfree(bpage);
+}
+
+/*
+ * We need to fit the time_stamp delta into 27 bits.
+ */
+static inline int test_time_stamp(u64 delta)
+{
+        if (delta & TS_DELTA_TEST)
+                return 1;
+        return 0;
+}
+
+#define BUF_PAGE_SIZE PAGE_SIZE
+
+/*
+ * head_page == tail_page && head == tail then buffer is empty.
+ */
+struct ring_buffer_per_cpu {
+        int                             cpu;
+        struct ring_buffer              *buffer;
+        spinlock_t                      lock;
+        struct lock_class_key           lock_key;
+        struct list_head                pages;
+        struct buffer_page              *head_page;     /* read from head */
+        struct buffer_page              *tail_page;     /* write to tail */
+        struct buffer_page              *commit_page;   /* commited pages */
+        struct buffer_page              *reader_page;
+        unsigned long                   overrun;
+        unsigned long                   entries;
+        u64                             write_stamp;
+        u64                             read_stamp;
+        atomic_t                        record_disabled;
+};
+
+struct ring_buffer {
+        unsigned long                   size;
+        unsigned                        pages;
+        unsigned                        flags;
+        int                             cpus;
+        cpumask_t                       cpumask;
+        atomic_t                        record_disabled;
+
+        struct mutex                    mutex;
+
+        struct ring_buffer_per_cpu      **buffers;
+};
+
+struct ring_buffer_iter {
+        struct ring_buffer_per_cpu      *cpu_buffer;
+        unsigned long                   head;
+        struct buffer_page              *head_page;
+        u64                             read_stamp;
+};
+
+#define RB_WARN_ON(buffer, cond)                                \
+        do {                                                    \
+                if (unlikely(cond)) {                           \
+                        atomic_inc(&buffer->record_disabled);   \
+                        WARN_ON(1);                             \
+                }                                               \
+        } while (0)
+
+#define RB_WARN_ON_RET(buffer, cond)                            \
+        do {                                                    \
+                if (unlikely(cond)) {                           \
+                        atomic_inc(&buffer->record_disabled);   \
+                        WARN_ON(1);                             \
+                        return -1;                              \
+                }                                               \
+        } while (0)
+
+#define RB_WARN_ON_ONCE(buffer, cond)                           \
+        do {                                                    \
+                static int once;                                \
+                if (unlikely(cond) && !once) {                  \
+                        once++;                                 \
+                        atomic_inc(&buffer->record_disabled);   \
+                        WARN_ON(1);                             \
+                }                                               \
+        } while (0)
+
+/**
+ * check_pages - integrity check of buffer pages
+ * @cpu_buffer: CPU buffer with pages to test
+ *
+ * As a safty measure we check to make sure the data pages have not
+ * been corrupted.
+ */
+static int rb_check_pages(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        struct list_head *head = &cpu_buffer->pages;
+        struct buffer_page *page, *tmp;
+
+        RB_WARN_ON_RET(cpu_buffer, head->next->prev != head);
+        RB_WARN_ON_RET(cpu_buffer, head->prev->next != head);
+
+        list_for_each_entry_safe(page, tmp, head, list) {
+                RB_WARN_ON_RET(cpu_buffer,
+                               page->list.next->prev != &page->list);
+                RB_WARN_ON_RET(cpu_buffer,
+                               page->list.prev->next != &page->list);
+        }
+
+        return 0;
+}
+
+static int rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
+                             unsigned nr_pages)
+{
+        struct list_head *head = &cpu_buffer->pages;
+        struct buffer_page *page, *tmp;
+        unsigned long addr;
+        LIST_HEAD(pages);
+        unsigned i;
+
+        for (i = 0; i < nr_pages; i++) {
+                page = kzalloc_node(ALIGN(sizeof(*page), cache_line_size()),
+                                    GFP_KERNEL, cpu_to_node(cpu_buffer->cpu));
+                if (!page)
+                        goto free_pages;
+                list_add(&page->list, &pages);
+
+                addr = __get_free_page(GFP_KERNEL);
+                if (!addr)
+                        goto free_pages;
+                page->page = (void *)addr;
+        }
+
+        list_splice(&pages, head);
+
+        rb_check_pages(cpu_buffer);
+
+        return 0;
+
+ free_pages:
+        list_for_each_entry_safe(page, tmp, &pages, list) {
+                list_del_init(&page->list);
+                free_buffer_page(page);
+        }
+        return -ENOMEM;
+}
+
+static struct ring_buffer_per_cpu *
+rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        struct buffer_page *page;
+        unsigned long addr;
+        int ret;
+
+        cpu_buffer = kzalloc_node(ALIGN(sizeof(*cpu_buffer), cache_line_size()),
+                                  GFP_KERNEL, cpu_to_node(cpu));
+        if (!cpu_buffer)
+                return NULL;
+
+        cpu_buffer->cpu = cpu;
+        cpu_buffer->buffer = buffer;
+        spin_lock_init(&cpu_buffer->lock);
+        INIT_LIST_HEAD(&cpu_buffer->pages);
+
+        page = kzalloc_node(ALIGN(sizeof(*page), cache_line_size()),
+                            GFP_KERNEL, cpu_to_node(cpu));
+        if (!page)
+                goto fail_free_buffer;
+
+        cpu_buffer->reader_page = page;
+        addr = __get_free_page(GFP_KERNEL);
+        if (!addr)
+                goto fail_free_reader;
+        page->page = (void *)addr;
+
+        INIT_LIST_HEAD(&cpu_buffer->reader_page->list);
+
+        ret = rb_allocate_pages(cpu_buffer, buffer->pages);
+        if (ret < 0)
+                goto fail_free_reader;
+
+        cpu_buffer->head_page
+                = list_entry(cpu_buffer->pages.next, struct buffer_page, list);
+        cpu_buffer->tail_page = cpu_buffer->commit_page = cpu_buffer->head_page;
+
+        return cpu_buffer;
+
+ fail_free_reader:
+        free_buffer_page(cpu_buffer->reader_page);
+
+ fail_free_buffer:
+        kfree(cpu_buffer);
+        return NULL;
+}
+
+static void rb_free_cpu_buffer(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        struct list_head *head = &cpu_buffer->pages;
+        struct buffer_page *page, *tmp;
+
+        list_del_init(&cpu_buffer->reader_page->list);
+        free_buffer_page(cpu_buffer->reader_page);
+
+        list_for_each_entry_safe(page, tmp, head, list) {
+                list_del_init(&page->list);
+                free_buffer_page(page);
+        }
+        kfree(cpu_buffer);
+}
+
+/*
+ * Causes compile errors if the struct buffer_page gets bigger
+ * than the struct page.
+ */
+extern int ring_buffer_page_too_big(void);
+
+/**
+ * ring_buffer_alloc - allocate a new ring_buffer
+ * @size: the size in bytes that is needed.
+ * @flags: attributes to set for the ring buffer.
+ *
+ * Currently the only flag that is available is the RB_FL_OVERWRITE
+ * flag. This flag means that the buffer will overwrite old data
+ * when the buffer wraps. If this flag is not set, the buffer will
+ * drop data when the tail hits the head.
+ */
+struct ring_buffer *ring_buffer_alloc(unsigned long size, unsigned flags)
+{
+        struct ring_buffer *buffer;
+        int bsize;
+        int cpu;
+
+        /* Paranoid! Optimizes out when all is well */
+        if (sizeof(struct buffer_page) > sizeof(struct page))
+                ring_buffer_page_too_big();
+
+
+        /* keep it in its own cache line */
+        buffer = kzalloc(ALIGN(sizeof(*buffer), cache_line_size()),
+                         GFP_KERNEL);
+        if (!buffer)
+                return NULL;
+
+        buffer->pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
+        buffer->flags = flags;
+
+        /* need at least two pages */
+        if (buffer->pages == 1)
+                buffer->pages++;
+
+        buffer->cpumask = cpu_possible_map;
+        buffer->cpus = nr_cpu_ids;
+
+        bsize = sizeof(void *) * nr_cpu_ids;
+        buffer->buffers = kzalloc(ALIGN(bsize, cache_line_size()),
+                                  GFP_KERNEL);
+        if (!buffer->buffers)
+                goto fail_free_buffer;
+
+        for_each_buffer_cpu(buffer, cpu) {
+                buffer->buffers[cpu] =
+                        rb_allocate_cpu_buffer(buffer, cpu);
+                if (!buffer->buffers[cpu])
+                        goto fail_free_buffers;
+        }
+
+        mutex_init(&buffer->mutex);
+
+        return buffer;
+
+ fail_free_buffers:
+        for_each_buffer_cpu(buffer, cpu) {
+                if (buffer->buffers[cpu])
+                        rb_free_cpu_buffer(buffer->buffers[cpu]);
+        }
+        kfree(buffer->buffers);
+
+ fail_free_buffer:
+        kfree(buffer);
+        return NULL;
+}
+
+/**
+ * ring_buffer_free - free a ring buffer.
+ * @buffer: the buffer to free.
+ */
+void
+ring_buffer_free(struct ring_buffer *buffer)
+{
+        int cpu;
+
+        for_each_buffer_cpu(buffer, cpu)
+                rb_free_cpu_buffer(buffer->buffers[cpu]);
+
+        kfree(buffer);
+}
+
+static void rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer);
+
+static void
+rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned nr_pages)
+{
+        struct buffer_page *page;
+        struct list_head *p;
+        unsigned i;
+
+        atomic_inc(&cpu_buffer->record_disabled);
+        synchronize_sched();
+
+        for (i = 0; i < nr_pages; i++) {
+                BUG_ON(list_empty(&cpu_buffer->pages));
+                p = cpu_buffer->pages.next;
+                page = list_entry(p, struct buffer_page, list);
+                list_del_init(&page->list);
+                free_buffer_page(page);
+        }
+        BUG_ON(list_empty(&cpu_buffer->pages));
+
+        rb_reset_cpu(cpu_buffer);
+
+        rb_check_pages(cpu_buffer);
+
+        atomic_dec(&cpu_buffer->record_disabled);
+
+}
+
+static void
+rb_insert_pages(struct ring_buffer_per_cpu *cpu_buffer,
+                struct list_head *pages, unsigned nr_pages)
+{
+        struct buffer_page *page;
+        struct list_head *p;
+        unsigned i;
+
+        atomic_inc(&cpu_buffer->record_disabled);
+        synchronize_sched();
+
+        for (i = 0; i < nr_pages; i++) {
+                BUG_ON(list_empty(pages));
+                p = pages->next;
+                page = list_entry(p, struct buffer_page, list);
+                list_del_init(&page->list);
+                list_add_tail(&page->list, &cpu_buffer->pages);
+        }
+        rb_reset_cpu(cpu_buffer);
+
+        rb_check_pages(cpu_buffer);
+
+        atomic_dec(&cpu_buffer->record_disabled);
+}
+
+/**
+ * ring_buffer_resize - resize the ring buffer
+ * @buffer: the buffer to resize.
+ * @size: the new size.
+ *
+ * The tracer is responsible for making sure that the buffer is
+ * not being used while changing the size.
+ * Note: We may be able to change the above requirement by using
+ *  RCU synchronizations.
+ *
+ * Minimum size is 2 * BUF_PAGE_SIZE.
+ *
+ * Returns -1 on failure.
+ */
+int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        unsigned nr_pages, rm_pages, new_pages;
+        struct buffer_page *page, *tmp;
+        unsigned long buffer_size;
+        unsigned long addr;
+        LIST_HEAD(pages);
+        int i, cpu;
+
+        size = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
+        size *= BUF_PAGE_SIZE;
+        buffer_size = buffer->pages * BUF_PAGE_SIZE;
+
+        /* we need a minimum of two pages */
+        if (size < BUF_PAGE_SIZE * 2)
+                size = BUF_PAGE_SIZE * 2;
+
+        if (size == buffer_size)
+                return size;
+
+        mutex_lock(&buffer->mutex);
+
+        nr_pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
+
+        if (size < buffer_size) {
+
+                /* easy case, just free pages */
+                BUG_ON(nr_pages >= buffer->pages);
+
+                rm_pages = buffer->pages - nr_pages;
+
+                for_each_buffer_cpu(buffer, cpu) {
+                        cpu_buffer = buffer->buffers[cpu];
+                        rb_remove_pages(cpu_buffer, rm_pages);
+                }
+                goto out;
+        }
+
+        /*
+         * This is a bit more difficult. We only want to add pages
+         * when we can allocate enough for all CPUs. We do this
+         * by allocating all the pages and storing them on a local
+         * link list. If we succeed in our allocation, then we
+         * add these pages to the cpu_buffers. Otherwise we just free
+         * them all and return -ENOMEM;
+         */
+        BUG_ON(nr_pages <= buffer->pages);
+        new_pages = nr_pages - buffer->pages;
+
+        for_each_buffer_cpu(buffer, cpu) {
+                for (i = 0; i < new_pages; i++) {
+                        page = kzalloc_node(ALIGN(sizeof(*page),
+                                                  cache_line_size()),
+                                            GFP_KERNEL, cpu_to_node(cpu));
+                        if (!page)
+                                goto free_pages;
+                        list_add(&page->list, &pages);
+                        addr = __get_free_page(GFP_KERNEL);
+                        if (!addr)
+                                goto free_pages;
+                        page->page = (void *)addr;
+                }
+        }
+
+        for_each_buffer_cpu(buffer, cpu) {
+                cpu_buffer = buffer->buffers[cpu];
+                rb_insert_pages(cpu_buffer, &pages, new_pages);
+        }
+
+        BUG_ON(!list_empty(&pages));
+
+ out:
+        buffer->pages = nr_pages;
+        mutex_unlock(&buffer->mutex);
+
+        return size;
+
+ free_pages:
+        list_for_each_entry_safe(page, tmp, &pages, list) {
+                list_del_init(&page->list);
+                free_buffer_page(page);
+        }
+        return -ENOMEM;
+}
+
+static inline int rb_null_event(struct ring_buffer_event *event)
+{
+        return event->type == RINGBUF_TYPE_PADDING;
+}
+
+static inline void *__rb_page_index(struct buffer_page *page, unsigned index)
+{
+        return page->page + index;
+}
+
+static inline struct ring_buffer_event *
+rb_reader_event(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        return __rb_page_index(cpu_buffer->reader_page,
+                               cpu_buffer->reader_page->read);
+}
+
+static inline struct ring_buffer_event *
+rb_head_event(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        return __rb_page_index(cpu_buffer->head_page,
+                               cpu_buffer->head_page->read);
+}
+
+static inline struct ring_buffer_event *
+rb_iter_head_event(struct ring_buffer_iter *iter)
+{
+        return __rb_page_index(iter->head_page, iter->head);
+}
+
+static inline unsigned rb_page_write(struct buffer_page *bpage)
+{
+        return local_read(&bpage->write);
+}
+
+static inline unsigned rb_page_commit(struct buffer_page *bpage)
+{
+        return local_read(&bpage->commit);
+}
+
+/* Size is determined by what has been commited */
+static inline unsigned rb_page_size(struct buffer_page *bpage)
+{
+        return rb_page_commit(bpage);
+}
+
+static inline unsigned
+rb_commit_index(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        return rb_page_commit(cpu_buffer->commit_page);
+}
+
+static inline unsigned rb_head_size(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        return rb_page_commit(cpu_buffer->head_page);
+}
+
+/*
+ * When the tail hits the head and the buffer is in overwrite mode,
+ * the head jumps to the next page and all content on the previous
+ * page is discarded. But before doing so, we update the overrun
+ * variable of the buffer.
+ */
+static void rb_update_overflow(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        struct ring_buffer_event *event;
+        unsigned long head;
+
+        for (head = 0; head < rb_head_size(cpu_buffer);
+             head += rb_event_length(event)) {
+
+                event = __rb_page_index(cpu_buffer->head_page, head);
+                BUG_ON(rb_null_event(event));
+                /* Only count data entries */
+                if (event->type != RINGBUF_TYPE_DATA)
+                        continue;
+                cpu_buffer->overrun++;
+                cpu_buffer->entries--;
+        }
+}
+
+static inline void rb_inc_page(struct ring_buffer_per_cpu *cpu_buffer,
+                               struct buffer_page **page)
+{
+        struct list_head *p = (*page)->list.next;
+
+        if (p == &cpu_buffer->pages)
+                p = p->next;
+
+        *page = list_entry(p, struct buffer_page, list);
+}
+
+static inline unsigned
+rb_event_index(struct ring_buffer_event *event)
+{
+        unsigned long addr = (unsigned long)event;
+
+        return (addr & ~PAGE_MASK) - (PAGE_SIZE - BUF_PAGE_SIZE);
+}
+
+static inline int
+rb_is_commit(struct ring_buffer_per_cpu *cpu_buffer,
+             struct ring_buffer_event *event)
+{
+        unsigned long addr = (unsigned long)event;
+        unsigned long index;
+
+        index = rb_event_index(event);
+        addr &= PAGE_MASK;
+
+        return cpu_buffer->commit_page->page == (void *)addr &&
+                rb_commit_index(cpu_buffer) == index;
+}
+
+static inline void
+rb_set_commit_event(struct ring_buffer_per_cpu *cpu_buffer,
+                    struct ring_buffer_event *event)
+{
+        unsigned long addr = (unsigned long)event;
+        unsigned long index;
+
+        index = rb_event_index(event);
+        addr &= PAGE_MASK;
+
+        while (cpu_buffer->commit_page->page != (void *)addr) {
+                RB_WARN_ON(cpu_buffer,
+                           cpu_buffer->commit_page == cpu_buffer->tail_page);
+                cpu_buffer->commit_page->commit =
+                        cpu_buffer->commit_page->write;
+                rb_inc_page(cpu_buffer, &cpu_buffer->commit_page);
+                cpu_buffer->write_stamp = cpu_buffer->commit_page->time_stamp;
+        }
+
+        /* Now set the commit to the event's index */
+        local_set(&cpu_buffer->commit_page->commit, index);
+}
+
+static inline void
+rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        /*
+         * We only race with interrupts and NMIs on this CPU.
+         * If we own the commit event, then we can commit
+         * all others that interrupted us, since the interruptions
+         * are in stack format (they finish before they come
+         * back to us). This allows us to do a simple loop to
+         * assign the commit to the tail.
+         */
+        while (cpu_buffer->commit_page != cpu_buffer->tail_page) {
+                cpu_buffer->commit_page->commit =
+                        cpu_buffer->commit_page->write;
+                rb_inc_page(cpu_buffer, &cpu_buffer->commit_page);
+                cpu_buffer->write_stamp = cpu_buffer->commit_page->time_stamp;
+                /* add barrier to keep gcc from optimizing too much */
+                barrier();
+        }
+        while (rb_commit_index(cpu_buffer) !=
+               rb_page_write(cpu_buffer->commit_page)) {
+                cpu_buffer->commit_page->commit =
+                        cpu_buffer->commit_page->write;
+                barrier();
+        }
+}
+
+static void rb_reset_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        cpu_buffer->read_stamp = cpu_buffer->reader_page->time_stamp;
+        cpu_buffer->reader_page->read = 0;
+}
+
+static inline void rb_inc_iter(struct ring_buffer_iter *iter)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+
+        /*
+         * The iterator could be on the reader page (it starts there).
+         * But the head could have moved, since the reader was
+         * found. Check for this case and assign the iterator
+         * to the head page instead of next.
+         */
+        if (iter->head_page == cpu_buffer->reader_page)
+                iter->head_page = cpu_buffer->head_page;
+        else
+                rb_inc_page(cpu_buffer, &iter->head_page);
+
+        iter->read_stamp = iter->head_page->time_stamp;
+        iter->head = 0;
+}
+
+/**
+ * ring_buffer_update_event - update event type and data
+ * @event: the even to update
+ * @type: the type of event
+ * @length: the size of the event field in the ring buffer
+ *
+ * Update the type and data fields of the event. The length
+ * is the actual size that is written to the ring buffer,
+ * and with this, we can determine what to place into the
+ * data field.
+ */
+static inline void
+rb_update_event(struct ring_buffer_event *event,
+                         unsigned type, unsigned length)
+{
+        event->type = type;
+
+        switch (type) {
+
+        case RINGBUF_TYPE_PADDING:
+                break;
+
+        case RINGBUF_TYPE_TIME_EXTEND:
+                event->len =
+                        (RB_LEN_TIME_EXTEND + (RB_ALIGNMENT-1))
+                        >> RB_ALIGNMENT_SHIFT;
+                break;
+
+        case RINGBUF_TYPE_TIME_STAMP:
+                event->len =
+                        (RB_LEN_TIME_STAMP + (RB_ALIGNMENT-1))
+                        >> RB_ALIGNMENT_SHIFT;
+                break;
+
+        case RINGBUF_TYPE_DATA:
+                length -= RB_EVNT_HDR_SIZE;
+                if (length > RB_MAX_SMALL_DATA) {
+                        event->len = 0;
+                        event->array[0] = length;
+                } else
+                        event->len =
+                                (length + (RB_ALIGNMENT-1))
+                                >> RB_ALIGNMENT_SHIFT;
+                break;
+        default:
+                BUG();
+        }
+}
+
+static inline unsigned rb_calculate_event_length(unsigned length)
+{
+        struct ring_buffer_event event; /* Used only for sizeof array */
+
+        /* zero length can cause confusions */
+        if (!length)
+                length = 1;
+
+        if (length > RB_MAX_SMALL_DATA)
+                length += sizeof(event.array[0]);
+
+        length += RB_EVNT_HDR_SIZE;
+        length = ALIGN(length, RB_ALIGNMENT);
+
+        return length;
+}
+
+static struct ring_buffer_event *
+__rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
+                  unsigned type, unsigned long length, u64 *ts)
+{
+        struct buffer_page *tail_page, *head_page, *reader_page;
+        unsigned long tail, write;
+        struct ring_buffer *buffer = cpu_buffer->buffer;
+        struct ring_buffer_event *event;
+        unsigned long flags;
+
+        tail_page = cpu_buffer->tail_page;
+        write = local_add_return(length, &tail_page->write);
+        tail = write - length;
+
+        /* See if we shot pass the end of this buffer page */
+        if (write > BUF_PAGE_SIZE) {
+                struct buffer_page *next_page = tail_page;
+
+                spin_lock_irqsave(&cpu_buffer->lock, flags);
+
+                rb_inc_page(cpu_buffer, &next_page);
+
+                head_page = cpu_buffer->head_page;
+                reader_page = cpu_buffer->reader_page;
+
+                /* we grabbed the lock before incrementing */
+                RB_WARN_ON(cpu_buffer, next_page == reader_page);
+
+                /*
+                 * If for some reason, we had an interrupt storm that made
+                 * it all the way around the buffer, bail, and warn
+                 * about it.
+                 */
+                if (unlikely(next_page == cpu_buffer->commit_page)) {
+                        WARN_ON_ONCE(1);
+                        goto out_unlock;
+                }
+
+                if (next_page == head_page) {
+                        if (!(buffer->flags & RB_FL_OVERWRITE)) {
+                                /* reset write */
+                                if (tail <= BUF_PAGE_SIZE)
+                                        local_set(&tail_page->write, tail);
+                                goto out_unlock;
+                        }
+
+                        /* tail_page has not moved yet? */
+                        if (tail_page == cpu_buffer->tail_page) {
+                                /* count overflows */
+                                rb_update_overflow(cpu_buffer);
+
+                                rb_inc_page(cpu_buffer, &head_page);
+                                cpu_buffer->head_page = head_page;
+                                cpu_buffer->head_page->read = 0;
+                        }
+                }
+
+                /*
+                 * If the tail page is still the same as what we think
+                 * it is, then it is up to us to update the tail
+                 * pointer.
+                 */
+                if (tail_page == cpu_buffer->tail_page) {
+                        local_set(&next_page->write, 0);
+                        local_set(&next_page->commit, 0);
+                        cpu_buffer->tail_page = next_page;
+
+                        /* reread the time stamp */
+                        *ts = ring_buffer_time_stamp(cpu_buffer->cpu);
+                        cpu_buffer->tail_page->time_stamp = *ts;
+                }
+
+                /*
+                 * The actual tail page has moved forward.
+                 */
+                if (tail < BUF_PAGE_SIZE) {
+                        /* Mark the rest of the page with padding */
+                        event = __rb_page_index(tail_page, tail);
+                        event->type = RINGBUF_TYPE_PADDING;
+                }
+
+                if (tail <= BUF_PAGE_SIZE)
+                        /* Set the write back to the previous setting */
+                        local_set(&tail_page->write, tail);
+
+                /*
+                 * If this was a commit entry that failed,
+                 * increment that too
+                 */
+                if (tail_page == cpu_buffer->commit_page &&
+                    tail == rb_commit_index(cpu_buffer)) {
+                        rb_set_commit_to_write(cpu_buffer);
+                }
+
+                spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+
+                /* fail and let the caller try again */
+                return ERR_PTR(-EAGAIN);
+        }
+
+        /* We reserved something on the buffer */
+
+        BUG_ON(write > BUF_PAGE_SIZE);
+
+        event = __rb_page_index(tail_page, tail);
+        rb_update_event(event, type, length);
+
+        /*
+         * If this is a commit and the tail is zero, then update
+         * this page's time stamp.
+         */
+        if (!tail && rb_is_commit(cpu_buffer, event))
+                cpu_buffer->commit_page->time_stamp = *ts;
+
+        return event;
+
+ out_unlock:
+        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+        return NULL;
+}
+
+static int
+rb_add_time_stamp(struct ring_buffer_per_cpu *cpu_buffer,
+                  u64 *ts, u64 *delta)
+{
+        struct ring_buffer_event *event;
+        static int once;
+        int ret;
+
+        if (unlikely(*delta > (1ULL << 59) && !once++)) {
+                printk(KERN_WARNING "Delta way too big! %llu"
+                       " ts=%llu write stamp = %llu\n",
+                       (unsigned long long)*delta,
+                       (unsigned long long)*ts,
+                       (unsigned long long)cpu_buffer->write_stamp);
+                WARN_ON(1);
+        }
+
+        /*
+         * The delta is too big, we to add a
+         * new timestamp.
+         */
+        event = __rb_reserve_next(cpu_buffer,
+                                  RINGBUF_TYPE_TIME_EXTEND,
+                                  RB_LEN_TIME_EXTEND,
+                                  ts);
+        if (!event)
+                return -EBUSY;
+
+        if (PTR_ERR(event) == -EAGAIN)
+                return -EAGAIN;
+
+        /* Only a commited time event can update the write stamp */
+        if (rb_is_commit(cpu_buffer, event)) {
+                /*
+                 * If this is the first on the page, then we need to
+                 * update the page itself, and just put in a zero.
+                 */
+                if (rb_event_index(event)) {
+                        event->time_delta = *delta & TS_MASK;
+                        event->array[0] = *delta >> TS_SHIFT;
+                } else {
+                        cpu_buffer->commit_page->time_stamp = *ts;
+                        event->time_delta = 0;
+                        event->array[0] = 0;
+                }
+                cpu_buffer->write_stamp = *ts;
+                /* let the caller know this was the commit */
+                ret = 1;
+        } else {
+                /* Darn, this is just wasted space */
+                event->time_delta = 0;
+                event->array[0] = 0;
+                ret = 0;
+        }
+
+        *delta = 0;
+
+        return ret;
+}
+
+static struct ring_buffer_event *
+rb_reserve_next_event(struct ring_buffer_per_cpu *cpu_buffer,
+                      unsigned type, unsigned long length)
+{
+        struct ring_buffer_event *event;
+        u64 ts, delta;
+        int commit = 0;
+        int nr_loops = 0;
+
+ again:
+        /*
+         * We allow for interrupts to reenter here and do a trace.
+         * If one does, it will cause this original code to loop
+         * back here. Even with heavy interrupts happening, this
+         * should only happen a few times in a row. If this happens
+         * 1000 times in a row, there must be either an interrupt
+         * storm or we have something buggy.
+         * Bail!
+         */
+        if (unlikely(++nr_loops > 1000)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
+
+        ts = ring_buffer_time_stamp(cpu_buffer->cpu);
+
+        /*
+         * Only the first commit can update the timestamp.
+         * Yes there is a race here. If an interrupt comes in
+         * just after the conditional and it traces too, then it
+         * will also check the deltas. More than one timestamp may
+         * also be made. But only the entry that did the actual
+         * commit will be something other than zero.
+         */
+        if (cpu_buffer->tail_page == cpu_buffer->commit_page &&
+            rb_page_write(cpu_buffer->tail_page) ==
+            rb_commit_index(cpu_buffer)) {
+
+                delta = ts - cpu_buffer->write_stamp;
+
+                /* make sure this delta is calculated here */
+                barrier();
+
+                /* Did the write stamp get updated already? */
+                if (unlikely(ts < cpu_buffer->write_stamp))
+                        goto again;
+
+                if (test_time_stamp(delta)) {
+
+                        commit = rb_add_time_stamp(cpu_buffer, &ts, &delta);
+
+                        if (commit == -EBUSY)
+                                return NULL;
+
+                        if (commit == -EAGAIN)
+                                goto again;
+
+                        RB_WARN_ON(cpu_buffer, commit < 0);
+                }
+        } else
+                /* Non commits have zero deltas */
+                delta = 0;
+
+        event = __rb_reserve_next(cpu_buffer, type, length, &ts);
+        if (PTR_ERR(event) == -EAGAIN)
+                goto again;
+
+        if (!event) {
+                if (unlikely(commit))
+                        /*
+                         * Ouch! We needed a timestamp and it was commited. But
+                         * we didn't get our event reserved.
+                         */
+                        rb_set_commit_to_write(cpu_buffer);
+                return NULL;
+        }
+
+        /*
+         * If the timestamp was commited, make the commit our entry
+         * now so that we will update it when needed.
+         */
+        if (commit)
+                rb_set_commit_event(cpu_buffer, event);
+        else if (!rb_is_commit(cpu_buffer, event))
+                delta = 0;
+
+        event->time_delta = delta;
+
+        return event;
+}
+
+static DEFINE_PER_CPU(int, rb_need_resched);
+
+/**
+ * ring_buffer_lock_reserve - reserve a part of the buffer
+ * @buffer: the ring buffer to reserve from
+ * @length: the length of the data to reserve (excluding event header)
+ * @flags: a pointer to save the interrupt flags
+ *
+ * Returns a reseverd event on the ring buffer to copy directly to.
+ * The user of this interface will need to get the body to write into
+ * and can use the ring_buffer_event_data() interface.
+ *
+ * The length is the length of the data needed, not the event length
+ * which also includes the event header.
+ *
+ * Must be paired with ring_buffer_unlock_commit, unless NULL is returned.
+ * If NULL is returned, then nothing has been allocated or locked.
+ */
+struct ring_buffer_event *
+ring_buffer_lock_reserve(struct ring_buffer *buffer,
+                         unsigned long length,
+                         unsigned long *flags)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_event *event;
+        int cpu, resched;
+
+        if (atomic_read(&buffer->record_disabled))
+                return NULL;
+
+        /* If we are tracing schedule, we don't want to recurse */
+        resched = need_resched();
+        preempt_disable_notrace();
+
+        cpu = raw_smp_processor_id();
+
+        if (!cpu_isset(cpu, buffer->cpumask))
+                goto out;
+
+        cpu_buffer = buffer->buffers[cpu];
+
+        if (atomic_read(&cpu_buffer->record_disabled))
+                goto out;
+
+        length = rb_calculate_event_length(length);
+        if (length > BUF_PAGE_SIZE)
+                goto out;
+
+        event = rb_reserve_next_event(cpu_buffer, RINGBUF_TYPE_DATA, length);
+        if (!event)
+                goto out;
+
+        /*
+         * Need to store resched state on this cpu.
+         * Only the first needs to.
+         */
+
+        if (preempt_count() == 1)
+                per_cpu(rb_need_resched, cpu) = resched;
+
+        return event;
+
+ out:
+        if (resched)
+                preempt_enable_notrace();
+        else
+                preempt_enable_notrace();
+        return NULL;
+}
+
+static void rb_commit(struct ring_buffer_per_cpu *cpu_buffer,
+                      struct ring_buffer_event *event)
+{
+        cpu_buffer->entries++;
+
+        /* Only process further if we own the commit */
+        if (!rb_is_commit(cpu_buffer, event))
+                return;
+
+        cpu_buffer->write_stamp += event->time_delta;
+
+        rb_set_commit_to_write(cpu_buffer);
+}
+
+/**
+ * ring_buffer_unlock_commit - commit a reserved
+ * @buffer: The buffer to commit to
+ * @event: The event pointer to commit.
+ * @flags: the interrupt flags received from ring_buffer_lock_reserve.
+ *
+ * This commits the data to the ring buffer, and releases any locks held.
+ *
+ * Must be paired with ring_buffer_lock_reserve.
+ */
+int ring_buffer_unlock_commit(struct ring_buffer *buffer,
+                              struct ring_buffer_event *event,
+                              unsigned long flags)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        int cpu = raw_smp_processor_id();
+
+        cpu_buffer = buffer->buffers[cpu];
+
+        rb_commit(cpu_buffer, event);
+
+        /*
+         * Only the last preempt count needs to restore preemption.
+         */
+        if (preempt_count() == 1) {
+                if (per_cpu(rb_need_resched, cpu))
+                        preempt_enable_no_resched_notrace();
+                else
+                        preempt_enable_notrace();
+        } else
+                preempt_enable_no_resched_notrace();
+
+        return 0;
+}
+
+/**
+ * ring_buffer_write - write data to the buffer without reserving
+ * @buffer: The ring buffer to write to.
+ * @length: The length of the data being written (excluding the event header)
+ * @data: The data to write to the buffer.
+ *
+ * This is like ring_buffer_lock_reserve and ring_buffer_unlock_commit as
+ * one function. If you already have the data to write to the buffer, it
+ * may be easier to simply call this function.
+ *
+ * Note, like ring_buffer_lock_reserve, the length is the length of the data
+ * and not the length of the event which would hold the header.
+ */
+int ring_buffer_write(struct ring_buffer *buffer,
+                        unsigned long length,
+                        void *data)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_event *event;
+        unsigned long event_length;
+        void *body;
+        int ret = -EBUSY;
+        int cpu, resched;
+
+        if (atomic_read(&buffer->record_disabled))
+                return -EBUSY;
+
+        resched = need_resched();
+        preempt_disable_notrace();
+
+        cpu = raw_smp_processor_id();
+
+        if (!cpu_isset(cpu, buffer->cpumask))
+                goto out;
+
+        cpu_buffer = buffer->buffers[cpu];
+
+        if (atomic_read(&cpu_buffer->record_disabled))
+                goto out;
+
+        event_length = rb_calculate_event_length(length);
+        event = rb_reserve_next_event(cpu_buffer,
+                                      RINGBUF_TYPE_DATA, event_length);
+        if (!event)
+                goto out;
+
+        body = rb_event_data(event);
+
+        memcpy(body, data, length);
+
+        rb_commit(cpu_buffer, event);
+
+        ret = 0;
+ out:
+        if (resched)
+                preempt_enable_no_resched_notrace();
+        else
+                preempt_enable_notrace();
+
+        return ret;
+}
+
+static inline int rb_per_cpu_empty(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        struct buffer_page *reader = cpu_buffer->reader_page;
+        struct buffer_page *head = cpu_buffer->head_page;
+        struct buffer_page *commit = cpu_buffer->commit_page;
+
+        return reader->read == rb_page_commit(reader) &&
+                (commit == reader ||
+                 (commit == head &&
+                  head->read == rb_page_commit(commit)));
+}
+
+/**
+ * ring_buffer_record_disable - stop all writes into the buffer
+ * @buffer: The ring buffer to stop writes to.
+ *
+ * This prevents all writes to the buffer. Any attempt to write
+ * to the buffer after this will fail and return NULL.
+ *
+ * The caller should call synchronize_sched() after this.
+ */
+void ring_buffer_record_disable(struct ring_buffer *buffer)
+{
+        atomic_inc(&buffer->record_disabled);
+}
+
+/**
+ * ring_buffer_record_enable - enable writes to the buffer
+ * @buffer: The ring buffer to enable writes
+ *
+ * Note, multiple disables will need the same number of enables
+ * to truely enable the writing (much like preempt_disable).
+ */
+void ring_buffer_record_enable(struct ring_buffer *buffer)
+{
+        atomic_dec(&buffer->record_disabled);
+}
+
+/**
+ * ring_buffer_record_disable_cpu - stop all writes into the cpu_buffer
+ * @buffer: The ring buffer to stop writes to.
+ * @cpu: The CPU buffer to stop
+ *
+ * This prevents all writes to the buffer. Any attempt to write
+ * to the buffer after this will fail and return NULL.
+ *
+ * The caller should call synchronize_sched() after this.
+ */
+void ring_buffer_record_disable_cpu(struct ring_buffer *buffer, int cpu)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+
+        if (!cpu_isset(cpu, buffer->cpumask))
+                return;
+
+        cpu_buffer = buffer->buffers[cpu];
+        atomic_inc(&cpu_buffer->record_disabled);
+}
+
+/**
+ * ring_buffer_record_enable_cpu - enable writes to the buffer
+ * @buffer: The ring buffer to enable writes
+ * @cpu: The CPU to enable.
+ *
+ * Note, multiple disables will need the same number of enables
+ * to truely enable the writing (much like preempt_disable).
+ */
+void ring_buffer_record_enable_cpu(struct ring_buffer *buffer, int cpu)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+
+        if (!cpu_isset(cpu, buffer->cpumask))
+                return;
+
+        cpu_buffer = buffer->buffers[cpu];
+        atomic_dec(&cpu_buffer->record_disabled);
+}
+
+/**
+ * ring_buffer_entries_cpu - get the number of entries in a cpu buffer
+ * @buffer: The ring buffer
+ * @cpu: The per CPU buffer to get the entries from.
+ */
+unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+
+        if (!cpu_isset(cpu, buffer->cpumask))
+                return 0;
+
+        cpu_buffer = buffer->buffers[cpu];
+        return cpu_buffer->entries;
+}
+
+/**
+ * ring_buffer_overrun_cpu - get the number of overruns in a cpu_buffer
+ * @buffer: The ring buffer
+ * @cpu: The per CPU buffer to get the number of overruns from
+ */
+unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+
+        if (!cpu_isset(cpu, buffer->cpumask))
+                return 0;
+
+        cpu_buffer = buffer->buffers[cpu];
+        return cpu_buffer->overrun;
+}
+
+/**
+ * ring_buffer_entries - get the number of entries in a buffer
+ * @buffer: The ring buffer
+ *
+ * Returns the total number of entries in the ring buffer
+ * (all CPU entries)
+ */
+unsigned long ring_buffer_entries(struct ring_buffer *buffer)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        unsigned long entries = 0;
+        int cpu;
+
+        /* if you care about this being correct, lock the buffer */
+        for_each_buffer_cpu(buffer, cpu) {
+                cpu_buffer = buffer->buffers[cpu];
+                entries += cpu_buffer->entries;
+        }
+
+        return entries;
+}
+
+/**
+ * ring_buffer_overrun_cpu - get the number of overruns in buffer
+ * @buffer: The ring buffer
+ *
+ * Returns the total number of overruns in the ring buffer
+ * (all CPU entries)
+ */
+unsigned long ring_buffer_overruns(struct ring_buffer *buffer)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        unsigned long overruns = 0;
+        int cpu;
+
+        /* if you care about this being correct, lock the buffer */
+        for_each_buffer_cpu(buffer, cpu) {
+                cpu_buffer = buffer->buffers[cpu];
+                overruns += cpu_buffer->overrun;
+        }
+
+        return overruns;
+}
+
+/**
+ * ring_buffer_iter_reset - reset an iterator
+ * @iter: The iterator to reset
+ *
+ * Resets the iterator, so that it will start from the beginning
+ * again.
+ */
+void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+
+        /* Iterator usage is expected to have record disabled */
+        if (list_empty(&cpu_buffer->reader_page->list)) {
+                iter->head_page = cpu_buffer->head_page;
+                iter->head = cpu_buffer->head_page->read;
+        } else {
+                iter->head_page = cpu_buffer->reader_page;
+                iter->head = cpu_buffer->reader_page->read;
+        }
+        if (iter->head)
+                iter->read_stamp = cpu_buffer->read_stamp;
+        else
+                iter->read_stamp = iter->head_page->time_stamp;
+}
+
+/**
+ * ring_buffer_iter_empty - check if an iterator has no more to read
+ * @iter: The iterator to check
+ */
+int ring_buffer_iter_empty(struct ring_buffer_iter *iter)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+
+        cpu_buffer = iter->cpu_buffer;
+
+        return iter->head_page == cpu_buffer->commit_page &&
+                iter->head == rb_commit_index(cpu_buffer);
+}
+
+static void
+rb_update_read_stamp(struct ring_buffer_per_cpu *cpu_buffer,
+                     struct ring_buffer_event *event)
+{
+        u64 delta;
+
+        switch (event->type) {
+        case RINGBUF_TYPE_PADDING:
+                return;
+
+        case RINGBUF_TYPE_TIME_EXTEND:
+                delta = event->array[0];
+                delta <<= TS_SHIFT;
+                delta += event->time_delta;
+                cpu_buffer->read_stamp += delta;
+                return;
+
+        case RINGBUF_TYPE_TIME_STAMP:
+                /* FIXME: not implemented */
+                return;
+
+        case RINGBUF_TYPE_DATA:
+                cpu_buffer->read_stamp += event->time_delta;
+                return;
+
+        default:
+                BUG();
+        }
+        return;
+}
+
+static void
+rb_update_iter_read_stamp(struct ring_buffer_iter *iter,
+                          struct ring_buffer_event *event)
+{
+        u64 delta;
+
+        switch (event->type) {
+        case RINGBUF_TYPE_PADDING:
+                return;
+
+        case RINGBUF_TYPE_TIME_EXTEND:
+                delta = event->array[0];
+                delta <<= TS_SHIFT;
+                delta += event->time_delta;
+                iter->read_stamp += delta;
+                return;
+
+        case RINGBUF_TYPE_TIME_STAMP:
+                /* FIXME: not implemented */
+                return;
+
+        case RINGBUF_TYPE_DATA:
+                iter->read_stamp += event->time_delta;
+                return;
+
+        default:
+                BUG();
+        }
+        return;
+}
+
+static struct buffer_page *
+rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        struct buffer_page *reader = NULL;
+        unsigned long flags;
+        int nr_loops = 0;
+
+        spin_lock_irqsave(&cpu_buffer->lock, flags);
+
+ again:
+        /*
+         * This should normally only loop twice. But because the
+         * start of the reader inserts an empty page, it causes
+         * a case where we will loop three times. There should be no
+         * reason to loop four times (that I know of).
+         */
+        if (unlikely(++nr_loops > 3)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                reader = NULL;
+                goto out;
+        }
+
+        reader = cpu_buffer->reader_page;
+
+        /* If there's more to read, return this page */
+        if (cpu_buffer->reader_page->read < rb_page_size(reader))
+                goto out;
+
+        /* Never should we have an index greater than the size */
+        RB_WARN_ON(cpu_buffer,
+                   cpu_buffer->reader_page->read > rb_page_size(reader));
+
+        /* check if we caught up to the tail */
+        reader = NULL;
+        if (cpu_buffer->commit_page == cpu_buffer->reader_page)
+                goto out;
+
+        /*
+         * Splice the empty reader page into the list around the head.
+         * Reset the reader page to size zero.
+         */
+
+        reader = cpu_buffer->head_page;
+        cpu_buffer->reader_page->list.next = reader->list.next;
+        cpu_buffer->reader_page->list.prev = reader->list.prev;
+
+        local_set(&cpu_buffer->reader_page->write, 0);
+        local_set(&cpu_buffer->reader_page->commit, 0);
+
+        /* Make the reader page now replace the head */
+        reader->list.prev->next = &cpu_buffer->reader_page->list;
+        reader->list.next->prev = &cpu_buffer->reader_page->list;
+
+        /*
+         * If the tail is on the reader, then we must set the head
+         * to the inserted page, otherwise we set it one before.
+         */
+        cpu_buffer->head_page = cpu_buffer->reader_page;
+
+        if (cpu_buffer->commit_page != reader)
+                rb_inc_page(cpu_buffer, &cpu_buffer->head_page);
+
+        /* Finally update the reader page to the new head */
+        cpu_buffer->reader_page = reader;
+        rb_reset_reader_page(cpu_buffer);
+
+        goto again;
+
+ out:
+        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+
+        return reader;
+}
+
+static void rb_advance_reader(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        struct ring_buffer_event *event;
+        struct buffer_page *reader;
+        unsigned length;
+
+        reader = rb_get_reader_page(cpu_buffer);
+
+        /* This function should not be called when buffer is empty */
+        BUG_ON(!reader);
+
+        event = rb_reader_event(cpu_buffer);
+
+        if (event->type == RINGBUF_TYPE_DATA)
+                cpu_buffer->entries--;
+
+        rb_update_read_stamp(cpu_buffer, event);
+
+        length = rb_event_length(event);
+        cpu_buffer->reader_page->read += length;
+}
+
+static void rb_advance_iter(struct ring_buffer_iter *iter)
+{
+        struct ring_buffer *buffer;
+        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_event *event;
+        unsigned length;
+
+        cpu_buffer = iter->cpu_buffer;
+        buffer = cpu_buffer->buffer;
+
+        /*
+         * Check if we are at the end of the buffer.
+         */
+        if (iter->head >= rb_page_size(iter->head_page)) {
+                BUG_ON(iter->head_page == cpu_buffer->commit_page);
+                rb_inc_iter(iter);
+                return;
+        }
+
+        event = rb_iter_head_event(iter);
+
+        length = rb_event_length(event);
+
+        /*
+         * This should not be called to advance the header if we are
+         * at the tail of the buffer.
+         */
+        BUG_ON((iter->head_page == cpu_buffer->commit_page) &&
+               (iter->head + length > rb_commit_index(cpu_buffer)));
+
+        rb_update_iter_read_stamp(iter, event);
+
+        iter->head += length;
+
+        /* check for end of page padding */
+        if ((iter->head >= rb_page_size(iter->head_page)) &&
+            (iter->head_page != cpu_buffer->commit_page))
+                rb_advance_iter(iter);
+}
+
+/**
+ * ring_buffer_peek - peek at the next event to be read
+ * @buffer: The ring buffer to read
+ * @cpu: The cpu to peak at
+ * @ts: The timestamp counter of this event.
+ *
+ * This will return the event that will be read next, but does
+ * not consume the data.
+ */
+struct ring_buffer_event *
+ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_event *event;
+        struct buffer_page *reader;
+        int nr_loops = 0;
+
+        if (!cpu_isset(cpu, buffer->cpumask))
+                return NULL;
+
+        cpu_buffer = buffer->buffers[cpu];
+
+ again:
+        /*
+         * We repeat when a timestamp is encountered. It is possible
+         * to get multiple timestamps from an interrupt entering just
+         * as one timestamp is about to be written. The max times
+         * that this can happen is the number of nested interrupts we
+         * can have.  Nesting 10 deep of interrupts is clearly
+         * an anomaly.
+         */
+        if (unlikely(++nr_loops > 10)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
+
+        reader = rb_get_reader_page(cpu_buffer);
+        if (!reader)
+                return NULL;
+
+        event = rb_reader_event(cpu_buffer);
+
+        switch (event->type) {
+        case RINGBUF_TYPE_PADDING:
+                RB_WARN_ON(cpu_buffer, 1);
+                rb_advance_reader(cpu_buffer);
+                return NULL;
+
+        case RINGBUF_TYPE_TIME_EXTEND:
+                /* Internal data, OK to advance */
+                rb_advance_reader(cpu_buffer);
+                goto again;
+
+        case RINGBUF_TYPE_TIME_STAMP:
+                /* FIXME: not implemented */
+                rb_advance_reader(cpu_buffer);
+                goto again;
+
+        case RINGBUF_TYPE_DATA:
+                if (ts) {
+                        *ts = cpu_buffer->read_stamp + event->time_delta;
+                        ring_buffer_normalize_time_stamp(cpu_buffer->cpu, ts);
+                }
+                return event;
+
+        default:
+                BUG();
+        }
+
+        return NULL;
+}
+
+/**
+ * ring_buffer_iter_peek - peek at the next event to be read
+ * @iter: The ring buffer iterator
+ * @ts: The timestamp counter of this event.
+ *
+ * This will return the event that will be read next, but does
+ * not increment the iterator.
+ */
+struct ring_buffer_event *
+ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
+{
+        struct ring_buffer *buffer;
+        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_event *event;
+        int nr_loops = 0;
+
+        if (ring_buffer_iter_empty(iter))
+                return NULL;
+
+        cpu_buffer = iter->cpu_buffer;
+        buffer = cpu_buffer->buffer;
+
+ again:
+        /*
+         * We repeat when a timestamp is encountered. It is possible
+         * to get multiple timestamps from an interrupt entering just
+         * as one timestamp is about to be written. The max times
+         * that this can happen is the number of nested interrupts we
+         * can have. Nesting 10 deep of interrupts is clearly
+         * an anomaly.
+         */
+        if (unlikely(++nr_loops > 10)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
+
+        if (rb_per_cpu_empty(cpu_buffer))
+                return NULL;
+
+        event = rb_iter_head_event(iter);
+
+        switch (event->type) {
+        case RINGBUF_TYPE_PADDING:
+                rb_inc_iter(iter);
+                goto again;
+
+        case RINGBUF_TYPE_TIME_EXTEND:
+                /* Internal data, OK to advance */
+                rb_advance_iter(iter);
+                goto again;
+
+        case RINGBUF_TYPE_TIME_STAMP:
+                /* FIXME: not implemented */
+                rb_advance_iter(iter);
+                goto again;
+
+        case RINGBUF_TYPE_DATA:
+                if (ts) {
+                        *ts = iter->read_stamp + event->time_delta;
+                        ring_buffer_normalize_time_stamp(cpu_buffer->cpu, ts);
+                }
+                return event;
+
+        default:
+                BUG();
+        }
+
+        return NULL;
+}
+
+/**
+ * ring_buffer_consume - return an event and consume it
+ * @buffer: The ring buffer to get the next event from
+ *
+ * Returns the next event in the ring buffer, and that event is consumed.
+ * Meaning, that sequential reads will keep returning a different event,
+ * and eventually empty the ring buffer if the producer is slower.
+ */
+struct ring_buffer_event *
+ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_event *event;
+
+        if (!cpu_isset(cpu, buffer->cpumask))
+                return NULL;
+
+        event = ring_buffer_peek(buffer, cpu, ts);
+        if (!event)
+                return NULL;
+
+        cpu_buffer = buffer->buffers[cpu];
+        rb_advance_reader(cpu_buffer);
+
+        return event;
+}
+
+/**
+ * ring_buffer_read_start - start a non consuming read of the buffer
+ * @buffer: The ring buffer to read from
+ * @cpu: The cpu buffer to iterate over
+ *
+ * This starts up an iteration through the buffer. It also disables
+ * the recording to the buffer until the reading is finished.
+ * This prevents the reading from being corrupted. This is not
+ * a consuming read, so a producer is not expected.
+ *
+ * Must be paired with ring_buffer_finish.
+ */
+struct ring_buffer_iter *
+ring_buffer_read_start(struct ring_buffer *buffer, int cpu)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_iter *iter;
+        unsigned long flags;
+
+        if (!cpu_isset(cpu, buffer->cpumask))
+                return NULL;
+
+        iter = kmalloc(sizeof(*iter), GFP_KERNEL);
+        if (!iter)
+                return NULL;
+
+        cpu_buffer = buffer->buffers[cpu];
+
+        iter->cpu_buffer = cpu_buffer;
+
+        atomic_inc(&cpu_buffer->record_disabled);
+        synchronize_sched();
+
+        spin_lock_irqsave(&cpu_buffer->lock, flags);
+        ring_buffer_iter_reset(iter);
+        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+
+        return iter;
+}
+
+/**
+ * ring_buffer_finish - finish reading the iterator of the buffer
+ * @iter: The iterator retrieved by ring_buffer_start
+ *
+ * This re-enables the recording to the buffer, and frees the
+ * iterator.
+ */
+void
+ring_buffer_read_finish(struct ring_buffer_iter *iter)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+
+        atomic_dec(&cpu_buffer->record_disabled);
+        kfree(iter);
+}
+
+/**
+ * ring_buffer_read - read the next item in the ring buffer by the iterator
+ * @iter: The ring buffer iterator
+ * @ts: The time stamp of the event read.
+ *
+ * This reads the next event in the ring buffer and increments the iterator.
+ */
+struct ring_buffer_event *
+ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts)
+{
+        struct ring_buffer_event *event;
+
+        event = ring_buffer_iter_peek(iter, ts);
+        if (!event)
+                return NULL;
+
+        rb_advance_iter(iter);
+
+        return event;
+}
+
+/**
+ * ring_buffer_size - return the size of the ring buffer (in bytes)
+ * @buffer: The ring buffer.
+ */
+unsigned long ring_buffer_size(struct ring_buffer *buffer)
+{
+        return BUF_PAGE_SIZE * buffer->pages;
+}
+
+static void
+rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
+{
+        cpu_buffer->head_page
+                = list_entry(cpu_buffer->pages.next, struct buffer_page, list);
+        local_set(&cpu_buffer->head_page->write, 0);
+        local_set(&cpu_buffer->head_page->commit, 0);
+
+        cpu_buffer->head_page->read = 0;
+
+        cpu_buffer->tail_page = cpu_buffer->head_page;
+        cpu_buffer->commit_page = cpu_buffer->head_page;
+
+        INIT_LIST_HEAD(&cpu_buffer->reader_page->list);
+        local_set(&cpu_buffer->reader_page->write, 0);
+        local_set(&cpu_buffer->reader_page->commit, 0);
+        cpu_buffer->reader_page->read = 0;
+
+        cpu_buffer->overrun = 0;
+        cpu_buffer->entries = 0;
+}
+
+/**
+ * ring_buffer_reset_cpu - reset a ring buffer per CPU buffer
+ * @buffer: The ring buffer to reset a per cpu buffer of
+ * @cpu: The CPU buffer to be reset
+ */
+void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
+        unsigned long flags;
+
+        if (!cpu_isset(cpu, buffer->cpumask))
+                return;
+
+        spin_lock_irqsave(&cpu_buffer->lock, flags);
+
+        rb_reset_cpu(cpu_buffer);
+
+        spin_unlock_irqrestore(&cpu_buffer->lock, flags);
+}
+
+/**
+ * ring_buffer_reset - reset a ring buffer
+ * @buffer: The ring buffer to reset all cpu buffers
+ */
+void ring_buffer_reset(struct ring_buffer *buffer)
+{
+        int cpu;
+
+        for_each_buffer_cpu(buffer, cpu)
+                ring_buffer_reset_cpu(buffer, cpu);
+}
+
+/**
+ * rind_buffer_empty - is the ring buffer empty?
+ * @buffer: The ring buffer to test
+ */
+int ring_buffer_empty(struct ring_buffer *buffer)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        int cpu;
+
+        /* yes this is racy, but if you don't like the race, lock the buffer */
+        for_each_buffer_cpu(buffer, cpu) {
+                cpu_buffer = buffer->buffers[cpu];
+                if (!rb_per_cpu_empty(cpu_buffer))
+                        return 0;
+        }
+        return 1;
+}
+
+/**
+ * ring_buffer_empty_cpu - is a cpu buffer of a ring buffer empty?
+ * @buffer: The ring buffer
+ * @cpu: The CPU buffer to test
+ */
+int ring_buffer_empty_cpu(struct ring_buffer *buffer, int cpu)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+
+        if (!cpu_isset(cpu, buffer->cpumask))
+                return 1;
+
+        cpu_buffer = buffer->buffers[cpu];
+        return rb_per_cpu_empty(cpu_buffer);
+}
+
+/**
+ * ring_buffer_swap_cpu - swap a CPU buffer between two ring buffers
+ * @buffer_a: One buffer to swap with
+ * @buffer_b: The other buffer to swap with
+ *
+ * This function is useful for tracers that want to take a "snapshot"
+ * of a CPU buffer and has another back up buffer lying around.
+ * it is expected that the tracer handles the cpu buffer not being
+ * used at the moment.
+ */
+int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
+                         struct ring_buffer *buffer_b, int cpu)
+{
+        struct ring_buffer_per_cpu *cpu_buffer_a;
+        struct ring_buffer_per_cpu *cpu_buffer_b;
+
+        if (!cpu_isset(cpu, buffer_a->cpumask) ||
+            !cpu_isset(cpu, buffer_b->cpumask))
+                return -EINVAL;
+
+        /* At least make sure the two buffers are somewhat the same */
+        if (buffer_a->size != buffer_b->size ||
+            buffer_a->pages != buffer_b->pages)
+                return -EINVAL;
+
+        cpu_buffer_a = buffer_a->buffers[cpu];
+        cpu_buffer_b = buffer_b->buffers[cpu];
+
+        /*
+         * We can't do a synchronize_sched here because this
+         * function can be called in atomic context.
+         * Normally this will be called from the same CPU as cpu.
+         * If not it's up to the caller to protect this.
+         */
+        atomic_inc(&cpu_buffer_a->record_disabled);
+        atomic_inc(&cpu_buffer_b->record_disabled);
+
+        buffer_a->buffers[cpu] = cpu_buffer_b;
+        buffer_b->buffers[cpu] = cpu_buffer_a;
+
+        cpu_buffer_b->buffer = buffer_a;
+        cpu_buffer_a->buffer = buffer_b;
+
+        atomic_dec(&cpu_buffer_a->record_disabled);
+        atomic_dec(&cpu_buffer_b->record_disabled);
+
+        return 0;
+}
+
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 8f3fb3db61c3..9f3b478f9171 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -14,6 +14,7 @@
 #include <linux/utsrelease.h>
 #include <linux/kallsyms.h>
 #include <linux/seq_file.h>
+#include <linux/notifier.h>
 #include <linux/debugfs.h>
 #include <linux/pagemap.h>
 #include <linux/hardirq.h>
@@ -22,6 +23,7 @@
 #include <linux/ftrace.h>
 #include <linux/module.h>
 #include <linux/percpu.h>
+#include <linux/kdebug.h>
 #include <linux/ctype.h>
 #include <linux/init.h>
 #include <linux/poll.h>
@@ -31,25 +33,37 @@
 #include <linux/writeback.h>
 
 #include <linux/stacktrace.h>
+#include <linux/ring_buffer.h>
+#include <linux/irqflags.h>
 
 #include "trace.h"
 
+#define TRACE_BUFFER_FLAGS      (RB_FL_OVERWRITE)
+
 unsigned long __read_mostly     tracing_max_latency = (cycle_t)ULONG_MAX;
 unsigned long __read_mostly     tracing_thresh;
 
-static unsigned long __read_mostly      tracing_nr_buffers;
+static DEFINE_PER_CPU(local_t, ftrace_cpu_disabled);
+
+static inline void ftrace_disable_cpu(void)
+{
+        preempt_disable();
+        local_inc(&__get_cpu_var(ftrace_cpu_disabled));
+}
+
+static inline void ftrace_enable_cpu(void)
+{
+        local_dec(&__get_cpu_var(ftrace_cpu_disabled));
+        preempt_enable();
+}
+
 static cpumask_t __read_mostly          tracing_buffer_mask;
 
 #define for_each_tracing_cpu(cpu)       \
         for_each_cpu_mask(cpu, tracing_buffer_mask)
 
-static int trace_alloc_page(void);
-static int trace_free_page(void);
-
 static int tracing_disabled = 1;
 
-static unsigned long tracing_pages_allocated;
-
 long
 ns2usecs(cycle_t nsec)
 {
@@ -60,7 +74,9 @@ ns2usecs(cycle_t nsec)
 
 cycle_t ftrace_now(int cpu)
 {
-        return cpu_clock(cpu);
+        u64 ts = ring_buffer_time_stamp(cpu);
+        ring_buffer_normalize_time_stamp(cpu, &ts);
+        return ts;
 }
 
 /*
@@ -100,11 +116,18 @@ static int			tracer_enabled = 1;
 int                             ftrace_function_enabled;
 
 /*
- * trace_nr_entries is the number of entries that is allocated
- * for a buffer. Note, the number of entries is always rounded
- * to ENTRIES_PER_PAGE.
+ * trace_buf_size is the size in bytes that is allocated
+ * for a buffer. Note, the number of bytes is always rounded
+ * to page size.
+ *
+ * This number is purposely set to a low number of 16384.
+ * If the dump on oops happens, it will be much appreciated
+ * to not have to wait for all that output. Anyway this can be
+ * boot time and run time configurable.
  */
-static unsigned long            trace_nr_entries = 65536UL;
+#define TRACE_BUF_SIZE_DEFAULT  1441792UL /* 16384 * 88 (sizeof(entry)) */
+
+static unsigned long            trace_buf_size = TRACE_BUF_SIZE_DEFAULT;
 
 /* trace_types holds a link list of available tracers. */
 static struct tracer            *trace_types __read_mostly;
@@ -133,24 +156,6 @@ static DECLARE_WAIT_QUEUE_HEAD(trace_wait);
 /* trace_flags holds iter_ctrl options */
 unsigned long trace_flags = TRACE_ITER_PRINT_PARENT;
 
-static notrace void no_trace_init(struct trace_array *tr)
-{
-        int cpu;
-
-        ftrace_function_enabled = 0;
-        if(tr->ctrl)
-                for_each_online_cpu(cpu)
-                        tracing_reset(tr->data[cpu]);
-        tracer_enabled = 0;
-}
-
-/* dummy trace to disable tracing */
-static struct tracer no_tracer __read_mostly = {
-        .name           = "none",
-        .init           = no_trace_init
-};
-
-
 /**
  * trace_wake_up - wake up tasks waiting for trace input
  *
@@ -167,23 +172,21 @@ void trace_wake_up(void)
                 wake_up(&trace_wait);
 }
 
-#define ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(struct trace_entry))
-
-static int __init set_nr_entries(char *str)
+static int __init set_buf_size(char *str)
 {
-        unsigned long nr_entries;
+        unsigned long buf_size;
         int ret;
 
         if (!str)
                 return 0;
-        ret = strict_strtoul(str, 0, &nr_entries);
+        ret = strict_strtoul(str, 0, &buf_size);
         /* nr_entries can not be zero */
-        if (ret < 0 || nr_entries == 0)
+        if (ret < 0 || buf_size == 0)
                 return 0;
-        trace_nr_entries = nr_entries;
+        trace_buf_size = buf_size;
         return 1;
 }
-__setup("trace_entries=", set_nr_entries);
+__setup("trace_buf_size=", set_buf_size);
 
 unsigned long nsecs_to_usecs(unsigned long nsecs)
 {
@@ -191,21 +194,6 @@ unsigned long nsecs_to_usecs(unsigned long nsecs)
 }
 
 /*
- * trace_flag_type is an enumeration that holds different
- * states when a trace occurs. These are:
- *  IRQS_OFF    - interrupts were disabled
- *  NEED_RESCED - reschedule is requested
- *  HARDIRQ     - inside an interrupt handler
- *  SOFTIRQ     - inside a softirq handler
- */
-enum trace_flag_type {
-        TRACE_FLAG_IRQS_OFF             = 0x01,
-        TRACE_FLAG_NEED_RESCHED         = 0x02,
-        TRACE_FLAG_HARDIRQ              = 0x04,
-        TRACE_FLAG_SOFTIRQ              = 0x08,
-};
-
-/*
  * TRACE_ITER_SYM_MASK masks the options in trace_flags that
  * control the output of kernel symbols.
  */
@@ -224,6 +212,7 @@ static const char *trace_options[] = {
         "block",
         "stacktrace",
         "sched-tree",
+        "ftrace_printk",
         NULL
 };
 
@@ -266,54 +255,6 @@ __update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
         tracing_record_cmdline(current);
 }
 
-#define CHECK_COND(cond)                        \
-        if (unlikely(cond)) {                   \
-                tracing_disabled = 1;           \
-                WARN_ON(1);                     \
-                return -1;                      \
-        }
-
-/**
- * check_pages - integrity check of trace buffers
- *
- * As a safty measure we check to make sure the data pages have not
- * been corrupted.
- */
-int check_pages(struct trace_array_cpu *data)
-{
-        struct page *page, *tmp;
-
-        CHECK_COND(data->trace_pages.next->prev != &data->trace_pages);
-        CHECK_COND(data->trace_pages.prev->next != &data->trace_pages);
-
-        list_for_each_entry_safe(page, tmp, &data->trace_pages, lru) {
-                CHECK_COND(page->lru.next->prev != &page->lru);
-                CHECK_COND(page->lru.prev->next != &page->lru);
-        }
-
-        return 0;
-}
-
-/**
- * head_page - page address of the first page in per_cpu buffer.
- *
- * head_page returns the page address of the first page in
- * a per_cpu buffer. This also preforms various consistency
- * checks to make sure the buffer has not been corrupted.
- */
-void *head_page(struct trace_array_cpu *data)
-{
-        struct page *page;
-
-        if (list_empty(&data->trace_pages))
-                return NULL;
-
-        page = list_entry(data->trace_pages.next, struct page, lru);
-        BUG_ON(&page->lru == &data->trace_pages);
-
-        return page_address(page);
-}
-
 /**
  * trace_seq_printf - sequence printing of trace information
  * @s: trace sequence descriptor
@@ -395,28 +336,23 @@ trace_seq_putmem(struct trace_seq *s, void *mem, size_t len)
         return len;
 }
 
-#define HEX_CHARS 17
-static const char hex2asc[] = "0123456789abcdef";
+#define MAX_MEMHEX_BYTES        8
+#define HEX_CHARS               (MAX_MEMHEX_BYTES*2 + 1)
 
 static int
 trace_seq_putmem_hex(struct trace_seq *s, void *mem, size_t len)
 {
         unsigned char hex[HEX_CHARS];
         unsigned char *data = mem;
-        unsigned char byte;
         int i, j;
 
-        BUG_ON(len >= HEX_CHARS);
-
 #ifdef __BIG_ENDIAN
         for (i = 0, j = 0; i < len; i++) {
 #else
         for (i = len-1, j = 0; i >= 0; i--) {
 #endif
-                byte = data[i];
-
-                hex[j++] = hex2asc[byte & 0x0f];
-                hex[j++] = hex2asc[byte >> 4];
+                hex[j++] = hex_asc_hi(data[i]);
+                hex[j++] = hex_asc_lo(data[i]);
         }
         hex[j++] = ' ';
 
@@ -460,34 +396,6 @@ trace_print_seq(struct seq_file *m, struct trace_seq *s)
         trace_seq_reset(s);
 }
 
-/*
- * flip the trace buffers between two trace descriptors.
- * This usually is the buffers between the global_trace and
- * the max_tr to record a snapshot of a current trace.
- *
- * The ftrace_max_lock must be held.
- */
-static void
-flip_trace(struct trace_array_cpu *tr1, struct trace_array_cpu *tr2)
-{
-        struct list_head flip_pages;
-
-        INIT_LIST_HEAD(&flip_pages);
-
-        memcpy(&tr1->trace_head_idx, &tr2->trace_head_idx,
-                sizeof(struct trace_array_cpu) -
-                offsetof(struct trace_array_cpu, trace_head_idx));
-
-        check_pages(tr1);
-        check_pages(tr2);
-        list_splice_init(&tr1->trace_pages, &flip_pages);
-        list_splice_init(&tr2->trace_pages, &tr1->trace_pages);
-        list_splice_init(&flip_pages, &tr2->trace_pages);
-        BUG_ON(!list_empty(&flip_pages));
-        check_pages(tr1);
-        check_pages(tr2);
-}
-
 /**
  * update_max_tr - snapshot all trace buffers from global_trace to max_tr
  * @tr: tracer
@@ -500,17 +408,17 @@ flip_trace(struct trace_array_cpu *tr1, struct trace_array_cpu *tr2)
 void
 update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
 {
-        struct trace_array_cpu *data;
-        int i;
+        struct ring_buffer *buf = tr->buffer;
 
         WARN_ON_ONCE(!irqs_disabled());
         __raw_spin_lock(&ftrace_max_lock);
-        /* clear out all the previous traces */
-        for_each_tracing_cpu(i) {
-                data = tr->data[i];
-                flip_trace(max_tr.data[i], data);
-                tracing_reset(data);
-        }
+
+        tr->buffer = max_tr.buffer;
+        max_tr.buffer = buf;
+
+        ftrace_disable_cpu();
+        ring_buffer_reset(tr->buffer);
+        ftrace_enable_cpu();
 
         __update_max_tr(tr, tsk, cpu);
         __raw_spin_unlock(&ftrace_max_lock);
@@ -527,16 +435,19 @@ update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
 void
 update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu)
 {
-        struct trace_array_cpu *data = tr->data[cpu];
-        int i;
+        int ret;
 
         WARN_ON_ONCE(!irqs_disabled());
         __raw_spin_lock(&ftrace_max_lock);
-        for_each_tracing_cpu(i)
-                tracing_reset(max_tr.data[i]);
 
-        flip_trace(max_tr.data[cpu], data);
-        tracing_reset(data);
+        ftrace_disable_cpu();
+
+        ring_buffer_reset(max_tr.buffer);
+        ret = ring_buffer_swap_cpu(max_tr.buffer, tr->buffer, cpu);
+
+        ftrace_enable_cpu();
+
+        WARN_ON_ONCE(ret);
 
         __update_max_tr(tr, tsk, cpu);
         __raw_spin_unlock(&ftrace_max_lock);
@@ -573,7 +484,6 @@ int register_tracer(struct tracer *type)
 #ifdef CONFIG_FTRACE_STARTUP_TEST
         if (type->selftest) {
                 struct tracer *saved_tracer = current_trace;
-                struct trace_array_cpu *data;
                 struct trace_array *tr = &global_trace;
                 int saved_ctrl = tr->ctrl;
                 int i;
@@ -585,10 +495,7 @@ int register_tracer(struct tracer *type)
                  * If we fail, we do not register this tracer.
                  */
                 for_each_tracing_cpu(i) {
-                        data = tr->data[i];
-                        if (!head_page(data))
-                                continue;
-                        tracing_reset(data);
+                        tracing_reset(tr, i);
                 }
                 current_trace = type;
                 tr->ctrl = 0;
@@ -604,10 +511,7 @@ int register_tracer(struct tracer *type)
                 }
                 /* Only reset on passing, to avoid touching corrupted buffers */
                 for_each_tracing_cpu(i) {
-                        data = tr->data[i];
-                        if (!head_page(data))
-                                continue;
-                        tracing_reset(data);
+                        tracing_reset(tr, i);
                 }
                 printk(KERN_CONT "PASSED\n");
         }
@@ -653,13 +557,11 @@ void unregister_tracer(struct tracer *type)
         mutex_unlock(&trace_types_lock);
 }
 
-void tracing_reset(struct trace_array_cpu *data)
+void tracing_reset(struct trace_array *tr, int cpu)
 {
-        data->trace_idx = 0;
-        data->overrun = 0;
-        data->trace_head = data->trace_tail = head_page(data);
-        data->trace_head_idx = 0;
-        data->trace_tail_idx = 0;
+        ftrace_disable_cpu();
+        ring_buffer_reset_cpu(tr->buffer, cpu);
+        ftrace_enable_cpu();
 }
 
 #define SAVED_CMDLINES 128
@@ -745,82 +647,20 @@ void tracing_record_cmdline(struct task_struct *tsk)
         trace_save_cmdline(tsk);
 }
 
-static inline struct list_head *
-trace_next_list(struct trace_array_cpu *data, struct list_head *next)
-{
-        /*
-         * Roundrobin - but skip the head (which is not a real page):
-         */
-        next = next->next;
-        if (unlikely(next == &data->trace_pages))
-                next = next->next;
-        BUG_ON(next == &data->trace_pages);
-
-        return next;
-}
-
-static inline void *
-trace_next_page(struct trace_array_cpu *data, void *addr)
-{
-        struct list_head *next;
-        struct page *page;
-
-        page = virt_to_page(addr);
-
-        next = trace_next_list(data, &page->lru);
-        page = list_entry(next, struct page, lru);
-
-        return page_address(page);
-}
-
-static inline struct trace_entry *
-tracing_get_trace_entry(struct trace_array *tr, struct trace_array_cpu *data)
-{
-        unsigned long idx, idx_next;
-        struct trace_entry *entry;
-
-        data->trace_idx++;
-        idx = data->trace_head_idx;
-        idx_next = idx + 1;
-
-        BUG_ON(idx * TRACE_ENTRY_SIZE >= PAGE_SIZE);
-
-        entry = data->trace_head + idx * TRACE_ENTRY_SIZE;
-
-        if (unlikely(idx_next >= ENTRIES_PER_PAGE)) {
-                data->trace_head = trace_next_page(data, data->trace_head);
-                idx_next = 0;
-        }
-
-        if (data->trace_head == data->trace_tail &&
-            idx_next == data->trace_tail_idx) {
-                /* overrun */
-                data->overrun++;
-                data->trace_tail_idx++;
-                if (data->trace_tail_idx >= ENTRIES_PER_PAGE) {
-                        data->trace_tail =
-                                trace_next_page(data, data->trace_tail);
-                        data->trace_tail_idx = 0;
-                }
-        }
-
-        data->trace_head_idx = idx_next;
-
-        return entry;
-}
-
-static inline void
-tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags)
+void
+tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags,
+                             int pc)
 {
         struct task_struct *tsk = current;
-        unsigned long pc;
 
-        pc = preempt_count();
-
-        entry->preempt_count    = pc & 0xff;
-        entry->pid              = (tsk) ? tsk->pid : 0;
-        entry->t                = ftrace_now(raw_smp_processor_id());
-        entry->flags = (irqs_disabled_flags(flags) ? TRACE_FLAG_IRQS_OFF : 0) |
+        entry->preempt_count            = pc & 0xff;
+        entry->pid                      = (tsk) ? tsk->pid : 0;
+        entry->flags =
+#ifdef CONFIG_TRACE_IRQFLAGS_SUPPORT
+                (irqs_disabled_flags(flags) ? TRACE_FLAG_IRQS_OFF : 0) |
+#else
+                TRACE_FLAG_IRQS_NOSUPPORT |
+#endif
                 ((pc & HARDIRQ_MASK) ? TRACE_FLAG_HARDIRQ : 0) |
                 ((pc & SOFTIRQ_MASK) ? TRACE_FLAG_SOFTIRQ : 0) |
                 (need_resched() ? TRACE_FLAG_NEED_RESCHED : 0);
@@ -828,145 +668,141 @@ tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags)
 
 void
 trace_function(struct trace_array *tr, struct trace_array_cpu *data,
-               unsigned long ip, unsigned long parent_ip, unsigned long flags)
+               unsigned long ip, unsigned long parent_ip, unsigned long flags,
+               int pc)
 {
-        struct trace_entry *entry;
+        struct ring_buffer_event *event;
+        struct ftrace_entry *entry;
         unsigned long irq_flags;
 
-        raw_local_irq_save(irq_flags);
-        __raw_spin_lock(&data->lock);
-        entry                   = tracing_get_trace_entry(tr, data);
-        tracing_generic_entry_update(entry, flags);
-        entry->type             = TRACE_FN;
-        entry->fn.ip            = ip;
-        entry->fn.parent_ip     = parent_ip;
-        __raw_spin_unlock(&data->lock);
-        raw_local_irq_restore(irq_flags);
+        /* If we are reading the ring buffer, don't trace */
+        if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
+                return;
+
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, flags, pc);
+        entry->ent.type                 = TRACE_FN;
+        entry->ip                       = ip;
+        entry->parent_ip                = parent_ip;
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
 }
 
 void
 ftrace(struct trace_array *tr, struct trace_array_cpu *data,
-       unsigned long ip, unsigned long parent_ip, unsigned long flags)
+       unsigned long ip, unsigned long parent_ip, unsigned long flags,
+       int pc)
 {
         if (likely(!atomic_read(&data->disabled)))
-                trace_function(tr, data, ip, parent_ip, flags);
+                trace_function(tr, data, ip, parent_ip, flags, pc);
 }
 
-#ifdef CONFIG_MMIOTRACE
-void __trace_mmiotrace_rw(struct trace_array *tr, struct trace_array_cpu *data,
-                                                struct mmiotrace_rw *rw)
+static void ftrace_trace_stack(struct trace_array *tr,
+                               struct trace_array_cpu *data,
+                               unsigned long flags,
+                               int skip, int pc)
 {
-        struct trace_entry *entry;
+#ifdef CONFIG_STACKTRACE
+        struct ring_buffer_event *event;
+        struct stack_entry *entry;
+        struct stack_trace trace;
         unsigned long irq_flags;
 
-        raw_local_irq_save(irq_flags);
-        __raw_spin_lock(&data->lock);
-
-        entry                   = tracing_get_trace_entry(tr, data);
-        tracing_generic_entry_update(entry, 0);
-        entry->type             = TRACE_MMIO_RW;
-        entry->mmiorw           = *rw;
-
-        __raw_spin_unlock(&data->lock);
-        raw_local_irq_restore(irq_flags);
-
-        trace_wake_up();
-}
-
-void __trace_mmiotrace_map(struct trace_array *tr, struct trace_array_cpu *data,
-                                                struct mmiotrace_map *map)
-{
-        struct trace_entry *entry;
-        unsigned long irq_flags;
+        if (!(trace_flags & TRACE_ITER_STACKTRACE))
+                return;
 
-        raw_local_irq_save(irq_flags);
-        __raw_spin_lock(&data->lock);
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, flags, pc);
+        entry->ent.type         = TRACE_STACK;
 
-        entry                   = tracing_get_trace_entry(tr, data);
-        tracing_generic_entry_update(entry, 0);
-        entry->type             = TRACE_MMIO_MAP;
-        entry->mmiomap          = *map;
+        memset(&entry->caller, 0, sizeof(entry->caller));
 
-        __raw_spin_unlock(&data->lock);
-        raw_local_irq_restore(irq_flags);
+        trace.nr_entries        = 0;
+        trace.max_entries       = FTRACE_STACK_ENTRIES;
+        trace.skip              = skip;
+        trace.entries           = entry->caller;
 
-        trace_wake_up();
-}
+        save_stack_trace(&trace);
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
 #endif
+}
 
 void __trace_stack(struct trace_array *tr,
                    struct trace_array_cpu *data,
                    unsigned long flags,
                    int skip)
 {
-        struct trace_entry *entry;
-        struct stack_trace trace;
-
-        if (!(trace_flags & TRACE_ITER_STACKTRACE))
-                return;
-
-        entry                   = tracing_get_trace_entry(tr, data);
-        tracing_generic_entry_update(entry, flags);
-        entry->type             = TRACE_STACK;
-
-        memset(&entry->stack, 0, sizeof(entry->stack));
-
-        trace.nr_entries        = 0;
-        trace.max_entries       = FTRACE_STACK_ENTRIES;
-        trace.skip              = skip;
-        trace.entries           = entry->stack.caller;
-
-        save_stack_trace(&trace);
+        ftrace_trace_stack(tr, data, flags, skip, preempt_count());
 }
 
-void
-__trace_special(void *__tr, void *__data,
-                unsigned long arg1, unsigned long arg2, unsigned long arg3)
+static void
+ftrace_trace_special(void *__tr, void *__data,
+                     unsigned long arg1, unsigned long arg2, unsigned long arg3,
+                     int pc)
 {
+        struct ring_buffer_event *event;
         struct trace_array_cpu *data = __data;
         struct trace_array *tr = __tr;
-        struct trace_entry *entry;
+        struct special_entry *entry;
         unsigned long irq_flags;
 
-        raw_local_irq_save(irq_flags);
-        __raw_spin_lock(&data->lock);
-        entry                   = tracing_get_trace_entry(tr, data);
-        tracing_generic_entry_update(entry, 0);
-        entry->type             = TRACE_SPECIAL;
-        entry->special.arg1     = arg1;
-        entry->special.arg2     = arg2;
-        entry->special.arg3     = arg3;
-        __trace_stack(tr, data, irq_flags, 4);
-        __raw_spin_unlock(&data->lock);
-        raw_local_irq_restore(irq_flags);
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, pc);
+        entry->ent.type                 = TRACE_SPECIAL;
+        entry->arg1                     = arg1;
+        entry->arg2                     = arg2;
+        entry->arg3                     = arg3;
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+        ftrace_trace_stack(tr, data, irq_flags, 4, pc);
 
         trace_wake_up();
 }
 
 void
+__trace_special(void *__tr, void *__data,
+                unsigned long arg1, unsigned long arg2, unsigned long arg3)
+{
+        ftrace_trace_special(__tr, __data, arg1, arg2, arg3, preempt_count());
+}
+
+void
 tracing_sched_switch_trace(struct trace_array *tr,
                            struct trace_array_cpu *data,
                            struct task_struct *prev,
                            struct task_struct *next,
-                           unsigned long flags)
+                           unsigned long flags, int pc)
 {
-        struct trace_entry *entry;
+        struct ring_buffer_event *event;
+        struct ctx_switch_entry *entry;
         unsigned long irq_flags;
 
-        raw_local_irq_save(irq_flags);
-        __raw_spin_lock(&data->lock);
-        entry                   = tracing_get_trace_entry(tr, data);
-        tracing_generic_entry_update(entry, flags);
-        entry->type             = TRACE_CTX;
-        entry->ctx.prev_pid     = prev->pid;
-        entry->ctx.prev_prio    = prev->prio;
-        entry->ctx.prev_state   = prev->state;
-        entry->ctx.next_pid     = next->pid;
-        entry->ctx.next_prio    = next->prio;
-        entry->ctx.next_state   = next->state;
-        __trace_stack(tr, data, flags, 5);
-        __raw_spin_unlock(&data->lock);
-        raw_local_irq_restore(irq_flags);
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                           &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, flags, pc);
+        entry->ent.type                 = TRACE_CTX;
+        entry->prev_pid                 = prev->pid;
+        entry->prev_prio                = prev->prio;
+        entry->prev_state               = prev->state;
+        entry->next_pid                 = next->pid;
+        entry->next_prio                = next->prio;
+        entry->next_state               = next->state;
+        entry->next_cpu = task_cpu(next);
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+        ftrace_trace_stack(tr, data, flags, 5, pc);
 }
 
 void
@@ -974,25 +810,28 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
                            struct trace_array_cpu *data,
                            struct task_struct *wakee,
                            struct task_struct *curr,
-                           unsigned long flags)
+                           unsigned long flags, int pc)
 {
-        struct trace_entry *entry;
+        struct ring_buffer_event *event;
+        struct ctx_switch_entry *entry;
         unsigned long irq_flags;
 
-        raw_local_irq_save(irq_flags);
-        __raw_spin_lock(&data->lock);
-        entry                   = tracing_get_trace_entry(tr, data);
-        tracing_generic_entry_update(entry, flags);
-        entry->type             = TRACE_WAKE;
-        entry->ctx.prev_pid     = curr->pid;
-        entry->ctx.prev_prio    = curr->prio;
-        entry->ctx.prev_state   = curr->state;
-        entry->ctx.next_pid     = wakee->pid;
-        entry->ctx.next_prio    = wakee->prio;
-        entry->ctx.next_state   = wakee->state;
-        __trace_stack(tr, data, flags, 6);
-        __raw_spin_unlock(&data->lock);
-        raw_local_irq_restore(irq_flags);
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                           &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, flags, pc);
+        entry->ent.type                 = TRACE_WAKE;
+        entry->prev_pid                 = curr->pid;
+        entry->prev_prio                = curr->prio;
+        entry->prev_state               = curr->state;
+        entry->next_pid                 = wakee->pid;
+        entry->next_prio                = wakee->prio;
+        entry->next_state               = wakee->state;
+        entry->next_cpu                 = task_cpu(wakee);
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+        ftrace_trace_stack(tr, data, flags, 6, pc);
 
         trace_wake_up();
 }
@@ -1002,26 +841,24 @@ ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
 {
         struct trace_array *tr = &global_trace;
         struct trace_array_cpu *data;
-        unsigned long flags;
-        long disabled;
         int cpu;
+        int pc;
 
-        if (tracing_disabled || current_trace == &no_tracer || !tr->ctrl)
+        if (tracing_disabled || !tr->ctrl)
                 return;
 
-        local_irq_save(flags);
+        pc = preempt_count();
+        preempt_disable_notrace();
         cpu = raw_smp_processor_id();
         data = tr->data[cpu];
-        disabled = atomic_inc_return(&data->disabled);
 
-        if (likely(disabled == 1))
-                __trace_special(tr, data, arg1, arg2, arg3);
+        if (likely(!atomic_read(&data->disabled)))
+                ftrace_trace_special(tr, data, arg1, arg2, arg3, pc);
 
-        atomic_dec(&data->disabled);
-        local_irq_restore(flags);
+        preempt_enable_notrace();
 }
 
-#ifdef CONFIG_FTRACE
+#ifdef CONFIG_FUNCTION_TRACER
 static void
 function_trace_call(unsigned long ip, unsigned long parent_ip)
 {
@@ -1029,24 +866,28 @@ function_trace_call(unsigned long ip, unsigned long parent_ip)
         struct trace_array_cpu *data;
         unsigned long flags;
         long disabled;
-        int cpu;
+        int cpu, resched;
+        int pc;
 
         if (unlikely(!ftrace_function_enabled))
                 return;
 
-        if (skip_trace(ip))
-                return;
-
-        local_irq_save(flags);
+        pc = preempt_count();
+        resched = need_resched();
+        preempt_disable_notrace();
+        local_save_flags(flags);
         cpu = raw_smp_processor_id();
         data = tr->data[cpu];
         disabled = atomic_inc_return(&data->disabled);
 
         if (likely(disabled == 1))
-                trace_function(tr, data, ip, parent_ip, flags);
+                trace_function(tr, data, ip, parent_ip, flags, pc);
 
         atomic_dec(&data->disabled);
-        local_irq_restore(flags);
+        if (resched)
+                preempt_enable_no_resched_notrace();
+        else
+                preempt_enable_notrace();
 }
 
 static struct ftrace_ops trace_ops __read_mostly =
@@ -1073,111 +914,96 @@ enum trace_file_type {
         TRACE_FILE_LAT_FMT      = 1,
 };
 
-static struct trace_entry *
-trace_entry_idx(struct trace_array *tr, struct trace_array_cpu *data,
-                struct trace_iterator *iter, int cpu)
+static void trace_iterator_increment(struct trace_iterator *iter, int cpu)
 {
-        struct page *page;
-        struct trace_entry *array;
+        /* Don't allow ftrace to trace into the ring buffers */
+        ftrace_disable_cpu();
 
-        if (iter->next_idx[cpu] >= tr->entries ||
-            iter->next_idx[cpu] >= data->trace_idx ||
-            (data->trace_head == data->trace_tail &&
-             data->trace_head_idx == data->trace_tail_idx))
-                return NULL;
+        iter->idx++;
+        if (iter->buffer_iter[iter->cpu])
+                ring_buffer_read(iter->buffer_iter[iter->cpu], NULL);
 
-        if (!iter->next_page[cpu]) {
-                /* Initialize the iterator for this cpu trace buffer */
-                WARN_ON(!data->trace_tail);
-                page = virt_to_page(data->trace_tail);
-                iter->next_page[cpu] = &page->lru;
-                iter->next_page_idx[cpu] = data->trace_tail_idx;
-        }
+        ftrace_enable_cpu();
+}
+
+static struct trace_entry *
+peek_next_entry(struct trace_iterator *iter, int cpu, u64 *ts)
+{
+        struct ring_buffer_event *event;
+        struct ring_buffer_iter *buf_iter = iter->buffer_iter[cpu];
 
-        page = list_entry(iter->next_page[cpu], struct page, lru);
-        BUG_ON(&data->trace_pages == &page->lru);
+        /* Don't allow ftrace to trace into the ring buffers */
+        ftrace_disable_cpu();
 
-        array = page_address(page);
+        if (buf_iter)
+                event = ring_buffer_iter_peek(buf_iter, ts);
+        else
+                event = ring_buffer_peek(iter->tr->buffer, cpu, ts);
+
+        ftrace_enable_cpu();
 
-        WARN_ON(iter->next_page_idx[cpu] >= ENTRIES_PER_PAGE);
-        return &array[iter->next_page_idx[cpu]];
+        return event ? ring_buffer_event_data(event) : NULL;
 }
 
 static struct trace_entry *
-find_next_entry(struct trace_iterator *iter, int *ent_cpu)
+__find_next_entry(struct trace_iterator *iter, int *ent_cpu, u64 *ent_ts)
 {
-        struct trace_array *tr = iter->tr;
+        struct ring_buffer *buffer = iter->tr->buffer;
         struct trace_entry *ent, *next = NULL;
+        u64 next_ts = 0, ts;
         int next_cpu = -1;
         int cpu;
 
         for_each_tracing_cpu(cpu) {
-                if (!head_page(tr->data[cpu]))
+
+                if (ring_buffer_empty_cpu(buffer, cpu))
                         continue;
-                ent = trace_entry_idx(tr, tr->data[cpu], iter, cpu);
+
+                ent = peek_next_entry(iter, cpu, &ts);
+
                 /*
                  * Pick the entry with the smallest timestamp:
                  */
-                if (ent && (!next || ent->t < next->t)) {
+                if (ent && (!next || ts < next_ts)) {
                         next = ent;
                         next_cpu = cpu;
+                        next_ts = ts;
                 }
         }
 
         if (ent_cpu)
                 *ent_cpu = next_cpu;
 
+        if (ent_ts)
+                *ent_ts = next_ts;
+
         return next;
 }
 
-static void trace_iterator_increment(struct trace_iterator *iter)
+/* Find the next real entry, without updating the iterator itself */
+static struct trace_entry *
+find_next_entry(struct trace_iterator *iter, int *ent_cpu, u64 *ent_ts)
 {
-        iter->idx++;
-        iter->next_idx[iter->cpu]++;
-        iter->next_page_idx[iter->cpu]++;
-
-        if (iter->next_page_idx[iter->cpu] >= ENTRIES_PER_PAGE) {
-                struct trace_array_cpu *data = iter->tr->data[iter->cpu];
-
-                iter->next_page_idx[iter->cpu] = 0;
-                iter->next_page[iter->cpu] =
-                        trace_next_list(data, iter->next_page[iter->cpu]);
-        }
+        return __find_next_entry(iter, ent_cpu, ent_ts);
 }
 
-static void trace_consume(struct trace_iterator *iter)
+/* Find the next real entry, and increment the iterator to the next entry */
+static void *find_next_entry_inc(struct trace_iterator *iter)
 {
-        struct trace_array_cpu *data = iter->tr->data[iter->cpu];
+        iter->ent = __find_next_entry(iter, &iter->cpu, &iter->ts);
 
-        data->trace_tail_idx++;
-        if (data->trace_tail_idx >= ENTRIES_PER_PAGE) {
-                data->trace_tail = trace_next_page(data, data->trace_tail);
-                data->trace_tail_idx = 0;
-        }
+        if (iter->ent)
+                trace_iterator_increment(iter, iter->cpu);
 
-        /* Check if we empty it, then reset the index */
-        if (data->trace_head == data->trace_tail &&
-            data->trace_head_idx == data->trace_tail_idx)
-                data->trace_idx = 0;
+        return iter->ent ? iter : NULL;
 }
 
-static void *find_next_entry_inc(struct trace_iterator *iter)
+static void trace_consume(struct trace_iterator *iter)
 {
-        struct trace_entry *next;
-        int next_cpu = -1;
-
-        next = find_next_entry(iter, &next_cpu);
-
-        iter->prev_ent = iter->ent;
-        iter->prev_cpu = iter->cpu;
-
-        iter->ent = next;
-        iter->cpu = next_cpu;
-
-        if (next)
-                trace_iterator_increment(iter);
-
-        return next ? iter : NULL;
+        /* Don't allow ftrace to trace into the ring buffers */
+        ftrace_disable_cpu();
+        ring_buffer_consume(iter->tr->buffer, iter->cpu, &iter->ts);
+        ftrace_enable_cpu();
 }
 
 static void *s_next(struct seq_file *m, void *v, loff_t *pos)
@@ -1210,7 +1036,7 @@ static void *s_start(struct seq_file *m, loff_t *pos)
         struct trace_iterator *iter = m->private;
         void *p = NULL;
         loff_t l = 0;
-        int i;
+        int cpu;
 
         mutex_lock(&trace_types_lock);
 
@@ -1229,14 +1055,15 @@ static void *s_start(struct seq_file *m, loff_t *pos)
                 iter->ent = NULL;
                 iter->cpu = 0;
                 iter->idx = -1;
-                iter->prev_ent = NULL;
-                iter->prev_cpu = -1;
 
-                for_each_tracing_cpu(i) {
-                        iter->next_idx[i] = 0;
-                        iter->next_page[i] = NULL;
+                ftrace_disable_cpu();
+
+                for_each_tracing_cpu(cpu) {
+                        ring_buffer_iter_reset(iter->buffer_iter[cpu]);
                 }
 
+                ftrace_enable_cpu();
+
                 for (p = iter; p && l < *pos; p = s_next(m, p, &l))
                         ;
 
@@ -1261,17 +1088,20 @@ static void s_stop(struct seq_file *m, void *p)
         mutex_unlock(&trace_types_lock);
 }
 
-#define KRETPROBE_MSG "[unknown/kretprobe'd]"
-
 #ifdef CONFIG_KRETPROBES
-static inline int kretprobed(unsigned long addr)
+static inline const char *kretprobed(const char *name)
 {
-        return addr == (unsigned long)kretprobe_trampoline;
+        static const char tramp_name[] = "kretprobe_trampoline";
+        int size = sizeof(tramp_name);
+
+        if (strncmp(tramp_name, name, size) == 0)
+                return "[unknown/kretprobe'd]";
+        return name;
 }
 #else
-static inline int kretprobed(unsigned long addr)
+static inline const char *kretprobed(const char *name)
 {
-        return 0;
+        return name;
 }
 #endif /* CONFIG_KRETPROBES */
 
@@ -1280,10 +1110,13 @@ seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
 {
 #ifdef CONFIG_KALLSYMS
         char str[KSYM_SYMBOL_LEN];
+        const char *name;
 
         kallsyms_lookup(address, NULL, NULL, NULL, str);
 
-        return trace_seq_printf(s, fmt, str);
+        name = kretprobed(str);
+
+        return trace_seq_printf(s, fmt, name);
 #endif
         return 1;
 }
@@ -1294,9 +1127,12 @@ seq_print_sym_offset(struct trace_seq *s, const char *fmt,
 {
 #ifdef CONFIG_KALLSYMS
         char str[KSYM_SYMBOL_LEN];
+        const char *name;
 
         sprint_symbol(str, address);
-        return trace_seq_printf(s, fmt, str);
+        name = kretprobed(str);
+
+        return trace_seq_printf(s, fmt, name);
 #endif
         return 1;
 }
@@ -1330,21 +1166,21 @@ seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
 
 static void print_lat_help_header(struct seq_file *m)
 {
-        seq_puts(m, "#                _------=> CPU#            \n");
-        seq_puts(m, "#               / _-----=> irqs-off        \n");
-        seq_puts(m, "#              | / _----=> need-resched    \n");
-        seq_puts(m, "#              || / _---=> hardirq/softirq \n");
-        seq_puts(m, "#              ||| / _--=> preempt-depth   \n");
-        seq_puts(m, "#              |||| /                      \n");
-        seq_puts(m, "#              |||||     delay             \n");
-        seq_puts(m, "#  cmd     pid ||||| time  |   caller      \n");
-        seq_puts(m, "#     \\   /    |||||   \\   |   /           \n");
+        seq_puts(m, "#                  _------=> CPU#            \n");
+        seq_puts(m, "#                 / _-----=> irqs-off        \n");
+        seq_puts(m, "#                | / _----=> need-resched    \n");
+        seq_puts(m, "#                || / _---=> hardirq/softirq \n");
+        seq_puts(m, "#                ||| / _--=> preempt-depth   \n");
+        seq_puts(m, "#                |||| /                      \n");
+        seq_puts(m, "#                |||||     delay             \n");
+        seq_puts(m, "#  cmd     pid   ||||| time  |   caller      \n");
+        seq_puts(m, "#     \\   /      |||||   \\   |   /           \n");
 }
 
 static void print_func_help_header(struct seq_file *m)
 {
-        seq_puts(m, "#           TASK-PID   CPU#    TIMESTAMP  FUNCTION\n");
-        seq_puts(m, "#              | |      |          |         |\n");
+        seq_puts(m, "#           TASK-PID    CPU#    TIMESTAMP  FUNCTION\n");
+        seq_puts(m, "#              | |       |          |         |\n");
 }
 
 
@@ -1355,23 +1191,16 @@ print_trace_header(struct seq_file *m, struct trace_iterator *iter)
         struct trace_array *tr = iter->tr;
         struct trace_array_cpu *data = tr->data[tr->cpu];
         struct tracer *type = current_trace;
-        unsigned long total   = 0;
-        unsigned long entries = 0;
-        int cpu;
+        unsigned long total;
+        unsigned long entries;
         const char *name = "preemption";
 
         if (type)
                 name = type->name;
 
-        for_each_tracing_cpu(cpu) {
-                if (head_page(tr->data[cpu])) {
-                        total += tr->data[cpu]->trace_idx;
-                        if (tr->data[cpu]->trace_idx > tr->entries)
-                                entries += tr->entries;
-                        else
-                                entries += tr->data[cpu]->trace_idx;
-                }
-        }
+        entries = ring_buffer_entries(iter->tr->buffer);
+        total = entries +
+                ring_buffer_overruns(iter->tr->buffer);
 
         seq_printf(m, "%s latency trace v1.1.5 on %s\n",
                    name, UTS_RELEASE);
@@ -1428,9 +1257,10 @@ lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
         comm = trace_find_cmdline(entry->pid);
 
         trace_seq_printf(s, "%8.8s-%-5d ", comm, entry->pid);
-        trace_seq_printf(s, "%d", cpu);
+        trace_seq_printf(s, "%3d", cpu);
         trace_seq_printf(s, "%c%c",
-                        (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' : '.',
+                        (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
+                         (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' : '.',
                         ((entry->flags & TRACE_FLAG_NEED_RESCHED) ? 'N' : '.'));
 
         hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
@@ -1457,7 +1287,7 @@ lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
 unsigned long preempt_mark_thresh = 100;
 
 static void
-lat_print_timestamp(struct trace_seq *s, unsigned long long abs_usecs,
+lat_print_timestamp(struct trace_seq *s, u64 abs_usecs,
                     unsigned long rel_usecs)
 {
         trace_seq_printf(s, " %4lldus", abs_usecs);
@@ -1471,34 +1301,76 @@ lat_print_timestamp(struct trace_seq *s, unsigned long long abs_usecs,
 
 static const char state_to_char[] = TASK_STATE_TO_CHAR_STR;
 
-static int
+/*
+ * The message is supposed to contain an ending newline.
+ * If the printing stops prematurely, try to add a newline of our own.
+ */
+void trace_seq_print_cont(struct trace_seq *s, struct trace_iterator *iter)
+{
+        struct trace_entry *ent;
+        struct trace_field_cont *cont;
+        bool ok = true;
+
+        ent = peek_next_entry(iter, iter->cpu, NULL);
+        if (!ent || ent->type != TRACE_CONT) {
+                trace_seq_putc(s, '\n');
+                return;
+        }
+
+        do {
+                cont = (struct trace_field_cont *)ent;
+                if (ok)
+                        ok = (trace_seq_printf(s, "%s", cont->buf) > 0);
+
+                ftrace_disable_cpu();
+
+                if (iter->buffer_iter[iter->cpu])
+                        ring_buffer_read(iter->buffer_iter[iter->cpu], NULL);
+                else
+                        ring_buffer_consume(iter->tr->buffer, iter->cpu, NULL);
+
+                ftrace_enable_cpu();
+
+                ent = peek_next_entry(iter, iter->cpu, NULL);
+        } while (ent && ent->type == TRACE_CONT);
+
+        if (!ok)
+                trace_seq_putc(s, '\n');
+}
+
+static enum print_line_t
 print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
 {
         struct trace_seq *s = &iter->seq;
         unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
-        struct trace_entry *next_entry = find_next_entry(iter, NULL);
+        struct trace_entry *next_entry;
         unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE);
         struct trace_entry *entry = iter->ent;
         unsigned long abs_usecs;
         unsigned long rel_usecs;
+        u64 next_ts;
         char *comm;
         int S, T;
         int i;
         unsigned state;
 
+        if (entry->type == TRACE_CONT)
+                return TRACE_TYPE_HANDLED;
+
+        next_entry = find_next_entry(iter, NULL, &next_ts);
         if (!next_entry)
-                next_entry = entry;
-        rel_usecs = ns2usecs(next_entry->t - entry->t);
-        abs_usecs = ns2usecs(entry->t - iter->tr->time_start);
+                next_ts = iter->ts;
+        rel_usecs = ns2usecs(next_ts - iter->ts);
+        abs_usecs = ns2usecs(iter->ts - iter->tr->time_start);
 
         if (verbose) {
                 comm = trace_find_cmdline(entry->pid);
-                trace_seq_printf(s, "%16s %5d %d %d %08x %08x [%08lx]"
+                trace_seq_printf(s, "%16s %5d %3d %d %08x %08x [%08lx]"
                                  " %ld.%03ldms (+%ld.%03ldms): ",
                                  comm,
                                  entry->pid, cpu, entry->flags,
                                  entry->preempt_count, trace_idx,
-                                 ns2usecs(entry->t),
+                                 ns2usecs(iter->ts),
                                  abs_usecs/1000,
                                  abs_usecs % 1000, rel_usecs/1000,
                                  rel_usecs % 1000);
@@ -1507,52 +1379,82 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
                 lat_print_timestamp(s, abs_usecs, rel_usecs);
         }
         switch (entry->type) {
-        case TRACE_FN:
-                seq_print_ip_sym(s, entry->fn.ip, sym_flags);
+        case TRACE_FN: {
+                struct ftrace_entry *field;
+
+                trace_assign_type(field, entry);
+
+                seq_print_ip_sym(s, field->ip, sym_flags);
                 trace_seq_puts(s, " (");
-                if (kretprobed(entry->fn.parent_ip))
-                        trace_seq_puts(s, KRETPROBE_MSG);
-                else
-                        seq_print_ip_sym(s, entry->fn.parent_ip, sym_flags);
+                seq_print_ip_sym(s, field->parent_ip, sym_flags);
                 trace_seq_puts(s, ")\n");
                 break;
+        }
         case TRACE_CTX:
-        case TRACE_WAKE:
-                T = entry->ctx.next_state < sizeof(state_to_char) ?
-                        state_to_char[entry->ctx.next_state] : 'X';
+        case TRACE_WAKE: {
+                struct ctx_switch_entry *field;
 
-                state = entry->ctx.prev_state ? __ffs(entry->ctx.prev_state) + 1 : 0;
+                trace_assign_type(field, entry);
+
+                T = field->next_state < sizeof(state_to_char) ?
+                        state_to_char[field->next_state] : 'X';
+
+                state = field->prev_state ?
+                        __ffs(field->prev_state) + 1 : 0;
                 S = state < sizeof(state_to_char) - 1 ? state_to_char[state] : 'X';
-                comm = trace_find_cmdline(entry->ctx.next_pid);
-                trace_seq_printf(s, " %5d:%3d:%c %s %5d:%3d:%c %s\n",
-                                 entry->ctx.prev_pid,
-                                 entry->ctx.prev_prio,
+                comm = trace_find_cmdline(field->next_pid);
+                trace_seq_printf(s, " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n",
+                                 field->prev_pid,
+                                 field->prev_prio,
                                  S, entry->type == TRACE_CTX ? "==>" : "  +",
-                                 entry->ctx.next_pid,
-                                 entry->ctx.next_prio,
+                                 field->next_cpu,
+                                 field->next_pid,
+                                 field->next_prio,
                                  T, comm);
                 break;
-        case TRACE_SPECIAL:
+        }
+        case TRACE_SPECIAL: {
+                struct special_entry *field;
+
+                trace_assign_type(field, entry);
+
                 trace_seq_printf(s, "# %ld %ld %ld\n",
-                                 entry->special.arg1,
-                                 entry->special.arg2,
-                                 entry->special.arg3);
+                                 field->arg1,
+                                 field->arg2,
+                                 field->arg3);
                 break;
-        case TRACE_STACK:
+        }
+        case TRACE_STACK: {
+                struct stack_entry *field;
+
+                trace_assign_type(field, entry);
+
                 for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
                         if (i)
                                 trace_seq_puts(s, " <= ");
-                        seq_print_ip_sym(s, entry->stack.caller[i], sym_flags);
+                        seq_print_ip_sym(s, field->caller[i], sym_flags);
                 }
                 trace_seq_puts(s, "\n");
                 break;
+        }
+        case TRACE_PRINT: {
+                struct print_entry *field;
+
+                trace_assign_type(field, entry);
+
+                seq_print_ip_sym(s, field->ip, sym_flags);
+                trace_seq_printf(s, ": %s", field->buf);
+                if (entry->flags & TRACE_FLAG_CONT)
+                        trace_seq_print_cont(s, iter);
+                break;
+        }
         default:
                 trace_seq_printf(s, "Unknown type %d\n", entry->type);
         }
-        return 1;
+        return TRACE_TYPE_HANDLED;
 }
 
-static int print_trace_fmt(struct trace_iterator *iter)
+static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
 {
         struct trace_seq *s = &iter->seq;
         unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
@@ -1567,90 +1469,123 @@ static int print_trace_fmt(struct trace_iterator *iter)
 
         entry = iter->ent;
 
+        if (entry->type == TRACE_CONT)
+                return TRACE_TYPE_HANDLED;
+
         comm = trace_find_cmdline(iter->ent->pid);
 
-        t = ns2usecs(entry->t);
+        t = ns2usecs(iter->ts);
         usec_rem = do_div(t, 1000000ULL);
         secs = (unsigned long)t;
 
         ret = trace_seq_printf(s, "%16s-%-5d ", comm, entry->pid);
         if (!ret)
-                return 0;
-        ret = trace_seq_printf(s, "[%02d] ", iter->cpu);
+                return TRACE_TYPE_PARTIAL_LINE;
+        ret = trace_seq_printf(s, "[%03d] ", iter->cpu);
         if (!ret)
-                return 0;
+                return TRACE_TYPE_PARTIAL_LINE;
         ret = trace_seq_printf(s, "%5lu.%06lu: ", secs, usec_rem);
         if (!ret)
-                return 0;
+                return TRACE_TYPE_PARTIAL_LINE;
 
         switch (entry->type) {
-        case TRACE_FN:
-                ret = seq_print_ip_sym(s, entry->fn.ip, sym_flags);
+        case TRACE_FN: {
+                struct ftrace_entry *field;
+
+                trace_assign_type(field, entry);
+
+                ret = seq_print_ip_sym(s, field->ip, sym_flags);
                 if (!ret)
-                        return 0;
+                        return TRACE_TYPE_PARTIAL_LINE;
                 if ((sym_flags & TRACE_ITER_PRINT_PARENT) &&
-                                                entry->fn.parent_ip) {
+                                                field->parent_ip) {
                         ret = trace_seq_printf(s, " <-");
                         if (!ret)
-                                return 0;
-                        if (kretprobed(entry->fn.parent_ip))
-                                ret = trace_seq_puts(s, KRETPROBE_MSG);
-                        else
-                                ret = seq_print_ip_sym(s, entry->fn.parent_ip,
-                                                       sym_flags);
+                                return TRACE_TYPE_PARTIAL_LINE;
+                        ret = seq_print_ip_sym(s,
+                                               field->parent_ip,
+                                               sym_flags);
                         if (!ret)
-                                return 0;
+                                return TRACE_TYPE_PARTIAL_LINE;
                 }
                 ret = trace_seq_printf(s, "\n");
                 if (!ret)
-                        return 0;
+                        return TRACE_TYPE_PARTIAL_LINE;
                 break;
+        }
         case TRACE_CTX:
-        case TRACE_WAKE:
-                S = entry->ctx.prev_state < sizeof(state_to_char) ?
-                        state_to_char[entry->ctx.prev_state] : 'X';
-                T = entry->ctx.next_state < sizeof(state_to_char) ?
-                        state_to_char[entry->ctx.next_state] : 'X';
-                ret = trace_seq_printf(s, " %5d:%3d:%c %s %5d:%3d:%c\n",
-                                       entry->ctx.prev_pid,
-                                       entry->ctx.prev_prio,
+        case TRACE_WAKE: {
+                struct ctx_switch_entry *field;
+
+                trace_assign_type(field, entry);
+
+                S = field->prev_state < sizeof(state_to_char) ?
+                        state_to_char[field->prev_state] : 'X';
+                T = field->next_state < sizeof(state_to_char) ?
+                        state_to_char[field->next_state] : 'X';
+                ret = trace_seq_printf(s, " %5d:%3d:%c %s [%03d] %5d:%3d:%c\n",
+                                       field->prev_pid,
+                                       field->prev_prio,
                                        S,
                                        entry->type == TRACE_CTX ? "==>" : "  +",
-                                       entry->ctx.next_pid,
-                                       entry->ctx.next_prio,
+                                       field->next_cpu,
+                                       field->next_pid,
+                                       field->next_prio,
                                        T);
                 if (!ret)
-                        return 0;
+                        return TRACE_TYPE_PARTIAL_LINE;
                 break;
-        case TRACE_SPECIAL:
+        }
+        case TRACE_SPECIAL: {
+                struct special_entry *field;
+
+                trace_assign_type(field, entry);
+
                 ret = trace_seq_printf(s, "# %ld %ld %ld\n",
-                                 entry->special.arg1,
-                                 entry->special.arg2,
-                                 entry->special.arg3);
+                                 field->arg1,
+                                 field->arg2,
+                                 field->arg3);
                 if (!ret)
-                        return 0;
+                        return TRACE_TYPE_PARTIAL_LINE;
                 break;
-        case TRACE_STACK:
+        }
+        case TRACE_STACK: {
+                struct stack_entry *field;
+
+                trace_assign_type(field, entry);
+
                 for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
                         if (i) {
                                 ret = trace_seq_puts(s, " <= ");
                                 if (!ret)
-                                        return 0;
+                                        return TRACE_TYPE_PARTIAL_LINE;
                         }
-                        ret = seq_print_ip_sym(s, entry->stack.caller[i],
+                        ret = seq_print_ip_sym(s, field->caller[i],
                                                sym_flags);
                         if (!ret)
-                                return 0;
+                                return TRACE_TYPE_PARTIAL_LINE;
                 }
                 ret = trace_seq_puts(s, "\n");
                 if (!ret)
-                        return 0;
+                        return TRACE_TYPE_PARTIAL_LINE;
                 break;
         }
-        return 1;
+        case TRACE_PRINT: {
+                struct print_entry *field;
+
+                trace_assign_type(field, entry);
+
+                seq_print_ip_sym(s, field->ip, sym_flags);
+                trace_seq_printf(s, ": %s", field->buf);
+                if (entry->flags & TRACE_FLAG_CONT)
+                        trace_seq_print_cont(s, iter);
+                break;
+        }
+        }
+        return TRACE_TYPE_HANDLED;
 }
 
-static int print_raw_fmt(struct trace_iterator *iter)
+static enum print_line_t print_raw_fmt(struct trace_iterator *iter)
 {
         struct trace_seq *s = &iter->seq;
         struct trace_entry *entry;
@@ -1659,47 +1594,77 @@ static int print_raw_fmt(struct trace_iterator *iter)
 
         entry = iter->ent;
 
+        if (entry->type == TRACE_CONT)
+                return TRACE_TYPE_HANDLED;
+
         ret = trace_seq_printf(s, "%d %d %llu ",
-                entry->pid, iter->cpu, entry->t);
+                entry->pid, iter->cpu, iter->ts);
         if (!ret)
-                return 0;
+                return TRACE_TYPE_PARTIAL_LINE;
 
         switch (entry->type) {
-        case TRACE_FN:
+        case TRACE_FN: {
+                struct ftrace_entry *field;
+
+                trace_assign_type(field, entry);
+
                 ret = trace_seq_printf(s, "%x %x\n",
-                                        entry->fn.ip, entry->fn.parent_ip);
+                                        field->ip,
+                                        field->parent_ip);
                 if (!ret)
-                        return 0;
+                        return TRACE_TYPE_PARTIAL_LINE;
                 break;
+        }
         case TRACE_CTX:
-        case TRACE_WAKE:
-                S = entry->ctx.prev_state < sizeof(state_to_char) ?
-                        state_to_char[entry->ctx.prev_state] : 'X';
-                T = entry->ctx.next_state < sizeof(state_to_char) ?
-                        state_to_char[entry->ctx.next_state] : 'X';
+        case TRACE_WAKE: {
+                struct ctx_switch_entry *field;
+
+                trace_assign_type(field, entry);
+
+                S = field->prev_state < sizeof(state_to_char) ?
+                        state_to_char[field->prev_state] : 'X';
+                T = field->next_state < sizeof(state_to_char) ?
+                        state_to_char[field->next_state] : 'X';
                 if (entry->type == TRACE_WAKE)
                         S = '+';
-                ret = trace_seq_printf(s, "%d %d %c %d %d %c\n",
-                                       entry->ctx.prev_pid,
-                                       entry->ctx.prev_prio,
+                ret = trace_seq_printf(s, "%d %d %c %d %d %d %c\n",
+                                       field->prev_pid,
+                                       field->prev_prio,
                                        S,
-                                       entry->ctx.next_pid,
-                                       entry->ctx.next_prio,
+                                       field->next_cpu,
+                                       field->next_pid,
+                                       field->next_prio,
                                        T);
                 if (!ret)
-                        return 0;
+                        return TRACE_TYPE_PARTIAL_LINE;
                 break;
+        }
         case TRACE_SPECIAL:
-        case TRACE_STACK:
+        case TRACE_STACK: {
+                struct special_entry *field;
+
+                trace_assign_type(field, entry);
+
                 ret = trace_seq_printf(s, "# %ld %ld %ld\n",
-                                 entry->special.arg1,
-                                 entry->special.arg2,
-                                 entry->special.arg3);
+                                 field->arg1,
+                                 field->arg2,
+                                 field->arg3);
                 if (!ret)
-                        return 0;
+                        return TRACE_TYPE_PARTIAL_LINE;
                 break;
         }
-        return 1;
+        case TRACE_PRINT: {
+                struct print_entry *field;
+
+                trace_assign_type(field, entry);
+
+                trace_seq_printf(s, "# %lx %s", field->ip, field->buf);
+                if (entry->flags & TRACE_FLAG_CONT)
+                        trace_seq_print_cont(s, iter);
+                break;
+        }
+        }
+        return TRACE_TYPE_HANDLED;
 }
 
 #define SEQ_PUT_FIELD_RET(s, x)                         \
@@ -1710,11 +1675,12 @@ do {							\
 
 #define SEQ_PUT_HEX_FIELD_RET(s, x)                     \
 do {                                                    \
+        BUILD_BUG_ON(sizeof(x) > MAX_MEMHEX_BYTES);     \
         if (!trace_seq_putmem_hex(s, &(x), sizeof(x)))  \
                 return 0;                               \
 } while (0)
 
-static int print_hex_fmt(struct trace_iterator *iter)
+static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
 {
         struct trace_seq *s = &iter->seq;
         unsigned char newline = '\n';
@@ -1723,97 +1689,139 @@ static int print_hex_fmt(struct trace_iterator *iter)
 
         entry = iter->ent;
 
+        if (entry->type == TRACE_CONT)
+                return TRACE_TYPE_HANDLED;
+
         SEQ_PUT_HEX_FIELD_RET(s, entry->pid);
         SEQ_PUT_HEX_FIELD_RET(s, iter->cpu);
-        SEQ_PUT_HEX_FIELD_RET(s, entry->t);
+        SEQ_PUT_HEX_FIELD_RET(s, iter->ts);
 
         switch (entry->type) {
-        case TRACE_FN:
-                SEQ_PUT_HEX_FIELD_RET(s, entry->fn.ip);
-                SEQ_PUT_HEX_FIELD_RET(s, entry->fn.parent_ip);
+        case TRACE_FN: {
+                struct ftrace_entry *field;
+
+                trace_assign_type(field, entry);
+
+                SEQ_PUT_HEX_FIELD_RET(s, field->ip);
+                SEQ_PUT_HEX_FIELD_RET(s, field->parent_ip);
                 break;
+        }
         case TRACE_CTX:
-        case TRACE_WAKE:
-                S = entry->ctx.prev_state < sizeof(state_to_char) ?
-                        state_to_char[entry->ctx.prev_state] : 'X';
-                T = entry->ctx.next_state < sizeof(state_to_char) ?
-                        state_to_char[entry->ctx.next_state] : 'X';
+        case TRACE_WAKE: {
+                struct ctx_switch_entry *field;
+
+                trace_assign_type(field, entry);
+
+                S = field->prev_state < sizeof(state_to_char) ?
+                        state_to_char[field->prev_state] : 'X';
+                T = field->next_state < sizeof(state_to_char) ?
+                        state_to_char[field->next_state] : 'X';
                 if (entry->type == TRACE_WAKE)
                         S = '+';
-                SEQ_PUT_HEX_FIELD_RET(s, entry->ctx.prev_pid);
-                SEQ_PUT_HEX_FIELD_RET(s, entry->ctx.prev_prio);
+                SEQ_PUT_HEX_FIELD_RET(s, field->prev_pid);
+                SEQ_PUT_HEX_FIELD_RET(s, field->prev_prio);
                 SEQ_PUT_HEX_FIELD_RET(s, S);
-                SEQ_PUT_HEX_FIELD_RET(s, entry->ctx.next_pid);
-                SEQ_PUT_HEX_FIELD_RET(s, entry->ctx.next_prio);
-                SEQ_PUT_HEX_FIELD_RET(s, entry->fn.parent_ip);
+                SEQ_PUT_HEX_FIELD_RET(s, field->next_cpu);
+                SEQ_PUT_HEX_FIELD_RET(s, field->next_pid);
+                SEQ_PUT_HEX_FIELD_RET(s, field->next_prio);
                 SEQ_PUT_HEX_FIELD_RET(s, T);
                 break;
+        }
         case TRACE_SPECIAL:
-        case TRACE_STACK:
-                SEQ_PUT_HEX_FIELD_RET(s, entry->special.arg1);
-                SEQ_PUT_HEX_FIELD_RET(s, entry->special.arg2);
-                SEQ_PUT_HEX_FIELD_RET(s, entry->special.arg3);
+        case TRACE_STACK: {
+                struct special_entry *field;
+
+                trace_assign_type(field, entry);
+
+                SEQ_PUT_HEX_FIELD_RET(s, field->arg1);
+                SEQ_PUT_HEX_FIELD_RET(s, field->arg2);
+                SEQ_PUT_HEX_FIELD_RET(s, field->arg3);
                 break;
         }
+        }
         SEQ_PUT_FIELD_RET(s, newline);
 
-        return 1;
+        return TRACE_TYPE_HANDLED;
 }
 
-static int print_bin_fmt(struct trace_iterator *iter)
+static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
 {
         struct trace_seq *s = &iter->seq;
         struct trace_entry *entry;
 
         entry = iter->ent;
 
+        if (entry->type == TRACE_CONT)
+                return TRACE_TYPE_HANDLED;
+
         SEQ_PUT_FIELD_RET(s, entry->pid);
-        SEQ_PUT_FIELD_RET(s, entry->cpu);
-        SEQ_PUT_FIELD_RET(s, entry->t);
+        SEQ_PUT_FIELD_RET(s, iter->cpu);
+        SEQ_PUT_FIELD_RET(s, iter->ts);
 
         switch (entry->type) {
-        case TRACE_FN:
-                SEQ_PUT_FIELD_RET(s, entry->fn.ip);
-                SEQ_PUT_FIELD_RET(s, entry->fn.parent_ip);
+        case TRACE_FN: {
+                struct ftrace_entry *field;
+
+                trace_assign_type(field, entry);
+
+                SEQ_PUT_FIELD_RET(s, field->ip);
+                SEQ_PUT_FIELD_RET(s, field->parent_ip);
                 break;
-        case TRACE_CTX:
-                SEQ_PUT_FIELD_RET(s, entry->ctx.prev_pid);
-                SEQ_PUT_FIELD_RET(s, entry->ctx.prev_prio);
-                SEQ_PUT_FIELD_RET(s, entry->ctx.prev_state);
-                SEQ_PUT_FIELD_RET(s, entry->ctx.next_pid);
-                SEQ_PUT_FIELD_RET(s, entry->ctx.next_prio);
-                SEQ_PUT_FIELD_RET(s, entry->ctx.next_state);
+        }
+        case TRACE_CTX: {
+                struct ctx_switch_entry *field;
+
+                trace_assign_type(field, entry);
+
+                SEQ_PUT_FIELD_RET(s, field->prev_pid);
+                SEQ_PUT_FIELD_RET(s, field->prev_prio);
+                SEQ_PUT_FIELD_RET(s, field->prev_state);
+                SEQ_PUT_FIELD_RET(s, field->next_pid);
+                SEQ_PUT_FIELD_RET(s, field->next_prio);
+                SEQ_PUT_FIELD_RET(s, field->next_state);
                 break;
+        }
         case TRACE_SPECIAL:
-        case TRACE_STACK:
-                SEQ_PUT_FIELD_RET(s, entry->special.arg1);
-                SEQ_PUT_FIELD_RET(s, entry->special.arg2);
-                SEQ_PUT_FIELD_RET(s, entry->special.arg3);
+        case TRACE_STACK: {
+                struct special_entry *field;
+
+                trace_assign_type(field, entry);
+
+                SEQ_PUT_FIELD_RET(s, field->arg1);
+                SEQ_PUT_FIELD_RET(s, field->arg2);
+                SEQ_PUT_FIELD_RET(s, field->arg3);
                 break;
         }
+        }
         return 1;
 }
 
 static int trace_empty(struct trace_iterator *iter)
 {
-        struct trace_array_cpu *data;
         int cpu;
 
         for_each_tracing_cpu(cpu) {
-                data = iter->tr->data[cpu];
-
-                if (head_page(data) && data->trace_idx &&
-                    (data->trace_tail != data->trace_head ||
-                     data->trace_tail_idx != data->trace_head_idx))
-                        return 0;
+                if (iter->buffer_iter[cpu]) {
+                        if (!ring_buffer_iter_empty(iter->buffer_iter[cpu]))
+                                return 0;
+                } else {
+                        if (!ring_buffer_empty_cpu(iter->tr->buffer, cpu))
+                                return 0;
+                }
         }
+
         return 1;
 }
 
-static int print_trace_line(struct trace_iterator *iter)
+static enum print_line_t print_trace_line(struct trace_iterator *iter)
 {
-        if (iter->trace && iter->trace->print_line)
-                return iter->trace->print_line(iter);
+        enum print_line_t ret;
+
+        if (iter->trace && iter->trace->print_line) {
+                ret = iter->trace->print_line(iter);
+                if (ret != TRACE_TYPE_UNHANDLED)
+                        return ret;
+        }
 
         if (trace_flags & TRACE_ITER_BIN)
                 return print_bin_fmt(iter);
@@ -1869,6 +1877,8 @@ static struct trace_iterator *
 __tracing_open(struct inode *inode, struct file *file, int *ret)
 {
         struct trace_iterator *iter;
+        struct seq_file *m;
+        int cpu;
 
         if (tracing_disabled) {
                 *ret = -ENODEV;
@@ -1889,28 +1899,45 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
         iter->trace = current_trace;
         iter->pos = -1;
 
+        for_each_tracing_cpu(cpu) {
+
+                iter->buffer_iter[cpu] =
+                        ring_buffer_read_start(iter->tr->buffer, cpu);
+
+                if (!iter->buffer_iter[cpu])
+                        goto fail_buffer;
+        }
+
         /* TODO stop tracer */
         *ret = seq_open(file, &tracer_seq_ops);
-        if (!*ret) {
-                struct seq_file *m = file->private_data;
-                m->private = iter;
+        if (*ret)
+                goto fail_buffer;
 
-                /* stop the trace while dumping */
-                if (iter->tr->ctrl) {
-                        tracer_enabled = 0;
-                        ftrace_function_enabled = 0;
-                }
+        m = file->private_data;
+        m->private = iter;
 
-                if (iter->trace && iter->trace->open)
-                        iter->trace->open(iter);
-        } else {
-                kfree(iter);
-                iter = NULL;
+        /* stop the trace while dumping */
+        if (iter->tr->ctrl) {
+                tracer_enabled = 0;
+                ftrace_function_enabled = 0;
         }
+
+        if (iter->trace && iter->trace->open)
+                        iter->trace->open(iter);
+
         mutex_unlock(&trace_types_lock);
 
  out:
         return iter;
+
+ fail_buffer:
+        for_each_tracing_cpu(cpu) {
+                if (iter->buffer_iter[cpu])
+                        ring_buffer_read_finish(iter->buffer_iter[cpu]);
+        }
+        mutex_unlock(&trace_types_lock);
+
+        return ERR_PTR(-ENOMEM);
 }
 
 int tracing_open_generic(struct inode *inode, struct file *filp)
@@ -1926,8 +1953,14 @@ int tracing_release(struct inode *inode, struct file *file)
 {
         struct seq_file *m = (struct seq_file *)file->private_data;
         struct trace_iterator *iter = m->private;
+        int cpu;
 
         mutex_lock(&trace_types_lock);
+        for_each_tracing_cpu(cpu) {
+                if (iter->buffer_iter[cpu])
+                        ring_buffer_read_finish(iter->buffer_iter[cpu]);
+        }
+
         if (iter->trace && iter->trace->close)
                 iter->trace->close(iter);
 
@@ -2352,6 +2385,9 @@ tracing_set_trace_write(struct file *filp, const char __user *ubuf,
         struct tracer *t;
         char buf[max_tracer_type_len+1];
         int i;
+        size_t ret;
+
+        ret = cnt;
 
         if (cnt > max_tracer_type_len)
                 cnt = max_tracer_type_len;
@@ -2370,7 +2406,11 @@ tracing_set_trace_write(struct file *filp, const char __user *ubuf,
                 if (strcmp(t->name, buf) == 0)
                         break;
         }
-        if (!t || t == current_trace)
+        if (!t) {
+                ret = -EINVAL;
+                goto out;
+        }
+        if (t == current_trace)
                 goto out;
 
         if (current_trace && current_trace->reset)
@@ -2383,9 +2423,10 @@ tracing_set_trace_write(struct file *filp, const char __user *ubuf,
  out:
         mutex_unlock(&trace_types_lock);
 
-        filp->f_pos += cnt;
+        if (ret > 0)
+                filp->f_pos += ret;
 
-        return cnt;
+        return ret;
 }
 
 static ssize_t
@@ -2500,20 +2541,12 @@ tracing_read_pipe(struct file *filp, char __user *ubuf,
                   size_t cnt, loff_t *ppos)
 {
         struct trace_iterator *iter = filp->private_data;
-        struct trace_array_cpu *data;
-        static cpumask_t mask;
-        unsigned long flags;
-#ifdef CONFIG_FTRACE
-        int ftrace_save;
-#endif
-        int cpu;
         ssize_t sret;
 
         /* return any leftover data */
         sret = trace_seq_to_user(&iter->seq, ubuf, cnt);
         if (sret != -EBUSY)
                 return sret;
-        sret = 0;
 
         trace_seq_reset(&iter->seq);
 
@@ -2524,6 +2557,8 @@ tracing_read_pipe(struct file *filp, char __user *ubuf,
                         goto out;
         }
 
+waitagain:
+        sret = 0;
         while (trace_empty(iter)) {
 
                 if ((filp->f_flags & O_NONBLOCK)) {
@@ -2588,46 +2623,12 @@ tracing_read_pipe(struct file *filp, char __user *ubuf,
                offsetof(struct trace_iterator, seq));
         iter->pos = -1;
 
-        /*
-         * We need to stop all tracing on all CPUS to read the
-         * the next buffer. This is a bit expensive, but is
-         * not done often. We fill all what we can read,
-         * and then release the locks again.
-         */
-
-        cpus_clear(mask);
-        local_irq_save(flags);
-#ifdef CONFIG_FTRACE
-        ftrace_save = ftrace_enabled;
-        ftrace_enabled = 0;
-#endif
-        smp_wmb();
-        for_each_tracing_cpu(cpu) {
-                data = iter->tr->data[cpu];
-
-                if (!head_page(data) || !data->trace_idx)
-                        continue;
-
-                atomic_inc(&data->disabled);
-                cpu_set(cpu, mask);
-        }
-
-        for_each_cpu_mask(cpu, mask) {
-                data = iter->tr->data[cpu];
-                __raw_spin_lock(&data->lock);
-
-                if (data->overrun > iter->last_overrun[cpu])
-                        iter->overrun[cpu] +=
-                                data->overrun - iter->last_overrun[cpu];
-                iter->last_overrun[cpu] = data->overrun;
-        }
-
         while (find_next_entry_inc(iter) != NULL) {
-                int ret;
+                enum print_line_t ret;
                 int len = iter->seq.len;
 
                 ret = print_trace_line(iter);
-                if (!ret) {
+                if (ret == TRACE_TYPE_PARTIAL_LINE) {
                         /* don't print partial lines */
                         iter->seq.len = len;
                         break;
@@ -2639,26 +2640,17 @@ tracing_read_pipe(struct file *filp, char __user *ubuf,
                         break;
         }
 
-        for_each_cpu_mask(cpu, mask) {
-                data = iter->tr->data[cpu];
-                __raw_spin_unlock(&data->lock);
-        }
-
-        for_each_cpu_mask(cpu, mask) {
-                data = iter->tr->data[cpu];
-                atomic_dec(&data->disabled);
-        }
-#ifdef CONFIG_FTRACE
-        ftrace_enabled = ftrace_save;
-#endif
-        local_irq_restore(flags);
-
         /* Now copy what we have to the user */
         sret = trace_seq_to_user(&iter->seq, ubuf, cnt);
         if (iter->seq.readpos >= iter->seq.len)
                 trace_seq_reset(&iter->seq);
+
+        /*
+         * If there was nothing to send to user, inspite of consuming trace
+         * entries, go back to wait for more entries.
+         */
         if (sret == -EBUSY)
-                sret = 0;
+                goto waitagain;
 
 out:
         mutex_unlock(&trace_types_lock);
@@ -2684,7 +2676,8 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
 {
         unsigned long val;
         char buf[64];
-        int i, ret;
+        int ret;
+        struct trace_array *tr = filp->private_data;
 
         if (cnt >= sizeof(buf))
                 return -EINVAL;
@@ -2704,59 +2697,38 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
 
         mutex_lock(&trace_types_lock);
 
-        if (current_trace != &no_tracer) {
+        if (tr->ctrl) {
                 cnt = -EBUSY;
-                pr_info("ftrace: set current_tracer to none"
+                pr_info("ftrace: please disable tracing"
                         " before modifying buffer size\n");
                 goto out;
         }
 
-        if (val > global_trace.entries) {
-                long pages_requested;
-                unsigned long freeable_pages;
-
-                /* make sure we have enough memory before mapping */
-                pages_requested =
-                        (val + (ENTRIES_PER_PAGE-1)) / ENTRIES_PER_PAGE;
-
-                /* account for each buffer (and max_tr) */
-                pages_requested *= tracing_nr_buffers * 2;
-
-                /* Check for overflow */
-                if (pages_requested < 0) {
-                        cnt = -ENOMEM;
+        if (val != global_trace.entries) {
+                ret = ring_buffer_resize(global_trace.buffer, val);
+                if (ret < 0) {
+                        cnt = ret;
                         goto out;
                 }
 
-                freeable_pages = determine_dirtyable_memory();
-
-                /* we only allow to request 1/4 of useable memory */
-                if (pages_requested >
-                    ((freeable_pages + tracing_pages_allocated) / 4)) {
-                        cnt = -ENOMEM;
-                        goto out;
-                }
-
-                while (global_trace.entries < val) {
-                        if (trace_alloc_page()) {
-                                cnt = -ENOMEM;
-                                goto out;
+                ret = ring_buffer_resize(max_tr.buffer, val);
+                if (ret < 0) {
+                        int r;
+                        cnt = ret;
+                        r = ring_buffer_resize(global_trace.buffer,
+                                               global_trace.entries);
+                        if (r < 0) {
+                                /* AARGH! We are left with different
+                                 * size max buffer!!!! */
+                                WARN_ON(1);
+                                tracing_disabled = 1;
                         }
-                        /* double check that we don't go over the known pages */
-                        if (tracing_pages_allocated > pages_requested)
-                                break;
+                        goto out;
                 }
 
-        } else {
-                /* include the number of entries in val (inc of page entries) */
-                while (global_trace.entries > val + (ENTRIES_PER_PAGE - 1))
-                        trace_free_page();
+                global_trace.entries = val;
         }
 
-        /* check integrity */
-        for_each_tracing_cpu(i)
-                check_pages(global_trace.data[i]);
-
         filp->f_pos += cnt;
 
         /* If check pages failed, return ENOMEM */
@@ -2769,6 +2741,52 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
         return cnt;
 }
 
+static int mark_printk(const char *fmt, ...)
+{
+        int ret;
+        va_list args;
+        va_start(args, fmt);
+        ret = trace_vprintk(0, fmt, args);
+        va_end(args);
+        return ret;
+}
+
+static ssize_t
+tracing_mark_write(struct file *filp, const char __user *ubuf,
+                                        size_t cnt, loff_t *fpos)
+{
+        char *buf;
+        char *end;
+        struct trace_array *tr = &global_trace;
+
+        if (!tr->ctrl || tracing_disabled)
+                return -EINVAL;
+
+        if (cnt > TRACE_BUF_SIZE)
+                cnt = TRACE_BUF_SIZE;
+
+        buf = kmalloc(cnt + 1, GFP_KERNEL);
+        if (buf == NULL)
+                return -ENOMEM;
+
+        if (copy_from_user(buf, ubuf, cnt)) {
+                kfree(buf);
+                return -EFAULT;
+        }
+
+        /* Cut from the first nil or newline. */
+        buf[cnt] = '\0';
+        end = strchr(buf, '\n');
+        if (end)
+                *end = '\0';
+
+        cnt = mark_printk("%s\n", buf);
+        kfree(buf);
+        *fpos += cnt;
+
+        return cnt;
+}
+
 static struct file_operations tracing_max_lat_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_max_lat_read,
@@ -2800,6 +2818,11 @@ static struct file_operations tracing_entries_fops = {
         .write          = tracing_entries_write,
 };
 
+static struct file_operations tracing_mark_fops = {
+        .open           = tracing_open_generic,
+        .write          = tracing_mark_write,
+};
+
 #ifdef CONFIG_DYNAMIC_FTRACE
 
 static ssize_t
@@ -2846,7 +2869,7 @@ struct dentry *tracing_init_dentry(void)
 #include "trace_selftest.c"
 #endif
 
-static __init void tracer_init_debugfs(void)
+static __init int tracer_init_debugfs(void)
 {
         struct dentry *d_tracer;
         struct dentry *entry;
@@ -2881,12 +2904,12 @@ static __init void tracer_init_debugfs(void)
         entry = debugfs_create_file("available_tracers", 0444, d_tracer,
                                     &global_trace, &show_traces_fops);
         if (!entry)
-                pr_warning("Could not create debugfs 'trace' entry\n");
+                pr_warning("Could not create debugfs 'available_tracers' entry\n");
 
         entry = debugfs_create_file("current_tracer", 0444, d_tracer,
                                     &global_trace, &set_tracer_fops);
         if (!entry)
-                pr_warning("Could not create debugfs 'trace' entry\n");
+                pr_warning("Could not create debugfs 'current_tracer' entry\n");
 
         entry = debugfs_create_file("tracing_max_latency", 0644, d_tracer,
                                     &tracing_max_latency,
@@ -2899,7 +2922,7 @@ static __init void tracer_init_debugfs(void)
                                     &tracing_thresh, &tracing_max_lat_fops);
         if (!entry)
                 pr_warning("Could not create debugfs "
-                           "'tracing_threash' entry\n");
+                           "'tracing_thresh' entry\n");
         entry = debugfs_create_file("README", 0644, d_tracer,
                                     NULL, &tracing_readme_fops);
         if (!entry)
@@ -2909,13 +2932,19 @@ static __init void tracer_init_debugfs(void)
                                     NULL, &tracing_pipe_fops);
         if (!entry)
                 pr_warning("Could not create debugfs "
-                           "'tracing_threash' entry\n");
+                           "'trace_pipe' entry\n");
 
         entry = debugfs_create_file("trace_entries", 0644, d_tracer,
                                     &global_trace, &tracing_entries_fops);
         if (!entry)
                 pr_warning("Could not create debugfs "
-                           "'tracing_threash' entry\n");
+                           "'trace_entries' entry\n");
+
+        entry = debugfs_create_file("trace_marker", 0220, d_tracer,
+                                    NULL, &tracing_mark_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs "
+                           "'trace_marker' entry\n");
 
 #ifdef CONFIG_DYNAMIC_FTRACE
         entry = debugfs_create_file("dyn_ftrace_total_info", 0444, d_tracer,
@@ -2928,230 +2957,263 @@ static __init void tracer_init_debugfs(void)
 #ifdef CONFIG_SYSPROF_TRACER
         init_tracer_sysprof_debugfs(d_tracer);
 #endif
+        return 0;
 }
 
-static int trace_alloc_page(void)
+int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
 {
+        static DEFINE_SPINLOCK(trace_buf_lock);
+        static char trace_buf[TRACE_BUF_SIZE];
+
+        struct ring_buffer_event *event;
+        struct trace_array *tr = &global_trace;
         struct trace_array_cpu *data;
-        struct page *page, *tmp;
-        LIST_HEAD(pages);
-        void *array;
-        unsigned pages_allocated = 0;
-        int i;
+        struct print_entry *entry;
+        unsigned long flags, irq_flags;
+        int cpu, len = 0, size, pc;
 
-        /* first allocate a page for each CPU */
-        for_each_tracing_cpu(i) {
-                array = (void *)__get_free_page(GFP_KERNEL);
-                if (array == NULL) {
-                        printk(KERN_ERR "tracer: failed to allocate page"
-                               "for trace buffer!\n");
-                        goto free_pages;
-                }
+        if (!tr->ctrl || tracing_disabled)
+                return 0;
 
-                pages_allocated++;
-                page = virt_to_page(array);
-                list_add(&page->lru, &pages);
+        pc = preempt_count();
+        preempt_disable_notrace();
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
 
-/* Only allocate if we are actually using the max trace */
-#ifdef CONFIG_TRACER_MAX_TRACE
-                array = (void *)__get_free_page(GFP_KERNEL);
-                if (array == NULL) {
-                        printk(KERN_ERR "tracer: failed to allocate page"
-                               "for trace buffer!\n");
-                        goto free_pages;
-                }
-                pages_allocated++;
-                page = virt_to_page(array);
-                list_add(&page->lru, &pages);
-#endif
-        }
+        if (unlikely(atomic_read(&data->disabled)))
+                goto out;
 
-        /* Now that we successfully allocate a page per CPU, add them */
-        for_each_tracing_cpu(i) {
-                data = global_trace.data[i];
-                page = list_entry(pages.next, struct page, lru);
-                list_del_init(&page->lru);
-                list_add_tail(&page->lru, &data->trace_pages);
-                ClearPageLRU(page);
+        spin_lock_irqsave(&trace_buf_lock, flags);
+        len = vsnprintf(trace_buf, TRACE_BUF_SIZE, fmt, args);
 
-#ifdef CONFIG_TRACER_MAX_TRACE
-                data = max_tr.data[i];
-                page = list_entry(pages.next, struct page, lru);
-                list_del_init(&page->lru);
-                list_add_tail(&page->lru, &data->trace_pages);
-                SetPageLRU(page);
-#endif
-        }
-        tracing_pages_allocated += pages_allocated;
-        global_trace.entries += ENTRIES_PER_PAGE;
+        len = min(len, TRACE_BUF_SIZE-1);
+        trace_buf[len] = 0;
 
-        return 0;
+        size = sizeof(*entry) + len + 1;
+        event = ring_buffer_lock_reserve(tr->buffer, size, &irq_flags);
+        if (!event)
+                goto out_unlock;
+        entry = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, flags, pc);
+        entry->ent.type                 = TRACE_PRINT;
+        entry->ip                       = ip;
 
- free_pages:
-        list_for_each_entry_safe(page, tmp, &pages, lru) {
-                list_del_init(&page->lru);
-                __free_page(page);
-        }
-        return -ENOMEM;
+        memcpy(&entry->buf, trace_buf, len);
+        entry->buf[len] = 0;
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+
+ out_unlock:
+        spin_unlock_irqrestore(&trace_buf_lock, flags);
+
+ out:
+        preempt_enable_notrace();
+
+        return len;
 }
+EXPORT_SYMBOL_GPL(trace_vprintk);
 
-static int trace_free_page(void)
+int __ftrace_printk(unsigned long ip, const char *fmt, ...)
 {
-        struct trace_array_cpu *data;
-        struct page *page;
-        struct list_head *p;
-        int i;
-        int ret = 0;
+        int ret;
+        va_list ap;
 
-        /* free one page from each buffer */
-        for_each_tracing_cpu(i) {
-                data = global_trace.data[i];
-                p = data->trace_pages.next;
-                if (p == &data->trace_pages) {
-                        /* should never happen */
-                        WARN_ON(1);
-                        tracing_disabled = 1;
-                        ret = -1;
-                        break;
-                }
-                page = list_entry(p, struct page, lru);
-                ClearPageLRU(page);
-                list_del(&page->lru);
-                tracing_pages_allocated--;
-                tracing_pages_allocated--;
-                __free_page(page);
+        if (!(trace_flags & TRACE_ITER_PRINTK))
+                return 0;
 
-                tracing_reset(data);
+        va_start(ap, fmt);
+        ret = trace_vprintk(ip, fmt, ap);
+        va_end(ap);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(__ftrace_printk);
 
-#ifdef CONFIG_TRACER_MAX_TRACE
-                data = max_tr.data[i];
-                p = data->trace_pages.next;
-                if (p == &data->trace_pages) {
-                        /* should never happen */
-                        WARN_ON(1);
-                        tracing_disabled = 1;
-                        ret = -1;
-                        break;
-                }
-                page = list_entry(p, struct page, lru);
-                ClearPageLRU(page);
-                list_del(&page->lru);
-                __free_page(page);
+static int trace_panic_handler(struct notifier_block *this,
+                               unsigned long event, void *unused)
+{
+        ftrace_dump();
+        return NOTIFY_OK;
+}
 
-                tracing_reset(data);
-#endif
-        }
-        global_trace.entries -= ENTRIES_PER_PAGE;
+static struct notifier_block trace_panic_notifier = {
+        .notifier_call  = trace_panic_handler,
+        .next           = NULL,
+        .priority       = 150   /* priority: INT_MAX >= x >= 0 */
+};
 
-        return ret;
+static int trace_die_handler(struct notifier_block *self,
+                             unsigned long val,
+                             void *data)
+{
+        switch (val) {
+        case DIE_OOPS:
+                ftrace_dump();
+                break;
+        default:
+                break;
+        }
+        return NOTIFY_OK;
 }
 
-__init static int tracer_alloc_buffers(void)
+static struct notifier_block trace_die_notifier = {
+        .notifier_call = trace_die_handler,
+        .priority = 200
+};
+
+/*
+ * printk is set to max of 1024, we really don't need it that big.
+ * Nothing should be printing 1000 characters anyway.
+ */
+#define TRACE_MAX_PRINT         1000
+
+/*
+ * Define here KERN_TRACE so that we have one place to modify
+ * it if we decide to change what log level the ftrace dump
+ * should be at.
+ */
+#define KERN_TRACE              KERN_INFO
+
+static void
+trace_printk_seq(struct trace_seq *s)
 {
-        struct trace_array_cpu *data;
-        void *array;
-        struct page *page;
-        int pages = 0;
-        int ret = -ENOMEM;
-        int i;
+        /* Probably should print a warning here. */
+        if (s->len >= 1000)
+                s->len = 1000;
 
-        /* TODO: make the number of buffers hot pluggable with CPUS */
-        tracing_nr_buffers = num_possible_cpus();
-        tracing_buffer_mask = cpu_possible_map;
+        /* should be zero ended, but we are paranoid. */
+        s->buffer[s->len] = 0;
 
-        /* Allocate the first page for all buffers */
-        for_each_tracing_cpu(i) {
-                data = global_trace.data[i] = &per_cpu(global_trace_cpu, i);
-                max_tr.data[i] = &per_cpu(max_data, i);
+        printk(KERN_TRACE "%s", s->buffer);
 
-                array = (void *)__get_free_page(GFP_KERNEL);
-                if (array == NULL) {
-                        printk(KERN_ERR "tracer: failed to allocate page"
-                               "for trace buffer!\n");
-                        goto free_buffers;
-                }
+        trace_seq_reset(s);
+}
+
+
+void ftrace_dump(void)
+{
+        static DEFINE_SPINLOCK(ftrace_dump_lock);
+        /* use static because iter can be a bit big for the stack */
+        static struct trace_iterator iter;
+        static cpumask_t mask;
+        static int dump_ran;
+        unsigned long flags;
+        int cnt = 0, cpu;
 
-                /* set the array to the list */
-                INIT_LIST_HEAD(&data->trace_pages);
-                page = virt_to_page(array);
-                list_add(&page->lru, &data->trace_pages);
-                /* use the LRU flag to differentiate the two buffers */
-                ClearPageLRU(page);
+        /* only one dump */
+        spin_lock_irqsave(&ftrace_dump_lock, flags);
+        if (dump_ran)
+                goto out;
 
-                data->lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
-                max_tr.data[i]->lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+        dump_ran = 1;
 
-/* Only allocate if we are actually using the max trace */
-#ifdef CONFIG_TRACER_MAX_TRACE
-                array = (void *)__get_free_page(GFP_KERNEL);
-                if (array == NULL) {
-                        printk(KERN_ERR "tracer: failed to allocate page"
-                               "for trace buffer!\n");
-                        goto free_buffers;
-                }
+        /* No turning back! */
+        ftrace_kill();
 
-                INIT_LIST_HEAD(&max_tr.data[i]->trace_pages);
-                page = virt_to_page(array);
-                list_add(&page->lru, &max_tr.data[i]->trace_pages);
-                SetPageLRU(page);
-#endif
+        for_each_tracing_cpu(cpu) {
+                atomic_inc(&global_trace.data[cpu]->disabled);
         }
 
+        printk(KERN_TRACE "Dumping ftrace buffer:\n");
+
+        iter.tr = &global_trace;
+        iter.trace = current_trace;
+
         /*
-         * Since we allocate by orders of pages, we may be able to
-         * round up a bit.
+         * We need to stop all tracing on all CPUS to read the
+         * the next buffer. This is a bit expensive, but is
+         * not done often. We fill all what we can read,
+         * and then release the locks again.
          */
-        global_trace.entries = ENTRIES_PER_PAGE;
-        pages++;
 
-        while (global_trace.entries < trace_nr_entries) {
-                if (trace_alloc_page())
-                        break;
-                pages++;
+        cpus_clear(mask);
+
+        while (!trace_empty(&iter)) {
+
+                if (!cnt)
+                        printk(KERN_TRACE "---------------------------------\n");
+
+                cnt++;
+
+                /* reset all but tr, trace, and overruns */
+                memset(&iter.seq, 0,
+                       sizeof(struct trace_iterator) -
+                       offsetof(struct trace_iterator, seq));
+                iter.iter_flags |= TRACE_FILE_LAT_FMT;
+                iter.pos = -1;
+
+                if (find_next_entry_inc(&iter) != NULL) {
+                        print_trace_line(&iter);
+                        trace_consume(&iter);
+                }
+
+                trace_printk_seq(&iter.seq);
         }
-        max_tr.entries = global_trace.entries;
 
-        pr_info("tracer: %d pages allocated for %ld entries of %ld bytes\n",
-                pages, trace_nr_entries, (long)TRACE_ENTRY_SIZE);
-        pr_info("   actual entries %ld\n", global_trace.entries);
+        if (!cnt)
+                printk(KERN_TRACE "   (ftrace buffer empty)\n");
+        else
+                printk(KERN_TRACE "---------------------------------\n");
 
-        tracer_init_debugfs();
+ out:
+        spin_unlock_irqrestore(&ftrace_dump_lock, flags);
+}
+
+__init static int tracer_alloc_buffers(void)
+{
+        struct trace_array_cpu *data;
+        int i;
+
+        /* TODO: make the number of buffers hot pluggable with CPUS */
+        tracing_buffer_mask = cpu_possible_map;
+
+        global_trace.buffer = ring_buffer_alloc(trace_buf_size,
+                                                   TRACE_BUFFER_FLAGS);
+        if (!global_trace.buffer) {
+                printk(KERN_ERR "tracer: failed to allocate ring buffer!\n");
+                WARN_ON(1);
+                return 0;
+        }
+        global_trace.entries = ring_buffer_size(global_trace.buffer);
+
+#ifdef CONFIG_TRACER_MAX_TRACE
+        max_tr.buffer = ring_buffer_alloc(trace_buf_size,
+                                             TRACE_BUFFER_FLAGS);
+        if (!max_tr.buffer) {
+                printk(KERN_ERR "tracer: failed to allocate max ring buffer!\n");
+                WARN_ON(1);
+                ring_buffer_free(global_trace.buffer);
+                return 0;
+        }
+        max_tr.entries = ring_buffer_size(max_tr.buffer);
+        WARN_ON(max_tr.entries != global_trace.entries);
+#endif
+
+        /* Allocate the first page for all buffers */
+        for_each_tracing_cpu(i) {
+                data = global_trace.data[i] = &per_cpu(global_trace_cpu, i);
+                max_tr.data[i] = &per_cpu(max_data, i);
+        }
 
         trace_init_cmdlines();
 
-        register_tracer(&no_tracer);
-        current_trace = &no_tracer;
+        register_tracer(&nop_trace);
+#ifdef CONFIG_BOOT_TRACER
+        register_tracer(&boot_tracer);
+        current_trace = &boot_tracer;
+        current_trace->init(&global_trace);
+#else
+        current_trace = &nop_trace;
+#endif
 
         /* All seems OK, enable tracing */
         global_trace.ctrl = tracer_enabled;
         tracing_disabled = 0;
 
-        return 0;
+        atomic_notifier_chain_register(&panic_notifier_list,
+                                       &trace_panic_notifier);
 
- free_buffers:
-        for (i-- ; i >= 0; i--) {
-                struct page *page, *tmp;
-                struct trace_array_cpu *data = global_trace.data[i];
+        register_die_notifier(&trace_die_notifier);
 
-                if (data) {
-                        list_for_each_entry_safe(page, tmp,
-                                                 &data->trace_pages, lru) {
-                                list_del_init(&page->lru);
-                                __free_page(page);
-                        }
-                }
-
-#ifdef CONFIG_TRACER_MAX_TRACE
-                data = max_tr.data[i];
-                if (data) {
-                        list_for_each_entry_safe(page, tmp,
-                                                 &data->trace_pages, lru) {
-                                list_del_init(&page->lru);
-                                __free_page(page);
-                        }
-                }
-#endif
-        }
-        return ret;
+        return 0;
 }
-fs_initcall(tracer_alloc_buffers);
+early_initcall(tracer_alloc_buffers);
+fs_initcall(tracer_init_debugfs);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index f69f86788c2b..8465ad052707 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -5,7 +5,9 @@
 #include <asm/atomic.h>
 #include <linux/sched.h>
 #include <linux/clocksource.h>
+#include <linux/ring_buffer.h>
 #include <linux/mmiotrace.h>
+#include <linux/ftrace.h>
 
 enum trace_type {
         __TRACE_FIRST_TYPE = 0,
@@ -13,38 +15,60 @@ enum trace_type {
         TRACE_FN,
         TRACE_CTX,
         TRACE_WAKE,
+        TRACE_CONT,
         TRACE_STACK,
+        TRACE_PRINT,
         TRACE_SPECIAL,
         TRACE_MMIO_RW,
         TRACE_MMIO_MAP,
+        TRACE_BOOT,
 
         __TRACE_LAST_TYPE
 };
 
 /*
+ * The trace entry - the most basic unit of tracing. This is what
+ * is printed in the end as a single line in the trace output, such as:
+ *
+ *     bash-15816 [01]   235.197585: idle_cpu <- irq_enter
+ */
+struct trace_entry {
+        unsigned char           type;
+        unsigned char           cpu;
+        unsigned char           flags;
+        unsigned char           preempt_count;
+        int                     pid;
+};
+
+/*
  * Function trace entry - function address and parent function addres:
  */
 struct ftrace_entry {
+        struct trace_entry      ent;
         unsigned long           ip;
         unsigned long           parent_ip;
 };
+extern struct tracer boot_tracer;
 
 /*
  * Context switch trace entry - which task (and prio) we switched from/to:
  */
 struct ctx_switch_entry {
+        struct trace_entry      ent;
         unsigned int            prev_pid;
         unsigned char           prev_prio;
         unsigned char           prev_state;
         unsigned int            next_pid;
         unsigned char           next_prio;
         unsigned char           next_state;
+        unsigned int            next_cpu;
 };
 
 /*
  * Special (free-form) trace entry:
  */
 struct special_entry {
+        struct trace_entry      ent;
         unsigned long           arg1;
         unsigned long           arg2;
         unsigned long           arg3;
@@ -57,33 +81,62 @@ struct special_entry {
 #define FTRACE_STACK_ENTRIES    8
 
 struct stack_entry {
+        struct trace_entry      ent;
         unsigned long           caller[FTRACE_STACK_ENTRIES];
 };
 
 /*
- * The trace entry - the most basic unit of tracing. This is what
- * is printed in the end as a single line in the trace output, such as:
- *
- *     bash-15816 [01]   235.197585: idle_cpu <- irq_enter
+ * ftrace_printk entry:
  */
-struct trace_entry {
-        char                    type;
-        char                    cpu;
-        char                    flags;
-        char                    preempt_count;
-        int                     pid;
-        cycle_t                 t;
-        union {
-                struct ftrace_entry             fn;
-                struct ctx_switch_entry         ctx;
-                struct special_entry            special;
-                struct stack_entry              stack;
-                struct mmiotrace_rw             mmiorw;
-                struct mmiotrace_map            mmiomap;
-        };
+struct print_entry {
+        struct trace_entry      ent;
+        unsigned long           ip;
+        char                    buf[];
+};
+
+#define TRACE_OLD_SIZE          88
+
+struct trace_field_cont {
+        unsigned char           type;
+        /* Temporary till we get rid of this completely */
+        char                    buf[TRACE_OLD_SIZE - 1];
+};
+
+struct trace_mmiotrace_rw {
+        struct trace_entry      ent;
+        struct mmiotrace_rw     rw;
+};
+
+struct trace_mmiotrace_map {
+        struct trace_entry      ent;
+        struct mmiotrace_map    map;
+};
+
+struct trace_boot {
+        struct trace_entry      ent;
+        struct boot_trace       initcall;
+};
+
+/*
+ * trace_flag_type is an enumeration that holds different
+ * states when a trace occurs. These are:
+ *  IRQS_OFF            - interrupts were disabled
+ *  IRQS_NOSUPPORT      - arch does not support irqs_disabled_flags
+ *  NEED_RESCED         - reschedule is requested
+ *  HARDIRQ             - inside an interrupt handler
+ *  SOFTIRQ             - inside a softirq handler
+ *  CONT                - multiple entries hold the trace item
+ */
+enum trace_flag_type {
+        TRACE_FLAG_IRQS_OFF             = 0x01,
+        TRACE_FLAG_IRQS_NOSUPPORT       = 0x02,
+        TRACE_FLAG_NEED_RESCHED         = 0x04,
+        TRACE_FLAG_HARDIRQ              = 0x08,
+        TRACE_FLAG_SOFTIRQ              = 0x10,
+        TRACE_FLAG_CONT                 = 0x20,
 };
 
-#define TRACE_ENTRY_SIZE        sizeof(struct trace_entry)
+#define TRACE_BUF_SIZE          1024
 
 /*
  * The CPU trace array - it consists of thousands of trace entries
@@ -91,16 +144,9 @@ struct trace_entry {
  * the trace, etc.)
  */
 struct trace_array_cpu {
-        struct list_head        trace_pages;
         atomic_t                disabled;
-        raw_spinlock_t          lock;
-        struct lock_class_key   lock_key;
 
         /* these fields get copied into max-trace: */
-        unsigned                trace_head_idx;
-        unsigned                trace_tail_idx;
-        void                    *trace_head; /* producer */
-        void                    *trace_tail; /* consumer */
         unsigned long           trace_idx;
         unsigned long           overrun;
         unsigned long           saved_latency;
@@ -124,6 +170,7 @@ struct trace_iterator;
  * They have on/off state as well:
  */
 struct trace_array {
+        struct ring_buffer      *buffer;
         unsigned long           entries;
         long                    ctrl;
         int                     cpu;
@@ -132,6 +179,56 @@ struct trace_array {
         struct trace_array_cpu  *data[NR_CPUS];
 };
 
+#define FTRACE_CMP_TYPE(var, type) \
+        __builtin_types_compatible_p(typeof(var), type *)
+
+#undef IF_ASSIGN
+#define IF_ASSIGN(var, entry, etype, id)                \
+        if (FTRACE_CMP_TYPE(var, etype)) {              \
+                var = (typeof(var))(entry);             \
+                WARN_ON(id && (entry)->type != id);     \
+                break;                                  \
+        }
+
+/* Will cause compile errors if type is not found. */
+extern void __ftrace_bad_type(void);
+
+/*
+ * The trace_assign_type is a verifier that the entry type is
+ * the same as the type being assigned. To add new types simply
+ * add a line with the following format:
+ *
+ * IF_ASSIGN(var, ent, type, id);
+ *
+ *  Where "type" is the trace type that includes the trace_entry
+ *  as the "ent" item. And "id" is the trace identifier that is
+ *  used in the trace_type enum.
+ *
+ *  If the type can have more than one id, then use zero.
+ */
+#define trace_assign_type(var, ent)                                     \
+        do {                                                            \
+                IF_ASSIGN(var, ent, struct ftrace_entry, TRACE_FN);     \
+                IF_ASSIGN(var, ent, struct ctx_switch_entry, 0);        \
+                IF_ASSIGN(var, ent, struct trace_field_cont, TRACE_CONT); \
+                IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK);   \
+                IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT);   \
+                IF_ASSIGN(var, ent, struct special_entry, 0);           \
+                IF_ASSIGN(var, ent, struct trace_mmiotrace_rw,          \
+                          TRACE_MMIO_RW);                               \
+                IF_ASSIGN(var, ent, struct trace_mmiotrace_map,         \
+                          TRACE_MMIO_MAP);                              \
+                IF_ASSIGN(var, ent, struct trace_boot, TRACE_BOOT);     \
+                __ftrace_bad_type();                                    \
+        } while (0)
+
+/* Return values for print_line callback */
+enum print_line_t {
+        TRACE_TYPE_PARTIAL_LINE = 0,    /* Retry after flushing the seq */
+        TRACE_TYPE_HANDLED      = 1,
+        TRACE_TYPE_UNHANDLED    = 2     /* Relay to other output functions */
+};
+
 /*
  * A specific tracer, represented by methods that operate on a trace array:
  */
@@ -152,7 +249,7 @@ struct tracer {
         int                     (*selftest)(struct tracer *trace,
                                             struct trace_array *tr);
 #endif
-        int                     (*print_line)(struct trace_iterator *iter);
+        enum print_line_t       (*print_line)(struct trace_iterator *iter);
         struct tracer           *next;
         int                     print_max;
 };
@@ -171,57 +268,58 @@ struct trace_iterator {
         struct trace_array      *tr;
         struct tracer           *trace;
         void                    *private;
-        long                    last_overrun[NR_CPUS];
-        long                    overrun[NR_CPUS];
+        struct ring_buffer_iter *buffer_iter[NR_CPUS];
 
         /* The below is zeroed out in pipe_read */
         struct trace_seq        seq;
         struct trace_entry      *ent;
         int                     cpu;
-
-        struct trace_entry      *prev_ent;
-        int                     prev_cpu;
+        u64                     ts;
 
         unsigned long           iter_flags;
         loff_t                  pos;
-        unsigned long           next_idx[NR_CPUS];
-        struct list_head        *next_page[NR_CPUS];
-        unsigned                next_page_idx[NR_CPUS];
         long                    idx;
 };
 
-void tracing_reset(struct trace_array_cpu *data);
+void trace_wake_up(void);
+void tracing_reset(struct trace_array *tr, int cpu);
 int tracing_open_generic(struct inode *inode, struct file *filp);
 struct dentry *tracing_init_dentry(void);
 void init_tracer_sysprof_debugfs(struct dentry *d_tracer);
 
+struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
+                                                struct trace_array_cpu *data);
+void tracing_generic_entry_update(struct trace_entry *entry,
+                                  unsigned long flags,
+                                  int pc);
+
 void ftrace(struct trace_array *tr,
                             struct trace_array_cpu *data,
                             unsigned long ip,
                             unsigned long parent_ip,
-                            unsigned long flags);
+                            unsigned long flags, int pc);
 void tracing_sched_switch_trace(struct trace_array *tr,
                                 struct trace_array_cpu *data,
                                 struct task_struct *prev,
                                 struct task_struct *next,
-                                unsigned long flags);
+                                unsigned long flags, int pc);
 void tracing_record_cmdline(struct task_struct *tsk);
 
 void tracing_sched_wakeup_trace(struct trace_array *tr,
                                 struct trace_array_cpu *data,
                                 struct task_struct *wakee,
                                 struct task_struct *cur,
-                                unsigned long flags);
+                                unsigned long flags, int pc);
 void trace_special(struct trace_array *tr,
                    struct trace_array_cpu *data,
                    unsigned long arg1,
                    unsigned long arg2,
-                   unsigned long arg3);
+                   unsigned long arg3, int pc);
 void trace_function(struct trace_array *tr,
                     struct trace_array_cpu *data,
                     unsigned long ip,
                     unsigned long parent_ip,
-                    unsigned long flags);
+                    unsigned long flags, int pc);
 
 void tracing_start_cmdline_record(void);
 void tracing_stop_cmdline_record(void);
@@ -239,7 +337,7 @@ void update_max_tr_single(struct trace_array *tr,
 
 extern cycle_t ftrace_now(int cpu);
 
-#ifdef CONFIG_FTRACE
+#ifdef CONFIG_FUNCTION_TRACER
 void tracing_start_function_trace(void);
 void tracing_stop_function_trace(void);
 #else
@@ -268,51 +366,33 @@ extern unsigned long ftrace_update_tot_cnt;
 extern int DYN_FTRACE_TEST_NAME(void);
 #endif
 
-#ifdef CONFIG_MMIOTRACE
-extern void __trace_mmiotrace_rw(struct trace_array *tr,
-                                struct trace_array_cpu *data,
-                                struct mmiotrace_rw *rw);
-extern void __trace_mmiotrace_map(struct trace_array *tr,
-                                struct trace_array_cpu *data,
-                                struct mmiotrace_map *map);
-#endif
-
 #ifdef CONFIG_FTRACE_STARTUP_TEST
-#ifdef CONFIG_FTRACE
 extern int trace_selftest_startup_function(struct tracer *trace,
                                            struct trace_array *tr);
-#endif
-#ifdef CONFIG_IRQSOFF_TRACER
 extern int trace_selftest_startup_irqsoff(struct tracer *trace,
                                           struct trace_array *tr);
-#endif
-#ifdef CONFIG_PREEMPT_TRACER
 extern int trace_selftest_startup_preemptoff(struct tracer *trace,
                                              struct trace_array *tr);
-#endif
-#if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER)
 extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace,
                                                  struct trace_array *tr);
-#endif
-#ifdef CONFIG_SCHED_TRACER
 extern int trace_selftest_startup_wakeup(struct tracer *trace,
                                          struct trace_array *tr);
-#endif
-#ifdef CONFIG_CONTEXT_SWITCH_TRACER
+extern int trace_selftest_startup_nop(struct tracer *trace,
+                                         struct trace_array *tr);
 extern int trace_selftest_startup_sched_switch(struct tracer *trace,
                                                struct trace_array *tr);
-#endif
-#ifdef CONFIG_SYSPROF_TRACER
 extern int trace_selftest_startup_sysprof(struct tracer *trace,
                                                struct trace_array *tr);
-#endif
 #endif /* CONFIG_FTRACE_STARTUP_TEST */
 
 extern void *head_page(struct trace_array_cpu *data);
 extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...);
+extern void trace_seq_print_cont(struct trace_seq *s,
+                                 struct trace_iterator *iter);
 extern ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf,
                                  size_t cnt);
 extern long ns2usecs(cycle_t nsec);
+extern int trace_vprintk(unsigned long ip, const char *fmt, va_list args);
 
 extern unsigned long trace_flags;
 
@@ -334,6 +414,9 @@ enum trace_iterator_flags {
         TRACE_ITER_BLOCK                = 0x80,
         TRACE_ITER_STACKTRACE           = 0x100,
         TRACE_ITER_SCHED_TREE           = 0x200,
+        TRACE_ITER_PRINTK               = 0x400,
 };
 
+extern struct tracer nop_trace;
+
 #endif /* _LINUX_KERNEL_TRACE_H */
diff --git a/kernel/trace/trace_boot.c b/kernel/trace/trace_boot.c
new file mode 100644
index 000000000000..d0a5e50eeff2
--- /dev/null
+++ b/kernel/trace/trace_boot.c
@@ -0,0 +1,126 @@
+/*
+ * ring buffer based initcalls tracer
+ *
+ * Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/debugfs.h>
+#include <linux/ftrace.h>
+#include <linux/kallsyms.h>
+
+#include "trace.h"
+
+static struct trace_array *boot_trace;
+static int trace_boot_enabled;
+
+
+/* Should be started after do_pre_smp_initcalls() in init/main.c */
+void start_boot_trace(void)
+{
+        trace_boot_enabled = 1;
+}
+
+void stop_boot_trace(void)
+{
+        trace_boot_enabled = 0;
+}
+
+void reset_boot_trace(struct trace_array *tr)
+{
+        stop_boot_trace();
+}
+
+static void boot_trace_init(struct trace_array *tr)
+{
+        int cpu;
+        boot_trace = tr;
+
+        trace_boot_enabled = 0;
+
+        for_each_cpu_mask(cpu, cpu_possible_map)
+                tracing_reset(tr, cpu);
+}
+
+static void boot_trace_ctrl_update(struct trace_array *tr)
+{
+        if (tr->ctrl)
+                start_boot_trace();
+        else
+                stop_boot_trace();
+}
+
+static enum print_line_t initcall_print_line(struct trace_iterator *iter)
+{
+        int ret;
+        struct trace_entry *entry = iter->ent;
+        struct trace_boot *field = (struct trace_boot *)entry;
+        struct boot_trace *it = &field->initcall;
+        struct trace_seq *s = &iter->seq;
+        struct timespec calltime = ktime_to_timespec(it->calltime);
+        struct timespec rettime = ktime_to_timespec(it->rettime);
+
+        if (entry->type == TRACE_BOOT) {
+                ret = trace_seq_printf(s, "[%5ld.%09ld] calling  %s @ %i\n",
+                                          calltime.tv_sec,
+                                          calltime.tv_nsec,
+                                          it->func, it->caller);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+
+                ret = trace_seq_printf(s, "[%5ld.%09ld] initcall %s "
+                                          "returned %d after %lld msecs\n",
+                                          rettime.tv_sec,
+                                          rettime.tv_nsec,
+                                          it->func, it->result, it->duration);
+
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+                return TRACE_TYPE_HANDLED;
+        }
+        return TRACE_TYPE_UNHANDLED;
+}
+
+struct tracer boot_tracer __read_mostly =
+{
+        .name           = "initcall",
+        .init           = boot_trace_init,
+        .reset          = reset_boot_trace,
+        .ctrl_update    = boot_trace_ctrl_update,
+        .print_line     = initcall_print_line,
+};
+
+void trace_boot(struct boot_trace *it, initcall_t fn)
+{
+        struct ring_buffer_event *event;
+        struct trace_boot *entry;
+        struct trace_array_cpu *data;
+        unsigned long irq_flags;
+        struct trace_array *tr = boot_trace;
+
+        if (!trace_boot_enabled)
+                return;
+
+        /* Get its name now since this function could
+         * disappear because it is in the .init section.
+         */
+        sprint_symbol(it->func, (unsigned long)fn);
+        preempt_disable();
+        data = tr->data[smp_processor_id()];
+
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                         &irq_flags);
+        if (!event)
+                goto out;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, 0);
+        entry->ent.type = TRACE_BOOT;
+        entry->initcall = *it;
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+
+        trace_wake_up();
+
+ out:
+        preempt_enable();
+}
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index 312144897970..0f85a64003d3 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -23,7 +23,7 @@ static void function_reset(struct trace_array *tr)
         tr->time_start = ftrace_now(tr->cpu);
 
         for_each_online_cpu(cpu)
-                tracing_reset(tr->data[cpu]);
+                tracing_reset(tr, cpu);
 }
 
 static void start_function_trace(struct trace_array *tr)
@@ -64,7 +64,7 @@ static void function_trace_ctrl_update(struct trace_array *tr)
 
 static struct tracer function_trace __read_mostly =
 {
-        .name        = "ftrace",
+        .name        = "function",
         .init        = function_trace_init,
         .reset       = function_trace_reset,
         .ctrl_update = function_trace_ctrl_update,
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index ece6cfb649fa..9c74071c10e0 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -63,7 +63,7 @@ irq_trace(void)
  */
 static __cacheline_aligned_in_smp       unsigned long max_sequence;
 
-#ifdef CONFIG_FTRACE
+#ifdef CONFIG_FUNCTION_TRACER
 /*
  * irqsoff uses its own tracer function to keep the overhead down:
  */
@@ -95,7 +95,7 @@ irqsoff_tracer_call(unsigned long ip, unsigned long parent_ip)
         disabled = atomic_inc_return(&data->disabled);
 
         if (likely(disabled == 1))
-                trace_function(tr, data, ip, parent_ip, flags);
+                trace_function(tr, data, ip, parent_ip, flags, preempt_count());
 
         atomic_dec(&data->disabled);
 }
@@ -104,7 +104,7 @@ static struct ftrace_ops trace_ops __read_mostly =
 {
         .func = irqsoff_tracer_call,
 };
-#endif /* CONFIG_FTRACE */
+#endif /* CONFIG_FUNCTION_TRACER */
 
 /*
  * Should this new latency be reported/recorded?
@@ -130,6 +130,7 @@ check_critical_timing(struct trace_array *tr,
         unsigned long latency, t0, t1;
         cycle_t T0, T1, delta;
         unsigned long flags;
+        int pc;
 
         /*
          * usecs conversion is slow so we try to delay the conversion
@@ -141,6 +142,8 @@ check_critical_timing(struct trace_array *tr,
 
         local_save_flags(flags);
 
+        pc = preempt_count();
+
         if (!report_latency(delta))
                 goto out;
 
@@ -150,7 +153,7 @@ check_critical_timing(struct trace_array *tr,
         if (!report_latency(delta))
                 goto out_unlock;
 
-        trace_function(tr, data, CALLER_ADDR0, parent_ip, flags);
+        trace_function(tr, data, CALLER_ADDR0, parent_ip, flags, pc);
 
         latency = nsecs_to_usecs(delta);
 
@@ -173,8 +176,8 @@ out_unlock:
 out:
         data->critical_sequence = max_sequence;
         data->preempt_timestamp = ftrace_now(cpu);
-        tracing_reset(data);
-        trace_function(tr, data, CALLER_ADDR0, parent_ip, flags);
+        tracing_reset(tr, cpu);
+        trace_function(tr, data, CALLER_ADDR0, parent_ip, flags, pc);
 }
 
 static inline void
@@ -203,11 +206,11 @@ start_critical_timing(unsigned long ip, unsigned long parent_ip)
         data->critical_sequence = max_sequence;
         data->preempt_timestamp = ftrace_now(cpu);
         data->critical_start = parent_ip ? : ip;
-        tracing_reset(data);
+        tracing_reset(tr, cpu);
 
         local_save_flags(flags);
 
-        trace_function(tr, data, ip, parent_ip, flags);
+        trace_function(tr, data, ip, parent_ip, flags, preempt_count());
 
         per_cpu(tracing_cpu, cpu) = 1;
 
@@ -234,14 +237,14 @@ stop_critical_timing(unsigned long ip, unsigned long parent_ip)
 
         data = tr->data[cpu];
 
-        if (unlikely(!data) || unlikely(!head_page(data)) ||
+        if (unlikely(!data) ||
             !data->critical_start || atomic_read(&data->disabled))
                 return;
 
         atomic_inc(&data->disabled);
 
         local_save_flags(flags);
-        trace_function(tr, data, ip, parent_ip, flags);
+        trace_function(tr, data, ip, parent_ip, flags, preempt_count());
         check_critical_timing(tr, data, parent_ip ? : ip, cpu);
         data->critical_start = 0;
         atomic_dec(&data->disabled);
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index b13dc19dcbb4..f28484618ff0 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -27,7 +27,7 @@ static void mmio_reset_data(struct trace_array *tr)
         tr->time_start = ftrace_now(tr->cpu);
 
         for_each_online_cpu(cpu)
-                tracing_reset(tr->data[cpu]);
+                tracing_reset(tr, cpu);
 }
 
 static void mmio_trace_init(struct trace_array *tr)
@@ -130,10 +130,14 @@ static unsigned long count_overruns(struct trace_iterator *iter)
 {
         int cpu;
         unsigned long cnt = 0;
+/* FIXME: */
+#if 0
         for_each_online_cpu(cpu) {
                 cnt += iter->overrun[cpu];
                 iter->overrun[cpu] = 0;
         }
+#endif
+        (void)cpu;
         return cnt;
 }
 
@@ -171,17 +175,21 @@ print_out:
         return (ret == -EBUSY) ? 0 : ret;
 }
 
-static int mmio_print_rw(struct trace_iterator *iter)
+static enum print_line_t mmio_print_rw(struct trace_iterator *iter)
 {
         struct trace_entry *entry = iter->ent;
-        struct mmiotrace_rw *rw = &entry->mmiorw;
+        struct trace_mmiotrace_rw *field;
+        struct mmiotrace_rw *rw;
         struct trace_seq *s     = &iter->seq;
-        unsigned long long t    = ns2usecs(entry->t);
+        unsigned long long t    = ns2usecs(iter->ts);
         unsigned long usec_rem  = do_div(t, 1000000ULL);
         unsigned secs           = (unsigned long)t;
         int ret = 1;
 
-        switch (entry->mmiorw.opcode) {
+        trace_assign_type(field, entry);
+        rw = &field->rw;
+
+        switch (rw->opcode) {
         case MMIO_READ:
                 ret = trace_seq_printf(s,
                         "R %d %lu.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
@@ -209,21 +217,25 @@ static int mmio_print_rw(struct trace_iterator *iter)
                 break;
         }
         if (ret)
-                return 1;
-        return 0;
+                return TRACE_TYPE_HANDLED;
+        return TRACE_TYPE_PARTIAL_LINE;
 }
 
-static int mmio_print_map(struct trace_iterator *iter)
+static enum print_line_t mmio_print_map(struct trace_iterator *iter)
 {
         struct trace_entry *entry = iter->ent;
-        struct mmiotrace_map *m = &entry->mmiomap;
+        struct trace_mmiotrace_map *field;
+        struct mmiotrace_map *m;
         struct trace_seq *s     = &iter->seq;
-        unsigned long long t    = ns2usecs(entry->t);
+        unsigned long long t    = ns2usecs(iter->ts);
         unsigned long usec_rem  = do_div(t, 1000000ULL);
         unsigned secs           = (unsigned long)t;
-        int ret = 1;
+        int ret;
 
-        switch (entry->mmiorw.opcode) {
+        trace_assign_type(field, entry);
+        m = &field->map;
+
+        switch (m->opcode) {
         case MMIO_PROBE:
                 ret = trace_seq_printf(s,
                         "MAP %lu.%06lu %d 0x%llx 0x%lx 0x%lx 0x%lx %d\n",
@@ -241,20 +253,43 @@ static int mmio_print_map(struct trace_iterator *iter)
                 break;
         }
         if (ret)
-                return 1;
-        return 0;
+                return TRACE_TYPE_HANDLED;
+        return TRACE_TYPE_PARTIAL_LINE;
+}
+
+static enum print_line_t mmio_print_mark(struct trace_iterator *iter)
+{
+        struct trace_entry *entry = iter->ent;
+        struct print_entry *print = (struct print_entry *)entry;
+        const char *msg         = print->buf;
+        struct trace_seq *s     = &iter->seq;
+        unsigned long long t    = ns2usecs(iter->ts);
+        unsigned long usec_rem  = do_div(t, 1000000ULL);
+        unsigned secs           = (unsigned long)t;
+        int ret;
+
+        /* The trailing newline must be in the message. */
+        ret = trace_seq_printf(s, "MARK %lu.%06lu %s", secs, usec_rem, msg);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        if (entry->flags & TRACE_FLAG_CONT)
+                trace_seq_print_cont(s, iter);
+
+        return TRACE_TYPE_HANDLED;
 }
 
-/* return 0 to abort printing without consuming current entry in pipe mode */
-static int mmio_print_line(struct trace_iterator *iter)
+static enum print_line_t mmio_print_line(struct trace_iterator *iter)
 {
         switch (iter->ent->type) {
         case TRACE_MMIO_RW:
                 return mmio_print_rw(iter);
         case TRACE_MMIO_MAP:
                 return mmio_print_map(iter);
+        case TRACE_PRINT:
+                return mmio_print_mark(iter);
         default:
-                return 1; /* ignore unknown entries */
+                return TRACE_TYPE_HANDLED; /* ignore unknown entries */
         }
 }
 
@@ -276,6 +311,27 @@ __init static int init_mmio_trace(void)
 }
 device_initcall(init_mmio_trace);
 
+static void __trace_mmiotrace_rw(struct trace_array *tr,
+                                struct trace_array_cpu *data,
+                                struct mmiotrace_rw *rw)
+{
+        struct ring_buffer_event *event;
+        struct trace_mmiotrace_rw *entry;
+        unsigned long irq_flags;
+
+        event   = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                           &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, preempt_count());
+        entry->ent.type                 = TRACE_MMIO_RW;
+        entry->rw                       = *rw;
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+
+        trace_wake_up();
+}
+
 void mmio_trace_rw(struct mmiotrace_rw *rw)
 {
         struct trace_array *tr = mmio_trace_array;
@@ -283,6 +339,27 @@ void mmio_trace_rw(struct mmiotrace_rw *rw)
         __trace_mmiotrace_rw(tr, data, rw);
 }
 
+static void __trace_mmiotrace_map(struct trace_array *tr,
+                                struct trace_array_cpu *data,
+                                struct mmiotrace_map *map)
+{
+        struct ring_buffer_event *event;
+        struct trace_mmiotrace_map *entry;
+        unsigned long irq_flags;
+
+        event   = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
+                                           &irq_flags);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, preempt_count());
+        entry->ent.type                 = TRACE_MMIO_MAP;
+        entry->map                      = *map;
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+
+        trace_wake_up();
+}
+
 void mmio_trace_mapping(struct mmiotrace_map *map)
 {
         struct trace_array *tr = mmio_trace_array;
@@ -293,3 +370,8 @@ void mmio_trace_mapping(struct mmiotrace_map *map)
         __trace_mmiotrace_map(tr, data, map);
         preempt_enable();
 }
+
+int mmio_trace_printk(const char *fmt, va_list args)
+{
+        return trace_vprintk(0, fmt, args);
+}
diff --git a/kernel/trace/trace_nop.c b/kernel/trace/trace_nop.c
new file mode 100644
index 000000000000..4592b4862515
--- /dev/null
+++ b/kernel/trace/trace_nop.c
@@ -0,0 +1,64 @@
+/*
+ * nop tracer
+ *
+ * Copyright (C) 2008 Steven Noonan <steven@uplinklabs.net>
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/debugfs.h>
+#include <linux/ftrace.h>
+
+#include "trace.h"
+
+static struct trace_array       *ctx_trace;
+
+static void start_nop_trace(struct trace_array *tr)
+{
+        /* Nothing to do! */
+}
+
+static void stop_nop_trace(struct trace_array *tr)
+{
+        /* Nothing to do! */
+}
+
+static void nop_trace_init(struct trace_array *tr)
+{
+        int cpu;
+        ctx_trace = tr;
+
+        for_each_online_cpu(cpu)
+                tracing_reset(tr, cpu);
+
+        if (tr->ctrl)
+                start_nop_trace(tr);
+}
+
+static void nop_trace_reset(struct trace_array *tr)
+{
+        if (tr->ctrl)
+                stop_nop_trace(tr);
+}
+
+static void nop_trace_ctrl_update(struct trace_array *tr)
+{
+        /* When starting a new trace, reset the buffers */
+        if (tr->ctrl)
+                start_nop_trace(tr);
+        else
+                stop_nop_trace(tr);
+}
+
+struct tracer nop_trace __read_mostly =
+{
+        .name           = "nop",
+        .init           = nop_trace_init,
+        .reset          = nop_trace_reset,
+        .ctrl_update    = nop_trace_ctrl_update,
+#ifdef CONFIG_FTRACE_SELFTEST
+        .selftest       = trace_selftest_startup_nop,
+#endif
+};
+
diff --git a/kernel/trace/trace_sched_switch.c b/kernel/trace/trace_sched_switch.c
index cb817a209aa0..b8f56beb1a62 100644
--- a/kernel/trace/trace_sched_switch.c
+++ b/kernel/trace/trace_sched_switch.c
@@ -9,8 +9,8 @@
 #include <linux/debugfs.h>
 #include <linux/kallsyms.h>
 #include <linux/uaccess.h>
-#include <linux/marker.h>
 #include <linux/ftrace.h>
+#include <trace/sched.h>
 
 #include "trace.h"
 
@@ -19,15 +19,16 @@ static int __read_mostly	tracer_enabled;
 static atomic_t                 sched_ref;
 
 static void
-sched_switch_func(void *private, void *__rq, struct task_struct *prev,
+probe_sched_switch(struct rq *__rq, struct task_struct *prev,
                         struct task_struct *next)
 {
-        struct trace_array **ptr = private;
-        struct trace_array *tr = *ptr;
         struct trace_array_cpu *data;
         unsigned long flags;
-        long disabled;
         int cpu;
+        int pc;
+
+        if (!atomic_read(&sched_ref))
+                return;
 
         tracing_record_cmdline(prev);
         tracing_record_cmdline(next);
@@ -35,97 +36,41 @@ sched_switch_func(void *private, void *__rq, struct task_struct *prev,
         if (!tracer_enabled)
                 return;
 
+        pc = preempt_count();
         local_irq_save(flags);
         cpu = raw_smp_processor_id();
-        data = tr->data[cpu];
-        disabled = atomic_inc_return(&data->disabled);
+        data = ctx_trace->data[cpu];
 
-        if (likely(disabled == 1))
-                tracing_sched_switch_trace(tr, data, prev, next, flags);
+        if (likely(!atomic_read(&data->disabled)))
+                tracing_sched_switch_trace(ctx_trace, data, prev, next, flags, pc);
 
-        atomic_dec(&data->disabled);
         local_irq_restore(flags);
 }
 
-static notrace void
-sched_switch_callback(void *probe_data, void *call_data,
-                      const char *format, va_list *args)
-{
-        struct task_struct *prev;
-        struct task_struct *next;
-        struct rq *__rq;
-
-        if (!atomic_read(&sched_ref))
-                return;
-
-        /* skip prev_pid %d next_pid %d prev_state %ld */
-        (void)va_arg(*args, int);
-        (void)va_arg(*args, int);
-        (void)va_arg(*args, long);
-        __rq = va_arg(*args, typeof(__rq));
-        prev = va_arg(*args, typeof(prev));
-        next = va_arg(*args, typeof(next));
-
-        /*
-         * If tracer_switch_func only points to the local
-         * switch func, it still needs the ptr passed to it.
-         */
-        sched_switch_func(probe_data, __rq, prev, next);
-}
-
 static void
-wakeup_func(void *private, void *__rq, struct task_struct *wakee, struct
-                        task_struct *curr)
+probe_sched_wakeup(struct rq *__rq, struct task_struct *wakee)
 {
-        struct trace_array **ptr = private;
-        struct trace_array *tr = *ptr;
         struct trace_array_cpu *data;
         unsigned long flags;
-        long disabled;
-        int cpu;
+        int cpu, pc;
 
-        if (!tracer_enabled)
+        if (!likely(tracer_enabled))
                 return;
 
-        tracing_record_cmdline(curr);
+        pc = preempt_count();
+        tracing_record_cmdline(current);
 
         local_irq_save(flags);
         cpu = raw_smp_processor_id();
-        data = tr->data[cpu];
-        disabled = atomic_inc_return(&data->disabled);
+        data = ctx_trace->data[cpu];
 
-        if (likely(disabled == 1))
-                tracing_sched_wakeup_trace(tr, data, wakee, curr, flags);
+        if (likely(!atomic_read(&data->disabled)))
+                tracing_sched_wakeup_trace(ctx_trace, data, wakee, current,
+                                           flags, pc);
 
-        atomic_dec(&data->disabled);
         local_irq_restore(flags);
 }
 
-static notrace void
-wake_up_callback(void *probe_data, void *call_data,
-                 const char *format, va_list *args)
-{
-        struct task_struct *curr;
-        struct task_struct *task;
-        struct rq *__rq;
-
-        if (likely(!tracer_enabled))
-                return;
-
-        /* Skip pid %d state %ld */
-        (void)va_arg(*args, int);
-        (void)va_arg(*args, long);
-        /* now get the meat: "rq %p task %p rq->curr %p" */
-        __rq = va_arg(*args, typeof(__rq));
-        task = va_arg(*args, typeof(task));
-        curr = va_arg(*args, typeof(curr));
-
-        tracing_record_cmdline(task);
-        tracing_record_cmdline(curr);
-
-        wakeup_func(probe_data, __rq, task, curr);
-}
-
 static void sched_switch_reset(struct trace_array *tr)
 {
         int cpu;
@@ -133,67 +78,47 @@ static void sched_switch_reset(struct trace_array *tr)
         tr->time_start = ftrace_now(tr->cpu);
 
         for_each_online_cpu(cpu)
-                tracing_reset(tr->data[cpu]);
+                tracing_reset(tr, cpu);
 }
 
 static int tracing_sched_register(void)
 {
         int ret;
 
-        ret = marker_probe_register("kernel_sched_wakeup",
-                        "pid %d state %ld ## rq %p task %p rq->curr %p",
-                        wake_up_callback,
-                        &ctx_trace);
+        ret = register_trace_sched_wakeup(probe_sched_wakeup);
         if (ret) {
-                pr_info("wakeup trace: Couldn't add marker"
+                pr_info("wakeup trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_wakeup\n");
                 return ret;
         }
 
-        ret = marker_probe_register("kernel_sched_wakeup_new",
-                        "pid %d state %ld ## rq %p task %p rq->curr %p",
-                        wake_up_callback,
-                        &ctx_trace);
+        ret = register_trace_sched_wakeup_new(probe_sched_wakeup);
         if (ret) {
-                pr_info("wakeup trace: Couldn't add marker"
+                pr_info("wakeup trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_wakeup_new\n");
                 goto fail_deprobe;
         }
 
-        ret = marker_probe_register("kernel_sched_schedule",
-                "prev_pid %d next_pid %d prev_state %ld "
-                "## rq %p prev %p next %p",
-                sched_switch_callback,
-                &ctx_trace);
+        ret = register_trace_sched_switch(probe_sched_switch);
         if (ret) {
-                pr_info("sched trace: Couldn't add marker"
+                pr_info("sched trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_schedule\n");
                 goto fail_deprobe_wake_new;
         }
 
         return ret;
 fail_deprobe_wake_new:
-        marker_probe_unregister("kernel_sched_wakeup_new",
-                                wake_up_callback,
-                                &ctx_trace);
+        unregister_trace_sched_wakeup_new(probe_sched_wakeup);
 fail_deprobe:
-        marker_probe_unregister("kernel_sched_wakeup",
-                                wake_up_callback,
-                                &ctx_trace);
+        unregister_trace_sched_wakeup(probe_sched_wakeup);
         return ret;
 }
 
 static void tracing_sched_unregister(void)
 {
-        marker_probe_unregister("kernel_sched_schedule",
-                                sched_switch_callback,
-                                &ctx_trace);
-        marker_probe_unregister("kernel_sched_wakeup_new",
-                                wake_up_callback,
-                                &ctx_trace);
-        marker_probe_unregister("kernel_sched_wakeup",
-                                wake_up_callback,
-                                &ctx_trace);
+        unregister_trace_sched_switch(probe_sched_switch);
+        unregister_trace_sched_wakeup_new(probe_sched_wakeup);
+        unregister_trace_sched_wakeup(probe_sched_wakeup);
 }
 
 static void tracing_start_sched_switch(void)
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index e303ccb62cdf..3ae93f16b565 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -15,7 +15,7 @@
 #include <linux/kallsyms.h>
 #include <linux/uaccess.h>
 #include <linux/ftrace.h>
-#include <linux/marker.h>
+#include <trace/sched.h>
 
 #include "trace.h"
 
@@ -31,7 +31,7 @@ static raw_spinlock_t wakeup_lock =
 
 static void __wakeup_reset(struct trace_array *tr);
 
-#ifdef CONFIG_FTRACE
+#ifdef CONFIG_FUNCTION_TRACER
 /*
  * irqsoff uses its own tracer function to keep the overhead down:
  */
@@ -44,10 +44,12 @@ wakeup_tracer_call(unsigned long ip, unsigned long parent_ip)
         long disabled;
         int resched;
         int cpu;
+        int pc;
 
         if (likely(!wakeup_task))
                 return;
 
+        pc = preempt_count();
         resched = need_resched();
         preempt_disable_notrace();
 
@@ -70,7 +72,7 @@ wakeup_tracer_call(unsigned long ip, unsigned long parent_ip)
         if (task_cpu(wakeup_task) != cpu)
                 goto unlock;
 
-        trace_function(tr, data, ip, parent_ip, flags);
+        trace_function(tr, data, ip, parent_ip, flags, pc);
 
  unlock:
         __raw_spin_unlock(&wakeup_lock);
@@ -94,7 +96,7 @@ static struct ftrace_ops trace_ops __read_mostly =
 {
         .func = wakeup_tracer_call,
 };
-#endif /* CONFIG_FTRACE */
+#endif /* CONFIG_FUNCTION_TRACER */
 
 /*
  * Should this new latency be reported/recorded?
@@ -112,17 +114,18 @@ static int report_latency(cycle_t delta)
 }
 
 static void notrace
-wakeup_sched_switch(void *private, void *rq, struct task_struct *prev,
+probe_wakeup_sched_switch(struct rq *rq, struct task_struct *prev,
         struct task_struct *next)
 {
         unsigned long latency = 0, t0 = 0, t1 = 0;
-        struct trace_array **ptr = private;
-        struct trace_array *tr = *ptr;
         struct trace_array_cpu *data;
         cycle_t T0, T1, delta;
         unsigned long flags;
         long disabled;
         int cpu;
+        int pc;
+
+        tracing_record_cmdline(prev);
 
         if (unlikely(!tracer_enabled))
                 return;
@@ -139,12 +142,14 @@ wakeup_sched_switch(void *private, void *rq, struct task_struct *prev,
         if (next != wakeup_task)
                 return;
 
+        pc = preempt_count();
+
         /* The task we are waiting for is waking up */
-        data = tr->data[wakeup_cpu];
+        data = wakeup_trace->data[wakeup_cpu];
 
         /* disable local data, not wakeup_cpu data */
         cpu = raw_smp_processor_id();
-        disabled = atomic_inc_return(&tr->data[cpu]->disabled);
+        disabled = atomic_inc_return(&wakeup_trace->data[cpu]->disabled);
         if (likely(disabled != 1))
                 goto out;
 
@@ -155,7 +160,7 @@ wakeup_sched_switch(void *private, void *rq, struct task_struct *prev,
         if (unlikely(!tracer_enabled || next != wakeup_task))
                 goto out_unlock;
 
-        trace_function(tr, data, CALLER_ADDR1, CALLER_ADDR2, flags);
+        trace_function(wakeup_trace, data, CALLER_ADDR1, CALLER_ADDR2, flags, pc);
 
         /*
          * usecs conversion is slow so we try to delay the conversion
@@ -174,39 +179,14 @@ wakeup_sched_switch(void *private, void *rq, struct task_struct *prev,
         t0 = nsecs_to_usecs(T0);
         t1 = nsecs_to_usecs(T1);
 
-        update_max_tr(tr, wakeup_task, wakeup_cpu);
+        update_max_tr(wakeup_trace, wakeup_task, wakeup_cpu);
 
 out_unlock:
-        __wakeup_reset(tr);
+        __wakeup_reset(wakeup_trace);
         __raw_spin_unlock(&wakeup_lock);
         local_irq_restore(flags);
 out:
-        atomic_dec(&tr->data[cpu]->disabled);
-}
-
-static notrace void
-sched_switch_callback(void *probe_data, void *call_data,
-                      const char *format, va_list *args)
-{
-        struct task_struct *prev;
-        struct task_struct *next;
-        struct rq *__rq;
-
-        /* skip prev_pid %d next_pid %d prev_state %ld */
-        (void)va_arg(*args, int);
-        (void)va_arg(*args, int);
-        (void)va_arg(*args, long);
-        __rq = va_arg(*args, typeof(__rq));
-        prev = va_arg(*args, typeof(prev));
-        next = va_arg(*args, typeof(next));
-
-        tracing_record_cmdline(prev);
-
-        /*
-         * If tracer_switch_func only points to the local
-         * switch func, it still needs the ptr passed to it.
-         */
-        wakeup_sched_switch(probe_data, __rq, prev, next);
+        atomic_dec(&wakeup_trace->data[cpu]->disabled);
 }
 
 static void __wakeup_reset(struct trace_array *tr)
@@ -216,7 +196,7 @@ static void __wakeup_reset(struct trace_array *tr)
 
         for_each_possible_cpu(cpu) {
                 data = tr->data[cpu];
-                tracing_reset(data);
+                tracing_reset(tr, cpu);
         }
 
         wakeup_cpu = -1;
@@ -240,19 +220,26 @@ static void wakeup_reset(struct trace_array *tr)
 }
 
 static void
-wakeup_check_start(struct trace_array *tr, struct task_struct *p,
-                   struct task_struct *curr)
+probe_wakeup(struct rq *rq, struct task_struct *p)
 {
         int cpu = smp_processor_id();
         unsigned long flags;
         long disabled;
+        int pc;
+
+        if (likely(!tracer_enabled))
+                return;
+
+        tracing_record_cmdline(p);
+        tracing_record_cmdline(current);
 
         if (likely(!rt_task(p)) ||
                         p->prio >= wakeup_prio ||
-                        p->prio >= curr->prio)
+                        p->prio >= current->prio)
                 return;
 
-        disabled = atomic_inc_return(&tr->data[cpu]->disabled);
+        pc = preempt_count();
+        disabled = atomic_inc_return(&wakeup_trace->data[cpu]->disabled);
         if (unlikely(disabled != 1))
                 goto out;
 
@@ -264,7 +251,7 @@ wakeup_check_start(struct trace_array *tr, struct task_struct *p,
                 goto out_locked;
 
         /* reset the trace */
-        __wakeup_reset(tr);
+        __wakeup_reset(wakeup_trace);
 
         wakeup_cpu = task_cpu(p);
         wakeup_prio = p->prio;
@@ -274,74 +261,37 @@ wakeup_check_start(struct trace_array *tr, struct task_struct *p,
 
         local_save_flags(flags);
 
-        tr->data[wakeup_cpu]->preempt_timestamp = ftrace_now(cpu);
-        trace_function(tr, tr->data[wakeup_cpu],
-                       CALLER_ADDR1, CALLER_ADDR2, flags);
+        wakeup_trace->data[wakeup_cpu]->preempt_timestamp = ftrace_now(cpu);
+        trace_function(wakeup_trace, wakeup_trace->data[wakeup_cpu],
+                       CALLER_ADDR1, CALLER_ADDR2, flags, pc);
 
 out_locked:
         __raw_spin_unlock(&wakeup_lock);
 out:
-        atomic_dec(&tr->data[cpu]->disabled);
-}
-
-static notrace void
-wake_up_callback(void *probe_data, void *call_data,
-                 const char *format, va_list *args)
-{
-        struct trace_array **ptr = probe_data;
-        struct trace_array *tr = *ptr;
-        struct task_struct *curr;
-        struct task_struct *task;
-        struct rq *__rq;
-
-        if (likely(!tracer_enabled))
-                return;
-
-        /* Skip pid %d state %ld */
-        (void)va_arg(*args, int);
-        (void)va_arg(*args, long);
-        /* now get the meat: "rq %p task %p rq->curr %p" */
-        __rq = va_arg(*args, typeof(__rq));
-        task = va_arg(*args, typeof(task));
-        curr = va_arg(*args, typeof(curr));
-
-        tracing_record_cmdline(task);
-        tracing_record_cmdline(curr);
-
-        wakeup_check_start(tr, task, curr);
+        atomic_dec(&wakeup_trace->data[cpu]->disabled);
 }
 
 static void start_wakeup_tracer(struct trace_array *tr)
 {
         int ret;
 
-        ret = marker_probe_register("kernel_sched_wakeup",
-                        "pid %d state %ld ## rq %p task %p rq->curr %p",
-                        wake_up_callback,
-                        &wakeup_trace);
+        ret = register_trace_sched_wakeup(probe_wakeup);
         if (ret) {
-                pr_info("wakeup trace: Couldn't add marker"
+                pr_info("wakeup trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_wakeup\n");
                 return;
         }
 
-        ret = marker_probe_register("kernel_sched_wakeup_new",
-                        "pid %d state %ld ## rq %p task %p rq->curr %p",
-                        wake_up_callback,
-                        &wakeup_trace);
+        ret = register_trace_sched_wakeup_new(probe_wakeup);
         if (ret) {
-                pr_info("wakeup trace: Couldn't add marker"
+                pr_info("wakeup trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_wakeup_new\n");
                 goto fail_deprobe;
         }
 
-        ret = marker_probe_register("kernel_sched_schedule",
-                "prev_pid %d next_pid %d prev_state %ld "
-                "## rq %p prev %p next %p",
-                sched_switch_callback,
-                &wakeup_trace);
+        ret = register_trace_sched_switch(probe_wakeup_sched_switch);
         if (ret) {
-                pr_info("sched trace: Couldn't add marker"
+                pr_info("sched trace: Couldn't activate tracepoint"
                         " probe to kernel_sched_schedule\n");
                 goto fail_deprobe_wake_new;
         }
@@ -363,28 +313,18 @@ static void start_wakeup_tracer(struct trace_array *tr)
 
         return;
 fail_deprobe_wake_new:
-        marker_probe_unregister("kernel_sched_wakeup_new",
-                                wake_up_callback,
-                                &wakeup_trace);
+        unregister_trace_sched_wakeup_new(probe_wakeup);
 fail_deprobe:
-        marker_probe_unregister("kernel_sched_wakeup",
-                                wake_up_callback,
-                                &wakeup_trace);
+        unregister_trace_sched_wakeup(probe_wakeup);
 }
 
 static void stop_wakeup_tracer(struct trace_array *tr)
 {
         tracer_enabled = 0;
         unregister_ftrace_function(&trace_ops);
-        marker_probe_unregister("kernel_sched_schedule",
-                                sched_switch_callback,
-                                &wakeup_trace);
-        marker_probe_unregister("kernel_sched_wakeup_new",
-                                wake_up_callback,
-                                &wakeup_trace);
-        marker_probe_unregister("kernel_sched_wakeup",
-                                wake_up_callback,
-                                &wakeup_trace);
+        unregister_trace_sched_switch(probe_wakeup_sched_switch);
+        unregister_trace_sched_wakeup_new(probe_wakeup);
+        unregister_trace_sched_wakeup(probe_wakeup);
 }
 
 static void wakeup_tracer_init(struct trace_array *tr)
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 0911b7e073bf..90bc752a7580 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -9,65 +9,29 @@ static inline int trace_valid_entry(struct trace_entry *entry)
         case TRACE_FN:
         case TRACE_CTX:
         case TRACE_WAKE:
+        case TRACE_CONT:
         case TRACE_STACK:
+        case TRACE_PRINT:
         case TRACE_SPECIAL:
                 return 1;
         }
         return 0;
 }
 
-static int
-trace_test_buffer_cpu(struct trace_array *tr, struct trace_array_cpu *data)
+static int trace_test_buffer_cpu(struct trace_array *tr, int cpu)
 {
-        struct trace_entry *entries;
-        struct page *page;
-        int idx = 0;
-        int i;
+        struct ring_buffer_event *event;
+        struct trace_entry *entry;
 
-        BUG_ON(list_empty(&data->trace_pages));
-        page = list_entry(data->trace_pages.next, struct page, lru);
-        entries = page_address(page);
+        while ((event = ring_buffer_consume(tr->buffer, cpu, NULL))) {
+                entry = ring_buffer_event_data(event);
 
-        check_pages(data);
-        if (head_page(data) != entries)
-                goto failed;
-
-        /*
-         * The starting trace buffer always has valid elements,
-         * if any element exists.
-         */
-        entries = head_page(data);
-
-        for (i = 0; i < tr->entries; i++) {
-
-                if (i < data->trace_idx && !trace_valid_entry(&entries[idx])) {
+                if (!trace_valid_entry(entry)) {
                         printk(KERN_CONT ".. invalid entry %d ",
-                                entries[idx].type);
+                                entry->type);
                         goto failed;
                 }
-
-                idx++;
-                if (idx >= ENTRIES_PER_PAGE) {
-                        page = virt_to_page(entries);
-                        if (page->lru.next == &data->trace_pages) {
-                                if (i != tr->entries - 1) {
-                                        printk(KERN_CONT ".. entries buffer mismatch");
-                                        goto failed;
-                                }
-                        } else {
-                                page = list_entry(page->lru.next, struct page, lru);
-                                entries = page_address(page);
-                        }
-                        idx = 0;
-                }
-        }
-
-        page = virt_to_page(entries);
-        if (page->lru.next != &data->trace_pages) {
-                printk(KERN_CONT ".. too many entries");
-                goto failed;
         }
-
         return 0;
 
  failed:
@@ -89,13 +53,11 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
         /* Don't allow flipping of max traces now */
         raw_local_irq_save(flags);
         __raw_spin_lock(&ftrace_max_lock);
-        for_each_possible_cpu(cpu) {
-                if (!head_page(tr->data[cpu]))
-                        continue;
 
-                cnt += tr->data[cpu]->trace_idx;
+        cnt = ring_buffer_entries(tr->buffer);
 
-                ret = trace_test_buffer_cpu(tr, tr->data[cpu]);
+        for_each_possible_cpu(cpu) {
+                ret = trace_test_buffer_cpu(tr, cpu);
                 if (ret)
                         break;
         }
@@ -108,7 +70,7 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
         return ret;
 }
 
-#ifdef CONFIG_FTRACE
+#ifdef CONFIG_FUNCTION_TRACER
 
 #ifdef CONFIG_DYNAMIC_FTRACE
 
@@ -120,11 +82,11 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
                                            struct trace_array *tr,
                                            int (*func)(void))
 {
-        unsigned long count;
-        int ret;
         int save_ftrace_enabled = ftrace_enabled;
         int save_tracer_enabled = tracer_enabled;
+        unsigned long count;
         char *func_name;
+        int ret;
 
         /* The ftrace test PASSED */
         printk(KERN_CONT "PASSED\n");
@@ -137,13 +99,6 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
         /* passed in by parameter to fool gcc from optimizing */
         func();
 
-        /* update the records */
-        ret = ftrace_force_update();
-        if (ret) {
-                printk(KERN_CONT ".. ftraced failed .. ");
-                return ret;
-        }
-
         /*
          * Some archs *cough*PowerPC*cough* add charachters to the
          * start of the function names. We simply put a '*' to
@@ -157,6 +112,7 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
         /* enable tracing */
         tr->ctrl = 1;
         trace->init(tr);
+
         /* Sleep for a 1/10 of a second */
         msleep(100);
 
@@ -212,21 +168,14 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
 int
 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
 {
-        unsigned long count;
-        int ret;
         int save_ftrace_enabled = ftrace_enabled;
         int save_tracer_enabled = tracer_enabled;
+        unsigned long count;
+        int ret;
 
         /* make sure msleep has been recorded */
         msleep(1);
 
-        /* force the recorded functions to be traced */
-        ret = ftrace_force_update();
-        if (ret) {
-                printk(KERN_CONT ".. ftraced failed .. ");
-                return ret;
-        }
-
         /* start the tracing */
         ftrace_enabled = 1;
         tracer_enabled = 1;
@@ -263,7 +212,7 @@ trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
 
         return ret;
 }
-#endif /* CONFIG_FTRACE */
+#endif /* CONFIG_FUNCTION_TRACER */
 
 #ifdef CONFIG_IRQSOFF_TRACER
 int
@@ -415,6 +364,15 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
 }
 #endif /* CONFIG_IRQSOFF_TRACER && CONFIG_PREEMPT_TRACER */
 
+#ifdef CONFIG_NOP_TRACER
+int
+trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)
+{
+        /* What could possibly go wrong? */
+        return 0;
+}
+#endif
+
 #ifdef CONFIG_SCHED_TRACER
 static int trace_wakeup_test_thread(void *data)
 {
@@ -486,6 +444,9 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
 
         wake_up_process(p);
 
+        /* give a little time to let the thread wake up */
+        msleep(100);
+
         /* stop the tracing. */
         tr->ctrl = 0;
         trace->ctrl_update(tr);
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
new file mode 100644
index 000000000000..be682b62fe58
--- /dev/null
+++ b/kernel/trace/trace_stack.c
@@ -0,0 +1,314 @@
+/*
+ * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
+ *
+ */
+#include <linux/stacktrace.h>
+#include <linux/kallsyms.h>
+#include <linux/seq_file.h>
+#include <linux/spinlock.h>
+#include <linux/uaccess.h>
+#include <linux/debugfs.h>
+#include <linux/ftrace.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include "trace.h"
+
+#define STACK_TRACE_ENTRIES 500
+
+static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES+1] =
+         { [0 ... (STACK_TRACE_ENTRIES)] = ULONG_MAX };
+static unsigned stack_dump_index[STACK_TRACE_ENTRIES];
+
+static struct stack_trace max_stack_trace = {
+        .max_entries            = STACK_TRACE_ENTRIES,
+        .entries                = stack_dump_trace,
+};
+
+static unsigned long max_stack_size;
+static raw_spinlock_t max_stack_lock =
+        (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+
+static int stack_trace_disabled __read_mostly;
+static DEFINE_PER_CPU(int, trace_active);
+
+static inline void check_stack(void)
+{
+        unsigned long this_size, flags;
+        unsigned long *p, *top, *start;
+        int i;
+
+        this_size = ((unsigned long)&this_size) & (THREAD_SIZE-1);
+        this_size = THREAD_SIZE - this_size;
+
+        if (this_size <= max_stack_size)
+                return;
+
+        /* we do not handle interrupt stacks yet */
+        if (!object_is_on_stack(&this_size))
+                return;
+
+        raw_local_irq_save(flags);
+        __raw_spin_lock(&max_stack_lock);
+
+        /* a race could have already updated it */
+        if (this_size <= max_stack_size)
+                goto out;
+
+        max_stack_size = this_size;
+
+        max_stack_trace.nr_entries      = 0;
+        max_stack_trace.skip            = 3;
+
+        save_stack_trace(&max_stack_trace);
+
+        /*
+         * Now find where in the stack these are.
+         */
+        i = 0;
+        start = &this_size;
+        top = (unsigned long *)
+                (((unsigned long)start & ~(THREAD_SIZE-1)) + THREAD_SIZE);
+
+        /*
+         * Loop through all the entries. One of the entries may
+         * for some reason be missed on the stack, so we may
+         * have to account for them. If they are all there, this
+         * loop will only happen once. This code only takes place
+         * on a new max, so it is far from a fast path.
+         */
+        while (i < max_stack_trace.nr_entries) {
+
+                stack_dump_index[i] = this_size;
+                p = start;
+
+                for (; p < top && i < max_stack_trace.nr_entries; p++) {
+                        if (*p == stack_dump_trace[i]) {
+                                this_size = stack_dump_index[i++] =
+                                        (top - p) * sizeof(unsigned long);
+                                /* Start the search from here */
+                                start = p + 1;
+                        }
+                }
+
+                i++;
+        }
+
+ out:
+        __raw_spin_unlock(&max_stack_lock);
+        raw_local_irq_restore(flags);
+}
+
+static void
+stack_trace_call(unsigned long ip, unsigned long parent_ip)
+{
+        int cpu, resched;
+
+        if (unlikely(!ftrace_enabled || stack_trace_disabled))
+                return;
+
+        resched = need_resched();
+        preempt_disable_notrace();
+
+        cpu = raw_smp_processor_id();
+        /* no atomic needed, we only modify this variable by this cpu */
+        if (per_cpu(trace_active, cpu)++ != 0)
+                goto out;
+
+        check_stack();
+
+ out:
+        per_cpu(trace_active, cpu)--;
+        /* prevent recursion in schedule */
+        if (resched)
+                preempt_enable_no_resched_notrace();
+        else
+                preempt_enable_notrace();
+}
+
+static struct ftrace_ops trace_ops __read_mostly =
+{
+        .func = stack_trace_call,
+};
+
+static ssize_t
+stack_max_size_read(struct file *filp, char __user *ubuf,
+                    size_t count, loff_t *ppos)
+{
+        unsigned long *ptr = filp->private_data;
+        char buf[64];
+        int r;
+
+        r = snprintf(buf, sizeof(buf), "%ld\n", *ptr);
+        if (r > sizeof(buf))
+                r = sizeof(buf);
+        return simple_read_from_buffer(ubuf, count, ppos, buf, r);
+}
+
+static ssize_t
+stack_max_size_write(struct file *filp, const char __user *ubuf,
+                     size_t count, loff_t *ppos)
+{
+        long *ptr = filp->private_data;
+        unsigned long val, flags;
+        char buf[64];
+        int ret;
+
+        if (count >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, count))
+                return -EFAULT;
+
+        buf[count] = 0;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret < 0)
+                return ret;
+
+        raw_local_irq_save(flags);
+        __raw_spin_lock(&max_stack_lock);
+        *ptr = val;
+        __raw_spin_unlock(&max_stack_lock);
+        raw_local_irq_restore(flags);
+
+        return count;
+}
+
+static struct file_operations stack_max_size_fops = {
+        .open           = tracing_open_generic,
+        .read           = stack_max_size_read,
+        .write          = stack_max_size_write,
+};
+
+static void *
+t_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        long i = (long)m->private;
+
+        (*pos)++;
+
+        i++;
+
+        if (i >= max_stack_trace.nr_entries ||
+            stack_dump_trace[i] == ULONG_MAX)
+                return NULL;
+
+        m->private = (void *)i;
+
+        return &m->private;
+}
+
+static void *t_start(struct seq_file *m, loff_t *pos)
+{
+        void *t = &m->private;
+        loff_t l = 0;
+
+        local_irq_disable();
+        __raw_spin_lock(&max_stack_lock);
+
+        for (; t && l < *pos; t = t_next(m, t, &l))
+                ;
+
+        return t;
+}
+
+static void t_stop(struct seq_file *m, void *p)
+{
+        __raw_spin_unlock(&max_stack_lock);
+        local_irq_enable();
+}
+
+static int trace_lookup_stack(struct seq_file *m, long i)
+{
+        unsigned long addr = stack_dump_trace[i];
+#ifdef CONFIG_KALLSYMS
+        char str[KSYM_SYMBOL_LEN];
+
+        sprint_symbol(str, addr);
+
+        return seq_printf(m, "%s\n", str);
+#else
+        return seq_printf(m, "%p\n", (void*)addr);
+#endif
+}
+
+static int t_show(struct seq_file *m, void *v)
+{
+        long i = *(long *)v;
+        int size;
+
+        if (i < 0) {
+                seq_printf(m, "        Depth   Size      Location"
+                           "    (%d entries)\n"
+                           "        -----   ----      --------\n",
+                           max_stack_trace.nr_entries);
+                return 0;
+        }
+
+        if (i >= max_stack_trace.nr_entries ||
+            stack_dump_trace[i] == ULONG_MAX)
+                return 0;
+
+        if (i+1 == max_stack_trace.nr_entries ||
+            stack_dump_trace[i+1] == ULONG_MAX)
+                size = stack_dump_index[i];
+        else
+                size = stack_dump_index[i] - stack_dump_index[i+1];
+
+        seq_printf(m, "%3ld) %8d   %5d   ", i, stack_dump_index[i], size);
+
+        trace_lookup_stack(m, i);
+
+        return 0;
+}
+
+static struct seq_operations stack_trace_seq_ops = {
+        .start          = t_start,
+        .next           = t_next,
+        .stop           = t_stop,
+        .show           = t_show,
+};
+
+static int stack_trace_open(struct inode *inode, struct file *file)
+{
+        int ret;
+
+        ret = seq_open(file, &stack_trace_seq_ops);
+        if (!ret) {
+                struct seq_file *m = file->private_data;
+                m->private = (void *)-1;
+        }
+
+        return ret;
+}
+
+static struct file_operations stack_trace_fops = {
+        .open           = stack_trace_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+};
+
+static __init int stack_trace_init(void)
+{
+        struct dentry *d_tracer;
+        struct dentry *entry;
+
+        d_tracer = tracing_init_dentry();
+
+        entry = debugfs_create_file("stack_max_size", 0644, d_tracer,
+                                    &max_stack_size, &stack_max_size_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs 'stack_max_size' entry\n");
+
+        entry = debugfs_create_file("stack_trace", 0444, d_tracer,
+                                    NULL, &stack_trace_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs 'stack_trace' entry\n");
+
+        register_ftrace_function(&trace_ops);
+
+        return 0;
+}
+
+device_initcall(stack_trace_init);
diff --git a/kernel/trace/trace_sysprof.c b/kernel/trace/trace_sysprof.c
index db58fb66a135..9587d3bcba55 100644
--- a/kernel/trace/trace_sysprof.c
+++ b/kernel/trace/trace_sysprof.c
@@ -241,7 +241,7 @@ static void stack_reset(struct trace_array *tr)
         tr->time_start = ftrace_now(tr->cpu);
 
         for_each_online_cpu(cpu)
-                tracing_reset(tr->data[cpu]);
+                tracing_reset(tr, cpu);
 }
 
 static void start_stack_trace(struct trace_array *tr)