68 files changed, 10737 insertions, 2782 deletions

diff --git a/kernel/exit.c b/kernel/exit.c
index efd30ccf3858..167e1e3ad7c6 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -980,12 +980,9 @@ static void check_stack_usage(void)
 {
         static DEFINE_SPINLOCK(low_water_lock);
         static int lowest_to_date = THREAD_SIZE;
-        unsigned long *n = end_of_stack(current);
         unsigned long free;
 
-        while (*n == 0)
-                n++;
-        free = (unsigned long)n - (unsigned long)end_of_stack(current);
+        free = stack_not_used(current);
 
         if (free >= lowest_to_date)
                 return;
diff --git a/kernel/extable.c b/kernel/extable.c
index e136ed8d82ba..0df6253730be 100644
--- a/kernel/extable.c
+++ b/kernel/extable.c
@@ -41,7 +41,7 @@ const struct exception_table_entry *search_exception_tables(unsigned long addr)
         return e;
 }
 
-__notrace_funcgraph int core_kernel_text(unsigned long addr)
+int core_kernel_text(unsigned long addr)
 {
         if (addr >= (unsigned long)_stext &&
             addr <= (unsigned long)_etext)
@@ -54,7 +54,7 @@ __notrace_funcgraph int core_kernel_text(unsigned long addr)
         return 0;
 }
 
-__notrace_funcgraph int __kernel_text_address(unsigned long addr)
+int __kernel_text_address(unsigned long addr)
 {
         if (core_kernel_text(addr))
                 return 1;
diff --git a/kernel/fork.c b/kernel/fork.c
index 4854c2c4a82e..6715ebc3761d 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -61,6 +61,7 @@
 #include <linux/proc_fs.h>
 #include <linux/blkdev.h>
 #include <trace/sched.h>
+#include <linux/magic.h>
 
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
@@ -212,6 +213,8 @@ static struct task_struct *dup_task_struct(struct task_struct *orig)
 {
         struct task_struct *tsk;
         struct thread_info *ti;
+        unsigned long *stackend;
+
         int err;
 
         prepare_to_copy(orig);
@@ -237,6 +240,8 @@ static struct task_struct *dup_task_struct(struct task_struct *orig)
                 goto out;
 
         setup_thread_stack(tsk, orig);
+        stackend = end_of_stack(tsk);
+        *stackend = STACK_END_MAGIC;    /* for overflow detection */
 
 #ifdef CONFIG_CC_STACKPROTECTOR
         tsk->stack_canary = get_random_int();
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index 7de11bd64dfe..122fef4b0bd3 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -46,7 +46,10 @@ void dynamic_irq_init(unsigned int irq)
         desc->irq_count = 0;
         desc->irqs_unhandled = 0;
 #ifdef CONFIG_SMP
-        cpumask_setall(&desc->affinity);
+        cpumask_setall(desc->affinity);
+#ifdef CONFIG_GENERIC_PENDING_IRQ
+        cpumask_clear(desc->pending_mask);
+#endif
 #endif
         spin_unlock_irqrestore(&desc->lock, flags);
 }
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 3aba8d12f328..412370ab9a34 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -17,6 +17,8 @@
 #include <linux/kernel_stat.h>
 #include <linux/rculist.h>
 #include <linux/hash.h>
+#include <trace/irq.h>
+#include <linux/bootmem.h>
 
 #include "internals.h"
 
@@ -69,6 +71,7 @@ int nr_irqs = NR_IRQS;
 EXPORT_SYMBOL_GPL(nr_irqs);
 
 #ifdef CONFIG_SPARSE_IRQ
+
 static struct irq_desc irq_desc_init = {
         .irq        = -1,
         .status     = IRQ_DISABLED,
@@ -76,9 +79,6 @@ static struct irq_desc irq_desc_init = {
         .handle_irq = handle_bad_irq,
         .depth      = 1,
         .lock       = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
-#ifdef CONFIG_SMP
-        .affinity   = CPU_MASK_ALL
-#endif
 };
 
 void init_kstat_irqs(struct irq_desc *desc, int cpu, int nr)
@@ -113,6 +113,10 @@ static void init_one_irq_desc(int irq, struct irq_desc *desc, int cpu)
                 printk(KERN_ERR "can not alloc kstat_irqs\n");
                 BUG_ON(1);
         }
+        if (!init_alloc_desc_masks(desc, cpu, false)) {
+                printk(KERN_ERR "can not alloc irq_desc cpumasks\n");
+                BUG_ON(1);
+        }
         arch_init_chip_data(desc, cpu);
 }
 
@@ -121,7 +125,7 @@ static void init_one_irq_desc(int irq, struct irq_desc *desc, int cpu)
  */
 DEFINE_SPINLOCK(sparse_irq_lock);
 
-struct irq_desc *irq_desc_ptrs[NR_IRQS] __read_mostly;
+struct irq_desc **irq_desc_ptrs __read_mostly;
 
 static struct irq_desc irq_desc_legacy[NR_IRQS_LEGACY] __cacheline_aligned_in_smp = {
         [0 ... NR_IRQS_LEGACY-1] = {
@@ -131,14 +135,10 @@ static struct irq_desc irq_desc_legacy[NR_IRQS_LEGACY] __cacheline_aligned_in_sm
                 .handle_irq = handle_bad_irq,
                 .depth      = 1,
                 .lock       = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
-#ifdef CONFIG_SMP
-                .affinity   = CPU_MASK_ALL
-#endif
         }
 };
 
-/* FIXME: use bootmem alloc ...*/
-static unsigned int kstat_irqs_legacy[NR_IRQS_LEGACY][NR_CPUS];
+static unsigned int *kstat_irqs_legacy;
 
 int __init early_irq_init(void)
 {
@@ -148,18 +148,30 @@ int __init early_irq_init(void)
 
         init_irq_default_affinity();
 
+         /* initialize nr_irqs based on nr_cpu_ids */
+        arch_probe_nr_irqs();
+        printk(KERN_INFO "NR_IRQS:%d nr_irqs:%d\n", NR_IRQS, nr_irqs);
+
         desc = irq_desc_legacy;
         legacy_count = ARRAY_SIZE(irq_desc_legacy);
 
+        /* allocate irq_desc_ptrs array based on nr_irqs */
+        irq_desc_ptrs = alloc_bootmem(nr_irqs * sizeof(void *));
+
+        /* allocate based on nr_cpu_ids */
+        /* FIXME: invert kstat_irgs, and it'd be a per_cpu_alloc'd thing */
+        kstat_irqs_legacy = alloc_bootmem(NR_IRQS_LEGACY * nr_cpu_ids *
+                                          sizeof(int));
+
         for (i = 0; i < legacy_count; i++) {
                 desc[i].irq = i;
-                desc[i].kstat_irqs = kstat_irqs_legacy[i];
+                desc[i].kstat_irqs = kstat_irqs_legacy + i * nr_cpu_ids;
                 lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
-
+                init_alloc_desc_masks(&desc[i], 0, true);
                 irq_desc_ptrs[i] = desc + i;
         }
 
-        for (i = legacy_count; i < NR_IRQS; i++)
+        for (i = legacy_count; i < nr_irqs; i++)
                 irq_desc_ptrs[i] = NULL;
 
         return arch_early_irq_init();
@@ -167,7 +179,10 @@ int __init early_irq_init(void)
 
 struct irq_desc *irq_to_desc(unsigned int irq)
 {
-        return (irq < NR_IRQS) ? irq_desc_ptrs[irq] : NULL;
+        if (irq_desc_ptrs && irq < nr_irqs)
+                return irq_desc_ptrs[irq];
+
+        return NULL;
 }
 
 struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
@@ -176,10 +191,9 @@ struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
         unsigned long flags;
         int node;
 
-        if (irq >= NR_IRQS) {
-                printk(KERN_WARNING "irq >= NR_IRQS in irq_to_desc_alloc: %d %d\n",
-                                irq, NR_IRQS);
-                WARN_ON(1);
+        if (irq >= nr_irqs) {
+                WARN(1, "irq (%d) >= nr_irqs (%d) in irq_to_desc_alloc\n",
+                        irq, nr_irqs);
                 return NULL;
         }
 
@@ -221,9 +235,6 @@ struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
                 .handle_irq = handle_bad_irq,
                 .depth = 1,
                 .lock = __SPIN_LOCK_UNLOCKED(irq_desc->lock),
-#ifdef CONFIG_SMP
-                .affinity = CPU_MASK_ALL
-#endif
         }
 };
 
@@ -235,12 +246,15 @@ int __init early_irq_init(void)
 
         init_irq_default_affinity();
 
+        printk(KERN_INFO "NR_IRQS:%d\n", NR_IRQS);
+
         desc = irq_desc;
         count = ARRAY_SIZE(irq_desc);
 
-        for (i = 0; i < count; i++)
+        for (i = 0; i < count; i++) {
                 desc[i].irq = i;
-
+                init_alloc_desc_masks(&desc[i], 0, true);
+        }
         return arch_early_irq_init();
 }
 
@@ -316,6 +330,9 @@ irqreturn_t no_action(int cpl, void *dev_id)
         return IRQ_NONE;
 }
 
+DEFINE_TRACE(irq_handler_entry);
+DEFINE_TRACE(irq_handler_exit);
+
 /**
  * handle_IRQ_event - irq action chain handler
  * @irq:        the interrupt number
@@ -332,7 +349,9 @@ irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
                 local_irq_enable_in_hardirq();
 
         do {
+                trace_irq_handler_entry(irq, action);
                 ret = action->handler(irq, action->dev_id);
+                trace_irq_handler_exit(irq, action, ret);
                 if (ret == IRQ_HANDLED)
                         status |= action->flags;
                 retval |= ret;
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index e6d0a43cc125..40416a81a0f5 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -16,7 +16,14 @@ extern int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
 extern struct lock_class_key irq_desc_lock_class;
 extern void init_kstat_irqs(struct irq_desc *desc, int cpu, int nr);
 extern spinlock_t sparse_irq_lock;
+
+#ifdef CONFIG_SPARSE_IRQ
+/* irq_desc_ptrs allocated at boot time */
+extern struct irq_desc **irq_desc_ptrs;
+#else
+/* irq_desc_ptrs is a fixed size array */
 extern struct irq_desc *irq_desc_ptrs[NR_IRQS];
+#endif
 
 #ifdef CONFIG_PROC_FS
 extern void register_irq_proc(unsigned int irq, struct irq_desc *desc);
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 291f03664552..a3a5dc9ef346 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -90,14 +90,14 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
 
 #ifdef CONFIG_GENERIC_PENDING_IRQ
         if (desc->status & IRQ_MOVE_PCNTXT || desc->status & IRQ_DISABLED) {
-                cpumask_copy(&desc->affinity, cpumask);
+                cpumask_copy(desc->affinity, cpumask);
                 desc->chip->set_affinity(irq, cpumask);
         } else {
                 desc->status |= IRQ_MOVE_PENDING;
-                cpumask_copy(&desc->pending_mask, cpumask);
+                cpumask_copy(desc->pending_mask, cpumask);
         }
 #else
-        cpumask_copy(&desc->affinity, cpumask);
+        cpumask_copy(desc->affinity, cpumask);
         desc->chip->set_affinity(irq, cpumask);
 #endif
         desc->status |= IRQ_AFFINITY_SET;
@@ -119,16 +119,16 @@ int do_irq_select_affinity(unsigned int irq, struct irq_desc *desc)
          * one of the targets is online.
          */
         if (desc->status & (IRQ_AFFINITY_SET | IRQ_NO_BALANCING)) {
-                if (cpumask_any_and(&desc->affinity, cpu_online_mask)
+                if (cpumask_any_and(desc->affinity, cpu_online_mask)
                     < nr_cpu_ids)
                         goto set_affinity;
                 else
                         desc->status &= ~IRQ_AFFINITY_SET;
         }
 
-        cpumask_and(&desc->affinity, cpu_online_mask, irq_default_affinity);
+        cpumask_and(desc->affinity, cpu_online_mask, irq_default_affinity);
 set_affinity:
-        desc->chip->set_affinity(irq, &desc->affinity);
+        desc->chip->set_affinity(irq, desc->affinity);
 
         return 0;
 }
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
index bd72329e630c..e05ad9be43b7 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -18,7 +18,7 @@ void move_masked_irq(int irq)
 
         desc->status &= ~IRQ_MOVE_PENDING;
 
-        if (unlikely(cpumask_empty(&desc->pending_mask)))
+        if (unlikely(cpumask_empty(desc->pending_mask)))
                 return;
 
         if (!desc->chip->set_affinity)
@@ -38,13 +38,13 @@ void move_masked_irq(int irq)
          * For correct operation this depends on the caller
          * masking the irqs.
          */
-        if (likely(cpumask_any_and(&desc->pending_mask, cpu_online_mask)
+        if (likely(cpumask_any_and(desc->pending_mask, cpu_online_mask)
                    < nr_cpu_ids)) {
-                cpumask_and(&desc->affinity,
-                            &desc->pending_mask, cpu_online_mask);
-                desc->chip->set_affinity(irq, &desc->affinity);
+                cpumask_and(desc->affinity,
+                            desc->pending_mask, cpu_online_mask);
+                desc->chip->set_affinity(irq, desc->affinity);
         }
-        cpumask_clear(&desc->pending_mask);
+        cpumask_clear(desc->pending_mask);
 }
 
 void move_native_irq(int irq)
diff --git a/kernel/irq/numa_migrate.c b/kernel/irq/numa_migrate.c
index acd88356ac76..7f9b80434e32 100644
--- a/kernel/irq/numa_migrate.c
+++ b/kernel/irq/numa_migrate.c
@@ -38,15 +38,22 @@ static void free_kstat_irqs(struct irq_desc *old_desc, struct irq_desc *desc)
         old_desc->kstat_irqs = NULL;
 }
 
-static void init_copy_one_irq_desc(int irq, struct irq_desc *old_desc,
+static bool init_copy_one_irq_desc(int irq, struct irq_desc *old_desc,
                  struct irq_desc *desc, int cpu)
 {
         memcpy(desc, old_desc, sizeof(struct irq_desc));
+        if (!init_alloc_desc_masks(desc, cpu, false)) {
+                printk(KERN_ERR "irq %d: can not get new irq_desc cpumask "
+                                "for migration.\n", irq);
+                return false;
+        }
         spin_lock_init(&desc->lock);
         desc->cpu = cpu;
         lockdep_set_class(&desc->lock, &irq_desc_lock_class);
         init_copy_kstat_irqs(old_desc, desc, cpu, nr_cpu_ids);
+        init_copy_desc_masks(old_desc, desc);
         arch_init_copy_chip_data(old_desc, desc, cpu);
+        return true;
 }
 
 static void free_one_irq_desc(struct irq_desc *old_desc, struct irq_desc *desc)
@@ -76,12 +83,18 @@ static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
         node = cpu_to_node(cpu);
         desc = kzalloc_node(sizeof(*desc), GFP_ATOMIC, node);
         if (!desc) {
-                printk(KERN_ERR "irq %d: can not get new irq_desc for migration.\n", irq);
+                printk(KERN_ERR "irq %d: can not get new irq_desc "
+                                "for migration.\n", irq);
+                /* still use old one */
+                desc = old_desc;
+                goto out_unlock;
+        }
+        if (!init_copy_one_irq_desc(irq, old_desc, desc, cpu)) {
                 /* still use old one */
+                kfree(desc);
                 desc = old_desc;
                 goto out_unlock;
         }
-        init_copy_one_irq_desc(irq, old_desc, desc, cpu);
 
         irq_desc_ptrs[irq] = desc;
         spin_unlock_irqrestore(&sparse_irq_lock, flags);
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index aae3f742bcec..692363dd591f 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -20,11 +20,11 @@ static struct proc_dir_entry *root_irq_dir;
 static int irq_affinity_proc_show(struct seq_file *m, void *v)
 {
         struct irq_desc *desc = irq_to_desc((long)m->private);
-        const struct cpumask *mask = &desc->affinity;
+        const struct cpumask *mask = desc->affinity;
 
 #ifdef CONFIG_GENERIC_PENDING_IRQ
         if (desc->status & IRQ_MOVE_PENDING)
-                mask = &desc->pending_mask;
+                mask = desc->pending_mask;
 #endif
         seq_cpumask(m, mask);
         seq_putc(m, '\n');
diff --git a/kernel/kexec.c b/kernel/kexec.c
index 483899578259..c7fd6692939d 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -1130,7 +1130,7 @@ void crash_save_cpu(struct pt_regs *regs, int cpu)
                 return;
         memset(&prstatus, 0, sizeof(prstatus));
         prstatus.pr_pid = current->pid;
-        elf_core_copy_regs(&prstatus.pr_reg, regs);
+        elf_core_copy_kernel_regs(&prstatus.pr_reg, regs);
         buf = append_elf_note(buf, KEXEC_CORE_NOTE_NAME, NT_PRSTATUS,
                               &prstatus, sizeof(prstatus));
         final_note(buf);
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index 7ba8cd9845cb..479d4d5672f9 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -43,6 +43,7 @@
 #include <linux/seq_file.h>
 #include <linux/debugfs.h>
 #include <linux/kdebug.h>
+#include <linux/memory.h>
 
 #include <asm-generic/sections.h>
 #include <asm/cacheflush.h>
@@ -699,9 +700,10 @@ int __kprobes register_kprobe(struct kprobe *p)
                 goto out;
         }
 
+        mutex_lock(&text_mutex);
         ret = arch_prepare_kprobe(p);
         if (ret)
-                goto out;
+                goto out_unlock_text;
 
         INIT_HLIST_NODE(&p->hlist);
         hlist_add_head_rcu(&p->hlist,
@@ -710,6 +712,8 @@ int __kprobes register_kprobe(struct kprobe *p)
         if (kprobe_enabled)
                 arch_arm_kprobe(p);
 
+out_unlock_text:
+        mutex_unlock(&text_mutex);
 out:
         mutex_unlock(&kprobe_mutex);
 
@@ -746,8 +750,11 @@ valid_p:
                  * enabled and not gone - otherwise, the breakpoint would
                  * already have been removed. We save on flushing icache.
                  */
-                if (kprobe_enabled && !kprobe_gone(old_p))
+                if (kprobe_enabled && !kprobe_gone(old_p)) {
+                        mutex_lock(&text_mutex);
                         arch_disarm_kprobe(p);
+                        mutex_unlock(&text_mutex);
+                }
                 hlist_del_rcu(&old_p->hlist);
         } else {
                 if (p->break_handler && !kprobe_gone(p))
@@ -1280,12 +1287,14 @@ static void __kprobes enable_all_kprobes(void)
         if (kprobe_enabled)
                 goto already_enabled;
 
+        mutex_lock(&text_mutex);
         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
                 head = &kprobe_table[i];
                 hlist_for_each_entry_rcu(p, node, head, hlist)
                         if (!kprobe_gone(p))
                                 arch_arm_kprobe(p);
         }
+        mutex_unlock(&text_mutex);
 
         kprobe_enabled = true;
         printk(KERN_INFO "Kprobes globally enabled\n");
@@ -1310,6 +1319,7 @@ static void __kprobes disable_all_kprobes(void)
 
         kprobe_enabled = false;
         printk(KERN_INFO "Kprobes globally disabled\n");
+        mutex_lock(&text_mutex);
         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
                 head = &kprobe_table[i];
                 hlist_for_each_entry_rcu(p, node, head, hlist) {
@@ -1318,6 +1328,7 @@ static void __kprobes disable_all_kprobes(void)
                 }
         }
 
+        mutex_unlock(&text_mutex);
         mutex_unlock(&kprobe_mutex);
         /* Allow all currently running kprobes to complete */
         synchronize_sched();
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index 06b0c3568f0b..71b567f52813 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -41,6 +41,8 @@
 #include <linux/utsname.h>
 #include <linux/hash.h>
 #include <linux/ftrace.h>
+#include <linux/stringify.h>
+#include <trace/lockdep.h>
 
 #include <asm/sections.h>
 
@@ -310,12 +312,14 @@ EXPORT_SYMBOL(lockdep_on);
 #if VERBOSE
 # define HARDIRQ_VERBOSE        1
 # define SOFTIRQ_VERBOSE        1
+# define RECLAIM_VERBOSE        1
 #else
 # define HARDIRQ_VERBOSE        0
 # define SOFTIRQ_VERBOSE        0
+# define RECLAIM_VERBOSE        0
 #endif
 
-#if VERBOSE || HARDIRQ_VERBOSE || SOFTIRQ_VERBOSE
+#if VERBOSE || HARDIRQ_VERBOSE || SOFTIRQ_VERBOSE || RECLAIM_VERBOSE
 /*
  * Quick filtering for interesting events:
  */
@@ -430,30 +434,24 @@ atomic_t nr_find_usage_forwards_checks;
 atomic_t nr_find_usage_forwards_recursions;
 atomic_t nr_find_usage_backwards_checks;
 atomic_t nr_find_usage_backwards_recursions;
-# define debug_atomic_inc(ptr)          atomic_inc(ptr)
-# define debug_atomic_dec(ptr)          atomic_dec(ptr)
-# define debug_atomic_read(ptr)         atomic_read(ptr)
-#else
-# define debug_atomic_inc(ptr)          do { } while (0)
-# define debug_atomic_dec(ptr)          do { } while (0)
-# define debug_atomic_read(ptr)         0
 #endif
 
 /*
  * Locking printouts:
  */
 
+#define __USAGE(__STATE)                                                \
+        [LOCK_USED_IN_##__STATE] = "IN-"__stringify(__STATE)"-W",       \
+        [LOCK_ENABLED_##__STATE] = __stringify(__STATE)"-ON-W",         \
+        [LOCK_USED_IN_##__STATE##_READ] = "IN-"__stringify(__STATE)"-R",\
+        [LOCK_ENABLED_##__STATE##_READ] = __stringify(__STATE)"-ON-R",
+
 static const char *usage_str[] =
 {
-        [LOCK_USED] =                   "initial-use ",
-        [LOCK_USED_IN_HARDIRQ] =        "in-hardirq-W",
-        [LOCK_USED_IN_SOFTIRQ] =        "in-softirq-W",
-        [LOCK_ENABLED_SOFTIRQS] =       "softirq-on-W",
-        [LOCK_ENABLED_HARDIRQS] =       "hardirq-on-W",
-        [LOCK_USED_IN_HARDIRQ_READ] =   "in-hardirq-R",
-        [LOCK_USED_IN_SOFTIRQ_READ] =   "in-softirq-R",
-        [LOCK_ENABLED_SOFTIRQS_READ] =  "softirq-on-R",
-        [LOCK_ENABLED_HARDIRQS_READ] =  "hardirq-on-R",
+#define LOCKDEP_STATE(__STATE) __USAGE(__STATE)
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+        [LOCK_USED] = "INITIAL USE",
 };
 
 const char * __get_key_name(struct lockdep_subclass_key *key, char *str)
@@ -461,46 +459,45 @@ const char * __get_key_name(struct lockdep_subclass_key *key, char *str)
         return kallsyms_lookup((unsigned long)key, NULL, NULL, NULL, str);
 }
 
-void
-get_usage_chars(struct lock_class *class, char *c1, char *c2, char *c3, char *c4)
+static inline unsigned long lock_flag(enum lock_usage_bit bit)
 {
-        *c1 = '.', *c2 = '.', *c3 = '.', *c4 = '.';
-
-        if (class->usage_mask & LOCKF_USED_IN_HARDIRQ)
-                *c1 = '+';
-        else
-                if (class->usage_mask & LOCKF_ENABLED_HARDIRQS)
-                        *c1 = '-';
+        return 1UL << bit;
+}
 
-        if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ)
-                *c2 = '+';
-        else
-                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS)
-                        *c2 = '-';
+static char get_usage_char(struct lock_class *class, enum lock_usage_bit bit)
+{
+        char c = '.';
 
-        if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ)
-                *c3 = '-';
-        if (class->usage_mask & LOCKF_USED_IN_HARDIRQ_READ) {
-                *c3 = '+';
-                if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ)
-                        *c3 = '?';
+        if (class->usage_mask & lock_flag(bit + 2))
+                c = '+';
+        if (class->usage_mask & lock_flag(bit)) {
+                c = '-';
+                if (class->usage_mask & lock_flag(bit + 2))
+                        c = '?';
         }
 
-        if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ)
-                *c4 = '-';
-        if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ_READ) {
-                *c4 = '+';
-                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ)
-                        *c4 = '?';
-        }
+        return c;
+}
+
+void get_usage_chars(struct lock_class *class, char usage[LOCK_USAGE_CHARS])
+{
+        int i = 0;
+
+#define LOCKDEP_STATE(__STATE)                                          \
+        usage[i++] = get_usage_char(class, LOCK_USED_IN_##__STATE);     \
+        usage[i++] = get_usage_char(class, LOCK_USED_IN_##__STATE##_READ);
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+
+        usage[i] = '\0';
 }
 
 static void print_lock_name(struct lock_class *class)
 {
-        char str[KSYM_NAME_LEN], c1, c2, c3, c4;
+        char str[KSYM_NAME_LEN], usage[LOCK_USAGE_CHARS];
         const char *name;
 
-        get_usage_chars(class, &c1, &c2, &c3, &c4);
+        get_usage_chars(class, usage);
 
         name = class->name;
         if (!name) {
@@ -513,7 +510,7 @@ static void print_lock_name(struct lock_class *class)
                 if (class->subclass)
                         printk("/%d", class->subclass);
         }
-        printk("){%c%c%c%c}", c1, c2, c3, c4);
+        printk("){%s}", usage);
 }
 
 static void print_lockdep_cache(struct lockdep_map *lock)
@@ -1263,9 +1260,49 @@ check_usage(struct task_struct *curr, struct held_lock *prev,
                         bit_backwards, bit_forwards, irqclass);
 }
 
-static int
-check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
-                struct held_lock *next)
+static const char *state_names[] = {
+#define LOCKDEP_STATE(__STATE) \
+        __stringify(__STATE),
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+};
+
+static const char *state_rnames[] = {
+#define LOCKDEP_STATE(__STATE) \
+        __stringify(__STATE)"-READ",
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+};
+
+static inline const char *state_name(enum lock_usage_bit bit)
+{
+        return (bit & 1) ? state_rnames[bit >> 2] : state_names[bit >> 2];
+}
+
+static int exclusive_bit(int new_bit)
+{
+        /*
+         * USED_IN
+         * USED_IN_READ
+         * ENABLED
+         * ENABLED_READ
+         *
+         * bit 0 - write/read
+         * bit 1 - used_in/enabled
+         * bit 2+  state
+         */
+
+        int state = new_bit & ~3;
+        int dir = new_bit & 2;
+
+        /*
+         * keep state, bit flip the direction and strip read.
+         */
+        return state | (dir ^ 2);
+}
+
+static int check_irq_usage(struct task_struct *curr, struct held_lock *prev,
+                           struct held_lock *next, enum lock_usage_bit bit)
 {
         /*
          * Prove that the new dependency does not connect a hardirq-safe
@@ -1273,38 +1310,34 @@ check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
          * the backwards-subgraph starting at <prev>, and the
          * forwards-subgraph starting at <next>:
          */
-        if (!check_usage(curr, prev, next, LOCK_USED_IN_HARDIRQ,
-                                        LOCK_ENABLED_HARDIRQS, "hard"))
+        if (!check_usage(curr, prev, next, bit,
+                           exclusive_bit(bit), state_name(bit)))
                 return 0;
 
+        bit++; /* _READ */
+
         /*
          * Prove that the new dependency does not connect a hardirq-safe-read
          * lock with a hardirq-unsafe lock - to achieve this we search
          * the backwards-subgraph starting at <prev>, and the
          * forwards-subgraph starting at <next>:
          */
-        if (!check_usage(curr, prev, next, LOCK_USED_IN_HARDIRQ_READ,
-                                        LOCK_ENABLED_HARDIRQS, "hard-read"))
+        if (!check_usage(curr, prev, next, bit,
+                           exclusive_bit(bit), state_name(bit)))
                 return 0;
 
-        /*
-         * Prove that the new dependency does not connect a softirq-safe
-         * lock with a softirq-unsafe lock - to achieve this we search
-         * the backwards-subgraph starting at <prev>, and the
-         * forwards-subgraph starting at <next>:
-         */
-        if (!check_usage(curr, prev, next, LOCK_USED_IN_SOFTIRQ,
-                                        LOCK_ENABLED_SOFTIRQS, "soft"))
-                return 0;
-        /*
-         * Prove that the new dependency does not connect a softirq-safe-read
-         * lock with a softirq-unsafe lock - to achieve this we search
-         * the backwards-subgraph starting at <prev>, and the
-         * forwards-subgraph starting at <next>:
-         */
-        if (!check_usage(curr, prev, next, LOCK_USED_IN_SOFTIRQ_READ,
-                                        LOCK_ENABLED_SOFTIRQS, "soft"))
+        return 1;
+}
+
+static int
+check_prev_add_irq(struct task_struct *curr, struct held_lock *prev,
+                struct held_lock *next)
+{
+#define LOCKDEP_STATE(__STATE)                                          \
+        if (!check_irq_usage(curr, prev, next, LOCK_USED_IN_##__STATE)) \
                 return 0;
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
 
         return 1;
 }
@@ -1861,9 +1894,9 @@ print_irq_inversion_bug(struct task_struct *curr, struct lock_class *other,
                 curr->comm, task_pid_nr(curr));
         print_lock(this);
         if (forwards)
-                printk("but this lock took another, %s-irq-unsafe lock in the past:\n", irqclass);
+                printk("but this lock took another, %s-unsafe lock in the past:\n", irqclass);
         else
-                printk("but this lock was taken by another, %s-irq-safe lock in the past:\n", irqclass);
+                printk("but this lock was taken by another, %s-safe lock in the past:\n", irqclass);
         print_lock_name(other);
         printk("\n\nand interrupts could create inverse lock ordering between them.\n\n");
 
@@ -1933,7 +1966,7 @@ void print_irqtrace_events(struct task_struct *curr)
         print_ip_sym(curr->softirq_disable_ip);
 }
 
-static int hardirq_verbose(struct lock_class *class)
+static int HARDIRQ_verbose(struct lock_class *class)
 {
 #if HARDIRQ_VERBOSE
         return class_filter(class);
@@ -1941,7 +1974,7 @@ static int hardirq_verbose(struct lock_class *class)
         return 0;
 }
 
-static int softirq_verbose(struct lock_class *class)
+static int SOFTIRQ_verbose(struct lock_class *class)
 {
 #if SOFTIRQ_VERBOSE
         return class_filter(class);
@@ -1949,185 +1982,95 @@ static int softirq_verbose(struct lock_class *class)
         return 0;
 }
 
+static int RECLAIM_FS_verbose(struct lock_class *class)
+{
+#if RECLAIM_VERBOSE
+        return class_filter(class);
+#endif
+        return 0;
+}
+
 #define STRICT_READ_CHECKS      1
 
-static int mark_lock_irq(struct task_struct *curr, struct held_lock *this,
+static int (*state_verbose_f[])(struct lock_class *class) = {
+#define LOCKDEP_STATE(__STATE) \
+        __STATE##_verbose,
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+};
+
+static inline int state_verbose(enum lock_usage_bit bit,
+                                struct lock_class *class)
+{
+        return state_verbose_f[bit >> 2](class);
+}
+
+typedef int (*check_usage_f)(struct task_struct *, struct held_lock *,
+                             enum lock_usage_bit bit, const char *name);
+
+static int
+mark_lock_irq(struct task_struct *curr, struct held_lock *this,
                 enum lock_usage_bit new_bit)
 {
-        int ret = 1;
+        int excl_bit = exclusive_bit(new_bit);
+        int read = new_bit & 1;
+        int dir = new_bit & 2;
 
-        switch(new_bit) {
-        case LOCK_USED_IN_HARDIRQ:
-                if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQS))
-                        return 0;
-                if (!valid_state(curr, this, new_bit,
-                                 LOCK_ENABLED_HARDIRQS_READ))
-                        return 0;
-                /*
-                 * just marked it hardirq-safe, check that this lock
-                 * took no hardirq-unsafe lock in the past:
-                 */
-                if (!check_usage_forwards(curr, this,
-                                          LOCK_ENABLED_HARDIRQS, "hard"))
-                        return 0;
-#if STRICT_READ_CHECKS
-                /*
-                 * just marked it hardirq-safe, check that this lock
-                 * took no hardirq-unsafe-read lock in the past:
-                 */
-                if (!check_usage_forwards(curr, this,
-                                LOCK_ENABLED_HARDIRQS_READ, "hard-read"))
-                        return 0;
-#endif
-                if (hardirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_USED_IN_SOFTIRQ:
-                if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQS))
-                        return 0;
-                if (!valid_state(curr, this, new_bit,
-                                 LOCK_ENABLED_SOFTIRQS_READ))
-                        return 0;
-                /*
-                 * just marked it softirq-safe, check that this lock
-                 * took no softirq-unsafe lock in the past:
-                 */
-                if (!check_usage_forwards(curr, this,
-                                          LOCK_ENABLED_SOFTIRQS, "soft"))
-                        return 0;
-#if STRICT_READ_CHECKS
-                /*
-                 * just marked it softirq-safe, check that this lock
-                 * took no softirq-unsafe-read lock in the past:
-                 */
-                if (!check_usage_forwards(curr, this,
-                                LOCK_ENABLED_SOFTIRQS_READ, "soft-read"))
-                        return 0;
-#endif
-                if (softirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_USED_IN_HARDIRQ_READ:
-                if (!valid_state(curr, this, new_bit, LOCK_ENABLED_HARDIRQS))
-                        return 0;
-                /*
-                 * just marked it hardirq-read-safe, check that this lock
-                 * took no hardirq-unsafe lock in the past:
-                 */
-                if (!check_usage_forwards(curr, this,
-                                          LOCK_ENABLED_HARDIRQS, "hard"))
-                        return 0;
-                if (hardirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_USED_IN_SOFTIRQ_READ:
-                if (!valid_state(curr, this, new_bit, LOCK_ENABLED_SOFTIRQS))
-                        return 0;
-                /*
-                 * just marked it softirq-read-safe, check that this lock
-                 * took no softirq-unsafe lock in the past:
-                 */
-                if (!check_usage_forwards(curr, this,
-                                          LOCK_ENABLED_SOFTIRQS, "soft"))
-                        return 0;
-                if (softirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_ENABLED_HARDIRQS:
-                if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ))
-                        return 0;
-                if (!valid_state(curr, this, new_bit,
-                                 LOCK_USED_IN_HARDIRQ_READ))
-                        return 0;
-                /*
-                 * just marked it hardirq-unsafe, check that no hardirq-safe
-                 * lock in the system ever took it in the past:
-                 */
-                if (!check_usage_backwards(curr, this,
-                                           LOCK_USED_IN_HARDIRQ, "hard"))
-                        return 0;
-#if STRICT_READ_CHECKS
-                /*
-                 * just marked it hardirq-unsafe, check that no
-                 * hardirq-safe-read lock in the system ever took
-                 * it in the past:
-                 */
-                if (!check_usage_backwards(curr, this,
-                                   LOCK_USED_IN_HARDIRQ_READ, "hard-read"))
-                        return 0;
-#endif
-                if (hardirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_ENABLED_SOFTIRQS:
-                if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ))
-                        return 0;
-                if (!valid_state(curr, this, new_bit,
-                                 LOCK_USED_IN_SOFTIRQ_READ))
-                        return 0;
-                /*
-                 * just marked it softirq-unsafe, check that no softirq-safe
-                 * lock in the system ever took it in the past:
-                 */
-                if (!check_usage_backwards(curr, this,
-                                           LOCK_USED_IN_SOFTIRQ, "soft"))
-                        return 0;
-#if STRICT_READ_CHECKS
-                /*
-                 * just marked it softirq-unsafe, check that no
-                 * softirq-safe-read lock in the system ever took
-                 * it in the past:
-                 */
-                if (!check_usage_backwards(curr, this,
-                                   LOCK_USED_IN_SOFTIRQ_READ, "soft-read"))
-                        return 0;
-#endif
-                if (softirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_ENABLED_HARDIRQS_READ:
-                if (!valid_state(curr, this, new_bit, LOCK_USED_IN_HARDIRQ))
-                        return 0;
-#if STRICT_READ_CHECKS
-                /*
-                 * just marked it hardirq-read-unsafe, check that no
-                 * hardirq-safe lock in the system ever took it in the past:
-                 */
-                if (!check_usage_backwards(curr, this,
-                                           LOCK_USED_IN_HARDIRQ, "hard"))
-                        return 0;
-#endif
-                if (hardirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        case LOCK_ENABLED_SOFTIRQS_READ:
-                if (!valid_state(curr, this, new_bit, LOCK_USED_IN_SOFTIRQ))
+        /*
+         * mark USED_IN has to look forwards -- to ensure no dependency
+         * has ENABLED state, which would allow recursion deadlocks.
+         *
+         * mark ENABLED has to look backwards -- to ensure no dependee
+         * has USED_IN state, which, again, would allow  recursion deadlocks.
+         */
+        check_usage_f usage = dir ?
+                check_usage_backwards : check_usage_forwards;
+
+        /*
+         * Validate that this particular lock does not have conflicting
+         * usage states.
+         */
+        if (!valid_state(curr, this, new_bit, excl_bit))
+                return 0;
+
+        /*
+         * Validate that the lock dependencies don't have conflicting usage
+         * states.
+         */
+        if ((!read || !dir || STRICT_READ_CHECKS) &&
+                        !usage(curr, this, excl_bit, state_name(new_bit & ~1)))
+                return 0;
+
+        /*
+         * Check for read in write conflicts
+         */
+        if (!read) {
+                if (!valid_state(curr, this, new_bit, excl_bit + 1))
                         return 0;
-#if STRICT_READ_CHECKS
-                /*
-                 * just marked it softirq-read-unsafe, check that no
-                 * softirq-safe lock in the system ever took it in the past:
-                 */
-                if (!check_usage_backwards(curr, this,
-                                           LOCK_USED_IN_SOFTIRQ, "soft"))
+
+                if (STRICT_READ_CHECKS &&
+                        !usage(curr, this, excl_bit + 1,
+                                state_name(new_bit + 1)))
                         return 0;
-#endif
-                if (softirq_verbose(hlock_class(this)))
-                        ret = 2;
-                break;
-        default:
-                WARN_ON(1);
-                break;
         }
 
-        return ret;
+        if (state_verbose(new_bit, hlock_class(this)))
+                return 2;
+
+        return 1;
 }
 
+enum mark_type {
+#define LOCKDEP_STATE(__STATE)  __STATE,
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+};
+
 /*
  * Mark all held locks with a usage bit:
  */
 static int
-mark_held_locks(struct task_struct *curr, int hardirq)
+mark_held_locks(struct task_struct *curr, enum mark_type mark)
 {
         enum lock_usage_bit usage_bit;
         struct held_lock *hlock;
@@ -2136,17 +2079,12 @@ mark_held_locks(struct task_struct *curr, int hardirq)
         for (i = 0; i < curr->lockdep_depth; i++) {
                 hlock = curr->held_locks + i;
 
-                if (hardirq) {
-                        if (hlock->read)
-                                usage_bit = LOCK_ENABLED_HARDIRQS_READ;
-                        else
-                                usage_bit = LOCK_ENABLED_HARDIRQS;
-                } else {
-                        if (hlock->read)
-                                usage_bit = LOCK_ENABLED_SOFTIRQS_READ;
-                        else
-                                usage_bit = LOCK_ENABLED_SOFTIRQS;
-                }
+                usage_bit = 2 + (mark << 2); /* ENABLED */
+                if (hlock->read)
+                        usage_bit += 1; /* READ */
+
+                BUG_ON(usage_bit >= LOCK_USAGE_STATES);
+
                 if (!mark_lock(curr, hlock, usage_bit))
                         return 0;
         }
@@ -2200,7 +2138,7 @@ void trace_hardirqs_on_caller(unsigned long ip)
          * We are going to turn hardirqs on, so set the
          * usage bit for all held locks:
          */
-        if (!mark_held_locks(curr, 1))
+        if (!mark_held_locks(curr, HARDIRQ))
                 return;
         /*
          * If we have softirqs enabled, then set the usage
@@ -2208,7 +2146,7 @@ void trace_hardirqs_on_caller(unsigned long ip)
          * this bit from being set before)
          */
         if (curr->softirqs_enabled)
-                if (!mark_held_locks(curr, 0))
+                if (!mark_held_locks(curr, SOFTIRQ))
                         return;
 
         curr->hardirq_enable_ip = ip;
@@ -2288,7 +2226,7 @@ void trace_softirqs_on(unsigned long ip)
          * enabled too:
          */
         if (curr->hardirqs_enabled)
-                mark_held_locks(curr, 0);
+                mark_held_locks(curr, SOFTIRQ);
 }
 
 /*
@@ -2317,6 +2255,31 @@ void trace_softirqs_off(unsigned long ip)
                 debug_atomic_inc(&redundant_softirqs_off);
 }
 
+void lockdep_trace_alloc(gfp_t gfp_mask)
+{
+        struct task_struct *curr = current;
+
+        if (unlikely(!debug_locks))
+                return;
+
+        /* no reclaim without waiting on it */
+        if (!(gfp_mask & __GFP_WAIT))
+                return;
+
+        /* this guy won't enter reclaim */
+        if ((curr->flags & PF_MEMALLOC) && !(gfp_mask & __GFP_NOMEMALLOC))
+                return;
+
+        /* We're only interested __GFP_FS allocations for now */
+        if (!(gfp_mask & __GFP_FS))
+                return;
+
+        if (DEBUG_LOCKS_WARN_ON(irqs_disabled()))
+                return;
+
+        mark_held_locks(curr, RECLAIM_FS);
+}
+
 static int mark_irqflags(struct task_struct *curr, struct held_lock *hlock)
 {
         /*
@@ -2345,19 +2308,35 @@ static int mark_irqflags(struct task_struct *curr, struct held_lock *hlock)
         if (!hlock->hardirqs_off) {
                 if (hlock->read) {
                         if (!mark_lock(curr, hlock,
-                                        LOCK_ENABLED_HARDIRQS_READ))
+                                        LOCK_ENABLED_HARDIRQ_READ))
                                 return 0;
                         if (curr->softirqs_enabled)
                                 if (!mark_lock(curr, hlock,
-                                                LOCK_ENABLED_SOFTIRQS_READ))
+                                                LOCK_ENABLED_SOFTIRQ_READ))
                                         return 0;
                 } else {
                         if (!mark_lock(curr, hlock,
-                                        LOCK_ENABLED_HARDIRQS))
+                                        LOCK_ENABLED_HARDIRQ))
                                 return 0;
                         if (curr->softirqs_enabled)
                                 if (!mark_lock(curr, hlock,
-                                                LOCK_ENABLED_SOFTIRQS))
+                                                LOCK_ENABLED_SOFTIRQ))
+                                        return 0;
+                }
+        }
+
+        /*
+         * We reuse the irq context infrastructure more broadly as a general
+         * context checking code. This tests GFP_FS recursion (a lock taken
+         * during reclaim for a GFP_FS allocation is held over a GFP_FS
+         * allocation).
+         */
+        if (!hlock->trylock && (curr->lockdep_reclaim_gfp & __GFP_FS)) {
+                if (hlock->read) {
+                        if (!mark_lock(curr, hlock, LOCK_USED_IN_RECLAIM_FS_READ))
+                                        return 0;
+                } else {
+                        if (!mark_lock(curr, hlock, LOCK_USED_IN_RECLAIM_FS))
                                         return 0;
                 }
         }
@@ -2412,6 +2391,10 @@ static inline int separate_irq_context(struct task_struct *curr,
         return 0;
 }
 
+void lockdep_trace_alloc(gfp_t gfp_mask)
+{
+}
+
 #endif
 
 /*
@@ -2445,14 +2428,13 @@ static int mark_lock(struct task_struct *curr, struct held_lock *this,
                 return 0;
 
         switch (new_bit) {
-        case LOCK_USED_IN_HARDIRQ:
-        case LOCK_USED_IN_SOFTIRQ:
-        case LOCK_USED_IN_HARDIRQ_READ:
-        case LOCK_USED_IN_SOFTIRQ_READ:
-        case LOCK_ENABLED_HARDIRQS:
-        case LOCK_ENABLED_SOFTIRQS:
-        case LOCK_ENABLED_HARDIRQS_READ:
-        case LOCK_ENABLED_SOFTIRQS_READ:
+#define LOCKDEP_STATE(__STATE)                  \
+        case LOCK_USED_IN_##__STATE:            \
+        case LOCK_USED_IN_##__STATE##_READ:     \
+        case LOCK_ENABLED_##__STATE:            \
+        case LOCK_ENABLED_##__STATE##_READ:
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
                 ret = mark_lock_irq(curr, this, new_bit);
                 if (!ret)
                         return 0;
@@ -2925,6 +2907,8 @@ void lock_set_class(struct lockdep_map *lock, const char *name,
 }
 EXPORT_SYMBOL_GPL(lock_set_class);
 
+DEFINE_TRACE(lock_acquire);
+
 /*
  * We are not always called with irqs disabled - do that here,
  * and also avoid lockdep recursion:
@@ -2935,6 +2919,8 @@ void lock_acquire(struct lockdep_map *lock, unsigned int subclass,
 {
         unsigned long flags;
 
+        trace_lock_acquire(lock, subclass, trylock, read, check, nest_lock, ip);
+
         if (unlikely(current->lockdep_recursion))
                 return;
 
@@ -2949,11 +2935,15 @@ void lock_acquire(struct lockdep_map *lock, unsigned int subclass,
 }
 EXPORT_SYMBOL_GPL(lock_acquire);
 
+DEFINE_TRACE(lock_release);
+
 void lock_release(struct lockdep_map *lock, int nested,
                           unsigned long ip)
 {
         unsigned long flags;
 
+        trace_lock_release(lock, nested, ip);
+
         if (unlikely(current->lockdep_recursion))
                 return;
 
@@ -2966,6 +2956,16 @@ void lock_release(struct lockdep_map *lock, int nested,
 }
 EXPORT_SYMBOL_GPL(lock_release);
 
+void lockdep_set_current_reclaim_state(gfp_t gfp_mask)
+{
+        current->lockdep_reclaim_gfp = gfp_mask;
+}
+
+void lockdep_clear_current_reclaim_state(void)
+{
+        current->lockdep_reclaim_gfp = 0;
+}
+
 #ifdef CONFIG_LOCK_STAT
 static int
 print_lock_contention_bug(struct task_struct *curr, struct lockdep_map *lock,
@@ -3092,10 +3092,14 @@ found_it:
         lock->ip = ip;
 }
 
+DEFINE_TRACE(lock_contended);
+
 void lock_contended(struct lockdep_map *lock, unsigned long ip)
 {
         unsigned long flags;
 
+        trace_lock_contended(lock, ip);
+
         if (unlikely(!lock_stat))
                 return;
 
@@ -3111,10 +3115,14 @@ void lock_contended(struct lockdep_map *lock, unsigned long ip)
 }
 EXPORT_SYMBOL_GPL(lock_contended);
 
+DEFINE_TRACE(lock_acquired);
+
 void lock_acquired(struct lockdep_map *lock, unsigned long ip)
 {
         unsigned long flags;
 
+        trace_lock_acquired(lock, ip);
+
         if (unlikely(!lock_stat))
                 return;
 
diff --git a/kernel/lockdep_internals.h b/kernel/lockdep_internals.h
index 56b196932c08..a2cc7e9a6e84 100644
--- a/kernel/lockdep_internals.h
+++ b/kernel/lockdep_internals.h
@@ -7,6 +7,45 @@
  */
 
 /*
+ * Lock-class usage-state bits:
+ */
+enum lock_usage_bit {
+#define LOCKDEP_STATE(__STATE)          \
+        LOCK_USED_IN_##__STATE,         \
+        LOCK_USED_IN_##__STATE##_READ,  \
+        LOCK_ENABLED_##__STATE,         \
+        LOCK_ENABLED_##__STATE##_READ,
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+        LOCK_USED,
+        LOCK_USAGE_STATES
+};
+
+/*
+ * Usage-state bitmasks:
+ */
+#define __LOCKF(__STATE)        LOCKF_##__STATE = (1 << LOCK_##__STATE),
+
+enum {
+#define LOCKDEP_STATE(__STATE)                                          \
+        __LOCKF(USED_IN_##__STATE)                                      \
+        __LOCKF(USED_IN_##__STATE##_READ)                               \
+        __LOCKF(ENABLED_##__STATE)                                      \
+        __LOCKF(ENABLED_##__STATE##_READ)
+#include "lockdep_states.h"
+#undef LOCKDEP_STATE
+        __LOCKF(USED)
+};
+
+#define LOCKF_ENABLED_IRQ (LOCKF_ENABLED_HARDIRQ | LOCKF_ENABLED_SOFTIRQ)
+#define LOCKF_USED_IN_IRQ (LOCKF_USED_IN_HARDIRQ | LOCKF_USED_IN_SOFTIRQ)
+
+#define LOCKF_ENABLED_IRQ_READ \
+                (LOCKF_ENABLED_HARDIRQ_READ | LOCKF_ENABLED_SOFTIRQ_READ)
+#define LOCKF_USED_IN_IRQ_READ \
+                (LOCKF_USED_IN_HARDIRQ_READ | LOCKF_USED_IN_SOFTIRQ_READ)
+
+/*
  * MAX_LOCKDEP_ENTRIES is the maximum number of lock dependencies
  * we track.
  *
@@ -31,8 +70,10 @@
 extern struct list_head all_lock_classes;
 extern struct lock_chain lock_chains[];
 
-extern void
-get_usage_chars(struct lock_class *class, char *c1, char *c2, char *c3, char *c4);
+#define LOCK_USAGE_CHARS (1+LOCK_USAGE_STATES/2)
+
+extern void get_usage_chars(struct lock_class *class,
+                            char usage[LOCK_USAGE_CHARS]);
 
 extern const char * __get_key_name(struct lockdep_subclass_key *key, char *str);
 
diff --git a/kernel/lockdep_proc.c b/kernel/lockdep_proc.c
index 13716b813896..d7135aa2d2c4 100644
--- a/kernel/lockdep_proc.c
+++ b/kernel/lockdep_proc.c
@@ -84,7 +84,7 @@ static int l_show(struct seq_file *m, void *v)
 {
         struct lock_class *class = v;
         struct lock_list *entry;
-        char c1, c2, c3, c4;
+        char usage[LOCK_USAGE_CHARS];
 
         if (v == SEQ_START_TOKEN) {
                 seq_printf(m, "all lock classes:\n");
@@ -100,8 +100,8 @@ static int l_show(struct seq_file *m, void *v)
         seq_printf(m, " BD:%5ld", lockdep_count_backward_deps(class));
 #endif
 
-        get_usage_chars(class, &c1, &c2, &c3, &c4);
-        seq_printf(m, " %c%c%c%c", c1, c2, c3, c4);
+        get_usage_chars(class, usage);
+        seq_printf(m, " %s", usage);
 
         seq_printf(m, ": ");
         print_name(m, class);
@@ -300,27 +300,27 @@ static int lockdep_stats_show(struct seq_file *m, void *v)
                         nr_uncategorized++;
                 if (class->usage_mask & LOCKF_USED_IN_IRQ)
                         nr_irq_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_IRQS)
+                if (class->usage_mask & LOCKF_ENABLED_IRQ)
                         nr_irq_unsafe++;
                 if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ)
                         nr_softirq_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS)
+                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQ)
                         nr_softirq_unsafe++;
                 if (class->usage_mask & LOCKF_USED_IN_HARDIRQ)
                         nr_hardirq_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_HARDIRQS)
+                if (class->usage_mask & LOCKF_ENABLED_HARDIRQ)
                         nr_hardirq_unsafe++;
                 if (class->usage_mask & LOCKF_USED_IN_IRQ_READ)
                         nr_irq_read_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_IRQS_READ)
+                if (class->usage_mask & LOCKF_ENABLED_IRQ_READ)
                         nr_irq_read_unsafe++;
                 if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ_READ)
                         nr_softirq_read_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ)
+                if (class->usage_mask & LOCKF_ENABLED_SOFTIRQ_READ)
                         nr_softirq_read_unsafe++;
                 if (class->usage_mask & LOCKF_USED_IN_HARDIRQ_READ)
                         nr_hardirq_read_safe++;
-                if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ)
+                if (class->usage_mask & LOCKF_ENABLED_HARDIRQ_READ)
                         nr_hardirq_read_unsafe++;
 
 #ifdef CONFIG_PROVE_LOCKING
@@ -601,6 +601,10 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
 static void seq_header(struct seq_file *m)
 {
         seq_printf(m, "lock_stat version 0.3\n");
+
+        if (unlikely(!debug_locks))
+                seq_printf(m, "*WARNING* lock debugging disabled!! - possibly due to a lockdep warning\n");
+
         seq_line(m, '-', 0, 40 + 1 + 10 * (14 + 1));
         seq_printf(m, "%40s %14s %14s %14s %14s %14s %14s %14s %14s "
                         "%14s %14s\n",
diff --git a/kernel/lockdep_states.h b/kernel/lockdep_states.h
new file mode 100644
index 000000000000..995b0cc2b84c
--- /dev/null
+++ b/kernel/lockdep_states.h
@@ -0,0 +1,9 @@
+/*
+ * Lockdep states,
+ *
+ * please update XXX_LOCK_USAGE_STATES in include/linux/lockdep.h whenever
+ * you add one, or come up with a nice dynamic solution.
+ */
+LOCKDEP_STATE(HARDIRQ)
+LOCKDEP_STATE(SOFTIRQ)
+LOCKDEP_STATE(RECLAIM_FS)
diff --git a/kernel/module.c b/kernel/module.c
index ba22484a987e..8b742f2b3845 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -51,6 +51,7 @@
 #include <linux/tracepoint.h>
 #include <linux/ftrace.h>
 #include <linux/async.h>
+#include <linux/percpu.h>
 
 #if 0
 #define DEBUGP printk
@@ -366,6 +367,34 @@ static struct module *find_module(const char *name)
 }
 
 #ifdef CONFIG_SMP
+
+#ifdef CONFIG_HAVE_DYNAMIC_PER_CPU_AREA
+
+static void *percpu_modalloc(unsigned long size, unsigned long align,
+                             const char *name)
+{
+        void *ptr;
+
+        if (align > PAGE_SIZE) {
+                printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",
+                       name, align, PAGE_SIZE);
+                align = PAGE_SIZE;
+        }
+
+        ptr = __alloc_reserved_percpu(size, align);
+        if (!ptr)
+                printk(KERN_WARNING
+                       "Could not allocate %lu bytes percpu data\n", size);
+        return ptr;
+}
+
+static void percpu_modfree(void *freeme)
+{
+        free_percpu(freeme);
+}
+
+#else /* ... !CONFIG_HAVE_DYNAMIC_PER_CPU_AREA */
+
 /* Number of blocks used and allocated. */
 static unsigned int pcpu_num_used, pcpu_num_allocated;
 /* Size of each block.  -ve means used. */
@@ -480,21 +509,6 @@ static void percpu_modfree(void *freeme)
         }
 }
 
-static unsigned int find_pcpusec(Elf_Ehdr *hdr,
-                                 Elf_Shdr *sechdrs,
-                                 const char *secstrings)
-{
-        return find_sec(hdr, sechdrs, secstrings, ".data.percpu");
-}
-
-static void percpu_modcopy(void *pcpudest, const void *from, unsigned long size)
-{
-        int cpu;
-
-        for_each_possible_cpu(cpu)
-                memcpy(pcpudest + per_cpu_offset(cpu), from, size);
-}
-
 static int percpu_modinit(void)
 {
         pcpu_num_used = 2;
@@ -513,7 +527,26 @@ static int percpu_modinit(void)
         return 0;
 }
 __initcall(percpu_modinit);
+
+#endif /* CONFIG_HAVE_DYNAMIC_PER_CPU_AREA */
+
+static unsigned int find_pcpusec(Elf_Ehdr *hdr,
+                                 Elf_Shdr *sechdrs,
+                                 const char *secstrings)
+{
+        return find_sec(hdr, sechdrs, secstrings, ".data.percpu");
+}
+
+static void percpu_modcopy(void *pcpudest, const void *from, unsigned long size)
+{
+        int cpu;
+
+        for_each_possible_cpu(cpu)
+                memcpy(pcpudest + per_cpu_offset(cpu), from, size);
+}
+
 #else /* ... !CONFIG_SMP */
+
 static inline void *percpu_modalloc(unsigned long size, unsigned long align,
                                     const char *name)
 {
@@ -535,6 +568,7 @@ static inline void percpu_modcopy(void *pcpudst, const void *src,
         /* pcpusec should be 0, and size of that section should be 0. */
         BUG_ON(size != 0);
 }
+
 #endif /* CONFIG_SMP */
 
 #define MODINFO_ATTR(field)     \
@@ -2735,7 +2769,7 @@ int is_module_address(unsigned long addr)
 
 
 /* Is this a valid kernel address? */
-__notrace_funcgraph struct module *__module_text_address(unsigned long addr)
+struct module *__module_text_address(unsigned long addr)
 {
         struct module *mod;
 
diff --git a/kernel/mutex-debug.c b/kernel/mutex-debug.c
index 1d94160eb532..50d022e5a560 100644
--- a/kernel/mutex-debug.c
+++ b/kernel/mutex-debug.c
@@ -26,11 +26,6 @@
 /*
  * Must be called with lock->wait_lock held.
  */
-void debug_mutex_set_owner(struct mutex *lock, struct thread_info *new_owner)
-{
-        lock->owner = new_owner;
-}
-
 void debug_mutex_lock_common(struct mutex *lock, struct mutex_waiter *waiter)
 {
         memset(waiter, MUTEX_DEBUG_INIT, sizeof(*waiter));
@@ -59,7 +54,6 @@ void debug_mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter,
 
         /* Mark the current thread as blocked on the lock: */
         ti->task->blocked_on = waiter;
-        waiter->lock = lock;
 }
 
 void mutex_remove_waiter(struct mutex *lock, struct mutex_waiter *waiter,
@@ -82,7 +76,7 @@ void debug_mutex_unlock(struct mutex *lock)
         DEBUG_LOCKS_WARN_ON(lock->magic != lock);
         DEBUG_LOCKS_WARN_ON(lock->owner != current_thread_info());
         DEBUG_LOCKS_WARN_ON(!lock->wait_list.prev && !lock->wait_list.next);
-        DEBUG_LOCKS_WARN_ON(lock->owner != current_thread_info());
+        mutex_clear_owner(lock);
 }
 
 void debug_mutex_init(struct mutex *lock, const char *name,
@@ -95,7 +89,6 @@ void debug_mutex_init(struct mutex *lock, const char *name,
         debug_check_no_locks_freed((void *)lock, sizeof(*lock));
         lockdep_init_map(&lock->dep_map, name, key, 0);
 #endif
-        lock->owner = NULL;
         lock->magic = lock;
 }
 
diff --git a/kernel/mutex-debug.h b/kernel/mutex-debug.h
index babfbdfc534b..6b2d735846a5 100644
--- a/kernel/mutex-debug.h
+++ b/kernel/mutex-debug.h
@@ -13,14 +13,6 @@
 /*
  * This must be called with lock->wait_lock held.
  */
-extern void
-debug_mutex_set_owner(struct mutex *lock, struct thread_info *new_owner);
-
-static inline void debug_mutex_clear_owner(struct mutex *lock)
-{
-        lock->owner = NULL;
-}
-
 extern void debug_mutex_lock_common(struct mutex *lock,
                                     struct mutex_waiter *waiter);
 extern void debug_mutex_wake_waiter(struct mutex *lock,
@@ -35,6 +27,16 @@ extern void debug_mutex_unlock(struct mutex *lock);
 extern void debug_mutex_init(struct mutex *lock, const char *name,
                              struct lock_class_key *key);
 
+static inline void mutex_set_owner(struct mutex *lock)
+{
+        lock->owner = current_thread_info();
+}
+
+static inline void mutex_clear_owner(struct mutex *lock)
+{
+        lock->owner = NULL;
+}
+
 #define spin_lock_mutex(lock, flags)                    \
         do {                                            \
                 struct mutex *l = container_of(lock, struct mutex, wait_lock); \
diff --git a/kernel/mutex.c b/kernel/mutex.c
index 4f45d4b658ef..5d79781394a3 100644
--- a/kernel/mutex.c
+++ b/kernel/mutex.c
@@ -10,6 +10,11 @@
  * Many thanks to Arjan van de Ven, Thomas Gleixner, Steven Rostedt and
  * David Howells for suggestions and improvements.
  *
+ *  - Adaptive spinning for mutexes by Peter Zijlstra. (Ported to mainline
+ *    from the -rt tree, where it was originally implemented for rtmutexes
+ *    by Steven Rostedt, based on work by Gregory Haskins, Peter Morreale
+ *    and Sven Dietrich.
+ *
  * Also see Documentation/mutex-design.txt.
  */
 #include <linux/mutex.h>
@@ -46,6 +51,7 @@ __mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key)
         atomic_set(&lock->count, 1);
         spin_lock_init(&lock->wait_lock);
         INIT_LIST_HEAD(&lock->wait_list);
+        mutex_clear_owner(lock);
 
         debug_mutex_init(lock, name, key);
 }
@@ -91,6 +97,7 @@ void inline __sched mutex_lock(struct mutex *lock)
          * 'unlocked' into 'locked' state.
          */
         __mutex_fastpath_lock(&lock->count, __mutex_lock_slowpath);
+        mutex_set_owner(lock);
 }
 
 EXPORT_SYMBOL(mutex_lock);
@@ -115,6 +122,14 @@ void __sched mutex_unlock(struct mutex *lock)
          * The unlocking fastpath is the 0->1 transition from 'locked'
          * into 'unlocked' state:
          */
+#ifndef CONFIG_DEBUG_MUTEXES
+        /*
+         * When debugging is enabled we must not clear the owner before time,
+         * the slow path will always be taken, and that clears the owner field
+         * after verifying that it was indeed current.
+         */
+        mutex_clear_owner(lock);
+#endif
         __mutex_fastpath_unlock(&lock->count, __mutex_unlock_slowpath);
 }
 
@@ -129,21 +144,75 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
 {
         struct task_struct *task = current;
         struct mutex_waiter waiter;
-        unsigned int old_val;
         unsigned long flags;
 
+        preempt_disable();
+        mutex_acquire(&lock->dep_map, subclass, 0, ip);
+#if defined(CONFIG_SMP) && !defined(CONFIG_DEBUG_MUTEXES)
+        /*
+         * Optimistic spinning.
+         *
+         * We try to spin for acquisition when we find that there are no
+         * pending waiters and the lock owner is currently running on a
+         * (different) CPU.
+         *
+         * The rationale is that if the lock owner is running, it is likely to
+         * release the lock soon.
+         *
+         * Since this needs the lock owner, and this mutex implementation
+         * doesn't track the owner atomically in the lock field, we need to
+         * track it non-atomically.
+         *
+         * We can't do this for DEBUG_MUTEXES because that relies on wait_lock
+         * to serialize everything.
+         */
+
+        for (;;) {
+                struct thread_info *owner;
+
+                /*
+                 * If there's an owner, wait for it to either
+                 * release the lock or go to sleep.
+                 */
+                owner = ACCESS_ONCE(lock->owner);
+                if (owner && !mutex_spin_on_owner(lock, owner))
+                        break;
+
+                if (atomic_cmpxchg(&lock->count, 1, 0) == 1) {
+                        lock_acquired(&lock->dep_map, ip);
+                        mutex_set_owner(lock);
+                        preempt_enable();
+                        return 0;
+                }
+
+                /*
+                 * When there's no owner, we might have preempted between the
+                 * owner acquiring the lock and setting the owner field. If
+                 * we're an RT task that will live-lock because we won't let
+                 * the owner complete.
+                 */
+                if (!owner && (need_resched() || rt_task(task)))
+                        break;
+
+                /*
+                 * The cpu_relax() call is a compiler barrier which forces
+                 * everything in this loop to be re-loaded. We don't need
+                 * memory barriers as we'll eventually observe the right
+                 * values at the cost of a few extra spins.
+                 */
+                cpu_relax();
+        }
+#endif
         spin_lock_mutex(&lock->wait_lock, flags);
 
         debug_mutex_lock_common(lock, &waiter);
-        mutex_acquire(&lock->dep_map, subclass, 0, ip);
         debug_mutex_add_waiter(lock, &waiter, task_thread_info(task));
 
         /* add waiting tasks to the end of the waitqueue (FIFO): */
         list_add_tail(&waiter.list, &lock->wait_list);
         waiter.task = task;
 
-        old_val = atomic_xchg(&lock->count, -1);
-        if (old_val == 1)
+        if (atomic_xchg(&lock->count, -1) == 1)
                 goto done;
 
         lock_contended(&lock->dep_map, ip);
@@ -158,8 +227,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
                  * that when we release the lock, we properly wake up the
                  * other waiters:
                  */
-                old_val = atomic_xchg(&lock->count, -1);
-                if (old_val == 1)
+                if (atomic_xchg(&lock->count, -1) == 1)
                         break;
 
                 /*
@@ -173,21 +241,22 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
                         spin_unlock_mutex(&lock->wait_lock, flags);
 
                         debug_mutex_free_waiter(&waiter);
+                        preempt_enable();
                         return -EINTR;
                 }
                 __set_task_state(task, state);
 
                 /* didnt get the lock, go to sleep: */
                 spin_unlock_mutex(&lock->wait_lock, flags);
-                schedule();
+                __schedule();
                 spin_lock_mutex(&lock->wait_lock, flags);
         }
 
 done:
         lock_acquired(&lock->dep_map, ip);
         /* got the lock - rejoice! */
-        mutex_remove_waiter(lock, &waiter, task_thread_info(task));
-        debug_mutex_set_owner(lock, task_thread_info(task));
+        mutex_remove_waiter(lock, &waiter, current_thread_info());
+        mutex_set_owner(lock);
 
         /* set it to 0 if there are no waiters left: */
         if (likely(list_empty(&lock->wait_list)))
@@ -196,6 +265,7 @@ done:
         spin_unlock_mutex(&lock->wait_lock, flags);
 
         debug_mutex_free_waiter(&waiter);
+        preempt_enable();
 
         return 0;
 }
@@ -222,7 +292,8 @@ int __sched
 mutex_lock_interruptible_nested(struct mutex *lock, unsigned int subclass)
 {
         might_sleep();
-        return __mutex_lock_common(lock, TASK_INTERRUPTIBLE, subclass, _RET_IP_);
+        return __mutex_lock_common(lock, TASK_INTERRUPTIBLE,
+                                   subclass, _RET_IP_);
 }
 
 EXPORT_SYMBOL_GPL(mutex_lock_interruptible_nested);
@@ -260,8 +331,6 @@ __mutex_unlock_common_slowpath(atomic_t *lock_count, int nested)
                 wake_up_process(waiter->task);
         }
 
-        debug_mutex_clear_owner(lock);
-
         spin_unlock_mutex(&lock->wait_lock, flags);
 }
 
@@ -298,18 +367,30 @@ __mutex_lock_interruptible_slowpath(atomic_t *lock_count);
  */
 int __sched mutex_lock_interruptible(struct mutex *lock)
 {
+        int ret;
+
         might_sleep();
-        return __mutex_fastpath_lock_retval
+        ret =  __mutex_fastpath_lock_retval
                         (&lock->count, __mutex_lock_interruptible_slowpath);
+        if (!ret)
+                mutex_set_owner(lock);
+
+        return ret;
 }
 
 EXPORT_SYMBOL(mutex_lock_interruptible);
 
 int __sched mutex_lock_killable(struct mutex *lock)
 {
+        int ret;
+
         might_sleep();
-        return __mutex_fastpath_lock_retval
+        ret = __mutex_fastpath_lock_retval
                         (&lock->count, __mutex_lock_killable_slowpath);
+        if (!ret)
+                mutex_set_owner(lock);
+
+        return ret;
 }
 EXPORT_SYMBOL(mutex_lock_killable);
 
@@ -352,9 +433,10 @@ static inline int __mutex_trylock_slowpath(atomic_t *lock_count)
 
         prev = atomic_xchg(&lock->count, -1);
         if (likely(prev == 1)) {
-                debug_mutex_set_owner(lock, current_thread_info());
+                mutex_set_owner(lock);
                 mutex_acquire(&lock->dep_map, 0, 1, _RET_IP_);
         }
+
         /* Set it back to 0 if there are no waiters: */
         if (likely(list_empty(&lock->wait_list)))
                 atomic_set(&lock->count, 0);
@@ -380,8 +462,13 @@ static inline int __mutex_trylock_slowpath(atomic_t *lock_count)
  */
 int __sched mutex_trylock(struct mutex *lock)
 {
-        return __mutex_fastpath_trylock(&lock->count,
-                                        __mutex_trylock_slowpath);
+        int ret;
+
+        ret = __mutex_fastpath_trylock(&lock->count, __mutex_trylock_slowpath);
+        if (ret)
+                mutex_set_owner(lock);
+
+        return ret;
 }
 
 EXPORT_SYMBOL(mutex_trylock);
diff --git a/kernel/mutex.h b/kernel/mutex.h
index a075dafbb290..67578ca48f94 100644
--- a/kernel/mutex.h
+++ b/kernel/mutex.h
@@ -16,8 +16,26 @@
 #define mutex_remove_waiter(lock, waiter, ti) \
                 __list_del((waiter)->list.prev, (waiter)->list.next)
 
-#define debug_mutex_set_owner(lock, new_owner)          do { } while (0)
-#define debug_mutex_clear_owner(lock)                   do { } while (0)
+#ifdef CONFIG_SMP
+static inline void mutex_set_owner(struct mutex *lock)
+{
+        lock->owner = current_thread_info();
+}
+
+static inline void mutex_clear_owner(struct mutex *lock)
+{
+        lock->owner = NULL;
+}
+#else
+static inline void mutex_set_owner(struct mutex *lock)
+{
+}
+
+static inline void mutex_clear_owner(struct mutex *lock)
+{
+}
+#endif
+
 #define debug_mutex_wake_waiter(lock, waiter)           do { } while (0)
 #define debug_mutex_free_waiter(waiter)                 do { } while (0)
 #define debug_mutex_add_waiter(lock, waiter, ti)        do { } while (0)
diff --git a/kernel/panic.c b/kernel/panic.c
index 2a2ff36ff44d..32fe4eff1b89 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -74,6 +74,9 @@ NORET_TYPE void panic(const char * fmt, ...)
         vsnprintf(buf, sizeof(buf), fmt, args);
         va_end(args);
         printk(KERN_EMERG "Kernel panic - not syncing: %s\n",buf);
+#ifdef CONFIG_DEBUG_BUGVERBOSE
+        dump_stack();
+#endif
         bust_spinlocks(0);
 
         /*
@@ -355,15 +358,18 @@ EXPORT_SYMBOL(warn_slowpath);
 #endif
 
 #ifdef CONFIG_CC_STACKPROTECTOR
+
 /*
  * Called when gcc's -fstack-protector feature is used, and
  * gcc detects corruption of the on-stack canary value
  */
 void __stack_chk_fail(void)
 {
-        panic("stack-protector: Kernel stack is corrupted");
+        panic("stack-protector: Kernel stack is corrupted in: %p\n",
+                __builtin_return_address(0));
 }
 EXPORT_SYMBOL(__stack_chk_fail);
+
 #endif
 
 core_param(panic, panic_timeout, int, 0644);
diff --git a/kernel/relay.c b/kernel/relay.c
index 9d79b7854fa6..edc0ba6d8160 100644
--- a/kernel/relay.c
+++ b/kernel/relay.c
@@ -677,9 +677,7 @@ int relay_late_setup_files(struct rchan *chan,
          */
         for_each_online_cpu(i) {
                 if (unlikely(!chan->buf[i])) {
-                        printk(KERN_ERR "relay_late_setup_files: CPU %u "
-                                        "has no buffer, it must have!\n", i);
-                        BUG();
+                        WARN_ONCE(1, KERN_ERR "CPU has no buffer!\n");
                         err = -EINVAL;
                         break;
                 }
diff --git a/kernel/sched.c b/kernel/sched.c
index 8e2558c2ba67..7299083e69e7 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -4404,10 +4404,7 @@ void scheduler_tick(void)
 #endif
 }
 
-#if defined(CONFIG_PREEMPT) && (defined(CONFIG_DEBUG_PREEMPT) || \
-                                defined(CONFIG_PREEMPT_TRACER))
-
-static inline unsigned long get_parent_ip(unsigned long addr)
+unsigned long get_parent_ip(unsigned long addr)
 {
         if (in_lock_functions(addr)) {
                 addr = CALLER_ADDR2;
@@ -4417,6 +4414,9 @@ static inline unsigned long get_parent_ip(unsigned long addr)
         return addr;
 }
 
+#if defined(CONFIG_PREEMPT) && (defined(CONFIG_DEBUG_PREEMPT) || \
+                                defined(CONFIG_PREEMPT_TRACER))
+
 void __kprobes add_preempt_count(int val)
 {
 #ifdef CONFIG_DEBUG_PREEMPT
@@ -4543,15 +4543,13 @@ pick_next_task(struct rq *rq, struct task_struct *prev)
 /*
  * schedule() is the main scheduler function.
  */
-asmlinkage void __sched schedule(void)
+asmlinkage void __sched __schedule(void)
 {
         struct task_struct *prev, *next;
         unsigned long *switch_count;
         struct rq *rq;
         int cpu;
 
-need_resched:
-        preempt_disable();
         cpu = smp_processor_id();
         rq = cpu_rq(cpu);
         rcu_qsctr_inc(cpu);
@@ -4608,13 +4606,80 @@ need_resched_nonpreemptible:
 
         if (unlikely(reacquire_kernel_lock(current) < 0))
                 goto need_resched_nonpreemptible;
+}
 
+asmlinkage void __sched schedule(void)
+{
+need_resched:
+        preempt_disable();
+        __schedule();
         preempt_enable_no_resched();
         if (unlikely(test_thread_flag(TIF_NEED_RESCHED)))
                 goto need_resched;
 }
 EXPORT_SYMBOL(schedule);
 
+#ifdef CONFIG_SMP
+/*
+ * Look out! "owner" is an entirely speculative pointer
+ * access and not reliable.
+ */
+int mutex_spin_on_owner(struct mutex *lock, struct thread_info *owner)
+{
+        unsigned int cpu;
+        struct rq *rq;
+
+        if (!sched_feat(OWNER_SPIN))
+                return 0;
+
+#ifdef CONFIG_DEBUG_PAGEALLOC
+        /*
+         * Need to access the cpu field knowing that
+         * DEBUG_PAGEALLOC could have unmapped it if
+         * the mutex owner just released it and exited.
+         */
+        if (probe_kernel_address(&owner->cpu, cpu))
+                goto out;
+#else
+        cpu = owner->cpu;
+#endif
+
+        /*
+         * Even if the access succeeded (likely case),
+         * the cpu field may no longer be valid.
+         */
+        if (cpu >= nr_cpumask_bits)
+                goto out;
+
+        /*
+         * We need to validate that we can do a
+         * get_cpu() and that we have the percpu area.
+         */
+        if (!cpu_online(cpu))
+                goto out;
+
+        rq = cpu_rq(cpu);
+
+        for (;;) {
+                /*
+                 * Owner changed, break to re-assess state.
+                 */
+                if (lock->owner != owner)
+                        break;
+
+                /*
+                 * Is that owner really running on that cpu?
+                 */
+                if (task_thread_info(rq->curr) != owner || need_resched())
+                        return 0;
+
+                cpu_relax();
+        }
+out:
+        return 1;
+}
+#endif
+
 #ifdef CONFIG_PREEMPT
 /*
  * this is the entry point to schedule() from in-kernel preemption
@@ -5944,12 +6009,7 @@ void sched_show_task(struct task_struct *p)
                 printk(KERN_CONT " %016lx ", thread_saved_pc(p));
 #endif
 #ifdef CONFIG_DEBUG_STACK_USAGE
-        {
-                unsigned long *n = end_of_stack(p);
-                while (!*n)
-                        n++;
-                free = (unsigned long)n - (unsigned long)end_of_stack(p);
-        }
+        free = stack_not_used(p);
 #endif
         printk(KERN_CONT "%5lu %5d %6d\n", free,
                 task_pid_nr(p), task_pid_nr(p->real_parent));
@@ -9490,7 +9550,7 @@ cpuacct_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp)
 
 static u64 cpuacct_cpuusage_read(struct cpuacct *ca, int cpu)
 {
-        u64 *cpuusage = percpu_ptr(ca->cpuusage, cpu);
+        u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
         u64 data;
 
 #ifndef CONFIG_64BIT
@@ -9509,7 +9569,7 @@ static u64 cpuacct_cpuusage_read(struct cpuacct *ca, int cpu)
 
 static void cpuacct_cpuusage_write(struct cpuacct *ca, int cpu, u64 val)
 {
-        u64 *cpuusage = percpu_ptr(ca->cpuusage, cpu);
+        u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
 
 #ifndef CONFIG_64BIT
         /*
@@ -9605,7 +9665,7 @@ static void cpuacct_charge(struct task_struct *tsk, u64 cputime)
         ca = task_ca(tsk);
 
         for (; ca; ca = ca->parent) {
-                u64 *cpuusage = percpu_ptr(ca->cpuusage, cpu);
+                u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
                 *cpuusage += cputime;
         }
 }
diff --git a/kernel/sched_clock.c b/kernel/sched_clock.c
index a0b0852414cc..7ec82c1c61c5 100644
--- a/kernel/sched_clock.c
+++ b/kernel/sched_clock.c
@@ -24,11 +24,12 @@
  * The clock: sched_clock_cpu() is monotonic per cpu, and should be somewhat
  * consistent between cpus (never more than 2 jiffies difference).
  */
-#include <linux/sched.h>
-#include <linux/percpu.h>
 #include <linux/spinlock.h>
-#include <linux/ktime.h>
+#include <linux/hardirq.h>
 #include <linux/module.h>
+#include <linux/percpu.h>
+#include <linux/ktime.h>
+#include <linux/sched.h>
 
 /*
  * Scheduler clock - returns current time in nanosec units.
@@ -43,6 +44,10 @@ unsigned long long __attribute__((weak)) sched_clock(void)
 static __read_mostly int sched_clock_running;
 
 #ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
+__read_mostly int sched_clock_stable;
+#else
+static const int sched_clock_stable = 1;
+#endif
 
 struct sched_clock_data {
         /*
@@ -87,7 +92,7 @@ void sched_clock_init(void)
 }
 
 /*
- * min,max except they take wrapping into account
+ * min, max except they take wrapping into account
  */
 
 static inline u64 wrap_min(u64 x, u64 y)
@@ -116,10 +121,13 @@ static u64 __update_sched_clock(struct sched_clock_data *scd, u64 now)
         if (unlikely(delta < 0))
                 delta = 0;
 
+        if (unlikely(!sched_clock_running))
+                return 0ull;
+
         /*
          * scd->clock = clamp(scd->tick_gtod + delta,
-         *                    max(scd->tick_gtod, scd->clock),
-         *                    scd->tick_gtod + TICK_NSEC);
+         *                    max(scd->tick_gtod, scd->clock),
+         *                    scd->tick_gtod + TICK_NSEC);
          */
 
         clock = scd->tick_gtod + delta;
@@ -148,8 +156,20 @@ static void lock_double_clock(struct sched_clock_data *data1,
 
 u64 sched_clock_cpu(int cpu)
 {
-        struct sched_clock_data *scd = cpu_sdc(cpu);
         u64 now, clock, this_clock, remote_clock;
+        struct sched_clock_data *scd;
+
+        if (sched_clock_stable)
+                return sched_clock();
+
+        scd = cpu_sdc(cpu);
+
+        /*
+         * Normally this is not called in NMI context - but if it is,
+         * trying to do any locking here is totally lethal.
+         */
+        if (unlikely(in_nmi()))
+                return scd->clock;
 
         if (unlikely(!sched_clock_running))
                 return 0ull;
@@ -193,6 +213,8 @@ u64 sched_clock_cpu(int cpu)
         return clock;
 }
 
+#ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
+
 void sched_clock_tick(void)
 {
         struct sched_clock_data *scd = this_scd();
@@ -235,22 +257,7 @@ void sched_clock_idle_wakeup_event(u64 delta_ns)
 }
 EXPORT_SYMBOL_GPL(sched_clock_idle_wakeup_event);
 
-#else /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
-
-void sched_clock_init(void)
-{
-        sched_clock_running = 1;
-}
-
-u64 sched_clock_cpu(int cpu)
-{
-        if (unlikely(!sched_clock_running))
-                return 0;
-
-        return sched_clock();
-}
-
-#endif
+#endif /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
 
 unsigned long long cpu_clock(int cpu)
 {
diff --git a/kernel/sched_features.h b/kernel/sched_features.h
index da5d93b5d2c6..07bc02e99ab1 100644
--- a/kernel/sched_features.h
+++ b/kernel/sched_features.h
@@ -13,3 +13,4 @@ SCHED_FEAT(LB_WAKEUP_UPDATE, 1)
 SCHED_FEAT(ASYM_EFF_LOAD, 1)
 SCHED_FEAT(WAKEUP_OVERLAP, 0)
 SCHED_FEAT(LAST_BUDDY, 1)
+SCHED_FEAT(OWNER_SPIN, 1)
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index bac1061cea2f..da932f4c8524 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -960,12 +960,13 @@ static struct task_struct *pick_next_highest_task_rt(struct rq *rq, int cpu)
 
 static DEFINE_PER_CPU(cpumask_var_t, local_cpu_mask);
 
-static inline int pick_optimal_cpu(int this_cpu, cpumask_t *mask)
+static inline int pick_optimal_cpu(int this_cpu,
+                                   const struct cpumask *mask)
 {
         int first;
 
         /* "this_cpu" is cheaper to preempt than a remote processor */
-        if ((this_cpu != -1) && cpu_isset(this_cpu, *mask))
+        if ((this_cpu != -1) && cpumask_test_cpu(this_cpu, mask))
                 return this_cpu;
 
         first = cpumask_first(mask);
@@ -981,6 +982,7 @@ static int find_lowest_rq(struct task_struct *task)
         struct cpumask *lowest_mask = __get_cpu_var(local_cpu_mask);
         int this_cpu = smp_processor_id();
         int cpu      = task_cpu(task);
+        cpumask_var_t domain_mask;
 
         if (task->rt.nr_cpus_allowed == 1)
                 return -1; /* No other targets possible */
@@ -1013,19 +1015,25 @@ static int find_lowest_rq(struct task_struct *task)
         if (this_cpu == cpu)
                 this_cpu = -1; /* Skip this_cpu opt if the same */
 
-        for_each_domain(cpu, sd) {
-                if (sd->flags & SD_WAKE_AFFINE) {
-                        cpumask_t domain_mask;
-                        int       best_cpu;
+        if (alloc_cpumask_var(&domain_mask, GFP_ATOMIC)) {
+                for_each_domain(cpu, sd) {
+                        if (sd->flags & SD_WAKE_AFFINE) {
+                                int best_cpu;
 
-                        cpumask_and(&domain_mask, sched_domain_span(sd),
-                                    lowest_mask);
+                                cpumask_and(domain_mask,
+                                            sched_domain_span(sd),
+                                            lowest_mask);
 
-                        best_cpu = pick_optimal_cpu(this_cpu,
-                                                    &domain_mask);
-                        if (best_cpu != -1)
-                                return best_cpu;
+                                best_cpu = pick_optimal_cpu(this_cpu,
+                                                            domain_mask);
+
+                                if (best_cpu != -1) {
+                                        free_cpumask_var(domain_mask);
+                                        return best_cpu;
+                                }
+                        }
                 }
+                free_cpumask_var(domain_mask);
         }
 
         /*
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 9041ea7948fe..65ff3e3961b4 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -21,8 +21,10 @@
 #include <linux/freezer.h>
 #include <linux/kthread.h>
 #include <linux/rcupdate.h>
+#include <linux/ftrace.h>
 #include <linux/smp.h>
 #include <linux/tick.h>
+#include <trace/irq.h>
 
 #include <asm/irq.h>
 /*
@@ -52,6 +54,11 @@ static struct softirq_action softirq_vec[NR_SOFTIRQS] __cacheline_aligned_in_smp
 
 static DEFINE_PER_CPU(struct task_struct *, ksoftirqd);
 
+char *softirq_to_name[NR_SOFTIRQS] = {
+        "HI", "TIMER", "NET_TX", "NET_RX", "BLOCK",
+        "TASKLET", "SCHED", "HRTIMER",  "RCU"
+};
+
 /*
  * we cannot loop indefinitely here to avoid userspace starvation,
  * but we also don't want to introduce a worst case 1/HZ latency
@@ -79,13 +86,23 @@ static void __local_bh_disable(unsigned long ip)
         WARN_ON_ONCE(in_irq());
 
         raw_local_irq_save(flags);
-        add_preempt_count(SOFTIRQ_OFFSET);
+        /*
+         * The preempt tracer hooks into add_preempt_count and will break
+         * lockdep because it calls back into lockdep after SOFTIRQ_OFFSET
+         * is set and before current->softirq_enabled is cleared.
+         * We must manually increment preempt_count here and manually
+         * call the trace_preempt_off later.
+         */
+        preempt_count() += SOFTIRQ_OFFSET;
         /*
          * Were softirqs turned off above:
          */
         if (softirq_count() == SOFTIRQ_OFFSET)
                 trace_softirqs_off(ip);
         raw_local_irq_restore(flags);
+
+        if (preempt_count() == SOFTIRQ_OFFSET)
+                trace_preempt_off(CALLER_ADDR0, get_parent_ip(CALLER_ADDR1));
 }
 #else /* !CONFIG_TRACE_IRQFLAGS */
 static inline void __local_bh_disable(unsigned long ip)
@@ -169,6 +186,9 @@ EXPORT_SYMBOL(local_bh_enable_ip);
  */
 #define MAX_SOFTIRQ_RESTART 10
 
+DEFINE_TRACE(softirq_entry);
+DEFINE_TRACE(softirq_exit);
+
 asmlinkage void __do_softirq(void)
 {
         struct softirq_action *h;
@@ -180,7 +200,7 @@ asmlinkage void __do_softirq(void)
         account_system_vtime(current);
 
         __local_bh_disable((unsigned long)__builtin_return_address(0));
-        trace_softirq_enter();
+        lockdep_softirq_enter();
 
         cpu = smp_processor_id();
 restart:
@@ -195,12 +215,14 @@ restart:
                 if (pending & 1) {
                         int prev_count = preempt_count();
 
+                        trace_softirq_entry(h, softirq_vec);
                         h->action(h);
-
+                        trace_softirq_exit(h, softirq_vec);
                         if (unlikely(prev_count != preempt_count())) {
-                                printk(KERN_ERR "huh, entered softirq %td %p"
+                                printk(KERN_ERR "huh, entered softirq %td %s %p"
                                        "with preempt_count %08x,"
                                        " exited with %08x?\n", h - softirq_vec,
+                                       softirq_to_name[h - softirq_vec],
                                        h->action, prev_count, preempt_count());
                                 preempt_count() = prev_count;
                         }
@@ -220,7 +242,7 @@ restart:
         if (pending)
                 wakeup_softirqd();
 
-        trace_softirq_exit();
+        lockdep_softirq_exit();
 
         account_system_vtime(current);
         _local_bh_enable();
@@ -796,6 +818,11 @@ int __init __weak early_irq_init(void)
         return 0;
 }
 
+int __init __weak arch_probe_nr_irqs(void)
+{
+        return 0;
+}
+
 int __init __weak arch_early_irq_init(void)
 {
         return 0;
diff --git a/kernel/stop_machine.c b/kernel/stop_machine.c
index 0cd415ee62a2..74541ca49536 100644
--- a/kernel/stop_machine.c
+++ b/kernel/stop_machine.c
@@ -170,7 +170,7 @@ int __stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus)
          * doesn't hit this CPU until we're ready. */
         get_cpu();
         for_each_online_cpu(i) {
-                sm_work = percpu_ptr(stop_machine_work, i);
+                sm_work = per_cpu_ptr(stop_machine_work, i);
                 INIT_WORK(sm_work, stop_cpu);
                 queue_work_on(i, stop_machine_wq, sm_work);
         }
diff --git a/kernel/timer.c b/kernel/timer.c
index 13dd64fe143d..ef1c385bc572 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -491,14 +491,18 @@ static inline void debug_timer_free(struct timer_list *timer)
         debug_object_free(timer, &timer_debug_descr);
 }
 
-static void __init_timer(struct timer_list *timer);
+static void __init_timer(struct timer_list *timer,
+                         const char *name,
+                         struct lock_class_key *key);
 
-void init_timer_on_stack(struct timer_list *timer)
+void init_timer_on_stack_key(struct timer_list *timer,
+                             const char *name,
+                             struct lock_class_key *key)
 {
         debug_object_init_on_stack(timer, &timer_debug_descr);
-        __init_timer(timer);
+        __init_timer(timer, name, key);
 }
-EXPORT_SYMBOL_GPL(init_timer_on_stack);
+EXPORT_SYMBOL_GPL(init_timer_on_stack_key);
 
 void destroy_timer_on_stack(struct timer_list *timer)
 {
@@ -512,7 +516,9 @@ static inline void debug_timer_activate(struct timer_list *timer) { }
 static inline void debug_timer_deactivate(struct timer_list *timer) { }
 #endif
 
-static void __init_timer(struct timer_list *timer)
+static void __init_timer(struct timer_list *timer,
+                         const char *name,
+                         struct lock_class_key *key)
 {
         timer->entry.next = NULL;
         timer->base = __raw_get_cpu_var(tvec_bases);
@@ -521,6 +527,7 @@ static void __init_timer(struct timer_list *timer)
         timer->start_pid = -1;
         memset(timer->start_comm, 0, TASK_COMM_LEN);
 #endif
+        lockdep_init_map(&timer->lockdep_map, name, key, 0);
 }
 
 /**
@@ -530,19 +537,23 @@ static void __init_timer(struct timer_list *timer)
  * init_timer() must be done to a timer prior calling *any* of the
  * other timer functions.
  */
-void init_timer(struct timer_list *timer)
+void init_timer_key(struct timer_list *timer,
+                    const char *name,
+                    struct lock_class_key *key)
 {
         debug_timer_init(timer);
-        __init_timer(timer);
+        __init_timer(timer, name, key);
 }
-EXPORT_SYMBOL(init_timer);
+EXPORT_SYMBOL(init_timer_key);
 
-void init_timer_deferrable(struct timer_list *timer)
+void init_timer_deferrable_key(struct timer_list *timer,
+                               const char *name,
+                               struct lock_class_key *key)
 {
-        init_timer(timer);
+        init_timer_key(timer, name, key);
         timer_set_deferrable(timer);
 }
-EXPORT_SYMBOL(init_timer_deferrable);
+EXPORT_SYMBOL(init_timer_deferrable_key);
 
 static inline void detach_timer(struct timer_list *timer,
                                 int clear_pending)
@@ -789,6 +800,15 @@ EXPORT_SYMBOL(try_to_del_timer_sync);
  */
 int del_timer_sync(struct timer_list *timer)
 {
+#ifdef CONFIG_LOCKDEP
+        unsigned long flags;
+
+        local_irq_save(flags);
+        lock_map_acquire(&timer->lockdep_map);
+        lock_map_release(&timer->lockdep_map);
+        local_irq_restore(flags);
+#endif
+
         for (;;) {
                 int ret = try_to_del_timer_sync(timer);
                 if (ret >= 0)
@@ -861,10 +881,36 @@ static inline void __run_timers(struct tvec_base *base)
 
                         set_running_timer(base, timer);
                         detach_timer(timer, 1);
+
                         spin_unlock_irq(&base->lock);
                         {
                                 int preempt_count = preempt_count();
+
+#ifdef CONFIG_LOCKDEP
+                                /*
+                                 * It is permissible to free the timer from
+                                 * inside the function that is called from
+                                 * it, this we need to take into account for
+                                 * lockdep too. To avoid bogus "held lock
+                                 * freed" warnings as well as problems when
+                                 * looking into timer->lockdep_map, make a
+                                 * copy and use that here.
+                                 */
+                                struct lockdep_map lockdep_map =
+                                        timer->lockdep_map;
+#endif
+                                /*
+                                 * Couple the lock chain with the lock chain at
+                                 * del_timer_sync() by acquiring the lock_map
+                                 * around the fn() call here and in
+                                 * del_timer_sync().
+                                 */
+                                lock_map_acquire(&lockdep_map);
+
                                 fn(data);
+
+                                lock_map_release(&lockdep_map);
+
                                 if (preempt_count != preempt_count()) {
                                         printk(KERN_ERR "huh, entered %p "
                                                "with preempt_count %08x, exited"
diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index 34e707e5ab87..b0a46f889659 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -9,6 +9,9 @@ config USER_STACKTRACE_SUPPORT
 config NOP_TRACER
         bool
 
+config HAVE_FTRACE_NMI_ENTER
+        bool
+
 config HAVE_FUNCTION_TRACER
         bool
 
@@ -31,12 +34,20 @@ config HAVE_FTRACE_MCOUNT_RECORD
 config HAVE_HW_BRANCH_TRACER
         bool
 
+config HAVE_FTRACE_SYSCALLS
+        bool
+
 config TRACER_MAX_TRACE
         bool
 
 config RING_BUFFER
         bool
 
+config FTRACE_NMI_ENTER
+       bool
+       depends on HAVE_FTRACE_NMI_ENTER
+       default y
+
 config TRACING
         bool
         select DEBUG_FS
@@ -44,13 +55,25 @@ config TRACING
         select STACKTRACE if STACKTRACE_SUPPORT
         select TRACEPOINTS
         select NOP_TRACER
+        select BINARY_PRINTF
+
+#
+# Minimum requirements an architecture has to meet for us to
+# be able to offer generic tracing facilities:
+#
+config TRACING_SUPPORT
+        bool
+        depends on TRACE_IRQFLAGS_SUPPORT
+        depends on STACKTRACE_SUPPORT
+        default y
+
+if TRACING_SUPPORT
 
 menu "Tracers"
 
 config FUNCTION_TRACER
         bool "Kernel Function Tracer"
         depends on HAVE_FUNCTION_TRACER
-        depends on DEBUG_KERNEL
         select FRAME_POINTER
         select KALLSYMS
         select TRACING
@@ -83,7 +106,6 @@ config IRQSOFF_TRACER
         default n
         depends on TRACE_IRQFLAGS_SUPPORT
         depends on GENERIC_TIME
-        depends on DEBUG_KERNEL
         select TRACE_IRQFLAGS
         select TRACING
         select TRACER_MAX_TRACE
@@ -106,7 +128,6 @@ config PREEMPT_TRACER
         default n
         depends on GENERIC_TIME
         depends on PREEMPT
-        depends on DEBUG_KERNEL
         select TRACING
         select TRACER_MAX_TRACE
         help
@@ -127,13 +148,13 @@ config SYSPROF_TRACER
         bool "Sysprof Tracer"
         depends on X86
         select TRACING
+        select CONTEXT_SWITCH_TRACER
         help
           This tracer provides the trace needed by the 'Sysprof' userspace
           tool.
 
 config SCHED_TRACER
         bool "Scheduling Latency Tracer"
-        depends on DEBUG_KERNEL
         select TRACING
         select CONTEXT_SWITCH_TRACER
         select TRACER_MAX_TRACE
@@ -143,16 +164,30 @@ config SCHED_TRACER
 
 config CONTEXT_SWITCH_TRACER
         bool "Trace process context switches"
-        depends on DEBUG_KERNEL
         select TRACING
         select MARKERS
         help
           This tracer gets called from the context switch and records
           all switching of tasks.
 
+config EVENT_TRACER
+        bool "Trace various events in the kernel"
+        select TRACING
+        help
+          This tracer hooks to various trace points in the kernel
+          allowing the user to pick and choose which trace point they
+          want to trace.
+
+config FTRACE_SYSCALLS
+        bool "Trace syscalls"
+        depends on HAVE_FTRACE_SYSCALLS
+        select TRACING
+        select KALLSYMS
+        help
+          Basic tracer to catch the syscall entry and exit events.
+
 config BOOT_TRACER
         bool "Trace boot initcalls"
-        depends on DEBUG_KERNEL
         select TRACING
         select CONTEXT_SWITCH_TRACER
         help
@@ -165,13 +200,11 @@ config BOOT_TRACER
           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. )
+          You must pass in ftrace=initcall to the kernel command line
+          to enable this on bootup.
 
 config TRACE_BRANCH_PROFILING
         bool "Trace likely/unlikely profiler"
-        depends on DEBUG_KERNEL
         select TRACING
         help
           This tracer profiles all the the likely and unlikely macros
@@ -224,7 +257,6 @@ config BRANCH_TRACER
 
 config POWER_TRACER
         bool "Trace power consumption behavior"
-        depends on DEBUG_KERNEL
         depends on X86
         select TRACING
         help
@@ -236,7 +268,6 @@ config POWER_TRACER
 config STACK_TRACER
         bool "Trace max stack"
         depends on HAVE_FUNCTION_TRACER
-        depends on DEBUG_KERNEL
         select FUNCTION_TRACER
         select STACKTRACE
         select KALLSYMS
@@ -266,11 +297,66 @@ config HW_BRANCH_TRACER
           This tracer records all branches on the system in a circular
           buffer giving access to the last N branches for each cpu.
 
+config KMEMTRACE
+        bool "Trace SLAB allocations"
+        select TRACING
+        help
+          kmemtrace provides tracing for slab allocator functions, such as
+          kmalloc, kfree, kmem_cache_alloc, kmem_cache_free etc.. Collected
+          data is then fed to the userspace application in order to analyse
+          allocation hotspots, internal fragmentation and so on, making it
+          possible to see how well an allocator performs, as well as debug
+          and profile kernel code.
+
+          This requires an userspace application to use. See
+          Documentation/vm/kmemtrace.txt for more information.
+
+          Saying Y will make the kernel somewhat larger and slower. However,
+          if you disable kmemtrace at run-time or boot-time, the performance
+          impact is minimal (depending on the arch the kernel is built for).
+
+          If unsure, say N.
+
+config WORKQUEUE_TRACER
+        bool "Trace workqueues"
+        select TRACING
+        help
+          The workqueue tracer provides some statistical informations
+          about each cpu workqueue thread such as the number of the
+          works inserted and executed since their creation. It can help
+          to evaluate the amount of work each of them have to perform.
+          For example it can help a developer to decide whether he should
+          choose a per cpu workqueue instead of a singlethreaded one.
+
+config BLK_DEV_IO_TRACE
+        bool "Support for tracing block io actions"
+        depends on SYSFS
+        depends on BLOCK
+        select RELAY
+        select DEBUG_FS
+        select TRACEPOINTS
+        select TRACING
+        select STACKTRACE
+        help
+          Say Y here if you want to be able to trace the block layer actions
+          on a given queue. Tracing allows you to see any traffic happening
+          on a block device queue. For more information (and the userspace
+          support tools needed), fetch the blktrace tools from:
+
+          git://git.kernel.dk/blktrace.git
+
+          Tracing also is possible using the ftrace interface, e.g.:
+
+            echo 1 > /sys/block/sda/sda1/trace/enable
+            echo blk > /sys/kernel/debug/tracing/current_tracer
+            cat /sys/kernel/debug/tracing/trace_pipe
+
+          If unsure, say N.
+
 config DYNAMIC_FTRACE
         bool "enable/disable ftrace tracepoints dynamically"
         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
@@ -296,7 +382,7 @@ config FTRACE_SELFTEST
 
 config FTRACE_STARTUP_TEST
         bool "Perform a startup test on ftrace"
-        depends on TRACING && DEBUG_KERNEL && !BOOT_TRACER
+        depends on TRACING
         select FTRACE_SELFTEST
         help
           This option performs a series of startup tests on ftrace. On bootup
@@ -306,7 +392,7 @@ config FTRACE_STARTUP_TEST
 
 config MMIOTRACE
         bool "Memory mapped IO tracing"
-        depends on HAVE_MMIOTRACE_SUPPORT && DEBUG_KERNEL && PCI
+        depends on HAVE_MMIOTRACE_SUPPORT && PCI
         select TRACING
         help
           Mmiotrace traces Memory Mapped I/O access and is meant for
@@ -328,3 +414,6 @@ config MMIOTRACE_TEST
           Say N, unless you absolutely know what you are doing.
 
 endmenu
+
+endif # TRACING_SUPPORT
+
diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
index 349d5a93653f..c3feea01c3e0 100644
--- a/kernel/trace/Makefile
+++ b/kernel/trace/Makefile
@@ -19,6 +19,10 @@ obj-$(CONFIG_FUNCTION_TRACER) += libftrace.o
 obj-$(CONFIG_RING_BUFFER) += ring_buffer.o
 
 obj-$(CONFIG_TRACING) += trace.o
+obj-$(CONFIG_TRACING) += trace_clock.o
+obj-$(CONFIG_TRACING) += trace_output.o
+obj-$(CONFIG_TRACING) += trace_stat.o
+obj-$(CONFIG_TRACING) += trace_printk.o
 obj-$(CONFIG_CONTEXT_SWITCH_TRACER) += trace_sched_switch.o
 obj-$(CONFIG_SYSPROF_TRACER) += trace_sysprof.o
 obj-$(CONFIG_FUNCTION_TRACER) += trace_functions.o
@@ -33,5 +37,12 @@ obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += trace_functions_graph.o
 obj-$(CONFIG_TRACE_BRANCH_PROFILING) += trace_branch.o
 obj-$(CONFIG_HW_BRANCH_TRACER) += trace_hw_branches.o
 obj-$(CONFIG_POWER_TRACER) += trace_power.o
+obj-$(CONFIG_KMEMTRACE) += kmemtrace.o
+obj-$(CONFIG_WORKQUEUE_TRACER) += trace_workqueue.o
+obj-$(CONFIG_BLK_DEV_IO_TRACE)  += blktrace.o
+obj-$(CONFIG_EVENT_TRACER) += trace_events.o
+obj-$(CONFIG_EVENT_TRACER) += events.o
+obj-$(CONFIG_EVENT_TRACER) += trace_export.o
+obj-$(CONFIG_FTRACE_SYSCALLS) += trace_syscalls.o
 
 libftrace-y := ftrace.o
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
new file mode 100644
index 000000000000..b171778e3863
--- /dev/null
+++ b/kernel/trace/blktrace.c
@@ -0,0 +1,1550 @@
+/*
+ * Copyright (C) 2006 Jens Axboe <axboe@kernel.dk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/blkdev.h>
+#include <linux/blktrace_api.h>
+#include <linux/percpu.h>
+#include <linux/init.h>
+#include <linux/mutex.h>
+#include <linux/debugfs.h>
+#include <linux/time.h>
+#include <trace/block.h>
+#include <linux/uaccess.h>
+#include "trace_output.h"
+
+static unsigned int blktrace_seq __read_mostly = 1;
+
+static struct trace_array *blk_tr;
+static int __read_mostly  blk_tracer_enabled;
+
+/* Select an alternative, minimalistic output than the original one */
+#define TRACE_BLK_OPT_CLASSIC   0x1
+
+static struct tracer_opt blk_tracer_opts[] = {
+        /* Default disable the minimalistic output */
+        { TRACER_OPT(blk_classic, TRACE_BLK_OPT_CLASSIC) },
+        { }
+};
+
+static struct tracer_flags blk_tracer_flags = {
+        .val  = 0,
+        .opts = blk_tracer_opts,
+};
+
+/* Global reference count of probes */
+static DEFINE_MUTEX(blk_probe_mutex);
+static atomic_t blk_probes_ref = ATOMIC_INIT(0);
+
+static int blk_register_tracepoints(void);
+static void blk_unregister_tracepoints(void);
+
+/*
+ * Send out a notify message.
+ */
+static void trace_note(struct blk_trace *bt, pid_t pid, int action,
+                       const void *data, size_t len)
+{
+        struct blk_io_trace *t;
+
+        if (!bt->rchan)
+                return;
+
+        t = relay_reserve(bt->rchan, sizeof(*t) + len);
+        if (t) {
+                const int cpu = smp_processor_id();
+
+                t->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION;
+                t->time = ktime_to_ns(ktime_get());
+                t->device = bt->dev;
+                t->action = action;
+                t->pid = pid;
+                t->cpu = cpu;
+                t->pdu_len = len;
+                memcpy((void *) t + sizeof(*t), data, len);
+        }
+}
+
+/*
+ * Send out a notify for this process, if we haven't done so since a trace
+ * started
+ */
+static void trace_note_tsk(struct blk_trace *bt, struct task_struct *tsk)
+{
+        tsk->btrace_seq = blktrace_seq;
+        trace_note(bt, tsk->pid, BLK_TN_PROCESS, tsk->comm, sizeof(tsk->comm));
+}
+
+static void trace_note_time(struct blk_trace *bt)
+{
+        struct timespec now;
+        unsigned long flags;
+        u32 words[2];
+
+        getnstimeofday(&now);
+        words[0] = now.tv_sec;
+        words[1] = now.tv_nsec;
+
+        local_irq_save(flags);
+        trace_note(bt, 0, BLK_TN_TIMESTAMP, words, sizeof(words));
+        local_irq_restore(flags);
+}
+
+void __trace_note_message(struct blk_trace *bt, const char *fmt, ...)
+{
+        int n;
+        va_list args;
+        unsigned long flags;
+        char *buf;
+
+        if (blk_tr) {
+                va_start(args, fmt);
+                ftrace_vprintk(fmt, args);
+                va_end(args);
+                return;
+        }
+
+        if (!bt->msg_data)
+                return;
+
+        local_irq_save(flags);
+        buf = per_cpu_ptr(bt->msg_data, smp_processor_id());
+        va_start(args, fmt);
+        n = vscnprintf(buf, BLK_TN_MAX_MSG, fmt, args);
+        va_end(args);
+
+        trace_note(bt, 0, BLK_TN_MESSAGE, buf, n);
+        local_irq_restore(flags);
+}
+EXPORT_SYMBOL_GPL(__trace_note_message);
+
+static int act_log_check(struct blk_trace *bt, u32 what, sector_t sector,
+                         pid_t pid)
+{
+        if (((bt->act_mask << BLK_TC_SHIFT) & what) == 0)
+                return 1;
+        if (sector < bt->start_lba || sector > bt->end_lba)
+                return 1;
+        if (bt->pid && pid != bt->pid)
+                return 1;
+
+        return 0;
+}
+
+/*
+ * Data direction bit lookup
+ */
+static u32 ddir_act[2] __read_mostly = { BLK_TC_ACT(BLK_TC_READ),
+                                         BLK_TC_ACT(BLK_TC_WRITE) };
+
+/* The ilog2() calls fall out because they're constant */
+#define MASK_TC_BIT(rw, __name) ((rw & (1 << BIO_RW_ ## __name)) << \
+          (ilog2(BLK_TC_ ## __name) + BLK_TC_SHIFT - BIO_RW_ ## __name))
+
+/*
+ * The worker for the various blk_add_trace*() types. Fills out a
+ * blk_io_trace structure and places it in a per-cpu subbuffer.
+ */
+static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,
+                     int rw, u32 what, int error, int pdu_len, void *pdu_data)
+{
+        struct task_struct *tsk = current;
+        struct ring_buffer_event *event = NULL;
+        struct blk_io_trace *t;
+        unsigned long flags = 0;
+        unsigned long *sequence;
+        pid_t pid;
+        int cpu, pc = 0;
+
+        if (unlikely(bt->trace_state != Blktrace_running ||
+                     !blk_tracer_enabled))
+                return;
+
+        what |= ddir_act[rw & WRITE];
+        what |= MASK_TC_BIT(rw, BARRIER);
+        what |= MASK_TC_BIT(rw, SYNCIO);
+        what |= MASK_TC_BIT(rw, AHEAD);
+        what |= MASK_TC_BIT(rw, META);
+        what |= MASK_TC_BIT(rw, DISCARD);
+
+        pid = tsk->pid;
+        if (unlikely(act_log_check(bt, what, sector, pid)))
+                return;
+        cpu = raw_smp_processor_id();
+
+        if (blk_tr) {
+                tracing_record_cmdline(current);
+
+                pc = preempt_count();
+                event = trace_buffer_lock_reserve(blk_tr, TRACE_BLK,
+                                                  sizeof(*t) + pdu_len,
+                                                  0, pc);
+                if (!event)
+                        return;
+                t = ring_buffer_event_data(event);
+                goto record_it;
+        }
+
+        /*
+         * A word about the locking here - we disable interrupts to reserve
+         * some space in the relay per-cpu buffer, to prevent an irq
+         * from coming in and stepping on our toes.
+         */
+        local_irq_save(flags);
+
+        if (unlikely(tsk->btrace_seq != blktrace_seq))
+                trace_note_tsk(bt, tsk);
+
+        t = relay_reserve(bt->rchan, sizeof(*t) + pdu_len);
+        if (t) {
+                sequence = per_cpu_ptr(bt->sequence, cpu);
+
+                t->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION;
+                t->sequence = ++(*sequence);
+                t->time = ktime_to_ns(ktime_get());
+record_it:
+                /*
+                 * These two are not needed in ftrace as they are in the
+                 * generic trace_entry, filled by tracing_generic_entry_update,
+                 * but for the trace_event->bin() synthesizer benefit we do it
+                 * here too.
+                 */
+                t->cpu = cpu;
+                t->pid = pid;
+
+                t->sector = sector;
+                t->bytes = bytes;
+                t->action = what;
+                t->device = bt->dev;
+                t->error = error;
+                t->pdu_len = pdu_len;
+
+                if (pdu_len)
+                        memcpy((void *) t + sizeof(*t), pdu_data, pdu_len);
+
+                if (blk_tr) {
+                        trace_buffer_unlock_commit(blk_tr, event, 0, pc);
+                        return;
+                }
+        }
+
+        local_irq_restore(flags);
+}
+
+static struct dentry *blk_tree_root;
+static DEFINE_MUTEX(blk_tree_mutex);
+
+static void blk_trace_cleanup(struct blk_trace *bt)
+{
+        debugfs_remove(bt->msg_file);
+        debugfs_remove(bt->dropped_file);
+        relay_close(bt->rchan);
+        free_percpu(bt->sequence);
+        free_percpu(bt->msg_data);
+        kfree(bt);
+        mutex_lock(&blk_probe_mutex);
+        if (atomic_dec_and_test(&blk_probes_ref))
+                blk_unregister_tracepoints();
+        mutex_unlock(&blk_probe_mutex);
+}
+
+int blk_trace_remove(struct request_queue *q)
+{
+        struct blk_trace *bt;
+
+        bt = xchg(&q->blk_trace, NULL);
+        if (!bt)
+                return -EINVAL;
+
+        if (bt->trace_state == Blktrace_setup ||
+            bt->trace_state == Blktrace_stopped)
+                blk_trace_cleanup(bt);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(blk_trace_remove);
+
+static int blk_dropped_open(struct inode *inode, struct file *filp)
+{
+        filp->private_data = inode->i_private;
+
+        return 0;
+}
+
+static ssize_t blk_dropped_read(struct file *filp, char __user *buffer,
+                                size_t count, loff_t *ppos)
+{
+        struct blk_trace *bt = filp->private_data;
+        char buf[16];
+
+        snprintf(buf, sizeof(buf), "%u\n", atomic_read(&bt->dropped));
+
+        return simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
+}
+
+static const struct file_operations blk_dropped_fops = {
+        .owner =        THIS_MODULE,
+        .open =         blk_dropped_open,
+        .read =         blk_dropped_read,
+};
+
+static int blk_msg_open(struct inode *inode, struct file *filp)
+{
+        filp->private_data = inode->i_private;
+
+        return 0;
+}
+
+static ssize_t blk_msg_write(struct file *filp, const char __user *buffer,
+                                size_t count, loff_t *ppos)
+{
+        char *msg;
+        struct blk_trace *bt;
+
+        if (count > BLK_TN_MAX_MSG)
+                return -EINVAL;
+
+        msg = kmalloc(count, GFP_KERNEL);
+        if (msg == NULL)
+                return -ENOMEM;
+
+        if (copy_from_user(msg, buffer, count)) {
+                kfree(msg);
+                return -EFAULT;
+        }
+
+        bt = filp->private_data;
+        __trace_note_message(bt, "%s", msg);
+        kfree(msg);
+
+        return count;
+}
+
+static const struct file_operations blk_msg_fops = {
+        .owner =        THIS_MODULE,
+        .open =         blk_msg_open,
+        .write =        blk_msg_write,
+};
+
+/*
+ * Keep track of how many times we encountered a full subbuffer, to aid
+ * the user space app in telling how many lost events there were.
+ */
+static int blk_subbuf_start_callback(struct rchan_buf *buf, void *subbuf,
+                                     void *prev_subbuf, size_t prev_padding)
+{
+        struct blk_trace *bt;
+
+        if (!relay_buf_full(buf))
+                return 1;
+
+        bt = buf->chan->private_data;
+        atomic_inc(&bt->dropped);
+        return 0;
+}
+
+static int blk_remove_buf_file_callback(struct dentry *dentry)
+{
+        struct dentry *parent = dentry->d_parent;
+        debugfs_remove(dentry);
+
+        /*
+        * this will fail for all but the last file, but that is ok. what we
+        * care about is the top level buts->name directory going away, when
+        * the last trace file is gone. Then we don't have to rmdir() that
+        * manually on trace stop, so it nicely solves the issue with
+        * force killing of running traces.
+        */
+
+        debugfs_remove(parent);
+        return 0;
+}
+
+static struct dentry *blk_create_buf_file_callback(const char *filename,
+                                                   struct dentry *parent,
+                                                   int mode,
+                                                   struct rchan_buf *buf,
+                                                   int *is_global)
+{
+        return debugfs_create_file(filename, mode, parent, buf,
+                                        &relay_file_operations);
+}
+
+static struct rchan_callbacks blk_relay_callbacks = {
+        .subbuf_start           = blk_subbuf_start_callback,
+        .create_buf_file        = blk_create_buf_file_callback,
+        .remove_buf_file        = blk_remove_buf_file_callback,
+};
+
+/*
+ * Setup everything required to start tracing
+ */
+int do_blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
+                        struct blk_user_trace_setup *buts)
+{
+        struct blk_trace *old_bt, *bt = NULL;
+        struct dentry *dir = NULL;
+        int ret, i;
+
+        if (!buts->buf_size || !buts->buf_nr)
+                return -EINVAL;
+
+        strncpy(buts->name, name, BLKTRACE_BDEV_SIZE);
+        buts->name[BLKTRACE_BDEV_SIZE - 1] = '\0';
+
+        /*
+         * some device names have larger paths - convert the slashes
+         * to underscores for this to work as expected
+         */
+        for (i = 0; i < strlen(buts->name); i++)
+                if (buts->name[i] == '/')
+                        buts->name[i] = '_';
+
+        ret = -ENOMEM;
+        bt = kzalloc(sizeof(*bt), GFP_KERNEL);
+        if (!bt)
+                goto err;
+
+        bt->sequence = alloc_percpu(unsigned long);
+        if (!bt->sequence)
+                goto err;
+
+        bt->msg_data = __alloc_percpu(BLK_TN_MAX_MSG, __alignof__(char));
+        if (!bt->msg_data)
+                goto err;
+
+        ret = -ENOENT;
+
+        if (!blk_tree_root) {
+                blk_tree_root = debugfs_create_dir("block", NULL);
+                if (!blk_tree_root)
+                        return -ENOMEM;
+        }
+
+        dir = debugfs_create_dir(buts->name, blk_tree_root);
+
+        if (!dir)
+                goto err;
+
+        bt->dir = dir;
+        bt->dev = dev;
+        atomic_set(&bt->dropped, 0);
+
+        ret = -EIO;
+        bt->dropped_file = debugfs_create_file("dropped", 0444, dir, bt,
+                                               &blk_dropped_fops);
+        if (!bt->dropped_file)
+                goto err;
+
+        bt->msg_file = debugfs_create_file("msg", 0222, dir, bt, &blk_msg_fops);
+        if (!bt->msg_file)
+                goto err;
+
+        bt->rchan = relay_open("trace", dir, buts->buf_size,
+                                buts->buf_nr, &blk_relay_callbacks, bt);
+        if (!bt->rchan)
+                goto err;
+
+        bt->act_mask = buts->act_mask;
+        if (!bt->act_mask)
+                bt->act_mask = (u16) -1;
+
+        bt->start_lba = buts->start_lba;
+        bt->end_lba = buts->end_lba;
+        if (!bt->end_lba)
+                bt->end_lba = -1ULL;
+
+        bt->pid = buts->pid;
+        bt->trace_state = Blktrace_setup;
+
+        mutex_lock(&blk_probe_mutex);
+        if (atomic_add_return(1, &blk_probes_ref) == 1) {
+                ret = blk_register_tracepoints();
+                if (ret)
+                        goto probe_err;
+        }
+        mutex_unlock(&blk_probe_mutex);
+
+        ret = -EBUSY;
+        old_bt = xchg(&q->blk_trace, bt);
+        if (old_bt) {
+                (void) xchg(&q->blk_trace, old_bt);
+                goto err;
+        }
+
+        return 0;
+probe_err:
+        atomic_dec(&blk_probes_ref);
+        mutex_unlock(&blk_probe_mutex);
+err:
+        if (bt) {
+                if (bt->msg_file)
+                        debugfs_remove(bt->msg_file);
+                if (bt->dropped_file)
+                        debugfs_remove(bt->dropped_file);
+                free_percpu(bt->sequence);
+                free_percpu(bt->msg_data);
+                if (bt->rchan)
+                        relay_close(bt->rchan);
+                kfree(bt);
+        }
+        return ret;
+}
+
+int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
+                    char __user *arg)
+{
+        struct blk_user_trace_setup buts;
+        int ret;
+
+        ret = copy_from_user(&buts, arg, sizeof(buts));
+        if (ret)
+                return -EFAULT;
+
+        ret = do_blk_trace_setup(q, name, dev, &buts);
+        if (ret)
+                return ret;
+
+        if (copy_to_user(arg, &buts, sizeof(buts)))
+                return -EFAULT;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(blk_trace_setup);
+
+int blk_trace_startstop(struct request_queue *q, int start)
+{
+        int ret;
+        struct blk_trace *bt = q->blk_trace;
+
+        if (bt == NULL)
+                return -EINVAL;
+
+        /*
+         * For starting a trace, we can transition from a setup or stopped
+         * trace. For stopping a trace, the state must be running
+         */
+        ret = -EINVAL;
+        if (start) {
+                if (bt->trace_state == Blktrace_setup ||
+                    bt->trace_state == Blktrace_stopped) {
+                        blktrace_seq++;
+                        smp_mb();
+                        bt->trace_state = Blktrace_running;
+
+                        trace_note_time(bt);
+                        ret = 0;
+                }
+        } else {
+                if (bt->trace_state == Blktrace_running) {
+                        bt->trace_state = Blktrace_stopped;
+                        relay_flush(bt->rchan);
+                        ret = 0;
+                }
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(blk_trace_startstop);
+
+/**
+ * blk_trace_ioctl: - handle the ioctls associated with tracing
+ * @bdev:       the block device
+ * @cmd:        the ioctl cmd
+ * @arg:        the argument data, if any
+ *
+ **/
+int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg)
+{
+        struct request_queue *q;
+        int ret, start = 0;
+        char b[BDEVNAME_SIZE];
+
+        q = bdev_get_queue(bdev);
+        if (!q)
+                return -ENXIO;
+
+        mutex_lock(&bdev->bd_mutex);
+
+        switch (cmd) {
+        case BLKTRACESETUP:
+                bdevname(bdev, b);
+                ret = blk_trace_setup(q, b, bdev->bd_dev, arg);
+                break;
+        case BLKTRACESTART:
+                start = 1;
+        case BLKTRACESTOP:
+                ret = blk_trace_startstop(q, start);
+                break;
+        case BLKTRACETEARDOWN:
+                ret = blk_trace_remove(q);
+                break;
+        default:
+                ret = -ENOTTY;
+                break;
+        }
+
+        mutex_unlock(&bdev->bd_mutex);
+        return ret;
+}
+
+/**
+ * blk_trace_shutdown: - stop and cleanup trace structures
+ * @q:    the request queue associated with the device
+ *
+ **/
+void blk_trace_shutdown(struct request_queue *q)
+{
+        if (q->blk_trace) {
+                blk_trace_startstop(q, 0);
+                blk_trace_remove(q);
+        }
+}
+
+/*
+ * blktrace probes
+ */
+
+/**
+ * blk_add_trace_rq - Add a trace for a request oriented action
+ * @q:          queue the io is for
+ * @rq:         the source request
+ * @what:       the action
+ *
+ * Description:
+ *     Records an action against a request. Will log the bio offset + size.
+ *
+ **/
+static void blk_add_trace_rq(struct request_queue *q, struct request *rq,
+                                    u32 what)
+{
+        struct blk_trace *bt = q->blk_trace;
+        int rw = rq->cmd_flags & 0x03;
+
+        if (likely(!bt))
+                return;
+
+        if (blk_discard_rq(rq))
+                rw |= (1 << BIO_RW_DISCARD);
+
+        if (blk_pc_request(rq)) {
+                what |= BLK_TC_ACT(BLK_TC_PC);
+                __blk_add_trace(bt, 0, rq->data_len, rw, what, rq->errors,
+                                sizeof(rq->cmd), rq->cmd);
+        } else  {
+                what |= BLK_TC_ACT(BLK_TC_FS);
+                __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9,
+                                rw, what, rq->errors, 0, NULL);
+        }
+}
+
+static void blk_add_trace_rq_abort(struct request_queue *q, struct request *rq)
+{
+        blk_add_trace_rq(q, rq, BLK_TA_ABORT);
+}
+
+static void blk_add_trace_rq_insert(struct request_queue *q, struct request *rq)
+{
+        blk_add_trace_rq(q, rq, BLK_TA_INSERT);
+}
+
+static void blk_add_trace_rq_issue(struct request_queue *q, struct request *rq)
+{
+        blk_add_trace_rq(q, rq, BLK_TA_ISSUE);
+}
+
+static void blk_add_trace_rq_requeue(struct request_queue *q,
+                                     struct request *rq)
+{
+        blk_add_trace_rq(q, rq, BLK_TA_REQUEUE);
+}
+
+static void blk_add_trace_rq_complete(struct request_queue *q,
+                                      struct request *rq)
+{
+        blk_add_trace_rq(q, rq, BLK_TA_COMPLETE);
+}
+
+/**
+ * blk_add_trace_bio - Add a trace for a bio oriented action
+ * @q:          queue the io is for
+ * @bio:        the source bio
+ * @what:       the action
+ *
+ * Description:
+ *     Records an action against a bio. Will log the bio offset + size.
+ *
+ **/
+static void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
+                                     u32 what)
+{
+        struct blk_trace *bt = q->blk_trace;
+
+        if (likely(!bt))
+                return;
+
+        __blk_add_trace(bt, bio->bi_sector, bio->bi_size, bio->bi_rw, what,
+                        !bio_flagged(bio, BIO_UPTODATE), 0, NULL);
+}
+
+static void blk_add_trace_bio_bounce(struct request_queue *q, struct bio *bio)
+{
+        blk_add_trace_bio(q, bio, BLK_TA_BOUNCE);
+}
+
+static void blk_add_trace_bio_complete(struct request_queue *q, struct bio *bio)
+{
+        blk_add_trace_bio(q, bio, BLK_TA_COMPLETE);
+}
+
+static void blk_add_trace_bio_backmerge(struct request_queue *q,
+                                        struct bio *bio)
+{
+        blk_add_trace_bio(q, bio, BLK_TA_BACKMERGE);
+}
+
+static void blk_add_trace_bio_frontmerge(struct request_queue *q,
+                                         struct bio *bio)
+{
+        blk_add_trace_bio(q, bio, BLK_TA_FRONTMERGE);
+}
+
+static void blk_add_trace_bio_queue(struct request_queue *q, struct bio *bio)
+{
+        blk_add_trace_bio(q, bio, BLK_TA_QUEUE);
+}
+
+static void blk_add_trace_getrq(struct request_queue *q,
+                                struct bio *bio, int rw)
+{
+        if (bio)
+                blk_add_trace_bio(q, bio, BLK_TA_GETRQ);
+        else {
+                struct blk_trace *bt = q->blk_trace;
+
+                if (bt)
+                        __blk_add_trace(bt, 0, 0, rw, BLK_TA_GETRQ, 0, 0, NULL);
+        }
+}
+
+
+static void blk_add_trace_sleeprq(struct request_queue *q,
+                                  struct bio *bio, int rw)
+{
+        if (bio)
+                blk_add_trace_bio(q, bio, BLK_TA_SLEEPRQ);
+        else {
+                struct blk_trace *bt = q->blk_trace;
+
+                if (bt)
+                        __blk_add_trace(bt, 0, 0, rw, BLK_TA_SLEEPRQ,
+                                        0, 0, NULL);
+        }
+}
+
+static void blk_add_trace_plug(struct request_queue *q)
+{
+        struct blk_trace *bt = q->blk_trace;
+
+        if (bt)
+                __blk_add_trace(bt, 0, 0, 0, BLK_TA_PLUG, 0, 0, NULL);
+}
+
+static void blk_add_trace_unplug_io(struct request_queue *q)
+{
+        struct blk_trace *bt = q->blk_trace;
+
+        if (bt) {
+                unsigned int pdu = q->rq.count[READ] + q->rq.count[WRITE];
+                __be64 rpdu = cpu_to_be64(pdu);
+
+                __blk_add_trace(bt, 0, 0, 0, BLK_TA_UNPLUG_IO, 0,
+                                sizeof(rpdu), &rpdu);
+        }
+}
+
+static void blk_add_trace_unplug_timer(struct request_queue *q)
+{
+        struct blk_trace *bt = q->blk_trace;
+
+        if (bt) {
+                unsigned int pdu = q->rq.count[READ] + q->rq.count[WRITE];
+                __be64 rpdu = cpu_to_be64(pdu);
+
+                __blk_add_trace(bt, 0, 0, 0, BLK_TA_UNPLUG_TIMER, 0,
+                                sizeof(rpdu), &rpdu);
+        }
+}
+
+static void blk_add_trace_split(struct request_queue *q, struct bio *bio,
+                                unsigned int pdu)
+{
+        struct blk_trace *bt = q->blk_trace;
+
+        if (bt) {
+                __be64 rpdu = cpu_to_be64(pdu);
+
+                __blk_add_trace(bt, bio->bi_sector, bio->bi_size, bio->bi_rw,
+                                BLK_TA_SPLIT, !bio_flagged(bio, BIO_UPTODATE),
+                                sizeof(rpdu), &rpdu);
+        }
+}
+
+/**
+ * blk_add_trace_remap - Add a trace for a remap operation
+ * @q:          queue the io is for
+ * @bio:        the source bio
+ * @dev:        target device
+ * @from:       source sector
+ * @to:         target sector
+ *
+ * Description:
+ *     Device mapper or raid target sometimes need to split a bio because
+ *     it spans a stripe (or similar). Add a trace for that action.
+ *
+ **/
+static void blk_add_trace_remap(struct request_queue *q, struct bio *bio,
+                                       dev_t dev, sector_t from, sector_t to)
+{
+        struct blk_trace *bt = q->blk_trace;
+        struct blk_io_trace_remap r;
+
+        if (likely(!bt))
+                return;
+
+        r.device = cpu_to_be32(dev);
+        r.device_from = cpu_to_be32(bio->bi_bdev->bd_dev);
+        r.sector = cpu_to_be64(to);
+
+        __blk_add_trace(bt, from, bio->bi_size, bio->bi_rw, BLK_TA_REMAP,
+                        !bio_flagged(bio, BIO_UPTODATE), sizeof(r), &r);
+}
+
+/**
+ * blk_add_driver_data - Add binary message with driver-specific data
+ * @q:          queue the io is for
+ * @rq:         io request
+ * @data:       driver-specific data
+ * @len:        length of driver-specific data
+ *
+ * Description:
+ *     Some drivers might want to write driver-specific data per request.
+ *
+ **/
+void blk_add_driver_data(struct request_queue *q,
+                         struct request *rq,
+                         void *data, size_t len)
+{
+        struct blk_trace *bt = q->blk_trace;
+
+        if (likely(!bt))
+                return;
+
+        if (blk_pc_request(rq))
+                __blk_add_trace(bt, 0, rq->data_len, 0, BLK_TA_DRV_DATA,
+                                rq->errors, len, data);
+        else
+                __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9,
+                                0, BLK_TA_DRV_DATA, rq->errors, len, data);
+}
+EXPORT_SYMBOL_GPL(blk_add_driver_data);
+
+static int blk_register_tracepoints(void)
+{
+        int ret;
+
+        ret = register_trace_block_rq_abort(blk_add_trace_rq_abort);
+        WARN_ON(ret);
+        ret = register_trace_block_rq_insert(blk_add_trace_rq_insert);
+        WARN_ON(ret);
+        ret = register_trace_block_rq_issue(blk_add_trace_rq_issue);
+        WARN_ON(ret);
+        ret = register_trace_block_rq_requeue(blk_add_trace_rq_requeue);
+        WARN_ON(ret);
+        ret = register_trace_block_rq_complete(blk_add_trace_rq_complete);
+        WARN_ON(ret);
+        ret = register_trace_block_bio_bounce(blk_add_trace_bio_bounce);
+        WARN_ON(ret);
+        ret = register_trace_block_bio_complete(blk_add_trace_bio_complete);
+        WARN_ON(ret);
+        ret = register_trace_block_bio_backmerge(blk_add_trace_bio_backmerge);
+        WARN_ON(ret);
+        ret = register_trace_block_bio_frontmerge(blk_add_trace_bio_frontmerge);
+        WARN_ON(ret);
+        ret = register_trace_block_bio_queue(blk_add_trace_bio_queue);
+        WARN_ON(ret);
+        ret = register_trace_block_getrq(blk_add_trace_getrq);
+        WARN_ON(ret);
+        ret = register_trace_block_sleeprq(blk_add_trace_sleeprq);
+        WARN_ON(ret);
+        ret = register_trace_block_plug(blk_add_trace_plug);
+        WARN_ON(ret);
+        ret = register_trace_block_unplug_timer(blk_add_trace_unplug_timer);
+        WARN_ON(ret);
+        ret = register_trace_block_unplug_io(blk_add_trace_unplug_io);
+        WARN_ON(ret);
+        ret = register_trace_block_split(blk_add_trace_split);
+        WARN_ON(ret);
+        ret = register_trace_block_remap(blk_add_trace_remap);
+        WARN_ON(ret);
+        return 0;
+}
+
+static void blk_unregister_tracepoints(void)
+{
+        unregister_trace_block_remap(blk_add_trace_remap);
+        unregister_trace_block_split(blk_add_trace_split);
+        unregister_trace_block_unplug_io(blk_add_trace_unplug_io);
+        unregister_trace_block_unplug_timer(blk_add_trace_unplug_timer);
+        unregister_trace_block_plug(blk_add_trace_plug);
+        unregister_trace_block_sleeprq(blk_add_trace_sleeprq);
+        unregister_trace_block_getrq(blk_add_trace_getrq);
+        unregister_trace_block_bio_queue(blk_add_trace_bio_queue);
+        unregister_trace_block_bio_frontmerge(blk_add_trace_bio_frontmerge);
+        unregister_trace_block_bio_backmerge(blk_add_trace_bio_backmerge);
+        unregister_trace_block_bio_complete(blk_add_trace_bio_complete);
+        unregister_trace_block_bio_bounce(blk_add_trace_bio_bounce);
+        unregister_trace_block_rq_complete(blk_add_trace_rq_complete);
+        unregister_trace_block_rq_requeue(blk_add_trace_rq_requeue);
+        unregister_trace_block_rq_issue(blk_add_trace_rq_issue);
+        unregister_trace_block_rq_insert(blk_add_trace_rq_insert);
+        unregister_trace_block_rq_abort(blk_add_trace_rq_abort);
+
+        tracepoint_synchronize_unregister();
+}
+
+/*
+ * struct blk_io_tracer formatting routines
+ */
+
+static void fill_rwbs(char *rwbs, const struct blk_io_trace *t)
+{
+        int i = 0;
+
+        if (t->action & BLK_TC_DISCARD)
+                rwbs[i++] = 'D';
+        else if (t->action & BLK_TC_WRITE)
+                rwbs[i++] = 'W';
+        else if (t->bytes)
+                rwbs[i++] = 'R';
+        else
+                rwbs[i++] = 'N';
+
+        if (t->action & BLK_TC_AHEAD)
+                rwbs[i++] = 'A';
+        if (t->action & BLK_TC_BARRIER)
+                rwbs[i++] = 'B';
+        if (t->action & BLK_TC_SYNC)
+                rwbs[i++] = 'S';
+        if (t->action & BLK_TC_META)
+                rwbs[i++] = 'M';
+
+        rwbs[i] = '\0';
+}
+
+static inline
+const struct blk_io_trace *te_blk_io_trace(const struct trace_entry *ent)
+{
+        return (const struct blk_io_trace *)ent;
+}
+
+static inline const void *pdu_start(const struct trace_entry *ent)
+{
+        return te_blk_io_trace(ent) + 1;
+}
+
+static inline u32 t_sec(const struct trace_entry *ent)
+{
+        return te_blk_io_trace(ent)->bytes >> 9;
+}
+
+static inline unsigned long long t_sector(const struct trace_entry *ent)
+{
+        return te_blk_io_trace(ent)->sector;
+}
+
+static inline __u16 t_error(const struct trace_entry *ent)
+{
+        return te_blk_io_trace(ent)->sector;
+}
+
+static __u64 get_pdu_int(const struct trace_entry *ent)
+{
+        const __u64 *val = pdu_start(ent);
+        return be64_to_cpu(*val);
+}
+
+static void get_pdu_remap(const struct trace_entry *ent,
+                          struct blk_io_trace_remap *r)
+{
+        const struct blk_io_trace_remap *__r = pdu_start(ent);
+        __u64 sector = __r->sector;
+
+        r->device = be32_to_cpu(__r->device);
+        r->device_from = be32_to_cpu(__r->device_from);
+        r->sector = be64_to_cpu(sector);
+}
+
+static int blk_log_action_iter(struct trace_iterator *iter, const char *act)
+{
+        char rwbs[6];
+        unsigned long long ts  = ns2usecs(iter->ts);
+        unsigned long usec_rem = do_div(ts, USEC_PER_SEC);
+        unsigned secs          = (unsigned long)ts;
+        const struct trace_entry *ent = iter->ent;
+        const struct blk_io_trace *t = (const struct blk_io_trace *)ent;
+
+        fill_rwbs(rwbs, t);
+
+        return trace_seq_printf(&iter->seq,
+                                "%3d,%-3d %2d %5d.%06lu %5u %2s %3s ",
+                                MAJOR(t->device), MINOR(t->device), iter->cpu,
+                                secs, usec_rem, ent->pid, act, rwbs);
+}
+
+static int blk_log_action_seq(struct trace_seq *s, const struct blk_io_trace *t,
+                              const char *act)
+{
+        char rwbs[6];
+        fill_rwbs(rwbs, t);
+        return trace_seq_printf(s, "%3d,%-3d %2s %3s ",
+                                MAJOR(t->device), MINOR(t->device), act, rwbs);
+}
+
+static int blk_log_generic(struct trace_seq *s, const struct trace_entry *ent)
+{
+        char cmd[TASK_COMM_LEN];
+
+        trace_find_cmdline(ent->pid, cmd);
+
+        if (t_sec(ent))
+                return trace_seq_printf(s, "%llu + %u [%s]\n",
+                                        t_sector(ent), t_sec(ent), cmd);
+        return trace_seq_printf(s, "[%s]\n", cmd);
+}
+
+static int blk_log_with_error(struct trace_seq *s,
+                              const struct trace_entry *ent)
+{
+        if (t_sec(ent))
+                return trace_seq_printf(s, "%llu + %u [%d]\n", t_sector(ent),
+                                        t_sec(ent), t_error(ent));
+        return trace_seq_printf(s, "%llu [%d]\n", t_sector(ent), t_error(ent));
+}
+
+static int blk_log_remap(struct trace_seq *s, const struct trace_entry *ent)
+{
+        struct blk_io_trace_remap r = { .device = 0, };
+
+        get_pdu_remap(ent, &r);
+        return trace_seq_printf(s, "%llu + %u <- (%d,%d) %llu\n",
+                               t_sector(ent),
+                               t_sec(ent), MAJOR(r.device), MINOR(r.device),
+                               (unsigned long long)r.sector);
+}
+
+static int blk_log_plug(struct trace_seq *s, const struct trace_entry *ent)
+{
+        char cmd[TASK_COMM_LEN];
+
+        trace_find_cmdline(ent->pid, cmd);
+
+        return trace_seq_printf(s, "[%s]\n", cmd);
+}
+
+static int blk_log_unplug(struct trace_seq *s, const struct trace_entry *ent)
+{
+        char cmd[TASK_COMM_LEN];
+
+        trace_find_cmdline(ent->pid, cmd);
+
+        return trace_seq_printf(s, "[%s] %llu\n", cmd, get_pdu_int(ent));
+}
+
+static int blk_log_split(struct trace_seq *s, const struct trace_entry *ent)
+{
+        char cmd[TASK_COMM_LEN];
+
+        trace_find_cmdline(ent->pid, cmd);
+
+        return trace_seq_printf(s, "%llu / %llu [%s]\n", t_sector(ent),
+                                get_pdu_int(ent), cmd);
+}
+
+/*
+ * struct tracer operations
+ */
+
+static void blk_tracer_print_header(struct seq_file *m)
+{
+        if (!(blk_tracer_flags.val & TRACE_BLK_OPT_CLASSIC))
+                return;
+        seq_puts(m, "# DEV   CPU TIMESTAMP     PID ACT FLG\n"
+                    "#  |     |     |           |   |   |\n");
+}
+
+static void blk_tracer_start(struct trace_array *tr)
+{
+        mutex_lock(&blk_probe_mutex);
+        if (atomic_add_return(1, &blk_probes_ref) == 1)
+                if (blk_register_tracepoints())
+                        atomic_dec(&blk_probes_ref);
+        mutex_unlock(&blk_probe_mutex);
+        trace_flags &= ~TRACE_ITER_CONTEXT_INFO;
+}
+
+static int blk_tracer_init(struct trace_array *tr)
+{
+        blk_tr = tr;
+        blk_tracer_start(tr);
+        mutex_lock(&blk_probe_mutex);
+        blk_tracer_enabled++;
+        mutex_unlock(&blk_probe_mutex);
+        return 0;
+}
+
+static void blk_tracer_stop(struct trace_array *tr)
+{
+        trace_flags |= TRACE_ITER_CONTEXT_INFO;
+        mutex_lock(&blk_probe_mutex);
+        if (atomic_dec_and_test(&blk_probes_ref))
+                blk_unregister_tracepoints();
+        mutex_unlock(&blk_probe_mutex);
+}
+
+static void blk_tracer_reset(struct trace_array *tr)
+{
+        if (!atomic_read(&blk_probes_ref))
+                return;
+
+        mutex_lock(&blk_probe_mutex);
+        blk_tracer_enabled--;
+        WARN_ON(blk_tracer_enabled < 0);
+        mutex_unlock(&blk_probe_mutex);
+
+        blk_tracer_stop(tr);
+}
+
+static struct {
+        const char *act[2];
+        int        (*print)(struct trace_seq *s, const struct trace_entry *ent);
+} what2act[] __read_mostly = {
+        [__BLK_TA_QUEUE]        = {{  "Q", "queue" },      blk_log_generic },
+        [__BLK_TA_BACKMERGE]    = {{  "M", "backmerge" },  blk_log_generic },
+        [__BLK_TA_FRONTMERGE]   = {{  "F", "frontmerge" }, blk_log_generic },
+        [__BLK_TA_GETRQ]        = {{  "G", "getrq" },      blk_log_generic },
+        [__BLK_TA_SLEEPRQ]      = {{  "S", "sleeprq" },    blk_log_generic },
+        [__BLK_TA_REQUEUE]      = {{  "R", "requeue" },    blk_log_with_error },
+        [__BLK_TA_ISSUE]        = {{  "D", "issue" },      blk_log_generic },
+        [__BLK_TA_COMPLETE]     = {{  "C", "complete" },   blk_log_with_error },
+        [__BLK_TA_PLUG]         = {{  "P", "plug" },       blk_log_plug },
+        [__BLK_TA_UNPLUG_IO]    = {{  "U", "unplug_io" },  blk_log_unplug },
+        [__BLK_TA_UNPLUG_TIMER] = {{ "UT", "unplug_timer" }, blk_log_unplug },
+        [__BLK_TA_INSERT]       = {{  "I", "insert" },     blk_log_generic },
+        [__BLK_TA_SPLIT]        = {{  "X", "split" },      blk_log_split },
+        [__BLK_TA_BOUNCE]       = {{  "B", "bounce" },     blk_log_generic },
+        [__BLK_TA_REMAP]        = {{  "A", "remap" },      blk_log_remap },
+};
+
+static enum print_line_t blk_trace_event_print(struct trace_iterator *iter,
+                                               int flags)
+{
+        struct trace_seq *s = &iter->seq;
+        const struct blk_io_trace *t = (struct blk_io_trace *)iter->ent;
+        const u16 what = t->action & ((1 << BLK_TC_SHIFT) - 1);
+        int ret;
+
+        if (!trace_print_context(iter))
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        if (unlikely(what == 0 || what > ARRAY_SIZE(what2act)))
+                ret = trace_seq_printf(s, "Bad pc action %x\n", what);
+        else {
+                const bool long_act = !!(trace_flags & TRACE_ITER_VERBOSE);
+                ret = blk_log_action_seq(s, t, what2act[what].act[long_act]);
+                if (ret)
+                        ret = what2act[what].print(s, iter->ent);
+        }
+
+        return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
+}
+
+static int blk_trace_synthesize_old_trace(struct trace_iterator *iter)
+{
+        struct trace_seq *s = &iter->seq;
+        struct blk_io_trace *t = (struct blk_io_trace *)iter->ent;
+        const int offset = offsetof(struct blk_io_trace, sector);
+        struct blk_io_trace old = {
+                .magic    = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION,
+                .time     = ns2usecs(iter->ts),
+        };
+
+        if (!trace_seq_putmem(s, &old, offset))
+                return 0;
+        return trace_seq_putmem(s, &t->sector,
+                                sizeof(old) - offset + t->pdu_len);
+}
+
+static enum print_line_t
+blk_trace_event_print_binary(struct trace_iterator *iter, int flags)
+{
+        return blk_trace_synthesize_old_trace(iter) ?
+                        TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
+}
+
+static enum print_line_t blk_tracer_print_line(struct trace_iterator *iter)
+{
+        const struct blk_io_trace *t;
+        u16 what;
+        int ret;
+
+        if (!(blk_tracer_flags.val & TRACE_BLK_OPT_CLASSIC))
+                return TRACE_TYPE_UNHANDLED;
+
+        t = (const struct blk_io_trace *)iter->ent;
+        what = t->action & ((1 << BLK_TC_SHIFT) - 1);
+
+        if (unlikely(what == 0 || what > ARRAY_SIZE(what2act)))
+                ret = trace_seq_printf(&iter->seq, "Bad pc action %x\n", what);
+        else {
+                const bool long_act = !!(trace_flags & TRACE_ITER_VERBOSE);
+                ret = blk_log_action_iter(iter, what2act[what].act[long_act]);
+                if (ret)
+                        ret = what2act[what].print(&iter->seq, iter->ent);
+        }
+
+        return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
+}
+
+static struct tracer blk_tracer __read_mostly = {
+        .name           = "blk",
+        .init           = blk_tracer_init,
+        .reset          = blk_tracer_reset,
+        .start          = blk_tracer_start,
+        .stop           = blk_tracer_stop,
+        .print_header   = blk_tracer_print_header,
+        .print_line     = blk_tracer_print_line,
+        .flags          = &blk_tracer_flags,
+};
+
+static struct trace_event trace_blk_event = {
+        .type           = TRACE_BLK,
+        .trace          = blk_trace_event_print,
+        .binary         = blk_trace_event_print_binary,
+};
+
+static int __init init_blk_tracer(void)
+{
+        if (!register_ftrace_event(&trace_blk_event)) {
+                pr_warning("Warning: could not register block events\n");
+                return 1;
+        }
+
+        if (register_tracer(&blk_tracer) != 0) {
+                pr_warning("Warning: could not register the block tracer\n");
+                unregister_ftrace_event(&trace_blk_event);
+                return 1;
+        }
+
+        return 0;
+}
+
+device_initcall(init_blk_tracer);
+
+static int blk_trace_remove_queue(struct request_queue *q)
+{
+        struct blk_trace *bt;
+
+        bt = xchg(&q->blk_trace, NULL);
+        if (bt == NULL)
+                return -EINVAL;
+
+        kfree(bt);
+        return 0;
+}
+
+/*
+ * Setup everything required to start tracing
+ */
+static int blk_trace_setup_queue(struct request_queue *q, dev_t dev)
+{
+        struct blk_trace *old_bt, *bt = NULL;
+        int ret;
+
+        ret = -ENOMEM;
+        bt = kzalloc(sizeof(*bt), GFP_KERNEL);
+        if (!bt)
+                goto err;
+
+        bt->dev = dev;
+        bt->act_mask = (u16)-1;
+        bt->end_lba = -1ULL;
+        bt->trace_state = Blktrace_running;
+
+        old_bt = xchg(&q->blk_trace, bt);
+        if (old_bt != NULL) {
+                (void)xchg(&q->blk_trace, old_bt);
+                kfree(bt);
+                ret = -EBUSY;
+        }
+        return 0;
+err:
+        return ret;
+}
+
+/*
+ * sysfs interface to enable and configure tracing
+ */
+
+static ssize_t sysfs_blk_trace_enable_show(struct device *dev,
+                                           struct device_attribute *attr,
+                                           char *buf)
+{
+        struct hd_struct *p = dev_to_part(dev);
+        struct block_device *bdev;
+        ssize_t ret = -ENXIO;
+
+        lock_kernel();
+        bdev = bdget(part_devt(p));
+        if (bdev != NULL) {
+                struct request_queue *q = bdev_get_queue(bdev);
+
+                if (q != NULL) {
+                        mutex_lock(&bdev->bd_mutex);
+                        ret = sprintf(buf, "%u\n", !!q->blk_trace);
+                        mutex_unlock(&bdev->bd_mutex);
+                }
+
+                bdput(bdev);
+        }
+
+        unlock_kernel();
+        return ret;
+}
+
+static ssize_t sysfs_blk_trace_enable_store(struct device *dev,
+                                            struct device_attribute *attr,
+                                            const char *buf, size_t count)
+{
+        struct block_device *bdev;
+        struct request_queue *q;
+        struct hd_struct *p;
+        int value;
+        ssize_t ret = -ENXIO;
+
+        if (count == 0 || sscanf(buf, "%d", &value) != 1)
+                goto out;
+
+        lock_kernel();
+        p = dev_to_part(dev);
+        bdev = bdget(part_devt(p));
+        if (bdev == NULL)
+                goto out_unlock_kernel;
+
+        q = bdev_get_queue(bdev);
+        if (q == NULL)
+                goto out_bdput;
+
+        mutex_lock(&bdev->bd_mutex);
+        if (value)
+                ret = blk_trace_setup_queue(q, bdev->bd_dev);
+        else
+                ret = blk_trace_remove_queue(q);
+        mutex_unlock(&bdev->bd_mutex);
+
+        if (ret == 0)
+                ret = count;
+out_bdput:
+        bdput(bdev);
+out_unlock_kernel:
+        unlock_kernel();
+out:
+        return ret;
+}
+
+static ssize_t sysfs_blk_trace_attr_show(struct device *dev,
+                                         struct device_attribute *attr,
+                                         char *buf);
+static ssize_t sysfs_blk_trace_attr_store(struct device *dev,
+                                          struct device_attribute *attr,
+                                          const char *buf, size_t count);
+#define BLK_TRACE_DEVICE_ATTR(_name) \
+        DEVICE_ATTR(_name, S_IRUGO | S_IWUSR, \
+                    sysfs_blk_trace_attr_show, \
+                    sysfs_blk_trace_attr_store)
+
+static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR,
+                   sysfs_blk_trace_enable_show, sysfs_blk_trace_enable_store);
+static BLK_TRACE_DEVICE_ATTR(act_mask);
+static BLK_TRACE_DEVICE_ATTR(pid);
+static BLK_TRACE_DEVICE_ATTR(start_lba);
+static BLK_TRACE_DEVICE_ATTR(end_lba);
+
+static struct attribute *blk_trace_attrs[] = {
+        &dev_attr_enable.attr,
+        &dev_attr_act_mask.attr,
+        &dev_attr_pid.attr,
+        &dev_attr_start_lba.attr,
+        &dev_attr_end_lba.attr,
+        NULL
+};
+
+struct attribute_group blk_trace_attr_group = {
+        .name  = "trace",
+        .attrs = blk_trace_attrs,
+};
+
+static int blk_str2act_mask(const char *str)
+{
+        int mask = 0;
+        char *copy = kstrdup(str, GFP_KERNEL), *s;
+
+        if (copy == NULL)
+                return -ENOMEM;
+
+        s = strstrip(copy);
+
+        while (1) {
+                char *sep = strchr(s, ',');
+
+                if (sep != NULL)
+                        *sep = '\0';
+
+                if (strcasecmp(s, "barrier") == 0)
+                        mask |= BLK_TC_BARRIER;
+                else if (strcasecmp(s, "complete") == 0)
+                        mask |= BLK_TC_COMPLETE;
+                else if (strcasecmp(s, "fs") == 0)
+                        mask |= BLK_TC_FS;
+                else if (strcasecmp(s, "issue") == 0)
+                        mask |= BLK_TC_ISSUE;
+                else if (strcasecmp(s, "pc") == 0)
+                        mask |= BLK_TC_PC;
+                else if (strcasecmp(s, "queue") == 0)
+                        mask |= BLK_TC_QUEUE;
+                else if (strcasecmp(s, "read") == 0)
+                        mask |= BLK_TC_READ;
+                else if (strcasecmp(s, "requeue") == 0)
+                        mask |= BLK_TC_REQUEUE;
+                else if (strcasecmp(s, "sync") == 0)
+                        mask |= BLK_TC_SYNC;
+                else if (strcasecmp(s, "write") == 0)
+                        mask |= BLK_TC_WRITE;
+
+                if (sep == NULL)
+                        break;
+
+                s = sep + 1;
+        }
+        kfree(copy);
+
+        return mask;
+}
+
+static ssize_t sysfs_blk_trace_attr_show(struct device *dev,
+                                         struct device_attribute *attr,
+                                         char *buf)
+{
+        struct hd_struct *p = dev_to_part(dev);
+        struct request_queue *q;
+        struct block_device *bdev;
+        ssize_t ret = -ENXIO;
+
+        lock_kernel();
+        bdev = bdget(part_devt(p));
+        if (bdev == NULL)
+                goto out_unlock_kernel;
+
+        q = bdev_get_queue(bdev);
+        if (q == NULL)
+                goto out_bdput;
+        mutex_lock(&bdev->bd_mutex);
+        if (q->blk_trace == NULL)
+                ret = sprintf(buf, "disabled\n");
+        else if (attr == &dev_attr_act_mask)
+                ret = sprintf(buf, "%#x\n", q->blk_trace->act_mask);
+        else if (attr == &dev_attr_pid)
+                ret = sprintf(buf, "%u\n", q->blk_trace->pid);
+        else if (attr == &dev_attr_start_lba)
+                ret = sprintf(buf, "%llu\n", q->blk_trace->start_lba);
+        else if (attr == &dev_attr_end_lba)
+                ret = sprintf(buf, "%llu\n", q->blk_trace->end_lba);
+        mutex_unlock(&bdev->bd_mutex);
+out_bdput:
+        bdput(bdev);
+out_unlock_kernel:
+        unlock_kernel();
+        return ret;
+}
+
+static ssize_t sysfs_blk_trace_attr_store(struct device *dev,
+                                          struct device_attribute *attr,
+                                          const char *buf, size_t count)
+{
+        struct block_device *bdev;
+        struct request_queue *q;
+        struct hd_struct *p;
+        u64 value;
+        ssize_t ret = -ENXIO;
+
+        if (count == 0)
+                goto out;
+
+        if (attr == &dev_attr_act_mask) {
+                if (sscanf(buf, "%llx", &value) != 1) {
+                        /* Assume it is a list of trace category names */
+                        value = blk_str2act_mask(buf);
+                        if (value < 0)
+                                goto out;
+                }
+        } else if (sscanf(buf, "%llu", &value) != 1)
+                goto out;
+
+        lock_kernel();
+        p = dev_to_part(dev);
+        bdev = bdget(part_devt(p));
+        if (bdev == NULL)
+                goto out_unlock_kernel;
+
+        q = bdev_get_queue(bdev);
+        if (q == NULL)
+                goto out_bdput;
+
+        mutex_lock(&bdev->bd_mutex);
+        ret = 0;
+        if (q->blk_trace == NULL)
+                ret = blk_trace_setup_queue(q, bdev->bd_dev);
+
+        if (ret == 0) {
+                if (attr == &dev_attr_act_mask)
+                        q->blk_trace->act_mask = value;
+                else if (attr == &dev_attr_pid)
+                        q->blk_trace->pid = value;
+                else if (attr == &dev_attr_start_lba)
+                        q->blk_trace->start_lba = value;
+                else if (attr == &dev_attr_end_lba)
+                        q->blk_trace->end_lba = value;
+                ret = count;
+        }
+        mutex_unlock(&bdev->bd_mutex);
+out_bdput:
+        bdput(bdev);
+out_unlock_kernel:
+        unlock_kernel();
+out:
+        return ret;
+}
diff --git a/kernel/trace/events.c b/kernel/trace/events.c
new file mode 100644
index 000000000000..9fc918da404f
--- /dev/null
+++ b/kernel/trace/events.c
@@ -0,0 +1,15 @@
+/*
+ * This is the place to register all trace points as events.
+ */
+
+#include <linux/stringify.h>
+
+#include <trace/trace_events.h>
+
+#include "trace_output.h"
+
+#include "trace_events_stage_1.h"
+#include "trace_events_stage_2.h"
+#include "trace_events_stage_3.h"
+
+#include <trace/trace_event_types.h>
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index fdf913dfc7e8..7847806eefef 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -27,6 +27,7 @@
 #include <linux/sysctl.h>
 #include <linux/ctype.h>
 #include <linux/list.h>
+#include <linux/hash.h>
 
 #include <asm/ftrace.h>
 
@@ -44,14 +45,14 @@
                         ftrace_kill();          \
         } while (0)
 
+/* hash bits for specific function selection */
+#define FTRACE_HASH_BITS 7
+#define FTRACE_FUNC_HASHSIZE (1 << FTRACE_HASH_BITS)
+
 /* ftrace_enabled is a method to turn ftrace on or off */
 int ftrace_enabled __read_mostly;
 static int last_ftrace_enabled;
 
-/* set when tracing only a pid */
-struct pid *ftrace_pid_trace;
-static struct pid * const ftrace_swapper_pid = &init_struct_pid;
-
 /* Quick disabling of function tracer. */
 int function_trace_stop;
 
@@ -61,9 +62,7 @@ int function_trace_stop;
  */
 static int ftrace_disabled __read_mostly;
 
-static DEFINE_SPINLOCK(ftrace_lock);
-static DEFINE_MUTEX(ftrace_sysctl_lock);
-static DEFINE_MUTEX(ftrace_start_lock);
+static DEFINE_MUTEX(ftrace_lock);
 
 static struct ftrace_ops ftrace_list_end __read_mostly =
 {
@@ -134,9 +133,6 @@ static void ftrace_test_stop_func(unsigned long ip, unsigned long parent_ip)
 
 static int __register_ftrace_function(struct ftrace_ops *ops)
 {
-        /* should not be called from interrupt context */
-        spin_lock(&ftrace_lock);
-
         ops->next = ftrace_list;
         /*
          * We are entering ops into the ftrace_list but another
@@ -172,18 +168,12 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
 #endif
         }
 
-        spin_unlock(&ftrace_lock);
-
         return 0;
 }
 
 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);
 
         /*
          * If we are removing the last function, then simply point
@@ -192,17 +182,15 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
         if (ftrace_list == ops && ops->next == &ftrace_list_end) {
                 ftrace_trace_function = ftrace_stub;
                 ftrace_list = &ftrace_list_end;
-                goto out;
+                return 0;
         }
 
         for (p = &ftrace_list; *p != &ftrace_list_end; p = &(*p)->next)
                 if (*p == ops)
                         break;
 
-        if (*p != ops) {
-                ret = -1;
-                goto out;
-        }
+        if (*p != ops)
+                return -1;
 
         *p = (*p)->next;
 
@@ -223,21 +211,15 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
                 }
         }
 
- out:
-        spin_unlock(&ftrace_lock);
-
-        return ret;
+        return 0;
 }
 
 static void ftrace_update_pid_func(void)
 {
         ftrace_func_t func;
 
-        /* should not be called from interrupt context */
-        spin_lock(&ftrace_lock);
-
         if (ftrace_trace_function == ftrace_stub)
-                goto out;
+                return;
 
         func = ftrace_trace_function;
 
@@ -254,23 +236,29 @@ static void ftrace_update_pid_func(void)
 #else
         __ftrace_trace_function = func;
 #endif
-
- out:
-        spin_unlock(&ftrace_lock);
 }
 
+/* set when tracing only a pid */
+struct pid *ftrace_pid_trace;
+static struct pid * const ftrace_swapper_pid = &init_struct_pid;
+
 #ifdef CONFIG_DYNAMIC_FTRACE
+
 #ifndef CONFIG_FTRACE_MCOUNT_RECORD
 # error Dynamic ftrace depends on MCOUNT_RECORD
 #endif
 
-/*
- * 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;
+static struct hlist_head ftrace_func_hash[FTRACE_FUNC_HASHSIZE] __read_mostly;
+
+struct ftrace_func_probe {
+        struct hlist_node       node;
+        struct ftrace_probe_ops *ops;
+        unsigned long           flags;
+        unsigned long           ip;
+        void                    *data;
+        struct rcu_head         rcu;
+};
+
 
 enum {
         FTRACE_ENABLE_CALLS             = (1 << 0),
@@ -284,13 +272,13 @@ enum {
 
 static int ftrace_filtered;
 
-static LIST_HEAD(ftrace_new_addrs);
+static struct dyn_ftrace *ftrace_new_addrs;
 
 static DEFINE_MUTEX(ftrace_regex_lock);
 
 struct ftrace_page {
         struct ftrace_page      *next;
-        unsigned long           index;
+        int                     index;
         struct dyn_ftrace       records[];
 };
 
@@ -305,6 +293,19 @@ static struct ftrace_page	*ftrace_pages;
 
 static struct dyn_ftrace *ftrace_free_records;
 
+/*
+ * This is a double for. Do not use 'break' to break out of the loop,
+ * you must use a goto.
+ */
+#define do_for_each_ftrace_rec(pg, rec)                                 \
+        for (pg = ftrace_pages_start; pg; pg = pg->next) {              \
+                int _____i;                                             \
+                for (_____i = 0; _____i < pg->index; _____i++) {        \
+                        rec = &pg->records[_____i];
+
+#define while_for_each_ftrace_rec()             \
+                }                               \
+        }
 
 #ifdef CONFIG_KPROBES
 
@@ -349,23 +350,17 @@ void ftrace_release(void *start, unsigned long size)
         struct ftrace_page *pg;
         unsigned long s = (unsigned long)start;
         unsigned long e = s + size;
-        int i;
 
         if (ftrace_disabled || !start)
                 return;
 
-        /* should not be called from interrupt context */
-        spin_lock(&ftrace_lock);
-
-        for (pg = ftrace_pages_start; pg; pg = pg->next) {
-                for (i = 0; i < pg->index; i++) {
-                        rec = &pg->records[i];
-
-                        if ((rec->ip >= s) && (rec->ip < e))
-                                ftrace_free_rec(rec);
-                }
-        }
-        spin_unlock(&ftrace_lock);
+        mutex_lock(&ftrace_lock);
+        do_for_each_ftrace_rec(pg, rec) {
+                if ((rec->ip >= s) && (rec->ip < e) &&
+                    !(rec->flags & FTRACE_FL_FREE))
+                        ftrace_free_rec(rec);
+        } while_for_each_ftrace_rec();
+        mutex_unlock(&ftrace_lock);
 }
 
 static struct dyn_ftrace *ftrace_alloc_dyn_node(unsigned long ip)
@@ -414,8 +409,8 @@ ftrace_record_ip(unsigned long ip)
                 return NULL;
 
         rec->ip = ip;
-
-        list_add(&rec->list, &ftrace_new_addrs);
+        rec->flags = (unsigned long)ftrace_new_addrs;
+        ftrace_new_addrs = rec;
 
         return rec;
 }
@@ -461,10 +456,10 @@ static void ftrace_bug(int failed, unsigned long ip)
 static int
 __ftrace_replace_code(struct dyn_ftrace *rec, int enable)
 {
-        unsigned long ip, fl;
         unsigned long ftrace_addr;
+        unsigned long ip, fl;
 
-        ftrace_addr = (unsigned long)ftrace_caller;
+        ftrace_addr = (unsigned long)FTRACE_ADDR;
 
         ip = rec->ip;
 
@@ -473,7 +468,7 @@ __ftrace_replace_code(struct dyn_ftrace *rec, int enable)
          * it is not enabled then do nothing.
          *
          * If this record is not to be traced and
-         * it is enabled then disabled it.
+         * it is enabled then disable it.
          *
          */
         if (rec->flags & FTRACE_FL_NOTRACE) {
@@ -493,7 +488,7 @@ __ftrace_replace_code(struct dyn_ftrace *rec, int enable)
                 if (fl == (FTRACE_FL_FILTER | FTRACE_FL_ENABLED))
                         return 0;
 
-                /* Record is not filtered and is not enabled do nothing */
+                /* Record is not filtered or enabled, do nothing */
                 if (!fl)
                         return 0;
 
@@ -515,7 +510,7 @@ __ftrace_replace_code(struct dyn_ftrace *rec, int enable)
 
                 } else {
 
-                        /* if record is not enabled do nothing */
+                        /* if record is not enabled, do nothing */
                         if (!(rec->flags & FTRACE_FL_ENABLED))
                                 return 0;
 
@@ -531,41 +526,41 @@ __ftrace_replace_code(struct dyn_ftrace *rec, int enable)
 
 static void ftrace_replace_code(int enable)
 {
-        int i, failed;
         struct dyn_ftrace *rec;
         struct ftrace_page *pg;
+        int failed;
 
-        for (pg = ftrace_pages_start; pg; pg = pg->next) {
-                for (i = 0; i < pg->index; i++) {
-                        rec = &pg->records[i];
-
-                        /*
-                         * Skip over free records and records that have
-                         * failed.
-                         */
-                        if (rec->flags & FTRACE_FL_FREE ||
-                            rec->flags & FTRACE_FL_FAILED)
-                                continue;
+        do_for_each_ftrace_rec(pg, rec) {
+                /*
+                 * Skip over free records, records that have
+                 * failed and not converted.
+                 */
+                if (rec->flags & FTRACE_FL_FREE ||
+                    rec->flags & FTRACE_FL_FAILED ||
+                    !(rec->flags & FTRACE_FL_CONVERTED))
+                        continue;
 
-                        /* ignore updates to this record's mcount site */
-                        if (get_kprobe((void *)rec->ip)) {
-                                freeze_record(rec);
-                                continue;
-                        } else {
-                                unfreeze_record(rec);
-                        }
+                /* ignore updates to this record's mcount site */
+                if (get_kprobe((void *)rec->ip)) {
+                        freeze_record(rec);
+                        continue;
+                } else {
+                        unfreeze_record(rec);
+                }
 
-                        failed = __ftrace_replace_code(rec, enable);
-                        if (failed && (rec->flags & FTRACE_FL_CONVERTED)) {
-                                rec->flags |= FTRACE_FL_FAILED;
-                                if ((system_state == SYSTEM_BOOTING) ||
-                                    !core_kernel_text(rec->ip)) {
-                                        ftrace_free_rec(rec);
-                                } else
-                                        ftrace_bug(failed, rec->ip);
-                        }
+                failed = __ftrace_replace_code(rec, enable);
+                if (failed) {
+                        rec->flags |= FTRACE_FL_FAILED;
+                        if ((system_state == SYSTEM_BOOTING) ||
+                            !core_kernel_text(rec->ip)) {
+                                ftrace_free_rec(rec);
+                                } else {
+                                ftrace_bug(failed, rec->ip);
+                                        /* Stop processing */
+                                        return;
+                                }
                 }
-        }
+        } while_for_each_ftrace_rec();
 }
 
 static int
@@ -576,7 +571,7 @@ ftrace_code_disable(struct module *mod, struct dyn_ftrace *rec)
 
         ip = rec->ip;
 
-        ret = ftrace_make_nop(mod, rec, mcount_addr);
+        ret = ftrace_make_nop(mod, rec, MCOUNT_ADDR);
         if (ret) {
                 ftrace_bug(ret, ip);
                 rec->flags |= FTRACE_FL_FAILED;
@@ -585,6 +580,24 @@ ftrace_code_disable(struct module *mod, struct dyn_ftrace *rec)
         return 1;
 }
 
+/*
+ * archs can override this function if they must do something
+ * before the modifying code is performed.
+ */
+int __weak ftrace_arch_code_modify_prepare(void)
+{
+        return 0;
+}
+
+/*
+ * archs can override this function if they must do something
+ * after the modifying code is performed.
+ */
+int __weak ftrace_arch_code_modify_post_process(void)
+{
+        return 0;
+}
+
 static int __ftrace_modify_code(void *data)
 {
         int *command = data;
@@ -607,7 +620,17 @@ static int __ftrace_modify_code(void *data)
 
 static void ftrace_run_update_code(int command)
 {
+        int ret;
+
+        ret = ftrace_arch_code_modify_prepare();
+        FTRACE_WARN_ON(ret);
+        if (ret)
+                return;
+
         stop_machine(__ftrace_modify_code, &command, NULL);
+
+        ret = ftrace_arch_code_modify_post_process();
+        FTRACE_WARN_ON(ret);
 }
 
 static ftrace_func_t saved_ftrace_func;
@@ -631,13 +654,10 @@ static void ftrace_startup(int command)
         if (unlikely(ftrace_disabled))
                 return;
 
-        mutex_lock(&ftrace_start_lock);
         ftrace_start_up++;
         command |= FTRACE_ENABLE_CALLS;
 
         ftrace_startup_enable(command);
-
-        mutex_unlock(&ftrace_start_lock);
 }
 
 static void ftrace_shutdown(int command)
@@ -645,7 +665,6 @@ static void ftrace_shutdown(int command)
         if (unlikely(ftrace_disabled))
                 return;
 
-        mutex_lock(&ftrace_start_lock);
         ftrace_start_up--;
         if (!ftrace_start_up)
                 command |= FTRACE_DISABLE_CALLS;
@@ -656,11 +675,9 @@ static void ftrace_shutdown(int command)
         }
 
         if (!command || !ftrace_enabled)
-                goto out;
+                return;
 
         ftrace_run_update_code(command);
- out:
-        mutex_unlock(&ftrace_start_lock);
 }
 
 static void ftrace_startup_sysctl(void)
@@ -670,7 +687,6 @@ static void ftrace_startup_sysctl(void)
         if (unlikely(ftrace_disabled))
                 return;
 
-        mutex_lock(&ftrace_start_lock);
         /* Force update next time */
         saved_ftrace_func = NULL;
         /* ftrace_start_up is true if we want ftrace running */
@@ -678,7 +694,6 @@ static void ftrace_startup_sysctl(void)
                 command |= FTRACE_ENABLE_CALLS;
 
         ftrace_run_update_code(command);
-        mutex_unlock(&ftrace_start_lock);
 }
 
 static void ftrace_shutdown_sysctl(void)
@@ -688,13 +703,11 @@ static void ftrace_shutdown_sysctl(void)
         if (unlikely(ftrace_disabled))
                 return;
 
-        mutex_lock(&ftrace_start_lock);
         /* ftrace_start_up is true if ftrace is running */
         if (ftrace_start_up)
                 command |= FTRACE_DISABLE_CALLS;
 
         ftrace_run_update_code(command);
-        mutex_unlock(&ftrace_start_lock);
 }
 
 static cycle_t          ftrace_update_time;
@@ -703,19 +716,21 @@ unsigned long		ftrace_update_tot_cnt;
 
 static int ftrace_update_code(struct module *mod)
 {
-        struct dyn_ftrace *p, *t;
+        struct dyn_ftrace *p;
         cycle_t start, stop;
 
         start = ftrace_now(raw_smp_processor_id());
         ftrace_update_cnt = 0;
 
-        list_for_each_entry_safe(p, t, &ftrace_new_addrs, list) {
+        while (ftrace_new_addrs) {
 
                 /* If something went wrong, bail without enabling anything */
                 if (unlikely(ftrace_disabled))
                         return -1;
 
-                list_del_init(&p->list);
+                p = ftrace_new_addrs;
+                ftrace_new_addrs = (struct dyn_ftrace *)p->flags;
+                p->flags = 0L;
 
                 /* convert record (i.e, patch mcount-call with NOP) */
                 if (ftrace_code_disable(mod, p)) {
@@ -781,13 +796,16 @@ enum {
         FTRACE_ITER_CONT        = (1 << 1),
         FTRACE_ITER_NOTRACE     = (1 << 2),
         FTRACE_ITER_FAILURES    = (1 << 3),
+        FTRACE_ITER_PRINTALL    = (1 << 4),
+        FTRACE_ITER_HASH        = (1 << 5),
 };
 
 #define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
 
 struct ftrace_iterator {
         struct ftrace_page      *pg;
-        unsigned                idx;
+        int                     hidx;
+        int                     idx;
         unsigned                flags;
         unsigned char           buffer[FTRACE_BUFF_MAX+1];
         unsigned                buffer_idx;
@@ -795,15 +813,89 @@ struct ftrace_iterator {
 };
 
 static void *
+t_hash_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        struct ftrace_iterator *iter = m->private;
+        struct hlist_node *hnd = v;
+        struct hlist_head *hhd;
+
+        WARN_ON(!(iter->flags & FTRACE_ITER_HASH));
+
+        (*pos)++;
+
+ retry:
+        if (iter->hidx >= FTRACE_FUNC_HASHSIZE)
+                return NULL;
+
+        hhd = &ftrace_func_hash[iter->hidx];
+
+        if (hlist_empty(hhd)) {
+                iter->hidx++;
+                hnd = NULL;
+                goto retry;
+        }
+
+        if (!hnd)
+                hnd = hhd->first;
+        else {
+                hnd = hnd->next;
+                if (!hnd) {
+                        iter->hidx++;
+                        goto retry;
+                }
+        }
+
+        return hnd;
+}
+
+static void *t_hash_start(struct seq_file *m, loff_t *pos)
+{
+        struct ftrace_iterator *iter = m->private;
+        void *p = NULL;
+
+        iter->flags |= FTRACE_ITER_HASH;
+
+        return t_hash_next(m, p, pos);
+}
+
+static int t_hash_show(struct seq_file *m, void *v)
+{
+        struct ftrace_func_probe *rec;
+        struct hlist_node *hnd = v;
+        char str[KSYM_SYMBOL_LEN];
+
+        rec = hlist_entry(hnd, struct ftrace_func_probe, node);
+
+        if (rec->ops->print)
+                return rec->ops->print(m, rec->ip, rec->ops, rec->data);
+
+        kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
+        seq_printf(m, "%s:", str);
+
+        kallsyms_lookup((unsigned long)rec->ops->func, NULL, NULL, NULL, str);
+        seq_printf(m, "%s", str);
+
+        if (rec->data)
+                seq_printf(m, ":%p", rec->data);
+        seq_putc(m, '\n');
+
+        return 0;
+}
+
+static void *
 t_next(struct seq_file *m, void *v, loff_t *pos)
 {
         struct ftrace_iterator *iter = m->private;
         struct dyn_ftrace *rec = NULL;
 
+        if (iter->flags & FTRACE_ITER_HASH)
+                return t_hash_next(m, v, pos);
+
         (*pos)++;
 
-        /* should not be called from interrupt context */
-        spin_lock(&ftrace_lock);
+        if (iter->flags & FTRACE_ITER_PRINTALL)
+                return NULL;
+
  retry:
         if (iter->idx >= iter->pg->index) {
                 if (iter->pg->next) {
@@ -832,7 +924,6 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                         goto retry;
                 }
         }
-        spin_unlock(&ftrace_lock);
 
         return rec;
 }
@@ -842,6 +933,23 @@ static void *t_start(struct seq_file *m, loff_t *pos)
         struct ftrace_iterator *iter = m->private;
         void *p = NULL;
 
+        mutex_lock(&ftrace_lock);
+        /*
+         * For set_ftrace_filter reading, if we have the filter
+         * off, we can short cut and just print out that all
+         * functions are enabled.
+         */
+        if (iter->flags & FTRACE_ITER_FILTER && !ftrace_filtered) {
+                if (*pos > 0)
+                        return t_hash_start(m, pos);
+                iter->flags |= FTRACE_ITER_PRINTALL;
+                (*pos)++;
+                return iter;
+        }
+
+        if (iter->flags & FTRACE_ITER_HASH)
+                return t_hash_start(m, pos);
+
         if (*pos > 0) {
                 if (iter->idx < 0)
                         return p;
@@ -851,18 +959,31 @@ static void *t_start(struct seq_file *m, loff_t *pos)
 
         p = t_next(m, p, pos);
 
+        if (!p)
+                return t_hash_start(m, pos);
+
         return p;
 }
 
 static void t_stop(struct seq_file *m, void *p)
 {
+        mutex_unlock(&ftrace_lock);
 }
 
 static int t_show(struct seq_file *m, void *v)
 {
+        struct ftrace_iterator *iter = m->private;
         struct dyn_ftrace *rec = v;
         char str[KSYM_SYMBOL_LEN];
 
+        if (iter->flags & FTRACE_ITER_HASH)
+                return t_hash_show(m, v);
+
+        if (iter->flags & FTRACE_ITER_PRINTALL) {
+                seq_printf(m, "#### all functions enabled ####\n");
+                return 0;
+        }
+
         if (!rec)
                 return 0;
 
@@ -941,23 +1062,16 @@ static void ftrace_filter_reset(int enable)
         struct ftrace_page *pg;
         struct dyn_ftrace *rec;
         unsigned long type = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
-        unsigned i;
 
-        /* should not be called from interrupt context */
-        spin_lock(&ftrace_lock);
+        mutex_lock(&ftrace_lock);
         if (enable)
                 ftrace_filtered = 0;
-        pg = ftrace_pages_start;
-        while (pg) {
-                for (i = 0; i < pg->index; i++) {
-                        rec = &pg->records[i];
-                        if (rec->flags & FTRACE_FL_FAILED)
-                                continue;
-                        rec->flags &= ~type;
-                }
-                pg = pg->next;
-        }
-        spin_unlock(&ftrace_lock);
+        do_for_each_ftrace_rec(pg, rec) {
+                if (rec->flags & FTRACE_FL_FAILED)
+                        continue;
+                rec->flags &= ~type;
+        } while_for_each_ftrace_rec();
+        mutex_unlock(&ftrace_lock);
 }
 
 static int
@@ -1008,16 +1122,6 @@ ftrace_notrace_open(struct inode *inode, struct file *file)
         return ftrace_regex_open(inode, file, 0);
 }
 
-static ssize_t
-ftrace_regex_read(struct file *file, char __user *ubuf,
-                       size_t cnt, loff_t *ppos)
-{
-        if (file->f_mode & FMODE_READ)
-                return seq_read(file, ubuf, cnt, ppos);
-        else
-                return -EPERM;
-}
-
 static loff_t
 ftrace_regex_lseek(struct file *file, loff_t offset, int origin)
 {
@@ -1038,86 +1142,536 @@ enum {
         MATCH_END_ONLY,
 };
 
-static void
-ftrace_match(unsigned char *buff, int len, int enable)
+/*
+ * (static function - no need for kernel doc)
+ *
+ * Pass in a buffer containing a glob and this function will
+ * set search to point to the search part of the buffer and
+ * return the type of search it is (see enum above).
+ * This does modify buff.
+ *
+ * Returns enum type.
+ *  search returns the pointer to use for comparison.
+ *  not returns 1 if buff started with a '!'
+ *     0 otherwise.
+ */
+static int
+ftrace_setup_glob(char *buff, int len, char **search, int *not)
 {
-        char str[KSYM_SYMBOL_LEN];
-        char *search = NULL;
-        struct ftrace_page *pg;
-        struct dyn_ftrace *rec;
         int type = MATCH_FULL;
-        unsigned long flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
-        unsigned i, match = 0, search_len = 0;
-        int not = 0;
+        int i;
 
         if (buff[0] == '!') {
-                not = 1;
+                *not = 1;
                 buff++;
                 len--;
-        }
+        } else
+                *not = 0;
+
+        *search = buff;
 
         for (i = 0; i < len; i++) {
                 if (buff[i] == '*') {
                         if (!i) {
-                                search = buff + i + 1;
+                                *search = buff + 1;
                                 type = MATCH_END_ONLY;
-                                search_len = len - (i + 1);
                         } else {
-                                if (type == MATCH_END_ONLY) {
+                                if (type == MATCH_END_ONLY)
                                         type = MATCH_MIDDLE_ONLY;
-                                } else {
-                                        match = i;
+                                else
                                         type = MATCH_FRONT_ONLY;
-                                }
                                 buff[i] = 0;
                                 break;
                         }
                 }
         }
 
-        /* should not be called from interrupt context */
-        spin_lock(&ftrace_lock);
-        if (enable)
-                ftrace_filtered = 1;
-        pg = ftrace_pages_start;
-        while (pg) {
-                for (i = 0; i < pg->index; i++) {
-                        int matched = 0;
-                        char *ptr;
-
-                        rec = &pg->records[i];
-                        if (rec->flags & FTRACE_FL_FAILED)
+        return type;
+}
+
+static int ftrace_match(char *str, char *regex, int len, int type)
+{
+        int matched = 0;
+        char *ptr;
+
+        switch (type) {
+        case MATCH_FULL:
+                if (strcmp(str, regex) == 0)
+                        matched = 1;
+                break;
+        case MATCH_FRONT_ONLY:
+                if (strncmp(str, regex, len) == 0)
+                        matched = 1;
+                break;
+        case MATCH_MIDDLE_ONLY:
+                if (strstr(str, regex))
+                        matched = 1;
+                break;
+        case MATCH_END_ONLY:
+                ptr = strstr(str, regex);
+                if (ptr && (ptr[len] == 0))
+                        matched = 1;
+                break;
+        }
+
+        return matched;
+}
+
+static int
+ftrace_match_record(struct dyn_ftrace *rec, char *regex, int len, int type)
+{
+        char str[KSYM_SYMBOL_LEN];
+
+        kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
+        return ftrace_match(str, regex, len, type);
+}
+
+static void ftrace_match_records(char *buff, int len, int enable)
+{
+        unsigned int search_len;
+        struct ftrace_page *pg;
+        struct dyn_ftrace *rec;
+        unsigned long flag;
+        char *search;
+        int type;
+        int not;
+
+        flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
+        type = ftrace_setup_glob(buff, len, &search, &not);
+
+        search_len = strlen(search);
+
+        mutex_lock(&ftrace_lock);
+        do_for_each_ftrace_rec(pg, rec) {
+
+                if (rec->flags & FTRACE_FL_FAILED)
+                        continue;
+
+                if (ftrace_match_record(rec, search, search_len, type)) {
+                        if (not)
+                                rec->flags &= ~flag;
+                        else
+                                rec->flags |= flag;
+                }
+                /*
+                 * Only enable filtering if we have a function that
+                 * is filtered on.
+                 */
+                if (enable && (rec->flags & FTRACE_FL_FILTER))
+                        ftrace_filtered = 1;
+        } while_for_each_ftrace_rec();
+        mutex_unlock(&ftrace_lock);
+}
+
+static int
+ftrace_match_module_record(struct dyn_ftrace *rec, char *mod,
+                           char *regex, int len, int type)
+{
+        char str[KSYM_SYMBOL_LEN];
+        char *modname;
+
+        kallsyms_lookup(rec->ip, NULL, NULL, &modname, str);
+
+        if (!modname || strcmp(modname, mod))
+                return 0;
+
+        /* blank search means to match all funcs in the mod */
+        if (len)
+                return ftrace_match(str, regex, len, type);
+        else
+                return 1;
+}
+
+static void ftrace_match_module_records(char *buff, char *mod, int enable)
+{
+        unsigned search_len = 0;
+        struct ftrace_page *pg;
+        struct dyn_ftrace *rec;
+        int type = MATCH_FULL;
+        char *search = buff;
+        unsigned long flag;
+        int not = 0;
+
+        flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
+
+        /* blank or '*' mean the same */
+        if (strcmp(buff, "*") == 0)
+                buff[0] = 0;
+
+        /* handle the case of 'dont filter this module' */
+        if (strcmp(buff, "!") == 0 || strcmp(buff, "!*") == 0) {
+                buff[0] = 0;
+                not = 1;
+        }
+
+        if (strlen(buff)) {
+                type = ftrace_setup_glob(buff, strlen(buff), &search, &not);
+                search_len = strlen(search);
+        }
+
+        mutex_lock(&ftrace_lock);
+        do_for_each_ftrace_rec(pg, rec) {
+
+                if (rec->flags & FTRACE_FL_FAILED)
+                        continue;
+
+                if (ftrace_match_module_record(rec, mod,
+                                               search, search_len, type)) {
+                        if (not)
+                                rec->flags &= ~flag;
+                        else
+                                rec->flags |= flag;
+                }
+                if (enable && (rec->flags & FTRACE_FL_FILTER))
+                        ftrace_filtered = 1;
+
+        } while_for_each_ftrace_rec();
+        mutex_unlock(&ftrace_lock);
+}
+
+/*
+ * We register the module command as a template to show others how
+ * to register the a command as well.
+ */
+
+static int
+ftrace_mod_callback(char *func, char *cmd, char *param, int enable)
+{
+        char *mod;
+
+        /*
+         * cmd == 'mod' because we only registered this func
+         * for the 'mod' ftrace_func_command.
+         * But if you register one func with multiple commands,
+         * you can tell which command was used by the cmd
+         * parameter.
+         */
+
+        /* we must have a module name */
+        if (!param)
+                return -EINVAL;
+
+        mod = strsep(&param, ":");
+        if (!strlen(mod))
+                return -EINVAL;
+
+        ftrace_match_module_records(func, mod, enable);
+        return 0;
+}
+
+static struct ftrace_func_command ftrace_mod_cmd = {
+        .name                   = "mod",
+        .func                   = ftrace_mod_callback,
+};
+
+static int __init ftrace_mod_cmd_init(void)
+{
+        return register_ftrace_command(&ftrace_mod_cmd);
+}
+device_initcall(ftrace_mod_cmd_init);
+
+static void
+function_trace_probe_call(unsigned long ip, unsigned long parent_ip)
+{
+        struct ftrace_func_probe *entry;
+        struct hlist_head *hhd;
+        struct hlist_node *n;
+        unsigned long key;
+        int resched;
+
+        key = hash_long(ip, FTRACE_HASH_BITS);
+
+        hhd = &ftrace_func_hash[key];
+
+        if (hlist_empty(hhd))
+                return;
+
+        /*
+         * Disable preemption for these calls to prevent a RCU grace
+         * period. This syncs the hash iteration and freeing of items
+         * on the hash. rcu_read_lock is too dangerous here.
+         */
+        resched = ftrace_preempt_disable();
+        hlist_for_each_entry_rcu(entry, n, hhd, node) {
+                if (entry->ip == ip)
+                        entry->ops->func(ip, parent_ip, &entry->data);
+        }
+        ftrace_preempt_enable(resched);
+}
+
+static struct ftrace_ops trace_probe_ops __read_mostly =
+{
+        .func = function_trace_probe_call,
+};
+
+static int ftrace_probe_registered;
+
+static void __enable_ftrace_function_probe(void)
+{
+        int i;
+
+        if (ftrace_probe_registered)
+                return;
+
+        for (i = 0; i < FTRACE_FUNC_HASHSIZE; i++) {
+                struct hlist_head *hhd = &ftrace_func_hash[i];
+                if (hhd->first)
+                        break;
+        }
+        /* Nothing registered? */
+        if (i == FTRACE_FUNC_HASHSIZE)
+                return;
+
+        __register_ftrace_function(&trace_probe_ops);
+        ftrace_startup(0);
+        ftrace_probe_registered = 1;
+}
+
+static void __disable_ftrace_function_probe(void)
+{
+        int i;
+
+        if (!ftrace_probe_registered)
+                return;
+
+        for (i = 0; i < FTRACE_FUNC_HASHSIZE; i++) {
+                struct hlist_head *hhd = &ftrace_func_hash[i];
+                if (hhd->first)
+                        return;
+        }
+
+        /* no more funcs left */
+        __unregister_ftrace_function(&trace_probe_ops);
+        ftrace_shutdown(0);
+        ftrace_probe_registered = 0;
+}
+
+
+static void ftrace_free_entry_rcu(struct rcu_head *rhp)
+{
+        struct ftrace_func_probe *entry =
+                container_of(rhp, struct ftrace_func_probe, rcu);
+
+        if (entry->ops->free)
+                entry->ops->free(&entry->data);
+        kfree(entry);
+}
+
+
+int
+register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
+                              void *data)
+{
+        struct ftrace_func_probe *entry;
+        struct ftrace_page *pg;
+        struct dyn_ftrace *rec;
+        int type, len, not;
+        unsigned long key;
+        int count = 0;
+        char *search;
+
+        type = ftrace_setup_glob(glob, strlen(glob), &search, &not);
+        len = strlen(search);
+
+        /* we do not support '!' for function probes */
+        if (WARN_ON(not))
+                return -EINVAL;
+
+        mutex_lock(&ftrace_lock);
+        do_for_each_ftrace_rec(pg, rec) {
+
+                if (rec->flags & FTRACE_FL_FAILED)
+                        continue;
+
+                if (!ftrace_match_record(rec, search, len, type))
+                        continue;
+
+                entry = kmalloc(sizeof(*entry), GFP_KERNEL);
+                if (!entry) {
+                        /* If we did not process any, then return error */
+                        if (!count)
+                                count = -ENOMEM;
+                        goto out_unlock;
+                }
+
+                count++;
+
+                entry->data = data;
+
+                /*
+                 * The caller might want to do something special
+                 * for each function we find. We call the callback
+                 * to give the caller an opportunity to do so.
+                 */
+                if (ops->callback) {
+                        if (ops->callback(rec->ip, &entry->data) < 0) {
+                                /* caller does not like this func */
+                                kfree(entry);
                                 continue;
-                        kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
-                        switch (type) {
-                        case MATCH_FULL:
-                                if (strcmp(str, buff) == 0)
-                                        matched = 1;
-                                break;
-                        case MATCH_FRONT_ONLY:
-                                if (memcmp(str, buff, match) == 0)
-                                        matched = 1;
-                                break;
-                        case MATCH_MIDDLE_ONLY:
-                                if (strstr(str, search))
-                                        matched = 1;
-                                break;
-                        case MATCH_END_ONLY:
-                                ptr = strstr(str, search);
-                                if (ptr && (ptr[search_len] == 0))
-                                        matched = 1;
-                                break;
                         }
-                        if (matched) {
-                                if (not)
-                                        rec->flags &= ~flag;
-                                else
-                                        rec->flags |= flag;
+                }
+
+                entry->ops = ops;
+                entry->ip = rec->ip;
+
+                key = hash_long(entry->ip, FTRACE_HASH_BITS);
+                hlist_add_head_rcu(&entry->node, &ftrace_func_hash[key]);
+
+        } while_for_each_ftrace_rec();
+        __enable_ftrace_function_probe();
+
+ out_unlock:
+        mutex_unlock(&ftrace_lock);
+
+        return count;
+}
+
+enum {
+        PROBE_TEST_FUNC         = 1,
+        PROBE_TEST_DATA         = 2
+};
+
+static void
+__unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
+                                  void *data, int flags)
+{
+        struct ftrace_func_probe *entry;
+        struct hlist_node *n, *tmp;
+        char str[KSYM_SYMBOL_LEN];
+        int type = MATCH_FULL;
+        int i, len = 0;
+        char *search;
+
+        if (glob && (strcmp(glob, "*") || !strlen(glob)))
+                glob = NULL;
+        else {
+                int not;
+
+                type = ftrace_setup_glob(glob, strlen(glob), &search, &not);
+                len = strlen(search);
+
+                /* we do not support '!' for function probes */
+                if (WARN_ON(not))
+                        return;
+        }
+
+        mutex_lock(&ftrace_lock);
+        for (i = 0; i < FTRACE_FUNC_HASHSIZE; i++) {
+                struct hlist_head *hhd = &ftrace_func_hash[i];
+
+                hlist_for_each_entry_safe(entry, n, tmp, hhd, node) {
+
+                        /* break up if statements for readability */
+                        if ((flags & PROBE_TEST_FUNC) && entry->ops != ops)
+                                continue;
+
+                        if ((flags & PROBE_TEST_DATA) && entry->data != data)
+                                continue;
+
+                        /* do this last, since it is the most expensive */
+                        if (glob) {
+                                kallsyms_lookup(entry->ip, NULL, NULL,
+                                                NULL, str);
+                                if (!ftrace_match(str, glob, len, type))
+                                        continue;
                         }
+
+                        hlist_del(&entry->node);
+                        call_rcu(&entry->rcu, ftrace_free_entry_rcu);
+                }
+        }
+        __disable_ftrace_function_probe();
+        mutex_unlock(&ftrace_lock);
+}
+
+void
+unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
+                                void *data)
+{
+        __unregister_ftrace_function_probe(glob, ops, data,
+                                          PROBE_TEST_FUNC | PROBE_TEST_DATA);
+}
+
+void
+unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops)
+{
+        __unregister_ftrace_function_probe(glob, ops, NULL, PROBE_TEST_FUNC);
+}
+
+void unregister_ftrace_function_probe_all(char *glob)
+{
+        __unregister_ftrace_function_probe(glob, NULL, NULL, 0);
+}
+
+static LIST_HEAD(ftrace_commands);
+static DEFINE_MUTEX(ftrace_cmd_mutex);
+
+int register_ftrace_command(struct ftrace_func_command *cmd)
+{
+        struct ftrace_func_command *p;
+        int ret = 0;
+
+        mutex_lock(&ftrace_cmd_mutex);
+        list_for_each_entry(p, &ftrace_commands, list) {
+                if (strcmp(cmd->name, p->name) == 0) {
+                        ret = -EBUSY;
+                        goto out_unlock;
                 }
-                pg = pg->next;
         }
-        spin_unlock(&ftrace_lock);
+        list_add(&cmd->list, &ftrace_commands);
+ out_unlock:
+        mutex_unlock(&ftrace_cmd_mutex);
+
+        return ret;
+}
+
+int unregister_ftrace_command(struct ftrace_func_command *cmd)
+{
+        struct ftrace_func_command *p, *n;
+        int ret = -ENODEV;
+
+        mutex_lock(&ftrace_cmd_mutex);
+        list_for_each_entry_safe(p, n, &ftrace_commands, list) {
+                if (strcmp(cmd->name, p->name) == 0) {
+                        ret = 0;
+                        list_del_init(&p->list);
+                        goto out_unlock;
+                }
+        }
+ out_unlock:
+        mutex_unlock(&ftrace_cmd_mutex);
+
+        return ret;
+}
+
+static int ftrace_process_regex(char *buff, int len, int enable)
+{
+        char *func, *command, *next = buff;
+        struct ftrace_func_command *p;
+        int ret = -EINVAL;
+
+        func = strsep(&next, ":");
+
+        if (!next) {
+                ftrace_match_records(func, len, enable);
+                return 0;
+        }
+
+        /* command found */
+
+        command = strsep(&next, ":");
+
+        mutex_lock(&ftrace_cmd_mutex);
+        list_for_each_entry(p, &ftrace_commands, list) {
+                if (strcmp(p->name, command) == 0) {
+                        ret = p->func(func, command, next, enable);
+                        goto out_unlock;
+                }
+        }
+ out_unlock:
+        mutex_unlock(&ftrace_cmd_mutex);
+
+        return ret;
 }
 
 static ssize_t
@@ -1187,7 +1741,10 @@ ftrace_regex_write(struct file *file, const char __user *ubuf,
         if (isspace(ch)) {
                 iter->filtered++;
                 iter->buffer[iter->buffer_idx] = 0;
-                ftrace_match(iter->buffer, iter->buffer_idx, enable);
+                ret = ftrace_process_regex(iter->buffer,
+                                           iter->buffer_idx, enable);
+                if (ret)
+                        goto out;
                 iter->buffer_idx = 0;
         } else
                 iter->flags |= FTRACE_ITER_CONT;
@@ -1226,7 +1783,7 @@ ftrace_set_regex(unsigned char *buf, int len, int reset, int enable)
         if (reset)
                 ftrace_filter_reset(enable);
         if (buf)
-                ftrace_match(buf, len, enable);
+                ftrace_match_records(buf, len, enable);
         mutex_unlock(&ftrace_regex_lock);
 }
 
@@ -1276,15 +1833,13 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
         if (iter->buffer_idx) {
                 iter->filtered++;
                 iter->buffer[iter->buffer_idx] = 0;
-                ftrace_match(iter->buffer, iter->buffer_idx, enable);
+                ftrace_match_records(iter->buffer, iter->buffer_idx, enable);
         }
 
-        mutex_lock(&ftrace_sysctl_lock);
-        mutex_lock(&ftrace_start_lock);
+        mutex_lock(&ftrace_lock);
         if (ftrace_start_up && ftrace_enabled)
                 ftrace_run_update_code(FTRACE_ENABLE_CALLS);
-        mutex_unlock(&ftrace_start_lock);
-        mutex_unlock(&ftrace_sysctl_lock);
+        mutex_unlock(&ftrace_lock);
 
         kfree(iter);
         mutex_unlock(&ftrace_regex_lock);
@@ -1303,31 +1858,31 @@ ftrace_notrace_release(struct inode *inode, struct file *file)
         return ftrace_regex_release(inode, file, 0);
 }
 
-static struct file_operations ftrace_avail_fops = {
+static const struct file_operations ftrace_avail_fops = {
         .open = ftrace_avail_open,
         .read = seq_read,
         .llseek = seq_lseek,
         .release = ftrace_avail_release,
 };
 
-static struct file_operations ftrace_failures_fops = {
+static const struct file_operations ftrace_failures_fops = {
         .open = ftrace_failures_open,
         .read = seq_read,
         .llseek = seq_lseek,
         .release = ftrace_avail_release,
 };
 
-static struct file_operations ftrace_filter_fops = {
+static const struct file_operations ftrace_filter_fops = {
         .open = ftrace_filter_open,
-        .read = ftrace_regex_read,
+        .read = seq_read,
         .write = ftrace_filter_write,
         .llseek = ftrace_regex_lseek,
         .release = ftrace_filter_release,
 };
 
-static struct file_operations ftrace_notrace_fops = {
+static const struct file_operations ftrace_notrace_fops = {
         .open = ftrace_notrace_open,
-        .read = ftrace_regex_read,
+        .read = seq_read,
         .write = ftrace_notrace_write,
         .llseek = ftrace_regex_lseek,
         .release = ftrace_notrace_release,
@@ -1360,6 +1915,10 @@ static void *g_start(struct seq_file *m, loff_t *pos)
 
         mutex_lock(&graph_lock);
 
+        /* Nothing, tell g_show to print all functions are enabled */
+        if (!ftrace_graph_count && !*pos)
+                return (void *)1;
+
         p = g_next(m, p, pos);
 
         return p;
@@ -1378,6 +1937,11 @@ static int g_show(struct seq_file *m, void *v)
         if (!ptr)
                 return 0;
 
+        if (ptr == (unsigned long *)1) {
+                seq_printf(m, "#### all functions enabled ####\n");
+                return 0;
+        }
+
         kallsyms_lookup(*ptr, NULL, NULL, NULL, str);
 
         seq_printf(m, "%s\n", str);
@@ -1420,53 +1984,53 @@ ftrace_graph_open(struct inode *inode, struct file *file)
         return ret;
 }
 
-static ssize_t
-ftrace_graph_read(struct file *file, char __user *ubuf,
-                       size_t cnt, loff_t *ppos)
-{
-        if (file->f_mode & FMODE_READ)
-                return seq_read(file, ubuf, cnt, ppos);
-        else
-                return -EPERM;
-}
-
 static int
-ftrace_set_func(unsigned long *array, int idx, char *buffer)
+ftrace_set_func(unsigned long *array, int *idx, char *buffer)
 {
-        char str[KSYM_SYMBOL_LEN];
         struct dyn_ftrace *rec;
         struct ftrace_page *pg;
+        int search_len;
         int found = 0;
-        int i, j;
+        int type, not;
+        char *search;
+        bool exists;
+        int i;
 
         if (ftrace_disabled)
                 return -ENODEV;
 
-        /* should not be called from interrupt context */
-        spin_lock(&ftrace_lock);
+        /* decode regex */
+        type = ftrace_setup_glob(buffer, strlen(buffer), &search, &not);
+        if (not)
+                return -EINVAL;
 
-        for (pg = ftrace_pages_start; pg; pg = pg->next) {
-                for (i = 0; i < pg->index; i++) {
-                        rec = &pg->records[i];
+        search_len = strlen(search);
 
-                        if (rec->flags & (FTRACE_FL_FAILED | FTRACE_FL_FREE))
-                                continue;
+        mutex_lock(&ftrace_lock);
+        do_for_each_ftrace_rec(pg, rec) {
+
+                if (*idx >= FTRACE_GRAPH_MAX_FUNCS)
+                        break;
 
-                        kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
-                        if (strcmp(str, buffer) == 0) {
+                if (rec->flags & (FTRACE_FL_FAILED | FTRACE_FL_FREE))
+                        continue;
+
+                if (ftrace_match_record(rec, search, search_len, type)) {
+                        /* ensure it is not already in the array */
+                        exists = false;
+                        for (i = 0; i < *idx; i++)
+                                if (array[i] == rec->ip) {
+                                        exists = true;
+                                        break;
+                                }
+                        if (!exists) {
+                                array[(*idx)++] = rec->ip;
                                 found = 1;
-                                for (j = 0; j < idx; j++)
-                                        if (array[j] == rec->ip) {
-                                                found = 0;
-                                                break;
-                                        }
-                                if (found)
-                                        array[idx] = rec->ip;
-                                break;
                         }
                 }
-        }
-        spin_unlock(&ftrace_lock);
+        } while_for_each_ftrace_rec();
+
+        mutex_unlock(&ftrace_lock);
 
         return found ? 0 : -EINVAL;
 }
@@ -1534,13 +2098,11 @@ ftrace_graph_write(struct file *file, const char __user *ubuf,
         }
         buffer[index] = 0;
 
-        /* we allow only one at a time */
-        ret = ftrace_set_func(array, ftrace_graph_count, buffer);
+        /* we allow only one expression at a time */
+        ret = ftrace_set_func(array, &ftrace_graph_count, buffer);
         if (ret)
                 goto out;
 
-        ftrace_graph_count++;
-
         file->f_pos += read;
 
         ret = read;
@@ -1552,7 +2114,7 @@ ftrace_graph_write(struct file *file, const char __user *ubuf,
 
 static const struct file_operations ftrace_graph_fops = {
         .open = ftrace_graph_open,
-        .read = ftrace_graph_read,
+        .read = seq_read,
         .write = ftrace_graph_write,
 };
 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
@@ -1604,7 +2166,7 @@ static int ftrace_convert_nops(struct module *mod,
         unsigned long addr;
         unsigned long flags;
 
-        mutex_lock(&ftrace_start_lock);
+        mutex_lock(&ftrace_lock);
         p = start;
         while (p < end) {
                 addr = ftrace_call_adjust(*p++);
@@ -1623,7 +2185,7 @@ static int ftrace_convert_nops(struct module *mod,
         local_irq_save(flags);
         ftrace_update_code(mod);
         local_irq_restore(flags);
-        mutex_unlock(&ftrace_start_lock);
+        mutex_unlock(&ftrace_lock);
 
         return 0;
 }
@@ -1796,7 +2358,7 @@ ftrace_pid_write(struct file *filp, const char __user *ubuf,
         if (ret < 0)
                 return ret;
 
-        mutex_lock(&ftrace_start_lock);
+        mutex_lock(&ftrace_lock);
         if (val < 0) {
                 /* disable pid tracing */
                 if (!ftrace_pid_trace)
@@ -1835,12 +2397,12 @@ ftrace_pid_write(struct file *filp, const char __user *ubuf,
         ftrace_startup_enable(0);
 
  out:
-        mutex_unlock(&ftrace_start_lock);
+        mutex_unlock(&ftrace_lock);
 
         return cnt;
 }
 
-static struct file_operations ftrace_pid_fops = {
+static const struct file_operations ftrace_pid_fops = {
         .read = ftrace_pid_read,
         .write = ftrace_pid_write,
 };
@@ -1863,7 +2425,6 @@ static __init int ftrace_init_debugfs(void)
                            "'set_ftrace_pid' entry\n");
         return 0;
 }
-
 fs_initcall(ftrace_init_debugfs);
 
 /**
@@ -1898,17 +2459,17 @@ int register_ftrace_function(struct ftrace_ops *ops)
         if (unlikely(ftrace_disabled))
                 return -1;
 
-        mutex_lock(&ftrace_sysctl_lock);
+        mutex_lock(&ftrace_lock);
 
         ret = __register_ftrace_function(ops);
         ftrace_startup(0);
 
-        mutex_unlock(&ftrace_sysctl_lock);
+        mutex_unlock(&ftrace_lock);
         return ret;
 }
 
 /**
- * unregister_ftrace_function - unresgister a function for profiling.
+ * unregister_ftrace_function - unregister a function for profiling.
  * @ops - ops structure that holds the function to unregister
  *
  * Unregister a function that was added to be called by ftrace profiling.
@@ -1917,10 +2478,10 @@ int unregister_ftrace_function(struct ftrace_ops *ops)
 {
         int ret;
 
-        mutex_lock(&ftrace_sysctl_lock);
+        mutex_lock(&ftrace_lock);
         ret = __unregister_ftrace_function(ops);
         ftrace_shutdown(0);
-        mutex_unlock(&ftrace_sysctl_lock);
+        mutex_unlock(&ftrace_lock);
 
         return ret;
 }
@@ -1935,7 +2496,7 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
         if (unlikely(ftrace_disabled))
                 return -ENODEV;
 
-        mutex_lock(&ftrace_sysctl_lock);
+        mutex_lock(&ftrace_lock);
 
         ret  = proc_dointvec(table, write, file, buffer, lenp, ppos);
 
@@ -1964,7 +2525,7 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
         }
 
  out:
-        mutex_unlock(&ftrace_sysctl_lock);
+        mutex_unlock(&ftrace_lock);
         return ret;
 }
 
@@ -2080,7 +2641,7 @@ int register_ftrace_graph(trace_func_graph_ret_t retfunc,
 {
         int ret = 0;
 
-        mutex_lock(&ftrace_sysctl_lock);
+        mutex_lock(&ftrace_lock);
 
         ftrace_suspend_notifier.notifier_call = ftrace_suspend_notifier_call;
         register_pm_notifier(&ftrace_suspend_notifier);
@@ -2098,13 +2659,13 @@ int register_ftrace_graph(trace_func_graph_ret_t retfunc,
         ftrace_startup(FTRACE_START_FUNC_RET);
 
 out:
-        mutex_unlock(&ftrace_sysctl_lock);
+        mutex_unlock(&ftrace_lock);
         return ret;
 }
 
 void unregister_ftrace_graph(void)
 {
-        mutex_lock(&ftrace_sysctl_lock);
+        mutex_lock(&ftrace_lock);
 
         atomic_dec(&ftrace_graph_active);
         ftrace_graph_return = (trace_func_graph_ret_t)ftrace_stub;
@@ -2112,7 +2673,7 @@ void unregister_ftrace_graph(void)
         ftrace_shutdown(FTRACE_STOP_FUNC_RET);
         unregister_pm_notifier(&ftrace_suspend_notifier);
 
-        mutex_unlock(&ftrace_sysctl_lock);
+        mutex_unlock(&ftrace_lock);
 }
 
 /* Allocate a return stack for newly created task */
diff --git a/kernel/trace/kmemtrace.c b/kernel/trace/kmemtrace.c
new file mode 100644
index 000000000000..ae201b3eda89
--- /dev/null
+++ b/kernel/trace/kmemtrace.c
@@ -0,0 +1,339 @@
+/*
+ * Memory allocator tracing
+ *
+ * Copyright (C) 2008 Eduard - Gabriel Munteanu
+ * Copyright (C) 2008 Pekka Enberg <penberg@cs.helsinki.fi>
+ * Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>
+ */
+
+#include <linux/dcache.h>
+#include <linux/debugfs.h>
+#include <linux/fs.h>
+#include <linux/seq_file.h>
+#include <trace/kmemtrace.h>
+
+#include "trace.h"
+#include "trace_output.h"
+
+/* Select an alternative, minimalistic output than the original one */
+#define TRACE_KMEM_OPT_MINIMAL  0x1
+
+static struct tracer_opt kmem_opts[] = {
+        /* Default disable the minimalistic output */
+        { TRACER_OPT(kmem_minimalistic, TRACE_KMEM_OPT_MINIMAL) },
+        { }
+};
+
+static struct tracer_flags kmem_tracer_flags = {
+        .val = 0,
+        .opts = kmem_opts
+};
+
+
+static bool kmem_tracing_enabled __read_mostly;
+static struct trace_array *kmemtrace_array;
+
+static int kmem_trace_init(struct trace_array *tr)
+{
+        int cpu;
+        kmemtrace_array = tr;
+
+        for_each_cpu_mask(cpu, cpu_possible_map)
+                tracing_reset(tr, cpu);
+
+        kmem_tracing_enabled = true;
+
+        return 0;
+}
+
+static void kmem_trace_reset(struct trace_array *tr)
+{
+        kmem_tracing_enabled = false;
+}
+
+static void kmemtrace_headers(struct seq_file *s)
+{
+        /* Don't need headers for the original kmemtrace output */
+        if (!(kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL))
+                return;
+
+        seq_printf(s, "#\n");
+        seq_printf(s, "# ALLOC  TYPE  REQ   GIVEN  FLAGS     "
+                        "      POINTER         NODE    CALLER\n");
+        seq_printf(s, "# FREE   |      |     |       |       "
+                        "       |   |            |        |\n");
+        seq_printf(s, "# |\n\n");
+}
+
+/*
+ * The two following functions give the original output from kmemtrace,
+ * or something close to....perhaps they need some missing things
+ */
+static enum print_line_t
+kmemtrace_print_alloc_original(struct trace_iterator *iter,
+                                struct kmemtrace_alloc_entry *entry)
+{
+        struct trace_seq *s = &iter->seq;
+        int ret;
+
+        /* Taken from the old linux/kmemtrace.h */
+        ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu "
+          "bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",
+           entry->type_id, entry->call_site, (unsigned long) entry->ptr,
+           (unsigned long) entry->bytes_req, (unsigned long) entry->bytes_alloc,
+           (unsigned long) entry->gfp_flags, entry->node);
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t
+kmemtrace_print_free_original(struct trace_iterator *iter,
+                                struct kmemtrace_free_entry *entry)
+{
+        struct trace_seq *s = &iter->seq;
+        int ret;
+
+        /* Taken from the old linux/kmemtrace.h */
+        ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu\n",
+           entry->type_id, entry->call_site, (unsigned long) entry->ptr);
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+
+/* The two other following provide a more minimalistic output */
+static enum print_line_t
+kmemtrace_print_alloc_compress(struct trace_iterator *iter,
+                                        struct kmemtrace_alloc_entry *entry)
+{
+        struct trace_seq *s = &iter->seq;
+        int ret;
+
+        /* Alloc entry */
+        ret = trace_seq_printf(s, "  +      ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Type */
+        switch (entry->type_id) {
+        case KMEMTRACE_TYPE_KMALLOC:
+                ret = trace_seq_printf(s, "K   ");
+                break;
+        case KMEMTRACE_TYPE_CACHE:
+                ret = trace_seq_printf(s, "C   ");
+                break;
+        case KMEMTRACE_TYPE_PAGES:
+                ret = trace_seq_printf(s, "P   ");
+                break;
+        default:
+                ret = trace_seq_printf(s, "?   ");
+        }
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Requested */
+        ret = trace_seq_printf(s, "%4zu   ", entry->bytes_req);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Allocated */
+        ret = trace_seq_printf(s, "%4zu   ", entry->bytes_alloc);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Flags
+         * TODO: would be better to see the name of the GFP flag names
+         */
+        ret = trace_seq_printf(s, "%08x   ", entry->gfp_flags);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Pointer to allocated */
+        ret = trace_seq_printf(s, "0x%tx   ", (ptrdiff_t)entry->ptr);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Node */
+        ret = trace_seq_printf(s, "%4d   ", entry->node);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Call site */
+        ret = seq_print_ip_sym(s, entry->call_site, 0);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        if (!trace_seq_printf(s, "\n"))
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t
+kmemtrace_print_free_compress(struct trace_iterator *iter,
+                                struct kmemtrace_free_entry *entry)
+{
+        struct trace_seq *s = &iter->seq;
+        int ret;
+
+        /* Free entry */
+        ret = trace_seq_printf(s, "  -      ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Type */
+        switch (entry->type_id) {
+        case KMEMTRACE_TYPE_KMALLOC:
+                ret = trace_seq_printf(s, "K     ");
+                break;
+        case KMEMTRACE_TYPE_CACHE:
+                ret = trace_seq_printf(s, "C     ");
+                break;
+        case KMEMTRACE_TYPE_PAGES:
+                ret = trace_seq_printf(s, "P     ");
+                break;
+        default:
+                ret = trace_seq_printf(s, "?     ");
+        }
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Skip requested/allocated/flags */
+        ret = trace_seq_printf(s, "                       ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Pointer to allocated */
+        ret = trace_seq_printf(s, "0x%tx   ", (ptrdiff_t)entry->ptr);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Skip node */
+        ret = trace_seq_printf(s, "       ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Call site */
+        ret = seq_print_ip_sym(s, entry->call_site, 0);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        if (!trace_seq_printf(s, "\n"))
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
+{
+        struct trace_entry *entry = iter->ent;
+
+        switch (entry->type) {
+        case TRACE_KMEM_ALLOC: {
+                struct kmemtrace_alloc_entry *field;
+                trace_assign_type(field, entry);
+                if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
+                        return kmemtrace_print_alloc_compress(iter, field);
+                else
+                        return kmemtrace_print_alloc_original(iter, field);
+        }
+
+        case TRACE_KMEM_FREE: {
+                struct kmemtrace_free_entry *field;
+                trace_assign_type(field, entry);
+                if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
+                        return kmemtrace_print_free_compress(iter, field);
+                else
+                        return kmemtrace_print_free_original(iter, field);
+        }
+
+        default:
+                return TRACE_TYPE_UNHANDLED;
+        }
+}
+
+/* Trace allocations */
+void kmemtrace_mark_alloc_node(enum kmemtrace_type_id type_id,
+                             unsigned long call_site,
+                             const void *ptr,
+                             size_t bytes_req,
+                             size_t bytes_alloc,
+                             gfp_t gfp_flags,
+                             int node)
+{
+        struct ring_buffer_event *event;
+        struct kmemtrace_alloc_entry *entry;
+        struct trace_array *tr = kmemtrace_array;
+
+        if (!kmem_tracing_enabled)
+                return;
+
+        event = trace_buffer_lock_reserve(tr, TRACE_KMEM_ALLOC,
+                                          sizeof(*entry), 0, 0);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+
+        entry->call_site = call_site;
+        entry->ptr = ptr;
+        entry->bytes_req = bytes_req;
+        entry->bytes_alloc = bytes_alloc;
+        entry->gfp_flags = gfp_flags;
+        entry->node     =       node;
+
+        trace_buffer_unlock_commit(tr, event, 0, 0);
+}
+EXPORT_SYMBOL(kmemtrace_mark_alloc_node);
+
+void kmemtrace_mark_free(enum kmemtrace_type_id type_id,
+                       unsigned long call_site,
+                       const void *ptr)
+{
+        struct ring_buffer_event *event;
+        struct kmemtrace_free_entry *entry;
+        struct trace_array *tr = kmemtrace_array;
+
+        if (!kmem_tracing_enabled)
+                return;
+
+        event = trace_buffer_lock_reserve(tr, TRACE_KMEM_FREE,
+                                          sizeof(*entry), 0, 0);
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        entry->type_id  = type_id;
+        entry->call_site = call_site;
+        entry->ptr = ptr;
+
+        trace_buffer_unlock_commit(tr, event, 0, 0);
+}
+EXPORT_SYMBOL(kmemtrace_mark_free);
+
+static struct tracer kmem_tracer __read_mostly = {
+        .name           = "kmemtrace",
+        .init           = kmem_trace_init,
+        .reset          = kmem_trace_reset,
+        .print_line     = kmemtrace_print_line,
+        .print_header = kmemtrace_headers,
+        .flags          = &kmem_tracer_flags
+};
+
+void kmemtrace_init(void)
+{
+        /* earliest opportunity to start kmem tracing */
+}
+
+static int __init init_kmem_tracer(void)
+{
+        return register_tracer(&kmem_tracer);
+}
+
+device_initcall(init_kmem_tracer);
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index bd38c5cfd8ad..58128ad2fde0 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -4,21 +4,92 @@
  * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
  */
 #include <linux/ring_buffer.h>
+#include <linux/trace_clock.h>
+#include <linux/ftrace_irq.h>
 #include <linux/spinlock.h>
 #include <linux/debugfs.h>
 #include <linux/uaccess.h>
+#include <linux/hardirq.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/cpu.h>
 #include <linux/fs.h>
 
 #include "trace.h"
 
 /*
+ * The ring buffer is made up of a list of pages. A separate list of pages is
+ * allocated for each CPU. A writer may only write to a buffer that is
+ * associated with the CPU it is currently executing on.  A reader may read
+ * from any per cpu buffer.
+ *
+ * The reader is special. For each per cpu buffer, the reader has its own
+ * reader page. When a reader has read the entire reader page, this reader
+ * page is swapped with another page in the ring buffer.
+ *
+ * Now, as long as the writer is off the reader page, the reader can do what
+ * ever it wants with that page. The writer will never write to that page
+ * again (as long as it is out of the ring buffer).
+ *
+ * Here's some silly ASCII art.
+ *
+ *   +------+
+ *   |reader|          RING BUFFER
+ *   |page  |
+ *   +------+        +---+   +---+   +---+
+ *                   |   |-->|   |-->|   |
+ *                   +---+   +---+   +---+
+ *                     ^               |
+ *                     |               |
+ *                     +---------------+
+ *
+ *
+ *   +------+
+ *   |reader|          RING BUFFER
+ *   |page  |------------------v
+ *   +------+        +---+   +---+   +---+
+ *                   |   |-->|   |-->|   |
+ *                   +---+   +---+   +---+
+ *                     ^               |
+ *                     |               |
+ *                     +---------------+
+ *
+ *
+ *   +------+
+ *   |reader|          RING BUFFER
+ *   |page  |------------------v
+ *   +------+        +---+   +---+   +---+
+ *      ^            |   |-->|   |-->|   |
+ *      |            +---+   +---+   +---+
+ *      |                              |
+ *      |                              |
+ *      +------------------------------+
+ *
+ *
+ *   +------+
+ *   |buffer|          RING BUFFER
+ *   |page  |------------------v
+ *   +------+        +---+   +---+   +---+
+ *      ^            |   |   |   |-->|   |
+ *      |   New      +---+   +---+   +---+
+ *      |  Reader------^               |
+ *      |   page                       |
+ *      +------------------------------+
+ *
+ *
+ * After we make this swap, the reader can hand this page off to the splice
+ * code and be done with it. It can even allocate a new page if it needs to
+ * and swap that into the ring buffer.
+ *
+ * We will be using cmpxchg soon to make all this lockless.
+ *
+ */
+
+/*
  * A fast way to enable or disable all ring buffers is to
  * call tracing_on or tracing_off. Turning off the ring buffers
  * prevents all ring buffers from being recorded to.
@@ -57,7 +128,9 @@ enum {
         RB_BUFFERS_DISABLED     = 1 << RB_BUFFERS_DISABLED_BIT,
 };
 
-static long ring_buffer_flags __read_mostly = RB_BUFFERS_ON;
+static unsigned long ring_buffer_flags __read_mostly = RB_BUFFERS_ON;
+
+#define BUF_PAGE_HDR_SIZE offsetof(struct buffer_data_page, data)
 
 /**
  * tracing_on - enable all tracing buffers
@@ -89,26 +162,34 @@ EXPORT_SYMBOL_GPL(tracing_off);
  * tracing_off_permanent - permanently disable ring buffers
  *
  * This function, once called, will disable all ring buffers
- * permanenty.
+ * permanently.
  */
 void tracing_off_permanent(void)
 {
         set_bit(RB_BUFFERS_DISABLED_BIT, &ring_buffer_flags);
 }
 
+/**
+ * tracing_is_on - show state of ring buffers enabled
+ */
+int tracing_is_on(void)
+{
+        return ring_buffer_flags == RB_BUFFERS_ON;
+}
+EXPORT_SYMBOL_GPL(tracing_is_on);
+
 #include "trace.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)
 {
         u64 time;
 
         preempt_disable_notrace();
         /* shift to debug/test normalization and TIME_EXTENTS */
-        time = sched_clock() << DEBUG_SHIFT;
+        time = trace_clock_local() << DEBUG_SHIFT;
         preempt_enable_no_resched_notrace();
 
         return time;
@@ -122,9 +203,8 @@ void ring_buffer_normalize_time_stamp(int cpu, u64 *ts)
 }
 EXPORT_SYMBOL_GPL(ring_buffer_normalize_time_stamp);
 
-#define RB_EVNT_HDR_SIZE (sizeof(struct ring_buffer_event))
-#define RB_ALIGNMENT_SHIFT      2
-#define RB_ALIGNMENT            (1 << RB_ALIGNMENT_SHIFT)
+#define RB_EVNT_HDR_SIZE (offsetof(struct ring_buffer_event, array))
+#define RB_ALIGNMENT            4U
 #define RB_MAX_SMALL_DATA       28
 
 enum {
@@ -133,7 +213,7 @@ enum {
 };
 
 /* inline for ring buffer fast paths */
-static inline unsigned
+static unsigned
 rb_event_length(struct ring_buffer_event *event)
 {
         unsigned length;
@@ -151,7 +231,7 @@ rb_event_length(struct ring_buffer_event *event)
 
         case RINGBUF_TYPE_DATA:
                 if (event->len)
-                        length = event->len << RB_ALIGNMENT_SHIFT;
+                        length = event->len * RB_ALIGNMENT;
                 else
                         length = event->array[0];
                 return length + RB_EVNT_HDR_SIZE;
@@ -179,7 +259,7 @@ unsigned ring_buffer_event_length(struct ring_buffer_event *event)
 EXPORT_SYMBOL_GPL(ring_buffer_event_length);
 
 /* inline for ring buffer fast paths */
-static inline void *
+static void *
 rb_event_data(struct ring_buffer_event *event)
 {
         BUG_ON(event->type != RINGBUF_TYPE_DATA);
@@ -209,7 +289,7 @@ EXPORT_SYMBOL_GPL(ring_buffer_event_data);
 
 struct buffer_data_page {
         u64              time_stamp;    /* page time stamp */
-        local_t          commit;        /* write commited index */
+        local_t          commit;        /* write committed index */
         unsigned char    data[];        /* data of buffer page */
 };
 
@@ -225,14 +305,25 @@ static void rb_init_page(struct buffer_data_page *bpage)
         local_set(&bpage->commit, 0);
 }
 
+/**
+ * ring_buffer_page_len - the size of data on the page.
+ * @page: The page to read
+ *
+ * Returns the amount of data on the page, including buffer page header.
+ */
+size_t ring_buffer_page_len(void *page)
+{
+        return local_read(&((struct buffer_data_page *)page)->commit)
+                + BUF_PAGE_HDR_SIZE;
+}
+
 /*
  * 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)
+static void free_buffer_page(struct buffer_page *bpage)
 {
-        if (bpage->page)
-                free_page((unsigned long)bpage->page);
+        free_page((unsigned long)bpage->page);
         kfree(bpage);
 }
 
@@ -246,7 +337,7 @@ static inline int test_time_stamp(u64 delta)
         return 0;
 }
 
-#define BUF_PAGE_SIZE (PAGE_SIZE - offsetof(struct buffer_data_page, data))
+#define BUF_PAGE_SIZE (PAGE_SIZE - BUF_PAGE_HDR_SIZE)
 
 /*
  * head_page == tail_page && head == tail then buffer is empty.
@@ -260,7 +351,7 @@ struct ring_buffer_per_cpu {
         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              *commit_page;   /* committed pages */
         struct buffer_page              *reader_page;
         unsigned long                   overrun;
         unsigned long                   entries;
@@ -273,12 +364,16 @@ struct ring_buffer {
         unsigned                        pages;
         unsigned                        flags;
         int                             cpus;
-        cpumask_var_t                   cpumask;
         atomic_t                        record_disabled;
+        cpumask_var_t                   cpumask;
 
         struct mutex                    mutex;
 
         struct ring_buffer_per_cpu      **buffers;
+
+#ifdef CONFIG_HOTPLUG_CPU
+        struct notifier_block           cpu_notify;
+#endif
 };
 
 struct ring_buffer_iter {
@@ -303,7 +398,7 @@ struct ring_buffer_iter {
  * 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
+ * As a safety 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)
@@ -437,6 +532,11 @@ static void rb_free_cpu_buffer(struct ring_buffer_per_cpu *cpu_buffer)
  */
 extern int ring_buffer_page_too_big(void);
 
+#ifdef CONFIG_HOTPLUG_CPU
+static int __cpuinit rb_cpu_notify(struct notifier_block *self,
+                                   unsigned long action, void *hcpu);
+#endif
+
 /**
  * ring_buffer_alloc - allocate a new ring_buffer
  * @size: the size in bytes per cpu that is needed.
@@ -474,7 +574,8 @@ struct ring_buffer *ring_buffer_alloc(unsigned long size, unsigned flags)
         if (buffer->pages == 1)
                 buffer->pages++;
 
-        cpumask_copy(buffer->cpumask, cpu_possible_mask);
+        get_online_cpus();
+        cpumask_copy(buffer->cpumask, cpu_online_mask);
         buffer->cpus = nr_cpu_ids;
 
         bsize = sizeof(void *) * nr_cpu_ids;
@@ -490,6 +591,13 @@ struct ring_buffer *ring_buffer_alloc(unsigned long size, unsigned flags)
                         goto fail_free_buffers;
         }
 
+#ifdef CONFIG_HOTPLUG_CPU
+        buffer->cpu_notify.notifier_call = rb_cpu_notify;
+        buffer->cpu_notify.priority = 0;
+        register_cpu_notifier(&buffer->cpu_notify);
+#endif
+
+        put_online_cpus();
         mutex_init(&buffer->mutex);
 
         return buffer;
@@ -503,6 +611,7 @@ struct ring_buffer *ring_buffer_alloc(unsigned long size, unsigned flags)
 
  fail_free_cpumask:
         free_cpumask_var(buffer->cpumask);
+        put_online_cpus();
 
  fail_free_buffer:
         kfree(buffer);
@@ -519,9 +628,17 @@ ring_buffer_free(struct ring_buffer *buffer)
 {
         int cpu;
 
+        get_online_cpus();
+
+#ifdef CONFIG_HOTPLUG_CPU
+        unregister_cpu_notifier(&buffer->cpu_notify);
+#endif
+
         for_each_buffer_cpu(buffer, cpu)
                 rb_free_cpu_buffer(buffer->buffers[cpu]);
 
+        put_online_cpus();
+
         free_cpumask_var(buffer->cpumask);
 
         kfree(buffer);
@@ -627,16 +744,15 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
                 return size;
 
         mutex_lock(&buffer->mutex);
+        get_online_cpus();
 
         nr_pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
 
         if (size < buffer_size) {
 
                 /* easy case, just free pages */
-                if (RB_WARN_ON(buffer, nr_pages >= buffer->pages)) {
-                        mutex_unlock(&buffer->mutex);
-                        return -1;
-                }
+                if (RB_WARN_ON(buffer, nr_pages >= buffer->pages))
+                        goto out_fail;
 
                 rm_pages = buffer->pages - nr_pages;
 
@@ -655,10 +771,8 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
          * add these pages to the cpu_buffers. Otherwise we just free
          * them all and return -ENOMEM;
          */
-        if (RB_WARN_ON(buffer, nr_pages <= buffer->pages)) {
-                mutex_unlock(&buffer->mutex);
-                return -1;
-        }
+        if (RB_WARN_ON(buffer, nr_pages <= buffer->pages))
+                goto out_fail;
 
         new_pages = nr_pages - buffer->pages;
 
@@ -683,13 +797,12 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
                 rb_insert_pages(cpu_buffer, &pages, new_pages);
         }
 
-        if (RB_WARN_ON(buffer, !list_empty(&pages))) {
-                mutex_unlock(&buffer->mutex);
-                return -1;
-        }
+        if (RB_WARN_ON(buffer, !list_empty(&pages)))
+                goto out_fail;
 
  out:
         buffer->pages = nr_pages;
+        put_online_cpus();
         mutex_unlock(&buffer->mutex);
 
         return size;
@@ -699,8 +812,18 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
                 list_del_init(&bpage->list);
                 free_buffer_page(bpage);
         }
+        put_online_cpus();
         mutex_unlock(&buffer->mutex);
         return -ENOMEM;
+
+        /*
+         * Something went totally wrong, and we are too paranoid
+         * to even clean up the mess.
+         */
+ out_fail:
+        put_online_cpus();
+        mutex_unlock(&buffer->mutex);
+        return -1;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_resize);
 
@@ -811,7 +934,7 @@ rb_event_index(struct ring_buffer_event *event)
         return (addr & ~PAGE_MASK) - (PAGE_SIZE - BUF_PAGE_SIZE);
 }
 
-static inline int
+static int
 rb_is_commit(struct ring_buffer_per_cpu *cpu_buffer,
              struct ring_buffer_event *event)
 {
@@ -825,7 +948,7 @@ rb_is_commit(struct ring_buffer_per_cpu *cpu_buffer,
                 rb_commit_index(cpu_buffer) == index;
 }
 
-static inline void
+static void
 rb_set_commit_event(struct ring_buffer_per_cpu *cpu_buffer,
                     struct ring_buffer_event *event)
 {
@@ -850,7 +973,7 @@ rb_set_commit_event(struct ring_buffer_per_cpu *cpu_buffer,
         local_set(&cpu_buffer->commit_page->page->commit, index);
 }
 
-static inline void
+static void
 rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
 {
         /*
@@ -896,7 +1019,7 @@ static void rb_reset_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
         cpu_buffer->reader_page->read = 0;
 }
 
-static inline void rb_inc_iter(struct ring_buffer_iter *iter)
+static void rb_inc_iter(struct ring_buffer_iter *iter)
 {
         struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
 
@@ -926,7 +1049,7 @@ static inline void rb_inc_iter(struct ring_buffer_iter *iter)
  * and with this, we can determine what to place into the
  * data field.
  */
-static inline void
+static void
 rb_update_event(struct ring_buffer_event *event,
                          unsigned type, unsigned length)
 {
@@ -938,15 +1061,11 @@ rb_update_event(struct ring_buffer_event *event,
                 break;
 
         case RINGBUF_TYPE_TIME_EXTEND:
-                event->len =
-                        (RB_LEN_TIME_EXTEND + (RB_ALIGNMENT-1))
-                        >> RB_ALIGNMENT_SHIFT;
+                event->len = DIV_ROUND_UP(RB_LEN_TIME_EXTEND, RB_ALIGNMENT);
                 break;
 
         case RINGBUF_TYPE_TIME_STAMP:
-                event->len =
-                        (RB_LEN_TIME_STAMP + (RB_ALIGNMENT-1))
-                        >> RB_ALIGNMENT_SHIFT;
+                event->len = DIV_ROUND_UP(RB_LEN_TIME_STAMP, RB_ALIGNMENT);
                 break;
 
         case RINGBUF_TYPE_DATA:
@@ -955,16 +1074,14 @@ rb_update_event(struct ring_buffer_event *event,
                         event->len = 0;
                         event->array[0] = length;
                 } else
-                        event->len =
-                                (length + (RB_ALIGNMENT-1))
-                                >> RB_ALIGNMENT_SHIFT;
+                        event->len = DIV_ROUND_UP(length, RB_ALIGNMENT);
                 break;
         default:
                 BUG();
         }
 }
 
-static inline unsigned rb_calculate_event_length(unsigned length)
+static unsigned rb_calculate_event_length(unsigned length)
 {
         struct ring_buffer_event event; /* Used only for sizeof array */
 
@@ -990,6 +1107,7 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
         struct ring_buffer *buffer = cpu_buffer->buffer;
         struct ring_buffer_event *event;
         unsigned long flags;
+        bool lock_taken = false;
 
         commit_page = cpu_buffer->commit_page;
         /* we just need to protect against interrupts */
@@ -1003,7 +1121,30 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
                 struct buffer_page *next_page = tail_page;
 
                 local_irq_save(flags);
-                __raw_spin_lock(&cpu_buffer->lock);
+                /*
+                 * Since the write to the buffer is still not
+                 * fully lockless, we must be careful with NMIs.
+                 * The locks in the writers are taken when a write
+                 * crosses to a new page. The locks protect against
+                 * races with the readers (this will soon be fixed
+                 * with a lockless solution).
+                 *
+                 * Because we can not protect against NMIs, and we
+                 * want to keep traces reentrant, we need to manage
+                 * what happens when we are in an NMI.
+                 *
+                 * NMIs can happen after we take the lock.
+                 * If we are in an NMI, only take the lock
+                 * if it is not already taken. Otherwise
+                 * simply fail.
+                 */
+                if (unlikely(in_nmi())) {
+                        if (!__raw_spin_trylock(&cpu_buffer->lock))
+                                goto out_reset;
+                } else
+                        __raw_spin_lock(&cpu_buffer->lock);
+
+                lock_taken = true;
 
                 rb_inc_page(cpu_buffer, &next_page);
 
@@ -1012,7 +1153,7 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
 
                 /* we grabbed the lock before incrementing */
                 if (RB_WARN_ON(cpu_buffer, next_page == reader_page))
-                        goto out_unlock;
+                        goto out_reset;
 
                 /*
                  * If for some reason, we had an interrupt storm that made
@@ -1021,12 +1162,12 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
                  */
                 if (unlikely(next_page == commit_page)) {
                         WARN_ON_ONCE(1);
-                        goto out_unlock;
+                        goto out_reset;
                 }
 
                 if (next_page == head_page) {
                         if (!(buffer->flags & RB_FL_OVERWRITE))
-                                goto out_unlock;
+                                goto out_reset;
 
                         /* tail_page has not moved yet? */
                         if (tail_page == cpu_buffer->tail_page) {
@@ -1100,12 +1241,13 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
 
         return event;
 
- out_unlock:
+ out_reset:
         /* reset write */
         if (tail <= BUF_PAGE_SIZE)
                 local_set(&tail_page->write, tail);
 
-        __raw_spin_unlock(&cpu_buffer->lock);
+        if (likely(lock_taken))
+                __raw_spin_unlock(&cpu_buffer->lock);
         local_irq_restore(flags);
         return NULL;
 }
@@ -1265,7 +1407,6 @@ 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
@@ -1278,9 +1419,7 @@ static DEFINE_PER_CPU(int, rb_need_resched);
  * 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)
+ring_buffer_lock_reserve(struct ring_buffer *buffer, unsigned long length)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
         struct ring_buffer_event *event;
@@ -1347,15 +1486,13 @@ static void rb_commit(struct ring_buffer_per_cpu *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_event *event)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
         int cpu = raw_smp_processor_id();
@@ -1438,7 +1575,7 @@ int ring_buffer_write(struct ring_buffer *buffer,
 }
 EXPORT_SYMBOL_GPL(ring_buffer_write);
 
-static inline int rb_per_cpu_empty(struct ring_buffer_per_cpu *cpu_buffer)
+static 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;
@@ -1528,12 +1665,15 @@ EXPORT_SYMBOL_GPL(ring_buffer_record_enable_cpu);
 unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
+        unsigned long ret;
 
         if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return 0;
 
         cpu_buffer = buffer->buffers[cpu];
-        return cpu_buffer->entries;
+        ret = cpu_buffer->entries;
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_entries_cpu);
 
@@ -1545,12 +1685,15 @@ EXPORT_SYMBOL_GPL(ring_buffer_entries_cpu);
 unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
+        unsigned long ret;
 
         if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return 0;
 
         cpu_buffer = buffer->buffers[cpu];
-        return cpu_buffer->overrun;
+        ret = cpu_buffer->overrun;
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_overrun_cpu);
 
@@ -1627,9 +1770,14 @@ static void rb_iter_reset(struct ring_buffer_iter *iter)
  */
 void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
 {
-        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+        struct ring_buffer_per_cpu *cpu_buffer;
         unsigned long flags;
 
+        if (!iter)
+                return;
+
+        cpu_buffer = iter->cpu_buffer;
+
         spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
         rb_iter_reset(iter);
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
@@ -1864,9 +2012,6 @@ rb_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
         struct buffer_page *reader;
         int nr_loops = 0;
 
-        if (!cpumask_test_cpu(cpu, buffer->cpumask))
-                return NULL;
-
         cpu_buffer = buffer->buffers[cpu];
 
  again:
@@ -1995,6 +2140,9 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
         struct ring_buffer_event *event;
         unsigned long flags;
 
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
+                return NULL;
+
         spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
         event = rb_buffer_peek(buffer, cpu, ts);
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
@@ -2035,24 +2183,31 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
 struct ring_buffer_event *
 ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts)
 {
-        struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
-        struct ring_buffer_event *event;
+        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_event *event = NULL;
         unsigned long flags;
 
+        /* might be called in atomic */
+        preempt_disable();
+
         if (!cpumask_test_cpu(cpu, buffer->cpumask))
-                return NULL;
+                goto out;
 
+        cpu_buffer = buffer->buffers[cpu];
         spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
 
         event = rb_buffer_peek(buffer, cpu, ts);
         if (!event)
-                goto out;
+                goto out_unlock;
 
         rb_advance_reader(cpu_buffer);
 
- out:
+ out_unlock:
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
+ out:
+        preempt_enable();
+
         return event;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_consume);
@@ -2232,6 +2387,7 @@ int ring_buffer_empty(struct ring_buffer *buffer)
                 if (!rb_per_cpu_empty(cpu_buffer))
                         return 0;
         }
+
         return 1;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_empty);
@@ -2244,12 +2400,16 @@ EXPORT_SYMBOL_GPL(ring_buffer_empty);
 int ring_buffer_empty_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
+        int ret;
 
         if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return 1;
 
         cpu_buffer = buffer->buffers[cpu];
-        return rb_per_cpu_empty(cpu_buffer);
+        ret = rb_per_cpu_empty(cpu_buffer);
+
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_empty_cpu);
 
@@ -2268,18 +2428,36 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
 {
         struct ring_buffer_per_cpu *cpu_buffer_a;
         struct ring_buffer_per_cpu *cpu_buffer_b;
+        int ret = -EINVAL;
 
         if (!cpumask_test_cpu(cpu, buffer_a->cpumask) ||
             !cpumask_test_cpu(cpu, buffer_b->cpumask))
-                return -EINVAL;
+                goto out;
 
         /* At least make sure the two buffers are somewhat the same */
         if (buffer_a->pages != buffer_b->pages)
-                return -EINVAL;
+                goto out;
+
+        ret = -EAGAIN;
+
+        if (ring_buffer_flags != RB_BUFFERS_ON)
+                goto out;
+
+        if (atomic_read(&buffer_a->record_disabled))
+                goto out;
+
+        if (atomic_read(&buffer_b->record_disabled))
+                goto out;
 
         cpu_buffer_a = buffer_a->buffers[cpu];
         cpu_buffer_b = buffer_b->buffers[cpu];
 
+        if (atomic_read(&cpu_buffer_a->record_disabled))
+                goto out;
+
+        if (atomic_read(&cpu_buffer_b->record_disabled))
+                goto out;
+
         /*
          * We can't do a synchronize_sched here because this
          * function can be called in atomic context.
@@ -2298,18 +2476,21 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
         atomic_dec(&cpu_buffer_a->record_disabled);
         atomic_dec(&cpu_buffer_b->record_disabled);
 
-        return 0;
+        ret = 0;
+out:
+        return ret;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_swap_cpu);
 
 static void rb_remove_entries(struct ring_buffer_per_cpu *cpu_buffer,
-                              struct buffer_data_page *bpage)
+                              struct buffer_data_page *bpage,
+                              unsigned int offset)
 {
         struct ring_buffer_event *event;
         unsigned long head;
 
         __raw_spin_lock(&cpu_buffer->lock);
-        for (head = 0; head < local_read(&bpage->commit);
+        for (head = offset; head < local_read(&bpage->commit);
              head += rb_event_length(event)) {
 
                 event = __rb_data_page_index(bpage, head);
@@ -2340,8 +2521,8 @@ static void rb_remove_entries(struct ring_buffer_per_cpu *cpu_buffer,
  */
 void *ring_buffer_alloc_read_page(struct ring_buffer *buffer)
 {
-        unsigned long addr;
         struct buffer_data_page *bpage;
+        unsigned long addr;
 
         addr = __get_free_page(GFP_KERNEL);
         if (!addr)
@@ -2349,6 +2530,8 @@ void *ring_buffer_alloc_read_page(struct ring_buffer *buffer)
 
         bpage = (void *)addr;
 
+        rb_init_page(bpage);
+
         return bpage;
 }
 
@@ -2368,6 +2551,7 @@ void ring_buffer_free_read_page(struct ring_buffer *buffer, void *data)
  * ring_buffer_read_page - extract a page from the ring buffer
  * @buffer: buffer to extract from
  * @data_page: the page to use allocated from ring_buffer_alloc_read_page
+ * @len: amount to extract
  * @cpu: the cpu of the buffer to extract
  * @full: should the extraction only happen when the page is full.
  *
@@ -2377,12 +2561,12 @@ void ring_buffer_free_read_page(struct ring_buffer *buffer, void *data)
  * to swap with a page in the ring buffer.
  *
  * for example:
- *      rpage = ring_buffer_alloc_page(buffer);
+ *      rpage = ring_buffer_alloc_read_page(buffer);
  *      if (!rpage)
  *              return error;
- *      ret = ring_buffer_read_page(buffer, &rpage, cpu, 0);
- *      if (ret)
- *              process_page(rpage);
+ *      ret = ring_buffer_read_page(buffer, &rpage, len, cpu, 0);
+ *      if (ret >= 0)
+ *              process_page(rpage, ret);
  *
  * When @full is set, the function will not return true unless
  * the writer is off the reader page.
@@ -2393,72 +2577,118 @@ void ring_buffer_free_read_page(struct ring_buffer *buffer, void *data)
  *  responsible for that.
  *
  * Returns:
- *  1 if data has been transferred
- *  0 if no data has been transferred.
+ *  >=0 if data has been transferred, returns the offset of consumed data.
+ *  <0 if no data has been transferred.
  */
 int ring_buffer_read_page(struct ring_buffer *buffer,
-                            void **data_page, int cpu, int full)
+                          void **data_page, size_t len, int cpu, int full)
 {
         struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
         struct ring_buffer_event *event;
         struct buffer_data_page *bpage;
+        struct buffer_page *reader;
         unsigned long flags;
-        int ret = 0;
+        unsigned int commit;
+        unsigned int read;
+        u64 save_timestamp;
+        int ret = -1;
+
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
+                goto out;
+
+        /*
+         * If len is not big enough to hold the page header, then
+         * we can not copy anything.
+         */
+        if (len <= BUF_PAGE_HDR_SIZE)
+                goto out;
+
+        len -= BUF_PAGE_HDR_SIZE;
 
         if (!data_page)
-                return 0;
+                goto out;
 
         bpage = *data_page;
         if (!bpage)
-                return 0;
+                goto out;
 
         spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
 
-        /*
-         * rb_buffer_peek will get the next ring buffer if
-         * the current reader page is empty.
-         */
-        event = rb_buffer_peek(buffer, cpu, NULL);
-        if (!event)
-                goto out;
+        reader = rb_get_reader_page(cpu_buffer);
+        if (!reader)
+                goto out_unlock;
+
+        event = rb_reader_event(cpu_buffer);
+
+        read = reader->read;
+        commit = rb_page_commit(reader);
 
-        /* check for data */
-        if (!local_read(&cpu_buffer->reader_page->page->commit))
-                goto out;
         /*
-         * If the writer is already off of the read page, then simply
-         * switch the read page with the given page. Otherwise
-         * we need to copy the data from the reader to the writer.
+         * If this page has been partially read or
+         * if len is not big enough to read the rest of the page or
+         * a writer is still on the page, then
+         * we must copy the data from the page to the buffer.
+         * Otherwise, we can simply swap the page with the one passed in.
          */
-        if (cpu_buffer->reader_page == cpu_buffer->commit_page) {
-                unsigned int read = cpu_buffer->reader_page->read;
+        if (read || (len < (commit - read)) ||
+            cpu_buffer->reader_page == cpu_buffer->commit_page) {
+                struct buffer_data_page *rpage = cpu_buffer->reader_page->page;
+                unsigned int rpos = read;
+                unsigned int pos = 0;
+                unsigned int size;
 
                 if (full)
-                        goto out;
-                /* The writer is still on the reader page, we must copy */
-                bpage = cpu_buffer->reader_page->page;
-                memcpy(bpage->data,
-                       cpu_buffer->reader_page->page->data + read,
-                       local_read(&bpage->commit) - read);
+                        goto out_unlock;
+
+                if (len > (commit - read))
+                        len = (commit - read);
+
+                size = rb_event_length(event);
+
+                if (len < size)
+                        goto out_unlock;
+
+                /* save the current timestamp, since the user will need it */
+                save_timestamp = cpu_buffer->read_stamp;
+
+                /* Need to copy one event at a time */
+                do {
+                        memcpy(bpage->data + pos, rpage->data + rpos, size);
+
+                        len -= size;
 
-                /* consume what was read */
-                cpu_buffer->reader_page += read;
+                        rb_advance_reader(cpu_buffer);
+                        rpos = reader->read;
+                        pos += size;
 
+                        event = rb_reader_event(cpu_buffer);
+                        size = rb_event_length(event);
+                } while (len > size);
+
+                /* update bpage */
+                local_set(&bpage->commit, pos);
+                bpage->time_stamp = save_timestamp;
+
+                /* we copied everything to the beginning */
+                read = 0;
         } else {
                 /* swap the pages */
                 rb_init_page(bpage);
-                bpage = cpu_buffer->reader_page->page;
-                cpu_buffer->reader_page->page = *data_page;
-                cpu_buffer->reader_page->read = 0;
+                bpage = reader->page;
+                reader->page = *data_page;
+                local_set(&reader->write, 0);
+                reader->read = 0;
                 *data_page = bpage;
+
+                /* update the entry counter */
+                rb_remove_entries(cpu_buffer, bpage, read);
         }
-        ret = 1;
+        ret = read;
 
-        /* update the entry counter */
-        rb_remove_entries(cpu_buffer, bpage);
- out:
+ out_unlock:
         spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
+ out:
         return ret;
 }
 
@@ -2466,7 +2696,7 @@ static ssize_t
 rb_simple_read(struct file *filp, char __user *ubuf,
                size_t cnt, loff_t *ppos)
 {
-        long *p = filp->private_data;
+        unsigned long *p = filp->private_data;
         char buf[64];
         int r;
 
@@ -2482,9 +2712,9 @@ static ssize_t
 rb_simple_write(struct file *filp, const char __user *ubuf,
                 size_t cnt, loff_t *ppos)
 {
-        long *p = filp->private_data;
+        unsigned long *p = filp->private_data;
         char buf[64];
-        long val;
+        unsigned long val;
         int ret;
 
         if (cnt >= sizeof(buf))
@@ -2509,7 +2739,7 @@ rb_simple_write(struct file *filp, const char __user *ubuf,
         return cnt;
 }
 
-static struct file_operations rb_simple_fops = {
+static const struct file_operations rb_simple_fops = {
         .open           = tracing_open_generic,
         .read           = rb_simple_read,
         .write          = rb_simple_write,
@@ -2532,3 +2762,42 @@ static __init int rb_init_debugfs(void)
 }
 
 fs_initcall(rb_init_debugfs);
+
+#ifdef CONFIG_HOTPLUG_CPU
+static int __cpuinit rb_cpu_notify(struct notifier_block *self,
+                                   unsigned long action, void *hcpu)
+{
+        struct ring_buffer *buffer =
+                container_of(self, struct ring_buffer, cpu_notify);
+        long cpu = (long)hcpu;
+
+        switch (action) {
+        case CPU_UP_PREPARE:
+        case CPU_UP_PREPARE_FROZEN:
+                if (cpu_isset(cpu, *buffer->cpumask))
+                        return NOTIFY_OK;
+
+                buffer->buffers[cpu] =
+                        rb_allocate_cpu_buffer(buffer, cpu);
+                if (!buffer->buffers[cpu]) {
+                        WARN(1, "failed to allocate ring buffer on CPU %ld\n",
+                             cpu);
+                        return NOTIFY_OK;
+                }
+                smp_wmb();
+                cpu_set(cpu, *buffer->cpumask);
+                break;
+        case CPU_DOWN_PREPARE:
+        case CPU_DOWN_PREPARE_FROZEN:
+                /*
+                 * Do nothing.
+                 *  If we were to free the buffer, then the user would
+                 *  lose any trace that was in the buffer.
+                 */
+                break;
+        default:
+                break;
+        }
+        return NOTIFY_OK;
+}
+#endif
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 17bb88d86ac2..1ce6208fd727 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -11,32 +11,33 @@
  *  Copyright (C) 2004-2006 Ingo Molnar
  *  Copyright (C) 2004 William Lee Irwin III
  */
+#include <linux/ring_buffer.h>
 #include <linux/utsrelease.h>
+#include <linux/stacktrace.h>
+#include <linux/writeback.h>
 #include <linux/kallsyms.h>
 #include <linux/seq_file.h>
 #include <linux/notifier.h>
+#include <linux/irqflags.h>
 #include <linux/debugfs.h>
 #include <linux/pagemap.h>
 #include <linux/hardirq.h>
 #include <linux/linkage.h>
 #include <linux/uaccess.h>
+#include <linux/kprobes.h>
 #include <linux/ftrace.h>
 #include <linux/module.h>
 #include <linux/percpu.h>
+#include <linux/splice.h>
 #include <linux/kdebug.h>
 #include <linux/ctype.h>
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <linux/gfp.h>
 #include <linux/fs.h>
-#include <linux/kprobes.h>
-#include <linux/writeback.h>
-
-#include <linux/stacktrace.h>
-#include <linux/ring_buffer.h>
-#include <linux/irqflags.h>
 
 #include "trace.h"
+#include "trace_output.h"
 
 #define TRACE_BUFFER_FLAGS      (RB_FL_OVERWRITE)
 
@@ -44,14 +45,25 @@ unsigned long __read_mostly	tracing_max_latency;
 unsigned long __read_mostly     tracing_thresh;
 
 /*
+ * On boot up, the ring buffer is set to the minimum size, so that
+ * we do not waste memory on systems that are not using tracing.
+ */
+static int ring_buffer_expanded;
+
+/*
  * We need to change this state when a selftest is running.
  * A selftest will lurk into the ring-buffer to count the
  * entries inserted during the selftest although some concurrent
- * insertions into the ring-buffer such as ftrace_printk could occurred
+ * insertions into the ring-buffer such as trace_printk could occurred
  * at the same time, giving false positive or negative results.
  */
 static bool __read_mostly tracing_selftest_running;
 
+/*
+ * If a tracer is running, we do not want to run SELFTEST.
+ */
+static bool __read_mostly tracing_selftest_disabled;
+
 /* For tracers that don't implement custom flags */
 static struct tracer_opt dummy_tracer_opt[] = {
         { }
@@ -73,7 +85,7 @@ static int dummy_set_flag(u32 old_flags, u32 bit, int set)
  * of the tracer is successful. But that is the only place that sets
  * this back to zero.
  */
-int tracing_disabled = 1;
+static int tracing_disabled = 1;
 
 static DEFINE_PER_CPU(local_t, ftrace_cpu_disabled);
 
@@ -91,6 +103,9 @@ static inline void ftrace_enable_cpu(void)
 
 static cpumask_var_t __read_mostly      tracing_buffer_mask;
 
+/* Define which cpu buffers are currently read in trace_pipe */
+static cpumask_var_t                    tracing_reader_cpumask;
+
 #define for_each_tracing_cpu(cpu)       \
         for_each_cpu(cpu, tracing_buffer_mask)
 
@@ -109,14 +124,21 @@ static cpumask_var_t __read_mostly	tracing_buffer_mask;
  */
 int ftrace_dump_on_oops;
 
-static int tracing_set_tracer(char *buf);
+static int tracing_set_tracer(const char *buf);
+
+#define BOOTUP_TRACER_SIZE              100
+static char bootup_tracer_buf[BOOTUP_TRACER_SIZE] __initdata;
+static char *default_bootup_tracer;
 
 static int __init set_ftrace(char *str)
 {
-        tracing_set_tracer(str);
+        strncpy(bootup_tracer_buf, str, BOOTUP_TRACER_SIZE);
+        default_bootup_tracer = bootup_tracer_buf;
+        /* We are using ftrace early, expand it */
+        ring_buffer_expanded = 1;
         return 1;
 }
-__setup("ftrace", set_ftrace);
+__setup("ftrace=", set_ftrace);
 
 static int __init set_ftrace_dump_on_oops(char *str)
 {
@@ -186,9 +208,6 @@ int tracing_is_enabled(void)
         return tracer_enabled;
 }
 
-/* function tracing enabled */
-int                             ftrace_function_enabled;
-
 /*
  * trace_buf_size is the size in bytes that is allocated
  * for a buffer. Note, the number of bytes is always rounded
@@ -229,7 +248,7 @@ static DECLARE_WAIT_QUEUE_HEAD(trace_wait);
 
 /* trace_flags holds trace_options default values */
 unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
-        TRACE_ITER_ANNOTATE;
+        TRACE_ITER_ANNOTATE | TRACE_ITER_CONTEXT_INFO;
 
 /**
  * trace_wake_up - wake up tasks waiting for trace input
@@ -280,13 +299,15 @@ static const char *trace_options[] = {
         "block",
         "stacktrace",
         "sched-tree",
-        "ftrace_printk",
+        "trace_printk",
         "ftrace_preempt",
         "branch",
         "annotate",
         "userstacktrace",
         "sym-userobj",
         "printk-msg-only",
+        "context-info",
+        "latency-format",
         NULL
 };
 
@@ -326,146 +347,37 @@ __update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
         data->rt_priority = tsk->rt_priority;
 
         /* record this tasks comm */
-        tracing_record_cmdline(current);
+        tracing_record_cmdline(tsk);
 }
 
-/**
- * trace_seq_printf - sequence printing of trace information
- * @s: trace sequence descriptor
- * @fmt: printf format string
- *
- * The tracer may use either sequence operations or its own
- * copy to user routines. To simplify formating of a trace
- * trace_seq_printf is used to store strings into a special
- * buffer (@s). Then the output may be either used by
- * the sequencer or pulled into another buffer.
- */
-int
-trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf, size_t cnt)
 {
-        int len = (PAGE_SIZE - 1) - s->len;
-        va_list ap;
+        int len;
         int ret;
 
-        if (!len)
-                return 0;
-
-        va_start(ap, fmt);
-        ret = vsnprintf(s->buffer + s->len, len, fmt, ap);
-        va_end(ap);
-
-        /* If we can't write it all, don't bother writing anything */
-        if (ret >= len)
-                return 0;
-
-        s->len += ret;
-
-        return len;
-}
-
-/**
- * trace_seq_puts - trace sequence printing of simple string
- * @s: trace sequence descriptor
- * @str: simple string to record
- *
- * The tracer may use either the sequence operations or its own
- * copy to user routines. This function records a simple string
- * into a special buffer (@s) for later retrieval by a sequencer
- * or other mechanism.
- */
-static int
-trace_seq_puts(struct trace_seq *s, const char *str)
-{
-        int len = strlen(str);
-
-        if (len > ((PAGE_SIZE - 1) - s->len))
-                return 0;
-
-        memcpy(s->buffer + s->len, str, len);
-        s->len += len;
-
-        return len;
-}
-
-static int
-trace_seq_putc(struct trace_seq *s, unsigned char c)
-{
-        if (s->len >= (PAGE_SIZE - 1))
-                return 0;
-
-        s->buffer[s->len++] = c;
-
-        return 1;
-}
-
-static int
-trace_seq_putmem(struct trace_seq *s, void *mem, size_t len)
-{
-        if (len > ((PAGE_SIZE - 1) - s->len))
+        if (!cnt)
                 return 0;
 
-        memcpy(s->buffer + s->len, mem, len);
-        s->len += len;
-
-        return len;
-}
-
-#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;
-        int i, j;
-
-#ifdef __BIG_ENDIAN
-        for (i = 0, j = 0; i < len; i++) {
-#else
-        for (i = len-1, j = 0; i >= 0; i--) {
-#endif
-                hex[j++] = hex_asc_hi(data[i]);
-                hex[j++] = hex_asc_lo(data[i]);
-        }
-        hex[j++] = ' ';
-
-        return trace_seq_putmem(s, hex, j);
-}
-
-static int
-trace_seq_path(struct trace_seq *s, struct path *path)
-{
-        unsigned char *p;
+        if (s->len <= s->readpos)
+                return -EBUSY;
 
-        if (s->len >= (PAGE_SIZE - 1))
-                return 0;
-        p = d_path(path, s->buffer + s->len, PAGE_SIZE - s->len);
-        if (!IS_ERR(p)) {
-                p = mangle_path(s->buffer + s->len, p, "\n");
-                if (p) {
-                        s->len = p - s->buffer;
-                        return 1;
-                }
-        } else {
-                s->buffer[s->len++] = '?';
-                return 1;
-        }
+        len = s->len - s->readpos;
+        if (cnt > len)
+                cnt = len;
+        ret = copy_to_user(ubuf, s->buffer + s->readpos, cnt);
+        if (ret == cnt)
+                return -EFAULT;
 
-        return 0;
-}
+        cnt -= ret;
 
-static void
-trace_seq_reset(struct trace_seq *s)
-{
-        s->len = 0;
-        s->readpos = 0;
+        s->readpos += cnt;
+        return cnt;
 }
 
-ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf, size_t cnt)
+ssize_t trace_seq_to_buffer(struct trace_seq *s, void *buf, size_t cnt)
 {
         int len;
-        int ret;
+        void *ret;
 
         if (s->len <= s->readpos)
                 return -EBUSY;
@@ -473,11 +385,11 @@ ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf, size_t cnt)
         len = s->len - s->readpos;
         if (cnt > len)
                 cnt = len;
-        ret = copy_to_user(ubuf, s->buffer + s->readpos, cnt);
-        if (ret)
+        ret = memcpy(buf, s->buffer + s->readpos, cnt);
+        if (!ret)
                 return -EFAULT;
 
-        s->readpos += len;
+        s->readpos += cnt;
         return cnt;
 }
 
@@ -489,7 +401,7 @@ trace_print_seq(struct seq_file *m, struct trace_seq *s)
         s->buffer[len] = 0;
         seq_puts(m, s->buffer);
 
-        trace_seq_reset(s);
+        trace_seq_init(s);
 }
 
 /**
@@ -543,7 +455,7 @@ update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu)
 
         ftrace_enable_cpu();
 
-        WARN_ON_ONCE(ret);
+        WARN_ON_ONCE(ret && ret != -EAGAIN);
 
         __update_max_tr(tr, tsk, cpu);
         __raw_spin_unlock(&ftrace_max_lock);
@@ -556,6 +468,8 @@ update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu)
  * Register a new plugin tracer.
  */
 int register_tracer(struct tracer *type)
+__releases(kernel_lock)
+__acquires(kernel_lock)
 {
         struct tracer *t;
         int len;
@@ -594,9 +508,12 @@ int register_tracer(struct tracer *type)
         else
                 if (!type->flags->opts)
                         type->flags->opts = dummy_tracer_opt;
+        if (!type->wait_pipe)
+                type->wait_pipe = default_wait_pipe;
+
 
 #ifdef CONFIG_FTRACE_STARTUP_TEST
-        if (type->selftest) {
+        if (type->selftest && !tracing_selftest_disabled) {
                 struct tracer *saved_tracer = current_trace;
                 struct trace_array *tr = &global_trace;
                 int i;
@@ -638,8 +555,26 @@ int register_tracer(struct tracer *type)
  out:
         tracing_selftest_running = false;
         mutex_unlock(&trace_types_lock);
-        lock_kernel();
 
+        if (ret || !default_bootup_tracer)
+                goto out_unlock;
+
+        if (strncmp(default_bootup_tracer, type->name, BOOTUP_TRACER_SIZE))
+                goto out_unlock;
+
+        printk(KERN_INFO "Starting tracer '%s'\n", type->name);
+        /* Do we want this tracer to start on bootup? */
+        tracing_set_tracer(type->name);
+        default_bootup_tracer = NULL;
+        /* disable other selftests, since this will break it. */
+        tracing_selftest_disabled = 1;
+#ifdef CONFIG_FTRACE_STARTUP_TEST
+        printk(KERN_INFO "Disabling FTRACE selftests due to running tracer '%s'\n",
+               type->name);
+#endif
+
+ out_unlock:
+        lock_kernel();
         return ret;
 }
 
@@ -658,6 +593,15 @@ void unregister_tracer(struct tracer *type)
 
  found:
         *t = (*t)->next;
+
+        if (type == current_trace && tracer_enabled) {
+                tracer_enabled = 0;
+                tracing_stop();
+                if (current_trace->stop)
+                        current_trace->stop(&global_trace);
+                current_trace = &nop_trace;
+        }
+
         if (strlen(type->name) != max_tracer_type_len)
                 goto out;
 
@@ -693,10 +637,10 @@ static unsigned map_pid_to_cmdline[PID_MAX_DEFAULT+1];
 static unsigned map_cmdline_to_pid[SAVED_CMDLINES];
 static char saved_cmdlines[SAVED_CMDLINES][TASK_COMM_LEN];
 static int cmdline_idx;
-static DEFINE_SPINLOCK(trace_cmdline_lock);
+static raw_spinlock_t trace_cmdline_lock = __RAW_SPIN_LOCK_UNLOCKED;
 
 /* temporary disable recording */
-atomic_t trace_record_cmdline_disabled __read_mostly;
+static atomic_t trace_record_cmdline_disabled __read_mostly;
 
 static void trace_init_cmdlines(void)
 {
@@ -738,13 +682,12 @@ void tracing_start(void)
                 return;
 
         spin_lock_irqsave(&tracing_start_lock, flags);
-        if (--trace_stop_count)
-                goto out;
-
-        if (trace_stop_count < 0) {
-                /* Someone screwed up their debugging */
-                WARN_ON_ONCE(1);
-                trace_stop_count = 0;
+        if (--trace_stop_count) {
+                if (trace_stop_count < 0) {
+                        /* Someone screwed up their debugging */
+                        WARN_ON_ONCE(1);
+                        trace_stop_count = 0;
+                }
                 goto out;
         }
 
@@ -806,7 +749,7 @@ static void trace_save_cmdline(struct task_struct *tsk)
          * nor do we want to disable interrupts,
          * so if we miss here, then better luck next time.
          */
-        if (!spin_trylock(&trace_cmdline_lock))
+        if (!__raw_spin_trylock(&trace_cmdline_lock))
                 return;
 
         idx = map_pid_to_cmdline[tsk->pid];
@@ -824,33 +767,37 @@ static void trace_save_cmdline(struct task_struct *tsk)
 
         memcpy(&saved_cmdlines[idx], tsk->comm, TASK_COMM_LEN);
 
-        spin_unlock(&trace_cmdline_lock);
+        __raw_spin_unlock(&trace_cmdline_lock);
 }
 
-char *trace_find_cmdline(int pid)
+void trace_find_cmdline(int pid, char comm[])
 {
-        char *cmdline = "<...>";
         unsigned map;
 
-        if (!pid)
-                return "<idle>";
+        if (!pid) {
+                strcpy(comm, "<idle>");
+                return;
+        }
 
-        if (pid > PID_MAX_DEFAULT)
-                goto out;
+        if (pid > PID_MAX_DEFAULT) {
+                strcpy(comm, "<...>");
+                return;
+        }
 
+        __raw_spin_lock(&trace_cmdline_lock);
         map = map_pid_to_cmdline[pid];
         if (map >= SAVED_CMDLINES)
                 goto out;
 
-        cmdline = saved_cmdlines[map];
+        strcpy(comm, saved_cmdlines[map]);
 
  out:
-        return cmdline;
+        __raw_spin_unlock(&trace_cmdline_lock);
 }
 
 void tracing_record_cmdline(struct task_struct *tsk)
 {
-        if (atomic_read(&trace_record_cmdline_disabled))
+        if (atomic_read(&trace_record_cmdline_disabled) || !tracing_is_on())
                 return;
 
         trace_save_cmdline(tsk);
@@ -864,7 +811,7 @@ tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags,
 
         entry->preempt_count            = pc & 0xff;
         entry->pid                      = (tsk) ? tsk->pid : 0;
-        entry->tgid                     = (tsk) ? tsk->tgid : 0;
+        entry->tgid                     = (tsk) ? tsk->tgid : 0;
         entry->flags =
 #ifdef CONFIG_TRACE_IRQFLAGS_SUPPORT
                 (irqs_disabled_flags(flags) ? TRACE_FLAG_IRQS_OFF : 0) |
@@ -876,78 +823,114 @@ tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags,
                 (need_resched() ? TRACE_FLAG_NEED_RESCHED : 0);
 }
 
+struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr,
+                                                    unsigned char type,
+                                                    unsigned long len,
+                                                    unsigned long flags, int pc)
+{
+        struct ring_buffer_event *event;
+
+        event = ring_buffer_lock_reserve(tr->buffer, len);
+        if (event != NULL) {
+                struct trace_entry *ent = ring_buffer_event_data(event);
+
+                tracing_generic_entry_update(ent, flags, pc);
+                ent->type = type;
+        }
+
+        return event;
+}
+static void ftrace_trace_stack(struct trace_array *tr,
+                               unsigned long flags, int skip, int pc);
+static void ftrace_trace_userstack(struct trace_array *tr,
+                                   unsigned long flags, int pc);
+
+void trace_buffer_unlock_commit(struct trace_array *tr,
+                                struct ring_buffer_event *event,
+                                unsigned long flags, int pc)
+{
+        ring_buffer_unlock_commit(tr->buffer, event);
+
+        ftrace_trace_stack(tr, flags, 6, pc);
+        ftrace_trace_userstack(tr, flags, pc);
+        trace_wake_up();
+}
+
+struct ring_buffer_event *
+trace_current_buffer_lock_reserve(unsigned char type, unsigned long len,
+                                  unsigned long flags, int pc)
+{
+        return trace_buffer_lock_reserve(&global_trace,
+                                         type, len, flags, pc);
+}
+
+void trace_current_buffer_unlock_commit(struct ring_buffer_event *event,
+                                        unsigned long flags, int pc)
+{
+        return trace_buffer_unlock_commit(&global_trace, event, flags, pc);
+}
+
 void
-trace_function(struct trace_array *tr, struct trace_array_cpu *data,
+trace_function(struct trace_array *tr,
                unsigned long ip, unsigned long parent_ip, unsigned long flags,
                int pc)
 {
         struct ring_buffer_event *event;
         struct ftrace_entry *entry;
-        unsigned long 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);
+        event = trace_buffer_lock_reserve(tr, TRACE_FN, sizeof(*entry),
+                                          flags, pc);
         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);
+        ring_buffer_unlock_commit(tr->buffer, event);
 }
 
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 static void __trace_graph_entry(struct trace_array *tr,
-                                struct trace_array_cpu *data,
                                 struct ftrace_graph_ent *trace,
                                 unsigned long flags,
                                 int pc)
 {
         struct ring_buffer_event *event;
         struct ftrace_graph_ent_entry *entry;
-        unsigned long irq_flags;
 
         if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
                 return;
 
-        event = ring_buffer_lock_reserve(global_trace.buffer, sizeof(*entry),
-                                         &irq_flags);
+        event = trace_buffer_lock_reserve(&global_trace, TRACE_GRAPH_ENT,
+                                          sizeof(*entry), flags, pc);
         if (!event)
                 return;
         entry   = ring_buffer_event_data(event);
-        tracing_generic_entry_update(&entry->ent, flags, pc);
-        entry->ent.type                 = TRACE_GRAPH_ENT;
         entry->graph_ent                        = *trace;
-        ring_buffer_unlock_commit(global_trace.buffer, event, irq_flags);
+        ring_buffer_unlock_commit(global_trace.buffer, event);
 }
 
 static void __trace_graph_return(struct trace_array *tr,
-                                struct trace_array_cpu *data,
                                 struct ftrace_graph_ret *trace,
                                 unsigned long flags,
                                 int pc)
 {
         struct ring_buffer_event *event;
         struct ftrace_graph_ret_entry *entry;
-        unsigned long irq_flags;
 
         if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
                 return;
 
-        event = ring_buffer_lock_reserve(global_trace.buffer, sizeof(*entry),
-                                         &irq_flags);
+        event = trace_buffer_lock_reserve(&global_trace, TRACE_GRAPH_RET,
+                                          sizeof(*entry), flags, pc);
         if (!event)
                 return;
         entry   = ring_buffer_event_data(event);
-        tracing_generic_entry_update(&entry->ent, flags, pc);
-        entry->ent.type                 = TRACE_GRAPH_RET;
         entry->ret                              = *trace;
-        ring_buffer_unlock_commit(global_trace.buffer, event, irq_flags);
+        ring_buffer_unlock_commit(global_trace.buffer, event);
 }
 #endif
 
@@ -957,31 +940,23 @@ ftrace(struct trace_array *tr, struct trace_array_cpu *data,
        int pc)
 {
         if (likely(!atomic_read(&data->disabled)))
-                trace_function(tr, data, ip, parent_ip, flags, pc);
+                trace_function(tr, ip, parent_ip, flags, pc);
 }
 
-static void ftrace_trace_stack(struct trace_array *tr,
-                               struct trace_array_cpu *data,
-                               unsigned long flags,
-                               int skip, int pc)
+static void __ftrace_trace_stack(struct trace_array *tr,
+                                 unsigned long flags,
+                                 int skip, int pc)
 {
 #ifdef CONFIG_STACKTRACE
         struct ring_buffer_event *event;
         struct stack_entry *entry;
         struct stack_trace trace;
-        unsigned long irq_flags;
-
-        if (!(trace_flags & TRACE_ITER_STACKTRACE))
-                return;
 
-        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
-                                         &irq_flags);
+        event = trace_buffer_lock_reserve(tr, TRACE_STACK,
+                                          sizeof(*entry), flags, pc);
         if (!event)
                 return;
         entry   = ring_buffer_event_data(event);
-        tracing_generic_entry_update(&entry->ent, flags, pc);
-        entry->ent.type         = TRACE_STACK;
-
         memset(&entry->caller, 0, sizeof(entry->caller));
 
         trace.nr_entries        = 0;
@@ -990,38 +965,43 @@ static void ftrace_trace_stack(struct trace_array *tr,
         trace.entries           = entry->caller;
 
         save_stack_trace(&trace);
-        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+        ring_buffer_unlock_commit(tr->buffer, event);
 #endif
 }
 
+static void ftrace_trace_stack(struct trace_array *tr,
+                               unsigned long flags,
+                               int skip, int pc)
+{
+        if (!(trace_flags & TRACE_ITER_STACKTRACE))
+                return;
+
+        __ftrace_trace_stack(tr, flags, skip, pc);
+}
+
 void __trace_stack(struct trace_array *tr,
-                   struct trace_array_cpu *data,
                    unsigned long flags,
-                   int skip)
+                   int skip, int pc)
 {
-        ftrace_trace_stack(tr, data, flags, skip, preempt_count());
+        __ftrace_trace_stack(tr, flags, skip, pc);
 }
 
 static void ftrace_trace_userstack(struct trace_array *tr,
-                   struct trace_array_cpu *data,
-                   unsigned long flags, int pc)
+                                   unsigned long flags, int pc)
 {
 #ifdef CONFIG_STACKTRACE
         struct ring_buffer_event *event;
         struct userstack_entry *entry;
         struct stack_trace trace;
-        unsigned long irq_flags;
 
         if (!(trace_flags & TRACE_ITER_USERSTACKTRACE))
                 return;
 
-        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
-                                         &irq_flags);
+        event = trace_buffer_lock_reserve(tr, TRACE_USER_STACK,
+                                          sizeof(*entry), flags, pc);
         if (!event)
                 return;
         entry   = ring_buffer_event_data(event);
-        tracing_generic_entry_update(&entry->ent, flags, pc);
-        entry->ent.type         = TRACE_USER_STACK;
 
         memset(&entry->caller, 0, sizeof(entry->caller));
 
@@ -1031,70 +1011,58 @@ static void ftrace_trace_userstack(struct trace_array *tr,
         trace.entries           = entry->caller;
 
         save_stack_trace_user(&trace);
-        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+        ring_buffer_unlock_commit(tr->buffer, event);
 #endif
 }
 
-void __trace_userstack(struct trace_array *tr,
-                   struct trace_array_cpu *data,
-                   unsigned long flags)
+#ifdef UNUSED
+static void __trace_userstack(struct trace_array *tr, unsigned long flags)
 {
-        ftrace_trace_userstack(tr, data, flags, preempt_count());
+        ftrace_trace_userstack(tr, flags, preempt_count());
 }
+#endif /* UNUSED */
 
 static void
-ftrace_trace_special(void *__tr, void *__data,
+ftrace_trace_special(void *__tr,
                      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 special_entry *entry;
-        unsigned long irq_flags;
 
-        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
-                                         &irq_flags);
+        event = trace_buffer_lock_reserve(tr, TRACE_SPECIAL,
+                                          sizeof(*entry), 0, pc);
         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);
-        ftrace_trace_userstack(tr, data, irq_flags, pc);
-
-        trace_wake_up();
+        trace_buffer_unlock_commit(tr, event, 0, pc);
 }
 
 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());
+        ftrace_trace_special(__tr, 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, int pc)
 {
         struct ring_buffer_event *event;
         struct ctx_switch_entry *entry;
-        unsigned long irq_flags;
 
-        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
-                                           &irq_flags);
+        event = trace_buffer_lock_reserve(tr, TRACE_CTX,
+                                          sizeof(*entry), flags, pc);
         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;
@@ -1102,29 +1070,23 @@ tracing_sched_switch_trace(struct trace_array *tr,
         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);
-        ftrace_trace_userstack(tr, data, flags, pc);
+        trace_buffer_unlock_commit(tr, event, flags, pc);
 }
 
 void
 tracing_sched_wakeup_trace(struct trace_array *tr,
-                           struct trace_array_cpu *data,
                            struct task_struct *wakee,
                            struct task_struct *curr,
                            unsigned long flags, int pc)
 {
         struct ring_buffer_event *event;
         struct ctx_switch_entry *entry;
-        unsigned long irq_flags;
 
-        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
-                                           &irq_flags);
+        event = trace_buffer_lock_reserve(tr, TRACE_WAKE,
+                                          sizeof(*entry), flags, pc);
         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;
@@ -1132,11 +1094,10 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
         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);
-        ftrace_trace_userstack(tr, data, flags, pc);
 
-        trace_wake_up();
+        ring_buffer_unlock_commit(tr->buffer, event);
+        ftrace_trace_stack(tr, flags, 6, pc);
+        ftrace_trace_userstack(tr, flags, pc);
 }
 
 void
@@ -1157,66 +1118,7 @@ ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
         data = tr->data[cpu];
 
         if (likely(atomic_inc_return(&data->disabled) == 1))
-                ftrace_trace_special(tr, data, arg1, arg2, arg3, pc);
-
-        atomic_dec(&data->disabled);
-        local_irq_restore(flags);
-}
-
-#ifdef CONFIG_FUNCTION_TRACER
-static void
-function_trace_call_preempt_only(unsigned long ip, unsigned long parent_ip)
-{
-        struct trace_array *tr = &global_trace;
-        struct trace_array_cpu *data;
-        unsigned long flags;
-        long disabled;
-        int cpu, resched;
-        int pc;
-
-        if (unlikely(!ftrace_function_enabled))
-                return;
-
-        pc = preempt_count();
-        resched = ftrace_preempt_disable();
-        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, pc);
-
-        atomic_dec(&data->disabled);
-        ftrace_preempt_enable(resched);
-}
-
-static void
-function_trace_call(unsigned long ip, unsigned long parent_ip)
-{
-        struct trace_array *tr = &global_trace;
-        struct trace_array_cpu *data;
-        unsigned long flags;
-        long disabled;
-        int cpu;
-        int pc;
-
-        if (unlikely(!ftrace_function_enabled))
-                return;
-
-        /*
-         * Need to use raw, since this must be called before the
-         * recursive protection is performed.
-         */
-        local_irq_save(flags);
-        cpu = raw_smp_processor_id();
-        data = tr->data[cpu];
-        disabled = atomic_inc_return(&data->disabled);
-
-        if (likely(disabled == 1)) {
-                pc = preempt_count();
-                trace_function(tr, data, ip, parent_ip, flags, pc);
-        }
+                ftrace_trace_special(tr, arg1, arg2, arg3, pc);
 
         atomic_dec(&data->disabled);
         local_irq_restore(flags);
@@ -1244,7 +1146,7 @@ int trace_graph_entry(struct ftrace_graph_ent *trace)
         disabled = atomic_inc_return(&data->disabled);
         if (likely(disabled == 1)) {
                 pc = preempt_count();
-                __trace_graph_entry(tr, data, trace, flags, pc);
+                __trace_graph_entry(tr, trace, flags, pc);
         }
         /* Only do the atomic if it is not already set */
         if (!test_tsk_trace_graph(current))
@@ -1270,7 +1172,7 @@ void trace_graph_return(struct ftrace_graph_ret *trace)
         disabled = atomic_inc_return(&data->disabled);
         if (likely(disabled == 1)) {
                 pc = preempt_count();
-                __trace_graph_return(tr, data, trace, flags, pc);
+                __trace_graph_return(tr, trace, flags, pc);
         }
         if (!trace->depth)
                 clear_tsk_trace_graph(current);
@@ -1279,30 +1181,124 @@ void trace_graph_return(struct ftrace_graph_ret *trace)
 }
 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 
-static struct ftrace_ops trace_ops __read_mostly =
-{
-        .func = function_trace_call,
-};
 
-void tracing_start_function_trace(void)
+/**
+ * trace_vbprintk - write binary msg to tracing buffer
+ *
+ */
+int trace_vbprintk(unsigned long ip, int depth, const char *fmt, va_list args)
 {
-        ftrace_function_enabled = 0;
+        static raw_spinlock_t trace_buf_lock =
+                (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+        static u32 trace_buf[TRACE_BUF_SIZE];
 
-        if (trace_flags & TRACE_ITER_PREEMPTONLY)
-                trace_ops.func = function_trace_call_preempt_only;
-        else
-                trace_ops.func = function_trace_call;
+        struct ring_buffer_event *event;
+        struct trace_array *tr = &global_trace;
+        struct trace_array_cpu *data;
+        struct bprint_entry *entry;
+        unsigned long flags;
+        int resched;
+        int cpu, len = 0, size, pc;
+
+        if (unlikely(tracing_selftest_running || tracing_disabled))
+                return 0;
+
+        /* Don't pollute graph traces with trace_vprintk internals */
+        pause_graph_tracing();
+
+        pc = preempt_count();
+        resched = ftrace_preempt_disable();
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+
+        if (unlikely(atomic_read(&data->disabled)))
+                goto out;
+
+        /* Lockdep uses trace_printk for lock tracing */
+        local_irq_save(flags);
+        __raw_spin_lock(&trace_buf_lock);
+        len = vbin_printf(trace_buf, TRACE_BUF_SIZE, fmt, args);
+
+        if (len > TRACE_BUF_SIZE || len < 0)
+                goto out_unlock;
+
+        size = sizeof(*entry) + sizeof(u32) * len;
+        event = trace_buffer_lock_reserve(tr, TRACE_BPRINT, size, flags, pc);
+        if (!event)
+                goto out_unlock;
+        entry = ring_buffer_event_data(event);
+        entry->ip                       = ip;
+        entry->depth                    = depth;
+        entry->fmt                      = fmt;
+
+        memcpy(entry->buf, trace_buf, sizeof(u32) * len);
+        ring_buffer_unlock_commit(tr->buffer, event);
+
+out_unlock:
+        __raw_spin_unlock(&trace_buf_lock);
+        local_irq_restore(flags);
+
+out:
+        ftrace_preempt_enable(resched);
+        unpause_graph_tracing();
 
-        register_ftrace_function(&trace_ops);
-        ftrace_function_enabled = 1;
+        return len;
 }
+EXPORT_SYMBOL_GPL(trace_vbprintk);
 
-void tracing_stop_function_trace(void)
+int trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args)
 {
-        ftrace_function_enabled = 0;
-        unregister_ftrace_function(&trace_ops);
+        static raw_spinlock_t trace_buf_lock = __RAW_SPIN_LOCK_UNLOCKED;
+        static char trace_buf[TRACE_BUF_SIZE];
+
+        struct ring_buffer_event *event;
+        struct trace_array *tr = &global_trace;
+        struct trace_array_cpu *data;
+        int cpu, len = 0, size, pc;
+        struct print_entry *entry;
+        unsigned long irq_flags;
+
+        if (tracing_disabled || tracing_selftest_running)
+                return 0;
+
+        pc = preempt_count();
+        preempt_disable_notrace();
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+
+        if (unlikely(atomic_read(&data->disabled)))
+                goto out;
+
+        pause_graph_tracing();
+        raw_local_irq_save(irq_flags);
+        __raw_spin_lock(&trace_buf_lock);
+        len = vsnprintf(trace_buf, TRACE_BUF_SIZE, fmt, args);
+
+        len = min(len, TRACE_BUF_SIZE-1);
+        trace_buf[len] = 0;
+
+        size = sizeof(*entry) + len + 1;
+        event = trace_buffer_lock_reserve(tr, TRACE_PRINT, size, irq_flags, pc);
+        if (!event)
+                goto out_unlock;
+        entry = ring_buffer_event_data(event);
+        entry->ip                       = ip;
+        entry->depth                    = depth;
+
+        memcpy(&entry->buf, trace_buf, len);
+        entry->buf[len] = 0;
+        ring_buffer_unlock_commit(tr->buffer, event);
+
+ out_unlock:
+        __raw_spin_unlock(&trace_buf_lock);
+        raw_local_irq_restore(irq_flags);
+        unpause_graph_tracing();
+ out:
+        preempt_enable_notrace();
+
+        return len;
 }
-#endif
+EXPORT_SYMBOL_GPL(trace_vprintk);
 
 enum trace_file_type {
         TRACE_FILE_LAT_FMT      = 1,
@@ -1345,10 +1341,25 @@ __find_next_entry(struct trace_iterator *iter, int *ent_cpu, u64 *ent_ts)
 {
         struct ring_buffer *buffer = iter->tr->buffer;
         struct trace_entry *ent, *next = NULL;
+        int cpu_file = iter->cpu_file;
         u64 next_ts = 0, ts;
         int next_cpu = -1;
         int cpu;
 
+        /*
+         * If we are in a per_cpu trace file, don't bother by iterating over
+         * all cpu and peek directly.
+         */
+        if (cpu_file > TRACE_PIPE_ALL_CPU) {
+                if (ring_buffer_empty_cpu(buffer, cpu_file))
+                        return NULL;
+                ent = peek_next_entry(iter, cpu_file, ent_ts);
+                if (ent_cpu)
+                        *ent_cpu = cpu_file;
+
+                return ent;
+        }
+
         for_each_tracing_cpu(cpu) {
 
                 if (ring_buffer_empty_cpu(buffer, cpu))
@@ -1376,8 +1387,8 @@ __find_next_entry(struct trace_iterator *iter, int *ent_cpu, u64 *ent_ts)
 }
 
 /* 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)
+struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
+                                          int *ent_cpu, u64 *ent_ts)
 {
         return __find_next_entry(iter, ent_cpu, ent_ts);
 }
@@ -1426,19 +1437,32 @@ static void *s_next(struct seq_file *m, void *v, loff_t *pos)
         return ent;
 }
 
+/*
+ * No necessary locking here. The worst thing which can
+ * happen is loosing events consumed at the same time
+ * by a trace_pipe reader.
+ * Other than that, we don't risk to crash the ring buffer
+ * because it serializes the readers.
+ *
+ * The current tracer is copied to avoid a global locking
+ * all around.
+ */
 static void *s_start(struct seq_file *m, loff_t *pos)
 {
         struct trace_iterator *iter = m->private;
+        static struct tracer *old_tracer;
+        int cpu_file = iter->cpu_file;
         void *p = NULL;
         loff_t l = 0;
         int cpu;
 
+        /* copy the tracer to avoid using a global lock all around */
         mutex_lock(&trace_types_lock);
-
-        if (!current_trace || current_trace != iter->trace) {
-                mutex_unlock(&trace_types_lock);
-                return NULL;
+        if (unlikely(old_tracer != current_trace && current_trace)) {
+                old_tracer = current_trace;
+                *iter->trace = *current_trace;
         }
+        mutex_unlock(&trace_types_lock);
 
         atomic_inc(&trace_record_cmdline_disabled);
 
@@ -1449,9 +1473,12 @@ static void *s_start(struct seq_file *m, loff_t *pos)
 
                 ftrace_disable_cpu();
 
-                for_each_tracing_cpu(cpu) {
-                        ring_buffer_iter_reset(iter->buffer_iter[cpu]);
-                }
+                if (cpu_file == TRACE_PIPE_ALL_CPU) {
+                        for_each_tracing_cpu(cpu)
+                                ring_buffer_iter_reset(iter->buffer_iter[cpu]);
+                } else
+                        ring_buffer_iter_reset(iter->buffer_iter[cpu_file]);
+
 
                 ftrace_enable_cpu();
 
@@ -1469,155 +1496,6 @@ static void *s_start(struct seq_file *m, loff_t *pos)
 static void s_stop(struct seq_file *m, void *p)
 {
         atomic_dec(&trace_record_cmdline_disabled);
-        mutex_unlock(&trace_types_lock);
-}
-
-#ifdef CONFIG_KRETPROBES
-static inline const char *kretprobed(const char *name)
-{
-        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 const char *kretprobed(const char *name)
-{
-        return name;
-}
-#endif /* CONFIG_KRETPROBES */
-
-static int
-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);
-
-        name = kretprobed(str);
-
-        return trace_seq_printf(s, fmt, name);
-#endif
-        return 1;
-}
-
-static int
-seq_print_sym_offset(struct trace_seq *s, const char *fmt,
-                     unsigned long address)
-{
-#ifdef CONFIG_KALLSYMS
-        char str[KSYM_SYMBOL_LEN];
-        const char *name;
-
-        sprint_symbol(str, address);
-        name = kretprobed(str);
-
-        return trace_seq_printf(s, fmt, name);
-#endif
-        return 1;
-}
-
-#ifndef CONFIG_64BIT
-# define IP_FMT "%08lx"
-#else
-# define IP_FMT "%016lx"
-#endif
-
-int
-seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
-{
-        int ret;
-
-        if (!ip)
-                return trace_seq_printf(s, "0");
-
-        if (sym_flags & TRACE_ITER_SYM_OFFSET)
-                ret = seq_print_sym_offset(s, "%s", ip);
-        else
-                ret = seq_print_sym_short(s, "%s", ip);
-
-        if (!ret)
-                return 0;
-
-        if (sym_flags & TRACE_ITER_SYM_ADDR)
-                ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
-        return ret;
-}
-
-static inline int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,
-                                    unsigned long ip, unsigned long sym_flags)
-{
-        struct file *file = NULL;
-        unsigned long vmstart = 0;
-        int ret = 1;
-
-        if (mm) {
-                const struct vm_area_struct *vma;
-
-                down_read(&mm->mmap_sem);
-                vma = find_vma(mm, ip);
-                if (vma) {
-                        file = vma->vm_file;
-                        vmstart = vma->vm_start;
-                }
-                if (file) {
-                        ret = trace_seq_path(s, &file->f_path);
-                        if (ret)
-                                ret = trace_seq_printf(s, "[+0x%lx]", ip - vmstart);
-                }
-                up_read(&mm->mmap_sem);
-        }
-        if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))
-                ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
-        return ret;
-}
-
-static int
-seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,
-                      unsigned long sym_flags)
-{
-        struct mm_struct *mm = NULL;
-        int ret = 1;
-        unsigned int i;
-
-        if (trace_flags & TRACE_ITER_SYM_USEROBJ) {
-                struct task_struct *task;
-                /*
-                 * we do the lookup on the thread group leader,
-                 * since individual threads might have already quit!
-                 */
-                rcu_read_lock();
-                task = find_task_by_vpid(entry->ent.tgid);
-                if (task)
-                        mm = get_task_mm(task);
-                rcu_read_unlock();
-        }
-
-        for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
-                unsigned long ip = entry->caller[i];
-
-                if (ip == ULONG_MAX || !ret)
-                        break;
-                if (i && ret)
-                        ret = trace_seq_puts(s, " <- ");
-                if (!ip) {
-                        if (ret)
-                                ret = trace_seq_puts(s, "??");
-                        continue;
-                }
-                if (!ret)
-                        break;
-                if (ret)
-                        ret = seq_print_user_ip(s, mm, ip, sym_flags);
-        }
-
-        if (mm)
-                mmput(mm);
-        return ret;
 }
 
 static void print_lat_help_header(struct seq_file *m)
@@ -1658,11 +1536,11 @@ print_trace_header(struct seq_file *m, struct trace_iterator *iter)
         total = entries +
                 ring_buffer_overruns(iter->tr->buffer);
 
-        seq_printf(m, "%s latency trace v1.1.5 on %s\n",
+        seq_printf(m, "# %s latency trace v1.1.5 on %s\n",
                    name, UTS_RELEASE);
-        seq_puts(m, "-----------------------------------"
+        seq_puts(m, "# -----------------------------------"
                  "---------------------------------\n");
-        seq_printf(m, " latency: %lu us, #%lu/%lu, CPU#%d |"
+        seq_printf(m, "# latency: %lu us, #%lu/%lu, CPU#%d |"
                    " (M:%s VP:%d, KP:%d, SP:%d HP:%d",
                    nsecs_to_usecs(data->saved_latency),
                    entries,
@@ -1684,121 +1562,24 @@ print_trace_header(struct seq_file *m, struct trace_iterator *iter)
 #else
         seq_puts(m, ")\n");
 #endif
-        seq_puts(m, "    -----------------\n");
-        seq_printf(m, "    | task: %.16s-%d "
+        seq_puts(m, "#    -----------------\n");
+        seq_printf(m, "#    | task: %.16s-%d "
                    "(uid:%d nice:%ld policy:%ld rt_prio:%ld)\n",
                    data->comm, data->pid, data->uid, data->nice,
                    data->policy, data->rt_priority);
-        seq_puts(m, "    -----------------\n");
+        seq_puts(m, "#    -----------------\n");
 
         if (data->critical_start) {
-                seq_puts(m, " => started at: ");
+                seq_puts(m, "#  => started at: ");
                 seq_print_ip_sym(&iter->seq, data->critical_start, sym_flags);
                 trace_print_seq(m, &iter->seq);
-                seq_puts(m, "\n => ended at:   ");
+                seq_puts(m, "\n#  => ended at:   ");
                 seq_print_ip_sym(&iter->seq, data->critical_end, sym_flags);
                 trace_print_seq(m, &iter->seq);
-                seq_puts(m, "\n");
-        }
-
-        seq_puts(m, "\n");
-}
-
-static void
-lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
-{
-        int hardirq, softirq;
-        char *comm;
-
-        comm = trace_find_cmdline(entry->pid);
-
-        trace_seq_printf(s, "%8.8s-%-5d ", comm, entry->pid);
-        trace_seq_printf(s, "%3d", cpu);
-        trace_seq_printf(s, "%c%c",
-                        (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;
-        softirq = entry->flags & TRACE_FLAG_SOFTIRQ;
-        if (hardirq && softirq) {
-                trace_seq_putc(s, 'H');
-        } else {
-                if (hardirq) {
-                        trace_seq_putc(s, 'h');
-                } else {
-                        if (softirq)
-                                trace_seq_putc(s, 's');
-                        else
-                                trace_seq_putc(s, '.');
-                }
-        }
-
-        if (entry->preempt_count)
-                trace_seq_printf(s, "%x", entry->preempt_count);
-        else
-                trace_seq_puts(s, ".");
-}
-
-unsigned long preempt_mark_thresh = 100;
-
-static void
-lat_print_timestamp(struct trace_seq *s, u64 abs_usecs,
-                    unsigned long rel_usecs)
-{
-        trace_seq_printf(s, " %4lldus", abs_usecs);
-        if (rel_usecs > preempt_mark_thresh)
-                trace_seq_puts(s, "!: ");
-        else if (rel_usecs > 1)
-                trace_seq_puts(s, "+: ");
-        else
-                trace_seq_puts(s, " : ");
-}
-
-static const char state_to_char[] = TASK_STATE_TO_CHAR_STR;
-
-static int task_state_char(unsigned long state)
-{
-        int bit = state ? __ffs(state) + 1 : 0;
-
-        return bit < sizeof(state_to_char) - 1 ? state_to_char[bit] : '?';
-}
-
-/*
- * 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;
+                seq_puts(m, "#\n");
         }
 
-        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');
+        seq_puts(m, "#\n");
 }
 
 static void test_cpu_buff_start(struct trace_iterator *iter)
@@ -1818,453 +1599,105 @@ static void test_cpu_buff_start(struct trace_iterator *iter)
         trace_seq_printf(s, "##### CPU %u buffer started ####\n", iter->cpu);
 }
 
-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;
-        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;
-
-        if (entry->type == TRACE_CONT)
-                return TRACE_TYPE_HANDLED;
-
-        test_cpu_buff_start(iter);
-
-        next_entry = find_next_entry(iter, NULL, &next_ts);
-        if (!next_entry)
-                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 %3d %d %08x %08x [%08lx]"
-                                 " %ld.%03ldms (+%ld.%03ldms): ",
-                                 comm,
-                                 entry->pid, cpu, entry->flags,
-                                 entry->preempt_count, trace_idx,
-                                 ns2usecs(iter->ts),
-                                 abs_usecs/1000,
-                                 abs_usecs % 1000, rel_usecs/1000,
-                                 rel_usecs % 1000);
-        } else {
-                lat_print_generic(s, entry, cpu);
-                lat_print_timestamp(s, abs_usecs, rel_usecs);
-        }
-        switch (entry->type) {
-        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, " (");
-                seq_print_ip_sym(s, field->parent_ip, sym_flags);
-                trace_seq_puts(s, ")\n");
-                break;
-        }
-        case TRACE_CTX:
-        case TRACE_WAKE: {
-                struct ctx_switch_entry *field;
-
-                trace_assign_type(field, entry);
-
-                T = task_state_char(field->next_state);
-                S = task_state_char(field->prev_state);
-                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 ? "==>" : "  +",
-                                 field->next_cpu,
-                                 field->next_pid,
-                                 field->next_prio,
-                                 T, comm);
-                break;
-        }
-        case TRACE_SPECIAL: {
-                struct special_entry *field;
-
-                trace_assign_type(field, entry);
-
-                trace_seq_printf(s, "# %ld %ld %ld\n",
-                                 field->arg1,
-                                 field->arg2,
-                                 field->arg3);
-                break;
-        }
-        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, 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;
-        }
-        case TRACE_BRANCH: {
-                struct trace_branch *field;
-
-                trace_assign_type(field, entry);
-
-                trace_seq_printf(s, "[%s] %s:%s:%d\n",
-                                 field->correct ? "  ok  " : " MISS ",
-                                 field->func,
-                                 field->file,
-                                 field->line);
-                break;
-        }
-        case TRACE_USER_STACK: {
-                struct userstack_entry *field;
-
-                trace_assign_type(field, entry);
-
-                seq_print_userip_objs(field, s, sym_flags);
-                trace_seq_putc(s, '\n');
-                break;
-        }
-        default:
-                trace_seq_printf(s, "Unknown type %d\n", entry->type);
-        }
-        return TRACE_TYPE_HANDLED;
-}
-
 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);
         struct trace_entry *entry;
-        unsigned long usec_rem;
-        unsigned long long t;
-        unsigned long secs;
-        char *comm;
-        int ret;
-        int S, T;
-        int i;
+        struct trace_event *event;
 
         entry = iter->ent;
 
-        if (entry->type == TRACE_CONT)
-                return TRACE_TYPE_HANDLED;
-
         test_cpu_buff_start(iter);
 
-        comm = trace_find_cmdline(iter->ent->pid);
-
-        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 TRACE_TYPE_PARTIAL_LINE;
-        ret = trace_seq_printf(s, "[%03d] ", iter->cpu);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-        ret = trace_seq_printf(s, "%5lu.%06lu: ", secs, usec_rem);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        switch (entry->type) {
-        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 TRACE_TYPE_PARTIAL_LINE;
-                if ((sym_flags & TRACE_ITER_PRINT_PARENT) &&
-                                                field->parent_ip) {
-                        ret = trace_seq_printf(s, " <-");
-                        if (!ret)
-                                return TRACE_TYPE_PARTIAL_LINE;
-                        ret = seq_print_ip_sym(s,
-                                               field->parent_ip,
-                                               sym_flags);
-                        if (!ret)
-                                return TRACE_TYPE_PARTIAL_LINE;
-                }
-                ret = trace_seq_printf(s, "\n");
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-                break;
-        }
-        case TRACE_CTX:
-        case TRACE_WAKE: {
-                struct ctx_switch_entry *field;
-
-                trace_assign_type(field, entry);
-
-                T = task_state_char(field->next_state);
-                S = task_state_char(field->prev_state);
-                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 ? "==>" : "  +",
-                                       field->next_cpu,
-                                       field->next_pid,
-                                       field->next_prio,
-                                       T);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-                break;
-        }
-        case TRACE_SPECIAL: {
-                struct special_entry *field;
-
-                trace_assign_type(field, entry);
+        event = ftrace_find_event(entry->type);
 
-                ret = trace_seq_printf(s, "# %ld %ld %ld\n",
-                                 field->arg1,
-                                 field->arg2,
-                                 field->arg3);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-                break;
-        }
-        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 TRACE_TYPE_PARTIAL_LINE;
-                        }
-                        ret = seq_print_ip_sym(s, field->caller[i],
-                                               sym_flags);
-                        if (!ret)
-                                return TRACE_TYPE_PARTIAL_LINE;
+        if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
+                if (iter->iter_flags & TRACE_FILE_LAT_FMT) {
+                        if (!trace_print_lat_context(iter))
+                                goto partial;
+                } else {
+                        if (!trace_print_context(iter))
+                                goto partial;
                 }
-                ret = trace_seq_puts(s, "\n");
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-                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;
-        }
-        case TRACE_GRAPH_RET: {
-                return print_graph_function(iter);
-        }
-        case TRACE_GRAPH_ENT: {
-                return print_graph_function(iter);
-        }
-        case TRACE_BRANCH: {
-                struct trace_branch *field;
+        if (event)
+                return event->trace(iter, sym_flags);
 
-                trace_assign_type(field, entry);
+        if (!trace_seq_printf(s, "Unknown type %d\n", entry->type))
+                goto partial;
 
-                trace_seq_printf(s, "[%s] %s:%s:%d\n",
-                                 field->correct ? "  ok  " : " MISS ",
-                                 field->func,
-                                 field->file,
-                                 field->line);
-                break;
-        }
-        case TRACE_USER_STACK: {
-                struct userstack_entry *field;
-
-                trace_assign_type(field, entry);
-
-                ret = seq_print_userip_objs(field, s, sym_flags);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-                ret = trace_seq_putc(s, '\n');
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-                break;
-        }
-        }
         return TRACE_TYPE_HANDLED;
+partial:
+        return TRACE_TYPE_PARTIAL_LINE;
 }
 
 static enum print_line_t print_raw_fmt(struct trace_iterator *iter)
 {
         struct trace_seq *s = &iter->seq;
         struct trace_entry *entry;
-        int ret;
-        int S, T;
+        struct trace_event *event;
 
         entry = iter->ent;
 
-        if (entry->type == TRACE_CONT)
-                return TRACE_TYPE_HANDLED;
-
-        ret = trace_seq_printf(s, "%d %d %llu ",
-                entry->pid, iter->cpu, iter->ts);
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
-        switch (entry->type) {
-        case TRACE_FN: {
-                struct ftrace_entry *field;
-
-                trace_assign_type(field, entry);
-
-                ret = trace_seq_printf(s, "%x %x\n",
-                                        field->ip,
-                                        field->parent_ip);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-                break;
+        if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
+                if (!trace_seq_printf(s, "%d %d %llu ",
+                                      entry->pid, iter->cpu, iter->ts))
+                        goto partial;
         }
-        case TRACE_CTX:
-        case TRACE_WAKE: {
-                struct ctx_switch_entry *field;
-
-                trace_assign_type(field, entry);
-
-                T = task_state_char(field->next_state);
-                S = entry->type == TRACE_WAKE ? '+' :
-                        task_state_char(field->prev_state);
-                ret = trace_seq_printf(s, "%d %d %c %d %d %d %c\n",
-                                       field->prev_pid,
-                                       field->prev_prio,
-                                       S,
-                                       field->next_cpu,
-                                       field->next_pid,
-                                       field->next_prio,
-                                       T);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-                break;
-        }
-        case TRACE_SPECIAL:
-        case TRACE_USER_STACK:
-        case TRACE_STACK: {
-                struct special_entry *field;
-
-                trace_assign_type(field, entry);
 
-                ret = trace_seq_printf(s, "# %ld %ld %ld\n",
-                                 field->arg1,
-                                 field->arg2,
-                                 field->arg3);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-                break;
-        }
-        case TRACE_PRINT: {
-                struct print_entry *field;
+        event = ftrace_find_event(entry->type);
+        if (event)
+                return event->raw(iter, 0);
 
-                trace_assign_type(field, entry);
+        if (!trace_seq_printf(s, "%d ?\n", entry->type))
+                goto partial;
 
-                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;
+partial:
+        return TRACE_TYPE_PARTIAL_LINE;
 }
 
-#define SEQ_PUT_FIELD_RET(s, x)                         \
-do {                                                    \
-        if (!trace_seq_putmem(s, &(x), sizeof(x)))      \
-                return 0;                               \
-} while (0)
-
-#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 enum print_line_t print_hex_fmt(struct trace_iterator *iter)
 {
         struct trace_seq *s = &iter->seq;
         unsigned char newline = '\n';
         struct trace_entry *entry;
-        int S, T;
+        struct trace_event *event;
 
         entry = iter->ent;
 
-        if (entry->type == TRACE_CONT)
-                return TRACE_TYPE_HANDLED;
+        if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
+                SEQ_PUT_HEX_FIELD_RET(s, entry->pid);
+                SEQ_PUT_HEX_FIELD_RET(s, iter->cpu);
+                SEQ_PUT_HEX_FIELD_RET(s, iter->ts);
+        }
 
-        SEQ_PUT_HEX_FIELD_RET(s, entry->pid);
-        SEQ_PUT_HEX_FIELD_RET(s, iter->cpu);
-        SEQ_PUT_HEX_FIELD_RET(s, iter->ts);
+        event = ftrace_find_event(entry->type);
+        if (event) {
+                enum print_line_t ret = event->hex(iter, 0);
+                if (ret != TRACE_TYPE_HANDLED)
+                        return ret;
+        }
 
-        switch (entry->type) {
-        case TRACE_FN: {
-                struct ftrace_entry *field;
+        SEQ_PUT_FIELD_RET(s, newline);
 
-                trace_assign_type(field, entry);
+        return TRACE_TYPE_HANDLED;
+}
 
-                SEQ_PUT_HEX_FIELD_RET(s, field->ip);
-                SEQ_PUT_HEX_FIELD_RET(s, field->parent_ip);
-                break;
-        }
-        case TRACE_CTX:
-        case TRACE_WAKE: {
-                struct ctx_switch_entry *field;
-
-                trace_assign_type(field, entry);
-
-                T = task_state_char(field->next_state);
-                S = entry->type == TRACE_WAKE ? '+' :
-                        task_state_char(field->prev_state);
-                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, 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_USER_STACK:
-        case TRACE_STACK: {
-                struct special_entry *field;
+static enum print_line_t print_bprintk_msg_only(struct trace_iterator *iter)
+{
+        struct trace_seq *s = &iter->seq;
+        struct trace_entry *entry = iter->ent;
+        struct bprint_entry *field;
+        int ret;
 
-                trace_assign_type(field, entry);
+        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);
+        ret = trace_seq_bprintf(s, field->fmt, field->buf);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
 
         return TRACE_TYPE_HANDLED;
 }
@@ -2278,13 +1711,10 @@ static enum print_line_t print_printk_msg_only(struct trace_iterator *iter)
 
         trace_assign_type(field, entry);
 
-        ret = trace_seq_printf(s, field->buf);
+        ret = trace_seq_printf(s, "%s", field->buf);
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
-        if (entry->flags & TRACE_FLAG_CONT)
-                trace_seq_print_cont(s, iter);
-
         return TRACE_TYPE_HANDLED;
 }
 
@@ -2292,59 +1722,37 @@ static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
 {
         struct trace_seq *s = &iter->seq;
         struct trace_entry *entry;
+        struct trace_event *event;
 
         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, iter->ts);
-
-        switch (entry->type) {
-        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: {
-                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;
+        if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
+                SEQ_PUT_FIELD_RET(s, entry->pid);
+                SEQ_PUT_FIELD_RET(s, iter->cpu);
+                SEQ_PUT_FIELD_RET(s, iter->ts);
         }
-        case TRACE_SPECIAL:
-        case TRACE_USER_STACK:
-        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;
+        event = ftrace_find_event(entry->type);
+        return event ? event->binary(iter, 0) : TRACE_TYPE_HANDLED;
 }
 
 static int trace_empty(struct trace_iterator *iter)
 {
         int cpu;
 
+        /* If we are looking at one CPU buffer, only check that one */
+        if (iter->cpu_file != TRACE_PIPE_ALL_CPU) {
+                cpu = iter->cpu_file;
+                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;
+        }
+
         for_each_tracing_cpu(cpu) {
                 if (iter->buffer_iter[cpu]) {
                         if (!ring_buffer_iter_empty(iter->buffer_iter[cpu]))
@@ -2368,6 +1776,11 @@ static enum print_line_t print_trace_line(struct trace_iterator *iter)
                         return ret;
         }
 
+        if (iter->ent->type == TRACE_BPRINT &&
+                        trace_flags & TRACE_ITER_PRINTK &&
+                        trace_flags & TRACE_ITER_PRINTK_MSGONLY)
+                return print_bprintk_msg_only(iter);
+
         if (iter->ent->type == TRACE_PRINT &&
                         trace_flags & TRACE_ITER_PRINTK &&
                         trace_flags & TRACE_ITER_PRINTK_MSGONLY)
@@ -2382,9 +1795,6 @@ static enum print_line_t print_trace_line(struct trace_iterator *iter)
         if (trace_flags & TRACE_ITER_RAW)
                 return print_raw_fmt(iter);
 
-        if (iter->iter_flags & TRACE_FILE_LAT_FMT)
-                return print_lat_fmt(iter, iter->idx, iter->cpu);
-
         return print_trace_fmt(iter);
 }
 
@@ -2426,30 +1836,40 @@ static struct seq_operations tracer_seq_ops = {
 };
 
 static struct trace_iterator *
-__tracing_open(struct inode *inode, struct file *file, int *ret)
+__tracing_open(struct inode *inode, struct file *file)
 {
+        long cpu_file = (long) inode->i_private;
+        void *fail_ret = ERR_PTR(-ENOMEM);
         struct trace_iterator *iter;
         struct seq_file *m;
-        int cpu;
+        int cpu, ret;
 
-        if (tracing_disabled) {
-                *ret = -ENODEV;
-                return NULL;
-        }
+        if (tracing_disabled)
+                return ERR_PTR(-ENODEV);
 
         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
-        if (!iter) {
-                *ret = -ENOMEM;
-                goto out;
-        }
+        if (!iter)
+                return ERR_PTR(-ENOMEM);
 
+        /*
+         * We make a copy of the current tracer to avoid concurrent
+         * changes on it while we are reading.
+         */
         mutex_lock(&trace_types_lock);
+        iter->trace = kzalloc(sizeof(*iter->trace), GFP_KERNEL);
+        if (!iter->trace)
+                goto fail;
+
+        if (current_trace)
+                *iter->trace = *current_trace;
+
         if (current_trace && current_trace->print_max)
                 iter->tr = &max_tr;
         else
-                iter->tr = inode->i_private;
-        iter->trace = current_trace;
+                iter->tr = &global_trace;
         iter->pos = -1;
+        mutex_init(&iter->mutex);
+        iter->cpu_file = cpu_file;
 
         /* Notify the tracer early; before we stop tracing. */
         if (iter->trace && iter->trace->open)
@@ -2459,20 +1879,24 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
         if (ring_buffer_overruns(iter->tr->buffer))
                 iter->iter_flags |= TRACE_FILE_ANNOTATE;
 
+        if (iter->cpu_file == TRACE_PIPE_ALL_CPU) {
+                for_each_tracing_cpu(cpu) {
 
-        for_each_tracing_cpu(cpu) {
-
+                        iter->buffer_iter[cpu] =
+                                ring_buffer_read_start(iter->tr->buffer, cpu);
+                }
+        } else {
+                cpu = iter->cpu_file;
                 iter->buffer_iter[cpu] =
-                        ring_buffer_read_start(iter->tr->buffer, cpu);
-
-                if (!iter->buffer_iter[cpu])
-                        goto fail_buffer;
+                                ring_buffer_read_start(iter->tr->buffer, cpu);
         }
 
         /* TODO stop tracer */
-        *ret = seq_open(file, &tracer_seq_ops);
-        if (*ret)
+        ret = seq_open(file, &tracer_seq_ops);
+        if (ret < 0) {
+                fail_ret = ERR_PTR(ret);
                 goto fail_buffer;
+        }
 
         m = file->private_data;
         m->private = iter;
@@ -2482,7 +1906,6 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
 
         mutex_unlock(&trace_types_lock);
 
- out:
         return iter;
 
  fail_buffer:
@@ -2490,10 +1913,12 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
                 if (iter->buffer_iter[cpu])
                         ring_buffer_read_finish(iter->buffer_iter[cpu]);
         }
+ fail:
         mutex_unlock(&trace_types_lock);
+        kfree(iter->trace);
         kfree(iter);
 
-        return ERR_PTR(-ENOMEM);
+        return fail_ret;
 }
 
 int tracing_open_generic(struct inode *inode, struct file *filp)
@@ -2505,7 +1930,7 @@ int tracing_open_generic(struct inode *inode, struct file *filp)
         return 0;
 }
 
-int tracing_release(struct inode *inode, struct file *file)
+static 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;
@@ -2525,33 +1950,26 @@ int tracing_release(struct inode *inode, struct file *file)
         mutex_unlock(&trace_types_lock);
 
         seq_release(inode, file);
+        mutex_destroy(&iter->mutex);
+        kfree(iter->trace);
         kfree(iter);
         return 0;
 }
 
 static int tracing_open(struct inode *inode, struct file *file)
 {
-        int ret;
-
-        __tracing_open(inode, file, &ret);
-
-        return ret;
-}
-
-static int tracing_lt_open(struct inode *inode, struct file *file)
-{
         struct trace_iterator *iter;
-        int ret;
-
-        iter = __tracing_open(inode, file, &ret);
+        int ret = 0;
 
-        if (!ret)
+        iter = __tracing_open(inode, file);
+        if (IS_ERR(iter))
+                ret = PTR_ERR(iter);
+        else if (trace_flags & TRACE_ITER_LATENCY_FMT)
                 iter->iter_flags |= TRACE_FILE_LAT_FMT;
 
         return ret;
 }
 
-
 static void *
 t_next(struct seq_file *m, void *v, loff_t *pos)
 {
@@ -2623,21 +2041,14 @@ static int show_traces_open(struct inode *inode, struct file *file)
         return ret;
 }
 
-static struct file_operations tracing_fops = {
+static const struct file_operations tracing_fops = {
         .open           = tracing_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
         .release        = tracing_release,
 };
 
-static struct file_operations tracing_lt_fops = {
-        .open           = tracing_lt_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = tracing_release,
-};
-
-static struct file_operations show_traces_fops = {
+static const struct file_operations show_traces_fops = {
         .open           = show_traces_open,
         .read           = seq_read,
         .release        = seq_release,
@@ -2730,7 +2141,7 @@ err_unlock:
         return err;
 }
 
-static struct file_operations tracing_cpumask_fops = {
+static const struct file_operations tracing_cpumask_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_cpumask_read,
         .write          = tracing_cpumask_write,
@@ -2740,57 +2151,62 @@ static ssize_t
 tracing_trace_options_read(struct file *filp, char __user *ubuf,
                        size_t cnt, loff_t *ppos)
 {
-        int i;
+        struct tracer_opt *trace_opts;
+        u32 tracer_flags;
+        int len = 0;
         char *buf;
         int r = 0;
-        int len = 0;
-        u32 tracer_flags = current_trace->flags->val;
-        struct tracer_opt *trace_opts = current_trace->flags->opts;
+        int i;
 
 
-        /* calulate max size */
+        /* calculate max size */
         for (i = 0; trace_options[i]; i++) {
                 len += strlen(trace_options[i]);
-                len += 3; /* "no" and space */
+                len += 3; /* "no" and newline */
         }
 
+        mutex_lock(&trace_types_lock);
+        tracer_flags = current_trace->flags->val;
+        trace_opts = current_trace->flags->opts;
+
         /*
          * Increase the size with names of options specific
          * of the current tracer.
          */
         for (i = 0; trace_opts[i].name; i++) {
                 len += strlen(trace_opts[i].name);
-                len += 3; /* "no" and space */
+                len += 3; /* "no" and newline */
         }
 
         /* +2 for \n and \0 */
         buf = kmalloc(len + 2, GFP_KERNEL);
-        if (!buf)
+        if (!buf) {
+                mutex_unlock(&trace_types_lock);
                 return -ENOMEM;
+        }
 
         for (i = 0; trace_options[i]; i++) {
                 if (trace_flags & (1 << i))
-                        r += sprintf(buf + r, "%s ", trace_options[i]);
+                        r += sprintf(buf + r, "%s\n", trace_options[i]);
                 else
-                        r += sprintf(buf + r, "no%s ", trace_options[i]);
+                        r += sprintf(buf + r, "no%s\n", trace_options[i]);
         }
 
         for (i = 0; trace_opts[i].name; i++) {
                 if (tracer_flags & trace_opts[i].bit)
-                        r += sprintf(buf + r, "%s ",
+                        r += sprintf(buf + r, "%s\n",
                                 trace_opts[i].name);
                 else
-                        r += sprintf(buf + r, "no%s ",
+                        r += sprintf(buf + r, "no%s\n",
                                 trace_opts[i].name);
         }
+        mutex_unlock(&trace_types_lock);
 
-        r += sprintf(buf + r, "\n");
         WARN_ON(r >= len + 2);
 
         r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 
         kfree(buf);
-
         return r;
 }
 
@@ -2865,7 +2281,9 @@ tracing_trace_options_write(struct file *filp, const char __user *ubuf,
 
         /* If no option could be set, test the specific tracer options */
         if (!trace_options[i]) {
+                mutex_lock(&trace_types_lock);
                 ret = set_tracer_option(current_trace, cmp, neg);
+                mutex_unlock(&trace_types_lock);
                 if (ret)
                         return ret;
         }
@@ -2875,7 +2293,7 @@ tracing_trace_options_write(struct file *filp, const char __user *ubuf,
         return cnt;
 }
 
-static struct file_operations tracing_iter_fops = {
+static const struct file_operations tracing_iter_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_trace_options_read,
         .write          = tracing_trace_options_write,
@@ -2908,7 +2326,7 @@ tracing_readme_read(struct file *filp, char __user *ubuf,
                                         readme_msg, strlen(readme_msg));
 }
 
-static struct file_operations tracing_readme_fops = {
+static const struct file_operations tracing_readme_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_readme_read,
 };
@@ -2930,7 +2348,7 @@ tracing_ctrl_write(struct file *filp, const char __user *ubuf,
 {
         struct trace_array *tr = filp->private_data;
         char buf[64];
-        long val;
+        unsigned long val;
         int ret;
 
         if (cnt >= sizeof(buf))
@@ -2985,13 +2403,105 @@ tracing_set_trace_read(struct file *filp, char __user *ubuf,
         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
 
-static int tracing_set_tracer(char *buf)
+int tracer_init(struct tracer *t, struct trace_array *tr)
+{
+        tracing_reset_online_cpus(tr);
+        return t->init(tr);
+}
+
+static int tracing_resize_ring_buffer(unsigned long size)
+{
+        int ret;
+
+        /*
+         * If kernel or user changes the size of the ring buffer
+         * we use the size that was given, and we can forget about
+         * expanding it later.
+         */
+        ring_buffer_expanded = 1;
+
+        ret = ring_buffer_resize(global_trace.buffer, size);
+        if (ret < 0)
+                return ret;
+
+        ret = ring_buffer_resize(max_tr.buffer, size);
+        if (ret < 0) {
+                int r;
+
+                r = ring_buffer_resize(global_trace.buffer,
+                                       global_trace.entries);
+                if (r < 0) {
+                        /*
+                         * AARGH! We are left with different
+                         * size max buffer!!!!
+                         * The max buffer is our "snapshot" buffer.
+                         * When a tracer needs a snapshot (one of the
+                         * latency tracers), it swaps the max buffer
+                         * with the saved snap shot. We succeeded to
+                         * update the size of the main buffer, but failed to
+                         * update the size of the max buffer. But when we tried
+                         * to reset the main buffer to the original size, we
+                         * failed there too. This is very unlikely to
+                         * happen, but if it does, warn and kill all
+                         * tracing.
+                         */
+                        WARN_ON(1);
+                        tracing_disabled = 1;
+                }
+                return ret;
+        }
+
+        global_trace.entries = size;
+
+        return ret;
+}
+
+/**
+ * tracing_update_buffers - used by tracing facility to expand ring buffers
+ *
+ * To save on memory when the tracing is never used on a system with it
+ * configured in. The ring buffers are set to a minimum size. But once
+ * a user starts to use the tracing facility, then they need to grow
+ * to their default size.
+ *
+ * This function is to be called when a tracer is about to be used.
+ */
+int tracing_update_buffers(void)
+{
+        int ret = 0;
+
+        mutex_lock(&trace_types_lock);
+        if (!ring_buffer_expanded)
+                ret = tracing_resize_ring_buffer(trace_buf_size);
+        mutex_unlock(&trace_types_lock);
+
+        return ret;
+}
+
+struct trace_option_dentry;
+
+static struct trace_option_dentry *
+create_trace_option_files(struct tracer *tracer);
+
+static void
+destroy_trace_option_files(struct trace_option_dentry *topts);
+
+static int tracing_set_tracer(const char *buf)
 {
+        static struct trace_option_dentry *topts;
         struct trace_array *tr = &global_trace;
         struct tracer *t;
         int ret = 0;
 
         mutex_lock(&trace_types_lock);
+
+        if (!ring_buffer_expanded) {
+                ret = tracing_resize_ring_buffer(trace_buf_size);
+                if (ret < 0)
+                        goto out;
+                ret = 0;
+        }
+
         for (t = trace_types; t; t = t->next) {
                 if (strcmp(t->name, buf) == 0)
                         break;
@@ -3007,9 +2517,14 @@ static int tracing_set_tracer(char *buf)
         if (current_trace && current_trace->reset)
                 current_trace->reset(tr);
 
+        destroy_trace_option_files(topts);
+
         current_trace = t;
+
+        topts = create_trace_option_files(current_trace);
+
         if (t->init) {
-                ret = t->init(tr);
+                ret = tracer_init(t, tr);
                 if (ret)
                         goto out;
         }
@@ -3072,9 +2587,9 @@ static ssize_t
 tracing_max_lat_write(struct file *filp, const char __user *ubuf,
                       size_t cnt, loff_t *ppos)
 {
-        long *ptr = filp->private_data;
+        unsigned long *ptr = filp->private_data;
         char buf[64];
-        long val;
+        unsigned long val;
         int ret;
 
         if (cnt >= sizeof(buf))
@@ -3094,54 +2609,96 @@ tracing_max_lat_write(struct file *filp, const char __user *ubuf,
         return cnt;
 }
 
-static atomic_t tracing_reader;
-
 static int tracing_open_pipe(struct inode *inode, struct file *filp)
 {
+        long cpu_file = (long) inode->i_private;
         struct trace_iterator *iter;
+        int ret = 0;
 
         if (tracing_disabled)
                 return -ENODEV;
 
-        /* We only allow for reader of the pipe */
-        if (atomic_inc_return(&tracing_reader) != 1) {
-                atomic_dec(&tracing_reader);
-                return -EBUSY;
+        mutex_lock(&trace_types_lock);
+
+        /* We only allow one reader per cpu */
+        if (cpu_file == TRACE_PIPE_ALL_CPU) {
+                if (!cpumask_empty(tracing_reader_cpumask)) {
+                        ret = -EBUSY;
+                        goto out;
+                }
+                cpumask_setall(tracing_reader_cpumask);
+        } else {
+                if (!cpumask_test_cpu(cpu_file, tracing_reader_cpumask))
+                        cpumask_set_cpu(cpu_file, tracing_reader_cpumask);
+                else {
+                        ret = -EBUSY;
+                        goto out;
+                }
         }
 
         /* create a buffer to store the information to pass to userspace */
         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
-        if (!iter)
-                return -ENOMEM;
+        if (!iter) {
+                ret = -ENOMEM;
+                goto out;
+        }
 
-        if (!alloc_cpumask_var(&iter->started, GFP_KERNEL)) {
-                kfree(iter);
-                return -ENOMEM;
+        /*
+         * We make a copy of the current tracer to avoid concurrent
+         * changes on it while we are reading.
+         */
+        iter->trace = kmalloc(sizeof(*iter->trace), GFP_KERNEL);
+        if (!iter->trace) {
+                ret = -ENOMEM;
+                goto fail;
         }
+        if (current_trace)
+                *iter->trace = *current_trace;
 
-        mutex_lock(&trace_types_lock);
+        if (!alloc_cpumask_var(&iter->started, GFP_KERNEL)) {
+                ret = -ENOMEM;
+                goto fail;
+        }
 
         /* trace pipe does not show start of buffer */
         cpumask_setall(iter->started);
 
+        iter->cpu_file = cpu_file;
         iter->tr = &global_trace;
-        iter->trace = current_trace;
+        mutex_init(&iter->mutex);
         filp->private_data = iter;
 
         if (iter->trace->pipe_open)
                 iter->trace->pipe_open(iter);
+
+out:
         mutex_unlock(&trace_types_lock);
+        return ret;
 
-        return 0;
+fail:
+        kfree(iter->trace);
+        kfree(iter);
+        mutex_unlock(&trace_types_lock);
+        return ret;
 }
 
 static int tracing_release_pipe(struct inode *inode, struct file *file)
 {
         struct trace_iterator *iter = file->private_data;
 
+        mutex_lock(&trace_types_lock);
+
+        if (iter->cpu_file == TRACE_PIPE_ALL_CPU)
+                cpumask_clear(tracing_reader_cpumask);
+        else
+                cpumask_clear_cpu(iter->cpu_file, tracing_reader_cpumask);
+
+        mutex_unlock(&trace_types_lock);
+
         free_cpumask_var(iter->started);
+        mutex_destroy(&iter->mutex);
+        kfree(iter->trace);
         kfree(iter);
-        atomic_dec(&tracing_reader);
 
         return 0;
 }
@@ -3167,67 +2724,57 @@ tracing_poll_pipe(struct file *filp, poll_table *poll_table)
         }
 }
 
-/*
- * Consumer reader.
- */
-static ssize_t
-tracing_read_pipe(struct file *filp, char __user *ubuf,
-                  size_t cnt, loff_t *ppos)
+
+void default_wait_pipe(struct trace_iterator *iter)
 {
-        struct trace_iterator *iter = filp->private_data;
-        ssize_t sret;
+        DEFINE_WAIT(wait);
 
-        /* return any leftover data */
-        sret = trace_seq_to_user(&iter->seq, ubuf, cnt);
-        if (sret != -EBUSY)
-                return sret;
+        prepare_to_wait(&trace_wait, &wait, TASK_INTERRUPTIBLE);
 
-        trace_seq_reset(&iter->seq);
+        if (trace_empty(iter))
+                schedule();
 
-        mutex_lock(&trace_types_lock);
-        if (iter->trace->read) {
-                sret = iter->trace->read(iter, filp, ubuf, cnt, ppos);
-                if (sret)
-                        goto out;
-        }
+        finish_wait(&trace_wait, &wait);
+}
+
+/*
+ * This is a make-shift waitqueue.
+ * A tracer might use this callback on some rare cases:
+ *
+ *  1) the current tracer might hold the runqueue lock when it wakes up
+ *     a reader, hence a deadlock (sched, function, and function graph tracers)
+ *  2) the function tracers, trace all functions, we don't want
+ *     the overhead of calling wake_up and friends
+ *     (and tracing them too)
+ *
+ *     Anyway, this is really very primitive wakeup.
+ */
+void poll_wait_pipe(struct trace_iterator *iter)
+{
+        set_current_state(TASK_INTERRUPTIBLE);
+        /* sleep for 100 msecs, and try again. */
+        schedule_timeout(HZ / 10);
+}
+
+/* Must be called with trace_types_lock mutex held. */
+static int tracing_wait_pipe(struct file *filp)
+{
+        struct trace_iterator *iter = filp->private_data;
 
-waitagain:
-        sret = 0;
         while (trace_empty(iter)) {
 
                 if ((filp->f_flags & O_NONBLOCK)) {
-                        sret = -EAGAIN;
-                        goto out;
+                        return -EAGAIN;
                 }
 
-                /*
-                 * This is a make-shift waitqueue. The reason we don't use
-                 * an actual wait queue is because:
-                 *  1) we only ever have one waiter
-                 *  2) the tracing, traces all functions, we don't want
-                 *     the overhead of calling wake_up and friends
-                 *     (and tracing them too)
-                 *     Anyway, this is really very primitive wakeup.
-                 */
-                set_current_state(TASK_INTERRUPTIBLE);
-                iter->tr->waiter = current;
-
-                mutex_unlock(&trace_types_lock);
+                mutex_unlock(&iter->mutex);
 
-                /* sleep for 100 msecs, and try again. */
-                schedule_timeout(HZ/10);
+                iter->trace->wait_pipe(iter);
 
-                mutex_lock(&trace_types_lock);
+                mutex_lock(&iter->mutex);
 
-                iter->tr->waiter = NULL;
-
-                if (signal_pending(current)) {
-                        sret = -EINTR;
-                        goto out;
-                }
-
-                if (iter->trace != current_trace)
-                        goto out;
+                if (signal_pending(current))
+                        return -EINTR;
 
                 /*
                  * We block until we read something and tracing is disabled.
@@ -3240,13 +2787,59 @@ waitagain:
                  */
                 if (!tracer_enabled && iter->pos)
                         break;
+        }
+
+        return 1;
+}
+
+/*
+ * Consumer reader.
+ */
+static ssize_t
+tracing_read_pipe(struct file *filp, char __user *ubuf,
+                  size_t cnt, loff_t *ppos)
+{
+        struct trace_iterator *iter = filp->private_data;
+        static struct tracer *old_tracer;
+        ssize_t sret;
 
-                continue;
+        /* return any leftover data */
+        sret = trace_seq_to_user(&iter->seq, ubuf, cnt);
+        if (sret != -EBUSY)
+                return sret;
+
+        trace_seq_init(&iter->seq);
+
+        /* copy the tracer to avoid using a global lock all around */
+        mutex_lock(&trace_types_lock);
+        if (unlikely(old_tracer != current_trace && current_trace)) {
+                old_tracer = current_trace;
+                *iter->trace = *current_trace;
+        }
+        mutex_unlock(&trace_types_lock);
+
+        /*
+         * Avoid more than one consumer on a single file descriptor
+         * This is just a matter of traces coherency, the ring buffer itself
+         * is protected.
+         */
+        mutex_lock(&iter->mutex);
+        if (iter->trace->read) {
+                sret = iter->trace->read(iter, filp, ubuf, cnt, ppos);
+                if (sret)
+                        goto out;
         }
 
+waitagain:
+        sret = tracing_wait_pipe(filp);
+        if (sret <= 0)
+                goto out;
+
         /* stop when tracing is finished */
-        if (trace_empty(iter))
+        if (trace_empty(iter)) {
+                sret = 0;
                 goto out;
+        }
 
         if (cnt >= PAGE_SIZE)
                 cnt = PAGE_SIZE - 1;
@@ -3267,8 +2860,8 @@ waitagain:
                         iter->seq.len = len;
                         break;
                 }
-
-                trace_consume(iter);
+                if (ret != TRACE_TYPE_NO_CONSUME)
+                        trace_consume(iter);
 
                 if (iter->seq.len >= cnt)
                         break;
@@ -3277,7 +2870,7 @@ waitagain:
         /* 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);
+                trace_seq_init(&iter->seq);
 
         /*
          * If there was nothing to send to user, inspite of consuming trace
@@ -3287,20 +2880,165 @@ waitagain:
                 goto waitagain;
 
 out:
-        mutex_unlock(&trace_types_lock);
+        mutex_unlock(&iter->mutex);
 
         return sret;
 }
 
+static void tracing_pipe_buf_release(struct pipe_inode_info *pipe,
+                                     struct pipe_buffer *buf)
+{
+        __free_page(buf->page);
+}
+
+static void tracing_spd_release_pipe(struct splice_pipe_desc *spd,
+                                     unsigned int idx)
+{
+        __free_page(spd->pages[idx]);
+}
+
+static struct pipe_buf_operations tracing_pipe_buf_ops = {
+        .can_merge              = 0,
+        .map                    = generic_pipe_buf_map,
+        .unmap                  = generic_pipe_buf_unmap,
+        .confirm                = generic_pipe_buf_confirm,
+        .release                = tracing_pipe_buf_release,
+        .steal                  = generic_pipe_buf_steal,
+        .get                    = generic_pipe_buf_get,
+};
+
+static size_t
+tracing_fill_pipe_page(size_t rem, struct trace_iterator *iter)
+{
+        size_t count;
+        int ret;
+
+        /* Seq buffer is page-sized, exactly what we need. */
+        for (;;) {
+                count = iter->seq.len;
+                ret = print_trace_line(iter);
+                count = iter->seq.len - count;
+                if (rem < count) {
+                        rem = 0;
+                        iter->seq.len -= count;
+                        break;
+                }
+                if (ret == TRACE_TYPE_PARTIAL_LINE) {
+                        iter->seq.len -= count;
+                        break;
+                }
+
+                trace_consume(iter);
+                rem -= count;
+                if (!find_next_entry_inc(iter)) {
+                        rem = 0;
+                        iter->ent = NULL;
+                        break;
+                }
+        }
+
+        return rem;
+}
+
+static ssize_t tracing_splice_read_pipe(struct file *filp,
+                                        loff_t *ppos,
+                                        struct pipe_inode_info *pipe,
+                                        size_t len,
+                                        unsigned int flags)
+{
+        struct page *pages[PIPE_BUFFERS];
+        struct partial_page partial[PIPE_BUFFERS];
+        struct trace_iterator *iter = filp->private_data;
+        struct splice_pipe_desc spd = {
+                .pages          = pages,
+                .partial        = partial,
+                .nr_pages       = 0, /* This gets updated below. */
+                .flags          = flags,
+                .ops            = &tracing_pipe_buf_ops,
+                .spd_release    = tracing_spd_release_pipe,
+        };
+        static struct tracer *old_tracer;
+        ssize_t ret;
+        size_t rem;
+        unsigned int i;
+
+        /* copy the tracer to avoid using a global lock all around */
+        mutex_lock(&trace_types_lock);
+        if (unlikely(old_tracer != current_trace && current_trace)) {
+                old_tracer = current_trace;
+                *iter->trace = *current_trace;
+        }
+        mutex_unlock(&trace_types_lock);
+
+        mutex_lock(&iter->mutex);
+
+        if (iter->trace->splice_read) {
+                ret = iter->trace->splice_read(iter, filp,
+                                               ppos, pipe, len, flags);
+                if (ret)
+                        goto out_err;
+        }
+
+        ret = tracing_wait_pipe(filp);
+        if (ret <= 0)
+                goto out_err;
+
+        if (!iter->ent && !find_next_entry_inc(iter)) {
+                ret = -EFAULT;
+                goto out_err;
+        }
+
+        /* Fill as many pages as possible. */
+        for (i = 0, rem = len; i < PIPE_BUFFERS && rem; i++) {
+                pages[i] = alloc_page(GFP_KERNEL);
+                if (!pages[i])
+                        break;
+
+                rem = tracing_fill_pipe_page(rem, iter);
+
+                /* Copy the data into the page, so we can start over. */
+                ret = trace_seq_to_buffer(&iter->seq,
+                                          page_address(pages[i]),
+                                          iter->seq.len);
+                if (ret < 0) {
+                        __free_page(pages[i]);
+                        break;
+                }
+                partial[i].offset = 0;
+                partial[i].len = iter->seq.len;
+
+                trace_seq_init(&iter->seq);
+        }
+
+        mutex_unlock(&iter->mutex);
+
+        spd.nr_pages = i;
+
+        return splice_to_pipe(pipe, &spd);
+
+out_err:
+        mutex_unlock(&iter->mutex);
+
+        return ret;
+}
+
 static ssize_t
 tracing_entries_read(struct file *filp, char __user *ubuf,
                      size_t cnt, loff_t *ppos)
 {
         struct trace_array *tr = filp->private_data;
-        char buf[64];
+        char buf[96];
         int r;
 
-        r = sprintf(buf, "%lu\n", tr->entries >> 10);
+        mutex_lock(&trace_types_lock);
+        if (!ring_buffer_expanded)
+                r = sprintf(buf, "%lu (expanded: %lu)\n",
+                            tr->entries >> 10,
+                            trace_buf_size >> 10);
+        else
+                r = sprintf(buf, "%lu\n", tr->entries >> 10);
+        mutex_unlock(&trace_types_lock);
+
         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
 
@@ -3344,28 +3082,11 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
         val <<= 10;
 
         if (val != global_trace.entries) {
-                ret = ring_buffer_resize(global_trace.buffer, val);
-                if (ret < 0) {
-                        cnt = ret;
-                        goto out;
-                }
-
-                ret = ring_buffer_resize(max_tr.buffer, val);
+                ret = tracing_resize_ring_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;
-                        }
                         goto out;
                 }
-
-                global_trace.entries = val;
         }
 
         filp->f_pos += cnt;
@@ -3433,42 +3154,288 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
         return cnt;
 }
 
-static struct file_operations tracing_max_lat_fops = {
+static const struct file_operations tracing_max_lat_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_max_lat_read,
         .write          = tracing_max_lat_write,
 };
 
-static struct file_operations tracing_ctrl_fops = {
+static const struct file_operations tracing_ctrl_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_ctrl_read,
         .write          = tracing_ctrl_write,
 };
 
-static struct file_operations set_tracer_fops = {
+static const struct file_operations set_tracer_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_set_trace_read,
         .write          = tracing_set_trace_write,
 };
 
-static struct file_operations tracing_pipe_fops = {
+static const struct file_operations tracing_pipe_fops = {
         .open           = tracing_open_pipe,
         .poll           = tracing_poll_pipe,
         .read           = tracing_read_pipe,
+        .splice_read    = tracing_splice_read_pipe,
         .release        = tracing_release_pipe,
 };
 
-static struct file_operations tracing_entries_fops = {
+static const struct file_operations tracing_entries_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_entries_read,
         .write          = tracing_entries_write,
 };
 
-static struct file_operations tracing_mark_fops = {
+static const struct file_operations tracing_mark_fops = {
         .open           = tracing_open_generic,
         .write          = tracing_mark_write,
 };
 
+struct ftrace_buffer_info {
+        struct trace_array      *tr;
+        void                    *spare;
+        int                     cpu;
+        unsigned int            read;
+};
+
+static int tracing_buffers_open(struct inode *inode, struct file *filp)
+{
+        int cpu = (int)(long)inode->i_private;
+        struct ftrace_buffer_info *info;
+
+        if (tracing_disabled)
+                return -ENODEV;
+
+        info = kzalloc(sizeof(*info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
+        info->tr        = &global_trace;
+        info->cpu       = cpu;
+        info->spare     = ring_buffer_alloc_read_page(info->tr->buffer);
+        /* Force reading ring buffer for first read */
+        info->read      = (unsigned int)-1;
+        if (!info->spare)
+                goto out;
+
+        filp->private_data = info;
+
+        return 0;
+
+ out:
+        kfree(info);
+        return -ENOMEM;
+}
+
+static ssize_t
+tracing_buffers_read(struct file *filp, char __user *ubuf,
+                     size_t count, loff_t *ppos)
+{
+        struct ftrace_buffer_info *info = filp->private_data;
+        unsigned int pos;
+        ssize_t ret;
+        size_t size;
+
+        if (!count)
+                return 0;
+
+        /* Do we have previous read data to read? */
+        if (info->read < PAGE_SIZE)
+                goto read;
+
+        info->read = 0;
+
+        ret = ring_buffer_read_page(info->tr->buffer,
+                                    &info->spare,
+                                    count,
+                                    info->cpu, 0);
+        if (ret < 0)
+                return 0;
+
+        pos = ring_buffer_page_len(info->spare);
+
+        if (pos < PAGE_SIZE)
+                memset(info->spare + pos, 0, PAGE_SIZE - pos);
+
+read:
+        size = PAGE_SIZE - info->read;
+        if (size > count)
+                size = count;
+
+        ret = copy_to_user(ubuf, info->spare + info->read, size);
+        if (ret == size)
+                return -EFAULT;
+        size -= ret;
+
+        *ppos += size;
+        info->read += size;
+
+        return size;
+}
+
+static int tracing_buffers_release(struct inode *inode, struct file *file)
+{
+        struct ftrace_buffer_info *info = file->private_data;
+
+        ring_buffer_free_read_page(info->tr->buffer, info->spare);
+        kfree(info);
+
+        return 0;
+}
+
+struct buffer_ref {
+        struct ring_buffer      *buffer;
+        void                    *page;
+        int                     ref;
+};
+
+static void buffer_pipe_buf_release(struct pipe_inode_info *pipe,
+                                    struct pipe_buffer *buf)
+{
+        struct buffer_ref *ref = (struct buffer_ref *)buf->private;
+
+        if (--ref->ref)
+                return;
+
+        ring_buffer_free_read_page(ref->buffer, ref->page);
+        kfree(ref);
+        buf->private = 0;
+}
+
+static int buffer_pipe_buf_steal(struct pipe_inode_info *pipe,
+                                 struct pipe_buffer *buf)
+{
+        return 1;
+}
+
+static void buffer_pipe_buf_get(struct pipe_inode_info *pipe,
+                                struct pipe_buffer *buf)
+{
+        struct buffer_ref *ref = (struct buffer_ref *)buf->private;
+
+        ref->ref++;
+}
+
+/* Pipe buffer operations for a buffer. */
+static struct pipe_buf_operations buffer_pipe_buf_ops = {
+        .can_merge              = 0,
+        .map                    = generic_pipe_buf_map,
+        .unmap                  = generic_pipe_buf_unmap,
+        .confirm                = generic_pipe_buf_confirm,
+        .release                = buffer_pipe_buf_release,
+        .steal                  = buffer_pipe_buf_steal,
+        .get                    = buffer_pipe_buf_get,
+};
+
+/*
+ * Callback from splice_to_pipe(), if we need to release some pages
+ * at the end of the spd in case we error'ed out in filling the pipe.
+ */
+static void buffer_spd_release(struct splice_pipe_desc *spd, unsigned int i)
+{
+        struct buffer_ref *ref =
+                (struct buffer_ref *)spd->partial[i].private;
+
+        if (--ref->ref)
+                return;
+
+        ring_buffer_free_read_page(ref->buffer, ref->page);
+        kfree(ref);
+        spd->partial[i].private = 0;
+}
+
+static ssize_t
+tracing_buffers_splice_read(struct file *file, loff_t *ppos,
+                            struct pipe_inode_info *pipe, size_t len,
+                            unsigned int flags)
+{
+        struct ftrace_buffer_info *info = file->private_data;
+        struct partial_page partial[PIPE_BUFFERS];
+        struct page *pages[PIPE_BUFFERS];
+        struct splice_pipe_desc spd = {
+                .pages          = pages,
+                .partial        = partial,
+                .flags          = flags,
+                .ops            = &buffer_pipe_buf_ops,
+                .spd_release    = buffer_spd_release,
+        };
+        struct buffer_ref *ref;
+        int size, i;
+        size_t ret;
+
+        /*
+         * We can't seek on a buffer input
+         */
+        if (unlikely(*ppos))
+                return -ESPIPE;
+
+
+        for (i = 0; i < PIPE_BUFFERS && len; i++, len -= size) {
+                struct page *page;
+                int r;
+
+                ref = kzalloc(sizeof(*ref), GFP_KERNEL);
+                if (!ref)
+                        break;
+
+                ref->buffer = info->tr->buffer;
+                ref->page = ring_buffer_alloc_read_page(ref->buffer);
+                if (!ref->page) {
+                        kfree(ref);
+                        break;
+                }
+
+                r = ring_buffer_read_page(ref->buffer, &ref->page,
+                                          len, info->cpu, 0);
+                if (r < 0) {
+                        ring_buffer_free_read_page(ref->buffer,
+                                                   ref->page);
+                        kfree(ref);
+                        break;
+                }
+
+                /*
+                 * zero out any left over data, this is going to
+                 * user land.
+                 */
+                size = ring_buffer_page_len(ref->page);
+                if (size < PAGE_SIZE)
+                        memset(ref->page + size, 0, PAGE_SIZE - size);
+
+                page = virt_to_page(ref->page);
+
+                spd.pages[i] = page;
+                spd.partial[i].len = PAGE_SIZE;
+                spd.partial[i].offset = 0;
+                spd.partial[i].private = (unsigned long)ref;
+                spd.nr_pages++;
+        }
+
+        spd.nr_pages = i;
+
+        /* did we read anything? */
+        if (!spd.nr_pages) {
+                if (flags & SPLICE_F_NONBLOCK)
+                        ret = -EAGAIN;
+                else
+                        ret = 0;
+                /* TODO: block */
+                return ret;
+        }
+
+        ret = splice_to_pipe(pipe, &spd);
+
+        return ret;
+}
+
+static const struct file_operations tracing_buffers_fops = {
+        .open           = tracing_buffers_open,
+        .read           = tracing_buffers_read,
+        .release        = tracing_buffers_release,
+        .splice_read    = tracing_buffers_splice_read,
+        .llseek         = no_llseek,
+};
+
 #ifdef CONFIG_DYNAMIC_FTRACE
 
 int __weak ftrace_arch_read_dyn_info(char *buf, int size)
@@ -3500,7 +3467,7 @@ tracing_read_dyn_info(struct file *filp, char __user *ubuf,
         return r;
 }
 
-static struct file_operations tracing_dyn_info_fops = {
+static const struct file_operations tracing_dyn_info_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_read_dyn_info,
 };
@@ -3526,15 +3493,350 @@ struct dentry *tracing_init_dentry(void)
         return d_tracer;
 }
 
+static struct dentry *d_percpu;
+
+struct dentry *tracing_dentry_percpu(void)
+{
+        static int once;
+        struct dentry *d_tracer;
+
+        if (d_percpu)
+                return d_percpu;
+
+        d_tracer = tracing_init_dentry();
+
+        if (!d_tracer)
+                return NULL;
+
+        d_percpu = debugfs_create_dir("per_cpu", d_tracer);
+
+        if (!d_percpu && !once) {
+                once = 1;
+                pr_warning("Could not create debugfs directory 'per_cpu'\n");
+                return NULL;
+        }
+
+        return d_percpu;
+}
+
+static void tracing_init_debugfs_percpu(long cpu)
+{
+        struct dentry *d_percpu = tracing_dentry_percpu();
+        struct dentry *entry, *d_cpu;
+        /* strlen(cpu) + MAX(log10(cpu)) + '\0' */
+        char cpu_dir[7];
+
+        if (cpu > 999 || cpu < 0)
+                return;
+
+        sprintf(cpu_dir, "cpu%ld", cpu);
+        d_cpu = debugfs_create_dir(cpu_dir, d_percpu);
+        if (!d_cpu) {
+                pr_warning("Could not create debugfs '%s' entry\n", cpu_dir);
+                return;
+        }
+
+        /* per cpu trace_pipe */
+        entry = debugfs_create_file("trace_pipe", 0444, d_cpu,
+                                (void *) cpu, &tracing_pipe_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs 'trace_pipe' entry\n");
+
+        /* per cpu trace */
+        entry = debugfs_create_file("trace", 0444, d_cpu,
+                                (void *) cpu, &tracing_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs 'trace' entry\n");
+
+        entry = debugfs_create_file("trace_pipe_raw", 0444, d_cpu,
+                                    (void *) cpu, &tracing_buffers_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs 'trace_pipe_raw' entry\n");
+}
+
 #ifdef CONFIG_FTRACE_SELFTEST
 /* Let selftest have access to static functions in this file */
 #include "trace_selftest.c"
 #endif
 
+struct trace_option_dentry {
+        struct tracer_opt               *opt;
+        struct tracer_flags             *flags;
+        struct dentry                   *entry;
+};
+
+static ssize_t
+trace_options_read(struct file *filp, char __user *ubuf, size_t cnt,
+                        loff_t *ppos)
+{
+        struct trace_option_dentry *topt = filp->private_data;
+        char *buf;
+
+        if (topt->flags->val & topt->opt->bit)
+                buf = "1\n";
+        else
+                buf = "0\n";
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
+}
+
+static ssize_t
+trace_options_write(struct file *filp, const char __user *ubuf, size_t cnt,
+                         loff_t *ppos)
+{
+        struct trace_option_dentry *topt = filp->private_data;
+        unsigned long val;
+        char buf[64];
+        int ret;
+
+        if (cnt >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret < 0)
+                return ret;
+
+        ret = 0;
+        switch (val) {
+        case 0:
+                /* do nothing if already cleared */
+                if (!(topt->flags->val & topt->opt->bit))
+                        break;
+
+                mutex_lock(&trace_types_lock);
+                if (current_trace->set_flag)
+                        ret = current_trace->set_flag(topt->flags->val,
+                                                      topt->opt->bit, 0);
+                mutex_unlock(&trace_types_lock);
+                if (ret)
+                        return ret;
+                topt->flags->val &= ~topt->opt->bit;
+                break;
+        case 1:
+                /* do nothing if already set */
+                if (topt->flags->val & topt->opt->bit)
+                        break;
+
+                mutex_lock(&trace_types_lock);
+                if (current_trace->set_flag)
+                        ret = current_trace->set_flag(topt->flags->val,
+                                                      topt->opt->bit, 1);
+                mutex_unlock(&trace_types_lock);
+                if (ret)
+                        return ret;
+                topt->flags->val |= topt->opt->bit;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        *ppos += cnt;
+
+        return cnt;
+}
+
+
+static const struct file_operations trace_options_fops = {
+        .open = tracing_open_generic,
+        .read = trace_options_read,
+        .write = trace_options_write,
+};
+
+static ssize_t
+trace_options_core_read(struct file *filp, char __user *ubuf, size_t cnt,
+                        loff_t *ppos)
+{
+        long index = (long)filp->private_data;
+        char *buf;
+
+        if (trace_flags & (1 << index))
+                buf = "1\n";
+        else
+                buf = "0\n";
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
+}
+
+static ssize_t
+trace_options_core_write(struct file *filp, const char __user *ubuf, size_t cnt,
+                         loff_t *ppos)
+{
+        long index = (long)filp->private_data;
+        char buf[64];
+        unsigned long val;
+        int ret;
+
+        if (cnt >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret < 0)
+                return ret;
+
+        switch (val) {
+        case 0:
+                trace_flags &= ~(1 << index);
+                break;
+        case 1:
+                trace_flags |= 1 << index;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        *ppos += cnt;
+
+        return cnt;
+}
+
+static const struct file_operations trace_options_core_fops = {
+        .open = tracing_open_generic,
+        .read = trace_options_core_read,
+        .write = trace_options_core_write,
+};
+
+static struct dentry *trace_options_init_dentry(void)
+{
+        struct dentry *d_tracer;
+        static struct dentry *t_options;
+
+        if (t_options)
+                return t_options;
+
+        d_tracer = tracing_init_dentry();
+        if (!d_tracer)
+                return NULL;
+
+        t_options = debugfs_create_dir("options", d_tracer);
+        if (!t_options) {
+                pr_warning("Could not create debugfs directory 'options'\n");
+                return NULL;
+        }
+
+        return t_options;
+}
+
+static void
+create_trace_option_file(struct trace_option_dentry *topt,
+                         struct tracer_flags *flags,
+                         struct tracer_opt *opt)
+{
+        struct dentry *t_options;
+        struct dentry *entry;
+
+        t_options = trace_options_init_dentry();
+        if (!t_options)
+                return;
+
+        topt->flags = flags;
+        topt->opt = opt;
+
+        entry = debugfs_create_file(opt->name, 0644, t_options, topt,
+                                    &trace_options_fops);
+
+        topt->entry = entry;
+
+}
+
+static struct trace_option_dentry *
+create_trace_option_files(struct tracer *tracer)
+{
+        struct trace_option_dentry *topts;
+        struct tracer_flags *flags;
+        struct tracer_opt *opts;
+        int cnt;
+
+        if (!tracer)
+                return NULL;
+
+        flags = tracer->flags;
+
+        if (!flags || !flags->opts)
+                return NULL;
+
+        opts = flags->opts;
+
+        for (cnt = 0; opts[cnt].name; cnt++)
+                ;
+
+        topts = kcalloc(cnt + 1, sizeof(*topts), GFP_KERNEL);
+        if (!topts)
+                return NULL;
+
+        for (cnt = 0; opts[cnt].name; cnt++)
+                create_trace_option_file(&topts[cnt], flags,
+                                         &opts[cnt]);
+
+        return topts;
+}
+
+static void
+destroy_trace_option_files(struct trace_option_dentry *topts)
+{
+        int cnt;
+
+        if (!topts)
+                return;
+
+        for (cnt = 0; topts[cnt].opt; cnt++) {
+                if (topts[cnt].entry)
+                        debugfs_remove(topts[cnt].entry);
+        }
+
+        kfree(topts);
+}
+
+static struct dentry *
+create_trace_option_core_file(const char *option, long index)
+{
+        struct dentry *t_options;
+        struct dentry *entry;
+
+        t_options = trace_options_init_dentry();
+        if (!t_options)
+                return NULL;
+
+        entry = debugfs_create_file(option, 0644, t_options, (void *)index,
+                                    &trace_options_core_fops);
+
+        return entry;
+}
+
+static __init void create_trace_options_dir(void)
+{
+        struct dentry *t_options;
+        struct dentry *entry;
+        int i;
+
+        t_options = trace_options_init_dentry();
+        if (!t_options)
+                return;
+
+        for (i = 0; trace_options[i]; i++) {
+                entry = create_trace_option_core_file(trace_options[i], i);
+                if (!entry)
+                        pr_warning("Could not create debugfs %s entry\n",
+                                   trace_options[i]);
+        }
+}
+
 static __init int tracer_init_debugfs(void)
 {
         struct dentry *d_tracer;
         struct dentry *entry;
+        int cpu;
 
         d_tracer = tracing_init_dentry();
 
@@ -3548,18 +3850,15 @@ static __init int tracer_init_debugfs(void)
         if (!entry)
                 pr_warning("Could not create debugfs 'trace_options' entry\n");
 
+        create_trace_options_dir();
+
         entry = debugfs_create_file("tracing_cpumask", 0644, d_tracer,
                                     NULL, &tracing_cpumask_fops);
         if (!entry)
                 pr_warning("Could not create debugfs 'tracing_cpumask' entry\n");
 
-        entry = debugfs_create_file("latency_trace", 0444, d_tracer,
-                                    &global_trace, &tracing_lt_fops);
-        if (!entry)
-                pr_warning("Could not create debugfs 'latency_trace' entry\n");
-
         entry = debugfs_create_file("trace", 0444, d_tracer,
-                                    &global_trace, &tracing_fops);
+                                 (void *) TRACE_PIPE_ALL_CPU, &tracing_fops);
         if (!entry)
                 pr_warning("Could not create debugfs 'trace' entry\n");
 
@@ -3590,8 +3889,8 @@ static __init int tracer_init_debugfs(void)
         if (!entry)
                 pr_warning("Could not create debugfs 'README' entry\n");
 
-        entry = debugfs_create_file("trace_pipe", 0644, d_tracer,
-                                    NULL, &tracing_pipe_fops);
+        entry = debugfs_create_file("trace_pipe", 0444, d_tracer,
+                        (void *) TRACE_PIPE_ALL_CPU, &tracing_pipe_fops);
         if (!entry)
                 pr_warning("Could not create debugfs "
                            "'trace_pipe' entry\n");
@@ -3619,77 +3918,12 @@ static __init int tracer_init_debugfs(void)
 #ifdef CONFIG_SYSPROF_TRACER
         init_tracer_sysprof_debugfs(d_tracer);
 #endif
-        return 0;
-}
-
-int trace_vprintk(unsigned long ip, int depth, 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;
-        int cpu, len = 0, size, pc;
-        struct print_entry *entry;
-        unsigned long irq_flags;
-
-        if (tracing_disabled || tracing_selftest_running)
-                return 0;
-
-        pc = preempt_count();
-        preempt_disable_notrace();
-        cpu = raw_smp_processor_id();
-        data = tr->data[cpu];
-
-        if (unlikely(atomic_read(&data->disabled)))
-                goto out;
-
-        pause_graph_tracing();
-        spin_lock_irqsave(&trace_buf_lock, irq_flags);
-        len = vsnprintf(trace_buf, TRACE_BUF_SIZE, fmt, args);
-
-        len = min(len, TRACE_BUF_SIZE-1);
-        trace_buf[len] = 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, irq_flags, pc);
-        entry->ent.type                 = TRACE_PRINT;
-        entry->ip                       = ip;
-        entry->depth                    = depth;
 
-        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, irq_flags);
-        unpause_graph_tracing();
- out:
-        preempt_enable_notrace();
+        for_each_tracing_cpu(cpu)
+                tracing_init_debugfs_percpu(cpu);
 
-        return len;
-}
-EXPORT_SYMBOL_GPL(trace_vprintk);
-
-int __ftrace_printk(unsigned long ip, const char *fmt, ...)
-{
-        int ret;
-        va_list ap;
-
-        if (!(trace_flags & TRACE_ITER_PRINTK))
-                return 0;
-
-        va_start(ap, fmt);
-        ret = trace_vprintk(ip, task_curr_ret_stack(current), fmt, ap);
-        va_end(ap);
-        return ret;
+        return 0;
 }
-EXPORT_SYMBOL_GPL(__ftrace_printk);
 
 static int trace_panic_handler(struct notifier_block *this,
                                unsigned long event, void *unused)
@@ -3750,7 +3984,7 @@ trace_printk_seq(struct trace_seq *s)
 
         printk(KERN_TRACE "%s", s->buffer);
 
-        trace_seq_reset(s);
+        trace_seq_init(s);
 }
 
 void ftrace_dump(void)
@@ -3782,8 +4016,10 @@ void ftrace_dump(void)
 
         printk(KERN_TRACE "Dumping ftrace buffer:\n");
 
+        /* Simulate the iterator */
         iter.tr = &global_trace;
         iter.trace = current_trace;
+        iter.cpu_file = TRACE_PIPE_ALL_CPU;
 
         /*
          * We need to stop all tracing on all CPUS to read the
@@ -3826,6 +4062,7 @@ void ftrace_dump(void)
 __init static int tracer_alloc_buffers(void)
 {
         struct trace_array_cpu *data;
+        int ring_buf_size;
         int i;
         int ret = -ENOMEM;
 
@@ -3835,11 +4072,21 @@ __init static int tracer_alloc_buffers(void)
         if (!alloc_cpumask_var(&tracing_cpumask, GFP_KERNEL))
                 goto out_free_buffer_mask;
 
+        if (!alloc_cpumask_var(&tracing_reader_cpumask, GFP_KERNEL))
+                goto out_free_tracing_cpumask;
+
+        /* To save memory, keep the ring buffer size to its minimum */
+        if (ring_buffer_expanded)
+                ring_buf_size = trace_buf_size;
+        else
+                ring_buf_size = 1;
+
         cpumask_copy(tracing_buffer_mask, cpu_possible_mask);
         cpumask_copy(tracing_cpumask, cpu_all_mask);
+        cpumask_clear(tracing_reader_cpumask);
 
         /* TODO: make the number of buffers hot pluggable with CPUS */
-        global_trace.buffer = ring_buffer_alloc(trace_buf_size,
+        global_trace.buffer = ring_buffer_alloc(ring_buf_size,
                                                    TRACE_BUFFER_FLAGS);
         if (!global_trace.buffer) {
                 printk(KERN_ERR "tracer: failed to allocate ring buffer!\n");
@@ -3850,7 +4097,7 @@ __init static int tracer_alloc_buffers(void)
 
 
 #ifdef CONFIG_TRACER_MAX_TRACE
-        max_tr.buffer = ring_buffer_alloc(trace_buf_size,
+        max_tr.buffer = ring_buffer_alloc(ring_buf_size,
                                              TRACE_BUFFER_FLAGS);
         if (!max_tr.buffer) {
                 printk(KERN_ERR "tracer: failed to allocate max ring buffer!\n");
@@ -3871,14 +4118,10 @@ __init static int tracer_alloc_buffers(void)
         trace_init_cmdlines();
 
         register_tracer(&nop_trace);
+        current_trace = &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 */
         tracing_disabled = 0;
 
@@ -3886,14 +4129,38 @@ __init static int tracer_alloc_buffers(void)
                                        &trace_panic_notifier);
 
         register_die_notifier(&trace_die_notifier);
-        ret = 0;
+
+        return 0;
 
 out_free_cpumask:
+        free_cpumask_var(tracing_reader_cpumask);
+out_free_tracing_cpumask:
         free_cpumask_var(tracing_cpumask);
 out_free_buffer_mask:
         free_cpumask_var(tracing_buffer_mask);
 out:
         return ret;
 }
+
+__init static int clear_boot_tracer(void)
+{
+        /*
+         * The default tracer at boot buffer is an init section.
+         * This function is called in lateinit. If we did not
+         * find the boot tracer, then clear it out, to prevent
+         * later registration from accessing the buffer that is
+         * about to be freed.
+         */
+        if (!default_bootup_tracer)
+                return 0;
+
+        printk(KERN_INFO "ftrace bootup tracer '%s' not registered.\n",
+               default_bootup_tracer);
+        default_bootup_tracer = NULL;
+
+        return 0;
+}
+
 early_initcall(tracer_alloc_buffers);
 fs_initcall(tracer_init_debugfs);
+late_initcall(clear_boot_tracer);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 4d3d381bfd95..546bcbd92a0c 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -9,6 +9,8 @@
 #include <linux/mmiotrace.h>
 #include <linux/ftrace.h>
 #include <trace/boot.h>
+#include <trace/kmemtrace.h>
+#include <trace/power.h>
 
 enum trace_type {
         __TRACE_FIRST_TYPE = 0,
@@ -16,9 +18,9 @@ enum trace_type {
         TRACE_FN,
         TRACE_CTX,
         TRACE_WAKE,
-        TRACE_CONT,
         TRACE_STACK,
         TRACE_PRINT,
+        TRACE_BPRINT,
         TRACE_SPECIAL,
         TRACE_MMIO_RW,
         TRACE_MMIO_MAP,
@@ -29,9 +31,14 @@ enum trace_type {
         TRACE_GRAPH_ENT,
         TRACE_USER_STACK,
         TRACE_HW_BRANCHES,
+        TRACE_SYSCALL_ENTER,
+        TRACE_SYSCALL_EXIT,
+        TRACE_KMEM_ALLOC,
+        TRACE_KMEM_FREE,
         TRACE_POWER,
+        TRACE_BLK,
 
-        __TRACE_LAST_TYPE
+        __TRACE_LAST_TYPE,
 };
 
 /*
@@ -42,7 +49,6 @@ enum trace_type {
  */
 struct trace_entry {
         unsigned char           type;
-        unsigned char           cpu;
         unsigned char           flags;
         unsigned char           preempt_count;
         int                     pid;
@@ -60,13 +66,13 @@ struct ftrace_entry {
 
 /* Function call entry */
 struct ftrace_graph_ent_entry {
-        struct trace_entry                      ent;
+        struct trace_entry              ent;
         struct ftrace_graph_ent         graph_ent;
 };
 
 /* Function return entry */
 struct ftrace_graph_ret_entry {
-        struct trace_entry                      ent;
+        struct trace_entry              ent;
         struct ftrace_graph_ret         ret;
 };
 extern struct tracer boot_tracer;
@@ -112,8 +118,16 @@ struct userstack_entry {
 };
 
 /*
- * ftrace_printk entry:
+ * trace_printk entry:
  */
+struct bprint_entry {
+        struct trace_entry      ent;
+        unsigned long           ip;
+        int                     depth;
+        const char              *fmt;
+        u32                     buf[];
+};
+
 struct print_entry {
         struct trace_entry      ent;
         unsigned long           ip;
@@ -170,15 +184,45 @@ struct trace_power {
         struct power_trace      state_data;
 };
 
+struct kmemtrace_alloc_entry {
+        struct trace_entry      ent;
+        enum kmemtrace_type_id type_id;
+        unsigned long call_site;
+        const void *ptr;
+        size_t bytes_req;
+        size_t bytes_alloc;
+        gfp_t gfp_flags;
+        int node;
+};
+
+struct kmemtrace_free_entry {
+        struct trace_entry      ent;
+        enum kmemtrace_type_id type_id;
+        unsigned long call_site;
+        const void *ptr;
+};
+
+struct syscall_trace_enter {
+        struct trace_entry      ent;
+        int                     nr;
+        unsigned long           args[];
+};
+
+struct syscall_trace_exit {
+        struct trace_entry      ent;
+        int                     nr;
+        unsigned long           ret;
+};
+
+
 /*
  * 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
+ *  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,
@@ -186,7 +230,6 @@ enum trace_flag_type {
         TRACE_FLAG_NEED_RESCHED         = 0x04,
         TRACE_FLAG_HARDIRQ              = 0x08,
         TRACE_FLAG_SOFTIRQ              = 0x10,
-        TRACE_FLAG_CONT                 = 0x20,
 };
 
 #define TRACE_BUF_SIZE          1024
@@ -198,6 +241,7 @@ enum trace_flag_type {
  */
 struct trace_array_cpu {
         atomic_t                disabled;
+        void                    *buffer_page;   /* ring buffer spare */
 
         /* these fields get copied into max-trace: */
         unsigned long           trace_idx;
@@ -262,10 +306,10 @@ extern void __ftrace_bad_type(void);
         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 userstack_entry, TRACE_USER_STACK);\
                 IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT);   \
+                IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \
                 IF_ASSIGN(var, ent, struct special_entry, 0);           \
                 IF_ASSIGN(var, ent, struct trace_mmiotrace_rw,          \
                           TRACE_MMIO_RW);                               \
@@ -279,7 +323,15 @@ extern void __ftrace_bad_type(void);
                 IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry,      \
                           TRACE_GRAPH_RET);             \
                 IF_ASSIGN(var, ent, struct hw_branch_entry, TRACE_HW_BRANCHES);\
-                IF_ASSIGN(var, ent, struct trace_power, TRACE_POWER); \
+                IF_ASSIGN(var, ent, struct trace_power, TRACE_POWER); \
+                IF_ASSIGN(var, ent, struct kmemtrace_alloc_entry,       \
+                          TRACE_KMEM_ALLOC);    \
+                IF_ASSIGN(var, ent, struct kmemtrace_free_entry,        \
+                          TRACE_KMEM_FREE);     \
+                IF_ASSIGN(var, ent, struct syscall_trace_enter,         \
+                          TRACE_SYSCALL_ENTER);                         \
+                IF_ASSIGN(var, ent, struct syscall_trace_exit,          \
+                          TRACE_SYSCALL_EXIT);                          \
                 __ftrace_bad_type();                                    \
         } while (0)
 
@@ -287,7 +339,8 @@ extern void __ftrace_bad_type(void);
 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 */
+        TRACE_TYPE_UNHANDLED    = 2,    /* Relay to other output functions */
+        TRACE_TYPE_NO_CONSUME   = 3     /* Handled but ask to not consume */
 };
 
 
@@ -297,8 +350,8 @@ enum print_line_t {
  * flags value in struct tracer_flags.
  */
 struct tracer_opt {
-        const char      *name; /* Will appear on the trace_options file */
-        u32             bit; /* Mask assigned in val field in tracer_flags */
+        const char      *name; /* Will appear on the trace_options file */
+        u32             bit; /* Mask assigned in val field in tracer_flags */
 };
 
 /*
@@ -307,28 +360,51 @@ struct tracer_opt {
  */
 struct tracer_flags {
         u32                     val;
-        struct tracer_opt       *opts;
+        struct tracer_opt       *opts;
 };
 
 /* Makes more easy to define a tracer opt */
 #define TRACER_OPT(s, b)        .name = #s, .bit = b
 
-/*
- * A specific tracer, represented by methods that operate on a trace array:
+
+/**
+ * struct tracer - a specific tracer and its callbacks to interact with debugfs
+ * @name: the name chosen to select it on the available_tracers file
+ * @init: called when one switches to this tracer (echo name > current_tracer)
+ * @reset: called when one switches to another tracer
+ * @start: called when tracing is unpaused (echo 1 > tracing_enabled)
+ * @stop: called when tracing is paused (echo 0 > tracing_enabled)
+ * @open: called when the trace file is opened
+ * @pipe_open: called when the trace_pipe file is opened
+ * @wait_pipe: override how the user waits for traces on trace_pipe
+ * @close: called when the trace file is released
+ * @read: override the default read callback on trace_pipe
+ * @splice_read: override the default splice_read callback on trace_pipe
+ * @selftest: selftest to run on boot (see trace_selftest.c)
+ * @print_headers: override the first lines that describe your columns
+ * @print_line: callback that prints a trace
+ * @set_flag: signals one of your private flags changed (trace_options file)
+ * @flags: your private flags
  */
 struct tracer {
         const char              *name;
-        /* Your tracer should raise a warning if init fails */
         int                     (*init)(struct trace_array *tr);
         void                    (*reset)(struct trace_array *tr);
         void                    (*start)(struct trace_array *tr);
         void                    (*stop)(struct trace_array *tr);
         void                    (*open)(struct trace_iterator *iter);
         void                    (*pipe_open)(struct trace_iterator *iter);
+        void                    (*wait_pipe)(struct trace_iterator *iter);
         void                    (*close)(struct trace_iterator *iter);
         ssize_t                 (*read)(struct trace_iterator *iter,
                                         struct file *filp, char __user *ubuf,
                                         size_t cnt, loff_t *ppos);
+        ssize_t                 (*splice_read)(struct trace_iterator *iter,
+                                               struct file *filp,
+                                               loff_t *ppos,
+                                               struct pipe_inode_info *pipe,
+                                               size_t len,
+                                               unsigned int flags);
 #ifdef CONFIG_FTRACE_STARTUP_TEST
         int                     (*selftest)(struct tracer *trace,
                                             struct trace_array *tr);
@@ -339,7 +415,8 @@ struct tracer {
         int                     (*set_flag)(u32 old_flags, u32 bit, int set);
         struct tracer           *next;
         int                     print_max;
-        struct tracer_flags     *flags;
+        struct tracer_flags     *flags;
+        struct tracer_stat      *stats;
 };
 
 struct trace_seq {
@@ -348,6 +425,16 @@ struct trace_seq {
         unsigned int            readpos;
 };
 
+static inline void
+trace_seq_init(struct trace_seq *s)
+{
+        s->len = 0;
+        s->readpos = 0;
+}
+
+
+#define TRACE_PIPE_ALL_CPU      -1
+
 /*
  * Trace iterator - used by printout routines who present trace
  * results to users and which routines might sleep, etc:
@@ -356,6 +443,8 @@ struct trace_iterator {
         struct trace_array      *tr;
         struct tracer           *trace;
         void                    *private;
+        int                     cpu_file;
+        struct mutex            mutex;
         struct ring_buffer_iter *buffer_iter[NR_CPUS];
 
         /* The below is zeroed out in pipe_read */
@@ -371,6 +460,7 @@ struct trace_iterator {
         cpumask_var_t           started;
 };
 
+int tracer_init(struct tracer *t, struct trace_array *tr);
 int tracing_is_enabled(void);
 void trace_wake_up(void);
 void tracing_reset(struct trace_array *tr, int cpu);
@@ -379,26 +469,48 @@ 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 ring_buffer_event;
+
+struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr,
+                                                    unsigned char type,
+                                                    unsigned long len,
+                                                    unsigned long flags,
+                                                    int pc);
+void trace_buffer_unlock_commit(struct trace_array *tr,
+                                struct ring_buffer_event *event,
+                                unsigned long flags, int pc);
+
+struct ring_buffer_event *
+trace_current_buffer_lock_reserve(unsigned char type, unsigned long len,
+                                  unsigned long flags, int pc);
+void trace_current_buffer_unlock_commit(struct ring_buffer_event *event,
+                                        unsigned long flags, int pc);
+
 struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
                                                 struct trace_array_cpu *data);
+
+struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
+                                          int *ent_cpu, u64 *ent_ts);
+
 void tracing_generic_entry_update(struct trace_entry *entry,
                                   unsigned long flags,
                                   int pc);
 
+void default_wait_pipe(struct trace_iterator *iter);
+void poll_wait_pipe(struct trace_iterator *iter);
+
 void ftrace(struct trace_array *tr,
                             struct trace_array_cpu *data,
                             unsigned long ip,
                             unsigned long parent_ip,
                             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, 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, int pc);
@@ -408,14 +520,12 @@ void trace_special(struct trace_array *tr,
                    unsigned long arg2,
                    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, int pc);
 
 void trace_graph_return(struct ftrace_graph_ret *trace);
 int trace_graph_entry(struct ftrace_graph_ent *trace);
-void trace_hw_branch(struct trace_array *tr, u64 from, u64 to);
 
 void tracing_start_cmdline_record(void);
 void tracing_stop_cmdline_record(void);
@@ -434,15 +544,11 @@ void 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);
 
-extern cycle_t ftrace_now(int cpu);
+void __trace_stack(struct trace_array *tr,
+                   unsigned long flags,
+                   int skip, int pc);
 
-#ifdef CONFIG_FUNCTION_TRACER
-void tracing_start_function_trace(void);
-void tracing_stop_function_trace(void);
-#else
-# define tracing_start_function_trace()         do { } while (0)
-# define tracing_stop_function_trace()          do { } while (0)
-#endif
+extern cycle_t ftrace_now(int cpu);
 
 #ifdef CONFIG_CONTEXT_SWITCH_TRACER
 typedef void
@@ -456,10 +562,10 @@ struct tracer_switch_ops {
         void                            *private;
         struct tracer_switch_ops        *next;
 };
-
-char *trace_find_cmdline(int pid);
 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */
 
+extern void trace_find_cmdline(int pid, char comm[]);
+
 #ifdef CONFIG_DYNAMIC_FTRACE
 extern unsigned long ftrace_update_tot_cnt;
 #define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
@@ -469,6 +575,8 @@ extern int DYN_FTRACE_TEST_NAME(void);
 #ifdef CONFIG_FTRACE_STARTUP_TEST
 extern int trace_selftest_startup_function(struct tracer *trace,
                                            struct trace_array *tr);
+extern int trace_selftest_startup_function_graph(struct tracer *trace,
+                                                 struct trace_array *tr);
 extern int trace_selftest_startup_irqsoff(struct tracer *trace,
                                           struct trace_array *tr);
 extern int trace_selftest_startup_preemptoff(struct tracer *trace,
@@ -488,17 +596,10 @@ extern int trace_selftest_startup_branch(struct tracer *trace,
 #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 int
-seq_print_ip_sym(struct trace_seq *s, unsigned long ip,
-                unsigned long sym_flags);
-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_vbprintk(unsigned long ip, int depth, const char *fmt, va_list args);
+extern int
 trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args);
 
 extern unsigned long trace_flags;
@@ -580,7 +681,9 @@ enum trace_iterator_flags {
         TRACE_ITER_ANNOTATE             = 0x2000,
         TRACE_ITER_USERSTACKTRACE       = 0x4000,
         TRACE_ITER_SYM_USEROBJ          = 0x8000,
-        TRACE_ITER_PRINTK_MSGONLY       = 0x10000
+        TRACE_ITER_PRINTK_MSGONLY       = 0x10000,
+        TRACE_ITER_CONTEXT_INFO         = 0x20000, /* Print pid/cpu/time */
+        TRACE_ITER_LATENCY_FMT          = 0x40000,
 };
 
 /*
@@ -601,12 +704,12 @@ extern struct tracer nop_trace;
  * preempt_enable (after a disable), a schedule might take place
  * causing an infinite recursion.
  *
- * To prevent this, we read the need_recshed flag before
+ * To prevent this, we read the need_resched flag before
  * disabling preemption. When we want to enable preemption we
  * check the flag, if it is set, then we call preempt_enable_no_resched.
  * Otherwise, we call preempt_enable.
  *
- * The rational for doing the above is that if need resched is set
+ * The rational for doing the above is that if need_resched is set
  * and we have yet to reschedule, we are either in an atomic location
  * (where we do not need to check for scheduling) or we are inside
  * the scheduler and do not want to resched.
@@ -627,7 +730,7 @@ static inline int ftrace_preempt_disable(void)
  *
  * This is a scheduler safe way to enable preemption and not miss
  * any preemption checks. The disabled saved the state of preemption.
- * If resched is set, then we were either inside an atomic or
+ * If resched is set, then we are either inside an atomic or
  * are inside the scheduler (we would have already scheduled
  * otherwise). In this case, we do not want to call normal
  * preempt_enable, but preempt_enable_no_resched instead.
@@ -664,4 +767,51 @@ static inline void trace_branch_disable(void)
 }
 #endif /* CONFIG_BRANCH_TRACER */
 
+/* set ring buffers to default size if not already done so */
+int tracing_update_buffers(void);
+
+/* trace event type bit fields, not numeric */
+enum {
+        TRACE_EVENT_TYPE_PRINTF         = 1,
+        TRACE_EVENT_TYPE_RAW            = 2,
+};
+
+struct ftrace_event_call {
+        char            *name;
+        char            *system;
+        struct dentry   *dir;
+        int             enabled;
+        int             (*regfunc)(void);
+        void            (*unregfunc)(void);
+        int             id;
+        int             (*raw_init)(void);
+        int             (*show_format)(struct trace_seq *s);
+};
+
+void event_trace_printk(unsigned long ip, const char *fmt, ...);
+extern struct ftrace_event_call __start_ftrace_events[];
+extern struct ftrace_event_call __stop_ftrace_events[];
+
+extern const char *__start___trace_bprintk_fmt[];
+extern const char *__stop___trace_bprintk_fmt[];
+
+/*
+ * The double __builtin_constant_p is because gcc will give us an error
+ * if we try to allocate the static variable to fmt if it is not a
+ * constant. Even with the outer if statement optimizing out.
+ */
+#define event_trace_printk(ip, fmt, args...)                            \
+do {                                                                    \
+        __trace_printk_check_format(fmt, ##args);                       \
+        tracing_record_cmdline(current);                                \
+        if (__builtin_constant_p(fmt)) {                                \
+                static const char *trace_printk_fmt                     \
+                  __attribute__((section("__trace_printk_fmt"))) =      \
+                        __builtin_constant_p(fmt) ? fmt : NULL;         \
+                                                                        \
+                __trace_bprintk(ip, trace_printk_fmt, ##args);          \
+        } else                                                          \
+                __trace_printk(ip, fmt, ##args);                        \
+} while (0)
+
 #endif /* _LINUX_KERNEL_TRACE_H */
diff --git a/kernel/trace/trace_boot.c b/kernel/trace/trace_boot.c
index 366c8c333e13..7a30fc4c3642 100644
--- a/kernel/trace/trace_boot.c
+++ b/kernel/trace/trace_boot.c
@@ -11,6 +11,7 @@
 #include <linux/kallsyms.h>
 
 #include "trace.h"
+#include "trace_output.h"
 
 static struct trace_array *boot_trace;
 static bool pre_initcalls_finished;
@@ -27,13 +28,13 @@ void start_boot_trace(void)
 
 void enable_boot_trace(void)
 {
-        if (pre_initcalls_finished)
+        if (boot_trace && pre_initcalls_finished)
                 tracing_start_sched_switch_record();
 }
 
 void disable_boot_trace(void)
 {
-        if (pre_initcalls_finished)
+        if (boot_trace && pre_initcalls_finished)
                 tracing_stop_sched_switch_record();
 }
 
@@ -42,6 +43,9 @@ static int boot_trace_init(struct trace_array *tr)
         int cpu;
         boot_trace = tr;
 
+        if (!tr)
+                return 0;
+
         for_each_cpu(cpu, cpu_possible_mask)
                 tracing_reset(tr, cpu);
 
@@ -128,10 +132,9 @@ void trace_boot_call(struct boot_trace_call *bt, initcall_t fn)
 {
         struct ring_buffer_event *event;
         struct trace_boot_call *entry;
-        unsigned long irq_flags;
         struct trace_array *tr = boot_trace;
 
-        if (!pre_initcalls_finished)
+        if (!tr || !pre_initcalls_finished)
                 return;
 
         /* Get its name now since this function could
@@ -140,18 +143,13 @@ void trace_boot_call(struct boot_trace_call *bt, initcall_t fn)
         sprint_symbol(bt->func, (unsigned long)fn);
         preempt_disable();
 
-        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
-                                         &irq_flags);
+        event = trace_buffer_lock_reserve(tr, TRACE_BOOT_CALL,
+                                          sizeof(*entry), 0, 0);
         if (!event)
                 goto out;
         entry   = ring_buffer_event_data(event);
-        tracing_generic_entry_update(&entry->ent, 0, 0);
-        entry->ent.type = TRACE_BOOT_CALL;
         entry->boot_call = *bt;
-        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
-
-        trace_wake_up();
-
+        trace_buffer_unlock_commit(tr, event, 0, 0);
  out:
         preempt_enable();
 }
@@ -160,27 +158,21 @@ void trace_boot_ret(struct boot_trace_ret *bt, initcall_t fn)
 {
         struct ring_buffer_event *event;
         struct trace_boot_ret *entry;
-        unsigned long irq_flags;
         struct trace_array *tr = boot_trace;
 
-        if (!pre_initcalls_finished)
+        if (!tr || !pre_initcalls_finished)
                 return;
 
         sprint_symbol(bt->func, (unsigned long)fn);
         preempt_disable();
 
-        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
-                                         &irq_flags);
+        event = trace_buffer_lock_reserve(tr, TRACE_BOOT_RET,
+                                          sizeof(*entry), 0, 0);
         if (!event)
                 goto out;
         entry   = ring_buffer_event_data(event);
-        tracing_generic_entry_update(&entry->ent, 0, 0);
-        entry->ent.type = TRACE_BOOT_RET;
         entry->boot_ret = *bt;
-        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
-
-        trace_wake_up();
-
+        trace_buffer_unlock_commit(tr, event, 0, 0);
  out:
         preempt_enable();
 }
diff --git a/kernel/trace/trace_branch.c b/kernel/trace/trace_branch.c
index 6c00feb3bac7..ad8c22efff41 100644
--- a/kernel/trace/trace_branch.c
+++ b/kernel/trace/trace_branch.c
@@ -14,12 +14,17 @@
 #include <linux/hash.h>
 #include <linux/fs.h>
 #include <asm/local.h>
+
 #include "trace.h"
+#include "trace_stat.h"
+#include "trace_output.h"
 
 #ifdef CONFIG_BRANCH_TRACER
 
+static struct tracer branch_trace;
 static int branch_tracing_enabled __read_mostly;
 static DEFINE_MUTEX(branch_tracing_mutex);
+
 static struct trace_array *branch_tracer;
 
 static void
@@ -28,7 +33,7 @@ probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
         struct trace_array *tr = branch_tracer;
         struct ring_buffer_event *event;
         struct trace_branch *entry;
-        unsigned long flags, irq_flags;
+        unsigned long flags;
         int cpu, pc;
         const char *p;
 
@@ -47,15 +52,13 @@ probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
         if (atomic_inc_return(&tr->data[cpu]->disabled) != 1)
                 goto out;
 
-        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
-                                         &irq_flags);
+        pc = preempt_count();
+        event = trace_buffer_lock_reserve(tr, TRACE_BRANCH,
+                                          sizeof(*entry), flags, pc);
         if (!event)
                 goto out;
 
-        pc = preempt_count();
         entry   = ring_buffer_event_data(event);
-        tracing_generic_entry_update(&entry->ent, flags, pc);
-        entry->ent.type         = TRACE_BRANCH;
 
         /* Strip off the path, only save the file */
         p = f->file + strlen(f->file);
@@ -70,7 +73,7 @@ probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
         entry->line = f->line;
         entry->correct = val == expect;
 
-        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+        ring_buffer_unlock_commit(tr->buffer, event);
 
  out:
         atomic_dec(&tr->data[cpu]->disabled);
@@ -88,8 +91,6 @@ void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
 
 int enable_branch_tracing(struct trace_array *tr)
 {
-        int ret = 0;
-
         mutex_lock(&branch_tracing_mutex);
         branch_tracer = tr;
         /*
@@ -100,7 +101,7 @@ int enable_branch_tracing(struct trace_array *tr)
         branch_tracing_enabled++;
         mutex_unlock(&branch_tracing_mutex);
 
-        return ret;
+        return 0;
 }
 
 void disable_branch_tracing(void)
@@ -128,11 +129,6 @@ static void stop_branch_trace(struct trace_array *tr)
 
 static int branch_trace_init(struct trace_array *tr)
 {
-        int cpu;
-
-        for_each_online_cpu(cpu)
-                tracing_reset(tr, cpu);
-
         start_branch_trace(tr);
         return 0;
 }
@@ -142,22 +138,53 @@ static void branch_trace_reset(struct trace_array *tr)
         stop_branch_trace(tr);
 }
 
-struct tracer branch_trace __read_mostly =
+static enum print_line_t trace_branch_print(struct trace_iterator *iter,
+                                            int flags)
+{
+        struct trace_branch *field;
+
+        trace_assign_type(field, iter->ent);
+
+        if (trace_seq_printf(&iter->seq, "[%s] %s:%s:%d\n",
+                             field->correct ? "  ok  " : " MISS ",
+                             field->func,
+                             field->file,
+                             field->line))
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+
+static struct trace_event trace_branch_event = {
+        .type           = TRACE_BRANCH,
+        .trace          = trace_branch_print,
+};
+
+static struct tracer branch_trace __read_mostly =
 {
         .name           = "branch",
         .init           = branch_trace_init,
         .reset          = branch_trace_reset,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest       = trace_selftest_startup_branch,
-#endif
+#endif /* CONFIG_FTRACE_SELFTEST */
 };
 
-__init static int init_branch_trace(void)
+__init static int init_branch_tracer(void)
 {
+        int ret;
+
+        ret = register_ftrace_event(&trace_branch_event);
+        if (!ret) {
+                printk(KERN_WARNING "Warning: could not register "
+                                    "branch events\n");
+                return 1;
+        }
         return register_tracer(&branch_trace);
 }
+device_initcall(init_branch_tracer);
 
-device_initcall(init_branch_trace);
 #else
 static inline
 void trace_likely_condition(struct ftrace_branch_data *f, int val, int expect)
@@ -183,66 +210,39 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect)
 }
 EXPORT_SYMBOL(ftrace_likely_update);
 
-struct ftrace_pointer {
-        void            *start;
-        void            *stop;
-        int             hit;
-};
+extern unsigned long __start_annotated_branch_profile[];
+extern unsigned long __stop_annotated_branch_profile[];
 
-static void *
-t_next(struct seq_file *m, void *v, loff_t *pos)
+static int annotated_branch_stat_headers(struct seq_file *m)
 {
-        const struct ftrace_pointer *f = m->private;
-        struct ftrace_branch_data *p = v;
-
-        (*pos)++;
-
-        if (v == (void *)1)
-                return f->start;
-
-        ++p;
-
-        if ((void *)p >= (void *)f->stop)
-                return NULL;
-
-        return p;
+        seq_printf(m, " correct incorrect  %% ");
+        seq_printf(m, "       Function                "
+                              "  File              Line\n"
+                              " ------- ---------  - "
+                              "       --------                "
+                              "  ----              ----\n");
+        return 0;
 }
 
-static void *t_start(struct seq_file *m, loff_t *pos)
+static inline long get_incorrect_percent(struct ftrace_branch_data *p)
 {
-        void *t = (void *)1;
-        loff_t l = 0;
-
-        for (; t && l < *pos; t = t_next(m, t, &l))
-                ;
+        long percent;
 
-        return t;
-}
+        if (p->correct) {
+                percent = p->incorrect * 100;
+                percent /= p->correct + p->incorrect;
+        } else
+                percent = p->incorrect ? 100 : -1;
 
-static void t_stop(struct seq_file *m, void *p)
-{
+        return percent;
 }
 
-static int t_show(struct seq_file *m, void *v)
+static int branch_stat_show(struct seq_file *m, void *v)
 {
-        const struct ftrace_pointer *fp = m->private;
         struct ftrace_branch_data *p = v;
         const char *f;
         long percent;
 
-        if (v == (void *)1) {
-                if (fp->hit)
-                        seq_printf(m, "   miss      hit    %% ");
-                else
-                        seq_printf(m, " correct incorrect  %% ");
-                seq_printf(m, "       Function                "
-                              "  File              Line\n"
-                              " ------- ---------  - "
-                              "       --------                "
-                              "  ----              ----\n");
-                return 0;
-        }
-
         /* Only print the file, not the path */
         f = p->file + strlen(p->file);
         while (f >= p->file && *f != '/')
@@ -252,11 +252,7 @@ static int t_show(struct seq_file *m, void *v)
         /*
          * The miss is overlayed on correct, and hit on incorrect.
          */
-        if (p->correct) {
-                percent = p->incorrect * 100;
-                percent /= p->correct + p->incorrect;
-        } else
-                percent = p->incorrect ? 100 : -1;
+        percent = get_incorrect_percent(p);
 
         seq_printf(m, "%8lu %8lu ",  p->correct, p->incorrect);
         if (percent < 0)
@@ -267,76 +263,118 @@ static int t_show(struct seq_file *m, void *v)
         return 0;
 }
 
-static struct seq_operations tracing_likely_seq_ops = {
-        .start          = t_start,
-        .next           = t_next,
-        .stop           = t_stop,
-        .show           = t_show,
+static void *annotated_branch_stat_start(void)
+{
+        return __start_annotated_branch_profile;
+}
+
+static void *
+annotated_branch_stat_next(void *v, int idx)
+{
+        struct ftrace_branch_data *p = v;
+
+        ++p;
+
+        if ((void *)p >= (void *)__stop_annotated_branch_profile)
+                return NULL;
+
+        return p;
+}
+
+static int annotated_branch_stat_cmp(void *p1, void *p2)
+{
+        struct ftrace_branch_data *a = p1;
+        struct ftrace_branch_data *b = p2;
+
+        long percent_a, percent_b;
+
+        percent_a = get_incorrect_percent(a);
+        percent_b = get_incorrect_percent(b);
+
+        if (percent_a < percent_b)
+                return -1;
+        if (percent_a > percent_b)
+                return 1;
+        else
+                return 0;
+}
+
+static struct tracer_stat annotated_branch_stats = {
+        .name = "branch_annotated",
+        .stat_start = annotated_branch_stat_start,
+        .stat_next = annotated_branch_stat_next,
+        .stat_cmp = annotated_branch_stat_cmp,
+        .stat_headers = annotated_branch_stat_headers,
+        .stat_show = branch_stat_show
 };
 
-static int tracing_branch_open(struct inode *inode, struct file *file)
+__init static int init_annotated_branch_stats(void)
 {
         int ret;
 
-        ret = seq_open(file, &tracing_likely_seq_ops);
+        ret = register_stat_tracer(&annotated_branch_stats);
         if (!ret) {
-                struct seq_file *m = file->private_data;
-                m->private = (void *)inode->i_private;
+                printk(KERN_WARNING "Warning: could not register "
+                                    "annotated branches stats\n");
+                return 1;
         }
-
-        return ret;
+        return 0;
 }
-
-static const struct file_operations tracing_branch_fops = {
-        .open           = tracing_branch_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-};
+fs_initcall(init_annotated_branch_stats);
 
 #ifdef CONFIG_PROFILE_ALL_BRANCHES
+
 extern unsigned long __start_branch_profile[];
 extern unsigned long __stop_branch_profile[];
 
-static const struct ftrace_pointer ftrace_branch_pos = {
-        .start                  = __start_branch_profile,
-        .stop                   = __stop_branch_profile,
-        .hit                    = 1,
-};
+static int all_branch_stat_headers(struct seq_file *m)
+{
+        seq_printf(m, "   miss      hit    %% ");
+        seq_printf(m, "       Function                "
+                              "  File              Line\n"
+                              " ------- ---------  - "
+                              "       --------                "
+                              "  ----              ----\n");
+        return 0;
+}
 
-#endif /* CONFIG_PROFILE_ALL_BRANCHES */
+static void *all_branch_stat_start(void)
+{
+        return __start_branch_profile;
+}
 
-extern unsigned long __start_annotated_branch_profile[];
-extern unsigned long __stop_annotated_branch_profile[];
+static void *
+all_branch_stat_next(void *v, int idx)
+{
+        struct ftrace_branch_data *p = v;
 
-static const struct ftrace_pointer ftrace_annotated_branch_pos = {
-        .start                  = __start_annotated_branch_profile,
-        .stop                   = __stop_annotated_branch_profile,
-};
+        ++p;
 
-static __init int ftrace_branch_init(void)
-{
-        struct dentry *d_tracer;
-        struct dentry *entry;
+        if ((void *)p >= (void *)__stop_branch_profile)
+                return NULL;
 
-        d_tracer = tracing_init_dentry();
+        return p;
+}
 
-        entry = debugfs_create_file("profile_annotated_branch", 0444, d_tracer,
-                                    (void *)&ftrace_annotated_branch_pos,
-                                    &tracing_branch_fops);
-        if (!entry)
-                pr_warning("Could not create debugfs "
-                           "'profile_annotatet_branch' entry\n");
+static struct tracer_stat all_branch_stats = {
+        .name = "branch_all",
+        .stat_start = all_branch_stat_start,
+        .stat_next = all_branch_stat_next,
+        .stat_headers = all_branch_stat_headers,
+        .stat_show = branch_stat_show
+};
 
-#ifdef CONFIG_PROFILE_ALL_BRANCHES
-        entry = debugfs_create_file("profile_branch", 0444, d_tracer,
-                                    (void *)&ftrace_branch_pos,
-                                    &tracing_branch_fops);
-        if (!entry)
-                pr_warning("Could not create debugfs"
-                           " 'profile_branch' entry\n");
-#endif
+__init static int all_annotated_branch_stats(void)
+{
+        int ret;
 
+        ret = register_stat_tracer(&all_branch_stats);
+        if (!ret) {
+                printk(KERN_WARNING "Warning: could not register "
+                                    "all branches stats\n");
+                return 1;
+        }
         return 0;
 }
-
-device_initcall(ftrace_branch_init);
+fs_initcall(all_annotated_branch_stats);
+#endif /* CONFIG_PROFILE_ALL_BRANCHES */
diff --git a/kernel/trace/trace_clock.c b/kernel/trace/trace_clock.c
new file mode 100644
index 000000000000..05b176abfd30
--- /dev/null
+++ b/kernel/trace/trace_clock.c
@@ -0,0 +1,108 @@
+/*
+ * tracing clocks
+ *
+ *  Copyright (C) 2009 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
+ *
+ * Implements 3 trace clock variants, with differing scalability/precision
+ * tradeoffs:
+ *
+ *  -   local: CPU-local trace clock
+ *  -  medium: scalable global clock with some jitter
+ *  -  global: globally monotonic, serialized clock
+ *
+ * Tracer plugins will chose a default from these clocks.
+ */
+#include <linux/spinlock.h>
+#include <linux/hardirq.h>
+#include <linux/module.h>
+#include <linux/percpu.h>
+#include <linux/sched.h>
+#include <linux/ktime.h>
+
+/*
+ * trace_clock_local(): the simplest and least coherent tracing clock.
+ *
+ * Useful for tracing that does not cross to other CPUs nor
+ * does it go through idle events.
+ */
+u64 notrace trace_clock_local(void)
+{
+        unsigned long flags;
+        u64 clock;
+
+        /*
+         * sched_clock() is an architecture implemented, fast, scalable,
+         * lockless clock. It is not guaranteed to be coherent across
+         * CPUs, nor across CPU idle events.
+         */
+        raw_local_irq_save(flags);
+        clock = sched_clock();
+        raw_local_irq_restore(flags);
+
+        return clock;
+}
+
+/*
+ * trace_clock(): 'inbetween' trace clock. Not completely serialized,
+ * but not completely incorrect when crossing CPUs either.
+ *
+ * This is based on cpu_clock(), which will allow at most ~1 jiffy of
+ * jitter between CPUs. So it's a pretty scalable clock, but there
+ * can be offsets in the trace data.
+ */
+u64 notrace trace_clock(void)
+{
+        return cpu_clock(raw_smp_processor_id());
+}
+
+
+/*
+ * trace_clock_global(): special globally coherent trace clock
+ *
+ * It has higher overhead than the other trace clocks but is still
+ * an order of magnitude faster than GTOD derived hardware clocks.
+ *
+ * Used by plugins that need globally coherent timestamps.
+ */
+
+static u64 prev_trace_clock_time;
+
+static raw_spinlock_t trace_clock_lock ____cacheline_aligned_in_smp =
+        (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
+
+u64 notrace trace_clock_global(void)
+{
+        unsigned long flags;
+        int this_cpu;
+        u64 now;
+
+        raw_local_irq_save(flags);
+
+        this_cpu = raw_smp_processor_id();
+        now = cpu_clock(this_cpu);
+        /*
+         * If in an NMI context then dont risk lockups and return the
+         * cpu_clock() time:
+         */
+        if (unlikely(in_nmi()))
+                goto out;
+
+        __raw_spin_lock(&trace_clock_lock);
+
+        /*
+         * TODO: if this happens often then maybe we should reset
+         * my_scd->clock to prev_trace_clock_time+1, to make sure
+         * we start ticking with the local clock from now on?
+         */
+        if ((s64)(now - prev_trace_clock_time) < 0)
+                now = prev_trace_clock_time + 1;
+
+        prev_trace_clock_time = now;
+
+        __raw_spin_unlock(&trace_clock_lock);
+
+ out:
+        raw_local_irq_restore(flags);
+
+        return now;
+}
diff --git a/kernel/trace/trace_event_types.h b/kernel/trace/trace_event_types.h
new file mode 100644
index 000000000000..019915063fe6
--- /dev/null
+++ b/kernel/trace/trace_event_types.h
@@ -0,0 +1,175 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM    ftrace
+
+/*
+ * We cheat and use the proto type field as the ID
+ * and args as the entry type (minus 'struct')
+ */
+TRACE_EVENT_FORMAT(function, TRACE_FN, ftrace_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(unsigned long, ip, ip)
+                TRACE_FIELD(unsigned long, parent_ip, parent_ip)
+        ),
+        TP_RAW_FMT(" %lx <-- %lx")
+);
+
+TRACE_EVENT_FORMAT(funcgraph_entry, TRACE_GRAPH_ENT,
+                   ftrace_graph_ent_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(unsigned long, graph_ent.func, func)
+                TRACE_FIELD(int, graph_ent.depth, depth)
+        ),
+        TP_RAW_FMT("--> %lx (%d)")
+);
+
+TRACE_EVENT_FORMAT(funcgraph_exit, TRACE_GRAPH_RET,
+                   ftrace_graph_ret_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(unsigned long, ret.func, func)
+                TRACE_FIELD(int, ret.depth, depth)
+        ),
+        TP_RAW_FMT("<-- %lx (%d)")
+);
+
+TRACE_EVENT_FORMAT(wakeup, TRACE_WAKE, ctx_switch_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(unsigned int, prev_pid, prev_pid)
+                TRACE_FIELD(unsigned char, prev_prio, prev_prio)
+                TRACE_FIELD(unsigned char, prev_state, prev_state)
+                TRACE_FIELD(unsigned int, next_pid, next_pid)
+                TRACE_FIELD(unsigned char, next_prio, next_prio)
+                TRACE_FIELD(unsigned char, next_state, next_state)
+                TRACE_FIELD(unsigned int, next_cpu, next_cpu)
+        ),
+        TP_RAW_FMT("%u:%u:%u  ==+ %u:%u:%u [%03u]")
+);
+
+TRACE_EVENT_FORMAT(context_switch, TRACE_CTX, ctx_switch_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(unsigned int, prev_pid, prev_pid)
+                TRACE_FIELD(unsigned char, prev_prio, prev_prio)
+                TRACE_FIELD(unsigned char, prev_state, prev_state)
+                TRACE_FIELD(unsigned int, next_pid, next_pid)
+                TRACE_FIELD(unsigned char, next_prio, next_prio)
+                TRACE_FIELD(unsigned char, next_state, next_state)
+                TRACE_FIELD(unsigned int, next_cpu, next_cpu)
+        ),
+        TP_RAW_FMT("%u:%u:%u  ==+ %u:%u:%u [%03u]")
+);
+
+TRACE_EVENT_FORMAT(special, TRACE_SPECIAL, special_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(unsigned long, arg1, arg1)
+                TRACE_FIELD(unsigned long, arg2, arg2)
+                TRACE_FIELD(unsigned long, arg3, arg3)
+        ),
+        TP_RAW_FMT("(%08lx) (%08lx) (%08lx)")
+);
+
+/*
+ * Stack-trace entry:
+ */
+
+/* #define FTRACE_STACK_ENTRIES   8 */
+
+TRACE_EVENT_FORMAT(kernel_stack, TRACE_STACK, stack_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(unsigned long, caller[0], stack0)
+                TRACE_FIELD(unsigned long, caller[1], stack1)
+                TRACE_FIELD(unsigned long, caller[2], stack2)
+                TRACE_FIELD(unsigned long, caller[3], stack3)
+                TRACE_FIELD(unsigned long, caller[4], stack4)
+                TRACE_FIELD(unsigned long, caller[5], stack5)
+                TRACE_FIELD(unsigned long, caller[6], stack6)
+                TRACE_FIELD(unsigned long, caller[7], stack7)
+        ),
+        TP_RAW_FMT("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
+                 "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n")
+);
+
+TRACE_EVENT_FORMAT(user_stack, TRACE_USER_STACK, userstack_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(unsigned long, caller[0], stack0)
+                TRACE_FIELD(unsigned long, caller[1], stack1)
+                TRACE_FIELD(unsigned long, caller[2], stack2)
+                TRACE_FIELD(unsigned long, caller[3], stack3)
+                TRACE_FIELD(unsigned long, caller[4], stack4)
+                TRACE_FIELD(unsigned long, caller[5], stack5)
+                TRACE_FIELD(unsigned long, caller[6], stack6)
+                TRACE_FIELD(unsigned long, caller[7], stack7)
+        ),
+        TP_RAW_FMT("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
+                 "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n")
+);
+
+TRACE_EVENT_FORMAT(bprint, TRACE_BPRINT, bprint_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(unsigned long, ip, ip)
+                TRACE_FIELD(unsigned int, depth, depth)
+                TRACE_FIELD(char *, fmt, fmt)
+                TRACE_FIELD_ZERO_CHAR(buf)
+        ),
+        TP_RAW_FMT("%08lx (%d) fmt:%p %s")
+);
+
+TRACE_EVENT_FORMAT(print, TRACE_PRINT, print_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(unsigned long, ip, ip)
+                TRACE_FIELD(unsigned int, depth, depth)
+                TRACE_FIELD_ZERO_CHAR(buf)
+        ),
+        TP_RAW_FMT("%08lx (%d) fmt:%p %s")
+);
+
+TRACE_EVENT_FORMAT(branch, TRACE_BRANCH, trace_branch, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(unsigned int, line, line)
+                TRACE_FIELD_SPECIAL(char func[TRACE_FUNC_SIZE+1], func, func)
+                TRACE_FIELD_SPECIAL(char file[TRACE_FUNC_SIZE+1], file, file)
+                TRACE_FIELD(char, correct, correct)
+        ),
+        TP_RAW_FMT("%u:%s:%s (%u)")
+);
+
+TRACE_EVENT_FORMAT(hw_branch, TRACE_HW_BRANCHES, hw_branch_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(u64, from, from)
+                TRACE_FIELD(u64, to, to)
+        ),
+        TP_RAW_FMT("from: %llx to: %llx")
+);
+
+TRACE_EVENT_FORMAT(power, TRACE_POWER, trace_power, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(ktime_t, state_data.stamp, stamp)
+                TRACE_FIELD(ktime_t, state_data.end, end)
+                TRACE_FIELD(int, state_data.type, type)
+                TRACE_FIELD(int, state_data.state, state)
+        ),
+        TP_RAW_FMT("%llx->%llx type:%u state:%u")
+);
+
+TRACE_EVENT_FORMAT(kmem_alloc, TRACE_KMEM_ALLOC, kmemtrace_alloc_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(enum kmemtrace_type_id, type_id, type_id)
+                TRACE_FIELD(unsigned long, call_site, call_site)
+                TRACE_FIELD(const void *, ptr, ptr)
+                TRACE_FIELD(size_t, bytes_req, bytes_req)
+                TRACE_FIELD(size_t, bytes_alloc, bytes_alloc)
+                TRACE_FIELD(gfp_t, gfp_flags, gfp_flags)
+                TRACE_FIELD(int, node, node)
+        ),
+        TP_RAW_FMT("type:%u call_site:%lx ptr:%p req:%lu alloc:%lu"
+                 " flags:%x node:%d")
+);
+
+TRACE_EVENT_FORMAT(kmem_free, TRACE_KMEM_FREE, kmemtrace_free_entry, ignore,
+        TRACE_STRUCT(
+                TRACE_FIELD(enum kmemtrace_type_id, type_id, type_id)
+                TRACE_FIELD(unsigned long, call_site, call_site)
+                TRACE_FIELD(const void *, ptr, ptr)
+        ),
+        TP_RAW_FMT("type:%u call_site:%lx ptr:%p")
+);
+
+#undef TRACE_SYSTEM
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
new file mode 100644
index 000000000000..c88227b3b9db
--- /dev/null
+++ b/kernel/trace/trace_events.c
@@ -0,0 +1,604 @@
+/*
+ * event tracer
+ *
+ * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ *  - Added format output of fields of the trace point.
+ *    This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
+ *
+ */
+
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <linux/ctype.h>
+
+#include "trace_output.h"
+
+#define TRACE_SYSTEM "TRACE_SYSTEM"
+
+static DEFINE_MUTEX(event_mutex);
+
+#define events_for_each(event)                                          \
+        for (event = __start_ftrace_events;                             \
+             (unsigned long)event < (unsigned long)__stop_ftrace_events; \
+             event++)
+
+static void ftrace_clear_events(void)
+{
+        struct ftrace_event_call *call = (void *)__start_ftrace_events;
+
+
+        while ((unsigned long)call < (unsigned long)__stop_ftrace_events) {
+
+                if (call->enabled) {
+                        call->enabled = 0;
+                        call->unregfunc();
+                }
+                call++;
+        }
+}
+
+static void ftrace_event_enable_disable(struct ftrace_event_call *call,
+                                        int enable)
+{
+
+        switch (enable) {
+        case 0:
+                if (call->enabled) {
+                        call->enabled = 0;
+                        call->unregfunc();
+                }
+                break;
+        case 1:
+                if (!call->enabled) {
+                        call->enabled = 1;
+                        call->regfunc();
+                }
+                break;
+        }
+}
+
+static int ftrace_set_clr_event(char *buf, int set)
+{
+        struct ftrace_event_call *call = __start_ftrace_events;
+        char *event = NULL, *sub = NULL, *match;
+        int ret = -EINVAL;
+
+        /*
+         * The buf format can be <subsystem>:<event-name>
+         *  *:<event-name> means any event by that name.
+         *  :<event-name> is the same.
+         *
+         *  <subsystem>:* means all events in that subsystem
+         *  <subsystem>: means the same.
+         *
+         *  <name> (no ':') means all events in a subsystem with
+         *  the name <name> or any event that matches <name>
+         */
+
+        match = strsep(&buf, ":");
+        if (buf) {
+                sub = match;
+                event = buf;
+                match = NULL;
+
+                if (!strlen(sub) || strcmp(sub, "*") == 0)
+                        sub = NULL;
+                if (!strlen(event) || strcmp(event, "*") == 0)
+                        event = NULL;
+        }
+
+        mutex_lock(&event_mutex);
+        events_for_each(call) {
+
+                if (!call->name || !call->regfunc)
+                        continue;
+
+                if (match &&
+                    strcmp(match, call->name) != 0 &&
+                    strcmp(match, call->system) != 0)
+                        continue;
+
+                if (sub && strcmp(sub, call->system) != 0)
+                        continue;
+
+                if (event && strcmp(event, call->name) != 0)
+                        continue;
+
+                ftrace_event_enable_disable(call, set);
+
+                ret = 0;
+        }
+        mutex_unlock(&event_mutex);
+
+        return ret;
+}
+
+/* 128 should be much more than enough */
+#define EVENT_BUF_SIZE          127
+
+static ssize_t
+ftrace_event_write(struct file *file, const char __user *ubuf,
+                   size_t cnt, loff_t *ppos)
+{
+        size_t read = 0;
+        int i, set = 1;
+        ssize_t ret;
+        char *buf;
+        char ch;
+
+        if (!cnt || cnt < 0)
+                return 0;
+
+        ret = tracing_update_buffers();
+        if (ret < 0)
+                return ret;
+
+        ret = get_user(ch, ubuf++);
+        if (ret)
+                return ret;
+        read++;
+        cnt--;
+
+        /* skip white space */
+        while (cnt && isspace(ch)) {
+                ret = get_user(ch, ubuf++);
+                if (ret)
+                        return ret;
+                read++;
+                cnt--;
+        }
+
+        /* Only white space found? */
+        if (isspace(ch)) {
+                file->f_pos += read;
+                ret = read;
+                return ret;
+        }
+
+        buf = kmalloc(EVENT_BUF_SIZE+1, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        if (cnt > EVENT_BUF_SIZE)
+                cnt = EVENT_BUF_SIZE;
+
+        i = 0;
+        while (cnt && !isspace(ch)) {
+                if (!i && ch == '!')
+                        set = 0;
+                else
+                        buf[i++] = ch;
+
+                ret = get_user(ch, ubuf++);
+                if (ret)
+                        goto out_free;
+                read++;
+                cnt--;
+        }
+        buf[i] = 0;
+
+        file->f_pos += read;
+
+        ret = ftrace_set_clr_event(buf, set);
+        if (ret)
+                goto out_free;
+
+        ret = read;
+
+ out_free:
+        kfree(buf);
+
+        return ret;
+}
+
+static void *
+t_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        struct ftrace_event_call *call = m->private;
+        struct ftrace_event_call *next = call;
+
+        (*pos)++;
+
+        for (;;) {
+                if ((unsigned long)call >= (unsigned long)__stop_ftrace_events)
+                        return NULL;
+
+                /*
+                 * The ftrace subsystem is for showing formats only.
+                 * They can not be enabled or disabled via the event files.
+                 */
+                if (call->regfunc)
+                        break;
+
+                call++;
+                next = call;
+        }
+
+        m->private = ++next;
+
+        return call;
+}
+
+static void *t_start(struct seq_file *m, loff_t *pos)
+{
+        return t_next(m, NULL, pos);
+}
+
+static void *
+s_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        struct ftrace_event_call *call = m->private;
+        struct ftrace_event_call *next;
+
+        (*pos)++;
+
+ retry:
+        if ((unsigned long)call >= (unsigned long)__stop_ftrace_events)
+                return NULL;
+
+        if (!call->enabled) {
+                call++;
+                goto retry;
+        }
+
+        next = call;
+        m->private = ++next;
+
+        return call;
+}
+
+static void *s_start(struct seq_file *m, loff_t *pos)
+{
+        return s_next(m, NULL, pos);
+}
+
+static int t_show(struct seq_file *m, void *v)
+{
+        struct ftrace_event_call *call = v;
+
+        if (strcmp(call->system, TRACE_SYSTEM) != 0)
+                seq_printf(m, "%s:", call->system);
+        seq_printf(m, "%s\n", call->name);
+
+        return 0;
+}
+
+static void t_stop(struct seq_file *m, void *p)
+{
+}
+
+static int
+ftrace_event_seq_open(struct inode *inode, struct file *file)
+{
+        int ret;
+        const struct seq_operations *seq_ops;
+
+        if ((file->f_mode & FMODE_WRITE) &&
+            !(file->f_flags & O_APPEND))
+                ftrace_clear_events();
+
+        seq_ops = inode->i_private;
+        ret = seq_open(file, seq_ops);
+        if (!ret) {
+                struct seq_file *m = file->private_data;
+
+                m->private = __start_ftrace_events;
+        }
+        return ret;
+}
+
+static ssize_t
+event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
+                  loff_t *ppos)
+{
+        struct ftrace_event_call *call = filp->private_data;
+        char *buf;
+
+        if (call->enabled)
+                buf = "1\n";
+        else
+                buf = "0\n";
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
+}
+
+static ssize_t
+event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
+                   loff_t *ppos)
+{
+        struct ftrace_event_call *call = filp->private_data;
+        char buf[64];
+        unsigned long val;
+        int ret;
+
+        if (cnt >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret < 0)
+                return ret;
+
+        ret = tracing_update_buffers();
+        if (ret < 0)
+                return ret;
+
+        switch (val) {
+        case 0:
+        case 1:
+                mutex_lock(&event_mutex);
+                ftrace_event_enable_disable(call, val);
+                mutex_unlock(&event_mutex);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        *ppos += cnt;
+
+        return cnt;
+}
+
+#undef FIELD
+#define FIELD(type, name)                                               \
+        #type, #name, offsetof(typeof(field), name), sizeof(field.name)
+
+static int trace_write_header(struct trace_seq *s)
+{
+        struct trace_entry field;
+
+        /* struct trace_entry */
+        return trace_seq_printf(s,
+                                "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
+                                "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
+                                "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
+                                "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
+                                "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
+                                "\n",
+                                FIELD(unsigned char, type),
+                                FIELD(unsigned char, flags),
+                                FIELD(unsigned char, preempt_count),
+                                FIELD(int, pid),
+                                FIELD(int, tgid));
+}
+
+static ssize_t
+event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
+                  loff_t *ppos)
+{
+        struct ftrace_event_call *call = filp->private_data;
+        struct trace_seq *s;
+        char *buf;
+        int r;
+
+        if (*ppos)
+                return 0;
+
+        s = kmalloc(sizeof(*s), GFP_KERNEL);
+        if (!s)
+                return -ENOMEM;
+
+        trace_seq_init(s);
+
+        /* If any of the first writes fail, so will the show_format. */
+
+        trace_seq_printf(s, "name: %s\n", call->name);
+        trace_seq_printf(s, "ID: %d\n", call->id);
+        trace_seq_printf(s, "format:\n");
+        trace_write_header(s);
+
+        r = call->show_format(s);
+        if (!r) {
+                /*
+                 * ug!  The format output is bigger than a PAGE!!
+                 */
+                buf = "FORMAT TOO BIG\n";
+                r = simple_read_from_buffer(ubuf, cnt, ppos,
+                                              buf, strlen(buf));
+                goto out;
+        }
+
+        r = simple_read_from_buffer(ubuf, cnt, ppos,
+                                    s->buffer, s->len);
+ out:
+        kfree(s);
+        return r;
+}
+
+static const struct seq_operations show_event_seq_ops = {
+        .start = t_start,
+        .next = t_next,
+        .show = t_show,
+        .stop = t_stop,
+};
+
+static const struct seq_operations show_set_event_seq_ops = {
+        .start = s_start,
+        .next = s_next,
+        .show = t_show,
+        .stop = t_stop,
+};
+
+static const struct file_operations ftrace_avail_fops = {
+        .open = ftrace_event_seq_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = seq_release,
+};
+
+static const struct file_operations ftrace_set_event_fops = {
+        .open = ftrace_event_seq_open,
+        .read = seq_read,
+        .write = ftrace_event_write,
+        .llseek = seq_lseek,
+        .release = seq_release,
+};
+
+static const struct file_operations ftrace_enable_fops = {
+        .open = tracing_open_generic,
+        .read = event_enable_read,
+        .write = event_enable_write,
+};
+
+static const struct file_operations ftrace_event_format_fops = {
+        .open = tracing_open_generic,
+        .read = event_format_read,
+};
+
+static struct dentry *event_trace_events_dir(void)
+{
+        static struct dentry *d_tracer;
+        static struct dentry *d_events;
+
+        if (d_events)
+                return d_events;
+
+        d_tracer = tracing_init_dentry();
+        if (!d_tracer)
+                return NULL;
+
+        d_events = debugfs_create_dir("events", d_tracer);
+        if (!d_events)
+                pr_warning("Could not create debugfs "
+                           "'events' directory\n");
+
+        return d_events;
+}
+
+struct event_subsystem {
+        struct list_head        list;
+        const char              *name;
+        struct dentry           *entry;
+};
+
+static LIST_HEAD(event_subsystems);
+
+static struct dentry *
+event_subsystem_dir(const char *name, struct dentry *d_events)
+{
+        struct event_subsystem *system;
+
+        /* First see if we did not already create this dir */
+        list_for_each_entry(system, &event_subsystems, list) {
+                if (strcmp(system->name, name) == 0)
+                        return system->entry;
+        }
+
+        /* need to create new entry */
+        system = kmalloc(sizeof(*system), GFP_KERNEL);
+        if (!system) {
+                pr_warning("No memory to create event subsystem %s\n",
+                           name);
+                return d_events;
+        }
+
+        system->entry = debugfs_create_dir(name, d_events);
+        if (!system->entry) {
+                pr_warning("Could not create event subsystem %s\n",
+                           name);
+                kfree(system);
+                return d_events;
+        }
+
+        system->name = name;
+        list_add(&system->list, &event_subsystems);
+
+        return system->entry;
+}
+
+static int
+event_create_dir(struct ftrace_event_call *call, struct dentry *d_events)
+{
+        struct dentry *entry;
+        int ret;
+
+        /*
+         * If the trace point header did not define TRACE_SYSTEM
+         * then the system would be called "TRACE_SYSTEM".
+         */
+        if (strcmp(call->system, "TRACE_SYSTEM") != 0)
+                d_events = event_subsystem_dir(call->system, d_events);
+
+        if (call->raw_init) {
+                ret = call->raw_init();
+                if (ret < 0) {
+                        pr_warning("Could not initialize trace point"
+                                   " events/%s\n", call->name);
+                        return ret;
+                }
+        }
+
+        call->dir = debugfs_create_dir(call->name, d_events);
+        if (!call->dir) {
+                pr_warning("Could not create debugfs "
+                           "'%s' directory\n", call->name);
+                return -1;
+        }
+
+        if (call->regfunc) {
+                entry = debugfs_create_file("enable", 0644, call->dir, call,
+                                            &ftrace_enable_fops);
+                if (!entry)
+                        pr_warning("Could not create debugfs "
+                                   "'%s/enable' entry\n", call->name);
+        }
+
+        /* A trace may not want to export its format */
+        if (!call->show_format)
+                return 0;
+
+        entry = debugfs_create_file("format", 0444, call->dir, call,
+                                    &ftrace_event_format_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs "
+                           "'%s/format' entry\n", call->name);
+
+        return 0;
+}
+
+static __init int event_trace_init(void)
+{
+        struct ftrace_event_call *call = __start_ftrace_events;
+        struct dentry *d_tracer;
+        struct dentry *entry;
+        struct dentry *d_events;
+
+        d_tracer = tracing_init_dentry();
+        if (!d_tracer)
+                return 0;
+
+        entry = debugfs_create_file("available_events", 0444, d_tracer,
+                                    (void *)&show_event_seq_ops,
+                                    &ftrace_avail_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs "
+                           "'available_events' entry\n");
+
+        entry = debugfs_create_file("set_event", 0644, d_tracer,
+                                    (void *)&show_set_event_seq_ops,
+                                    &ftrace_set_event_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs "
+                           "'set_event' entry\n");
+
+        d_events = event_trace_events_dir();
+        if (!d_events)
+                return 0;
+
+        events_for_each(call) {
+                /* The linker may leave blanks */
+                if (!call->name)
+                        continue;
+                event_create_dir(call, d_events);
+        }
+
+        return 0;
+}
+fs_initcall(event_trace_init);
diff --git a/kernel/trace/trace_events_stage_1.h b/kernel/trace/trace_events_stage_1.h
new file mode 100644
index 000000000000..38985f9b379c
--- /dev/null
+++ b/kernel/trace/trace_events_stage_1.h
@@ -0,0 +1,39 @@
+/*
+ * Stage 1 of the trace events.
+ *
+ * Override the macros in <trace/trace_event_types.h> to include the following:
+ *
+ * struct ftrace_raw_<call> {
+ *      struct trace_entry              ent;
+ *      <type>                          <item>;
+ *      <type2>                         <item2>[<len>];
+ *      [...]
+ * };
+ *
+ * The <type> <item> is created by the __field(type, item) macro or
+ * the __array(type2, item2, len) macro.
+ * We simply do "type item;", and that will create the fields
+ * in the structure.
+ */
+
+#undef TRACE_FORMAT
+#define TRACE_FORMAT(call, proto, args, fmt)
+
+#undef __array
+#define __array(type, item, len)        type    item[len];
+
+#undef __field
+#define __field(type, item)             type    item;
+
+#undef TP_STRUCT__entry
+#define TP_STRUCT__entry(args...) args
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(name, proto, args, tstruct, assign, print)  \
+        struct ftrace_raw_##name {                              \
+                struct trace_entry      ent;                    \
+                tstruct                                         \
+        };                                                      \
+        static struct ftrace_event_call event_##name
+
+#include <trace/trace_event_types.h>
diff --git a/kernel/trace/trace_events_stage_2.h b/kernel/trace/trace_events_stage_2.h
new file mode 100644
index 000000000000..5117c43f5c67
--- /dev/null
+++ b/kernel/trace/trace_events_stage_2.h
@@ -0,0 +1,131 @@
+/*
+ * Stage 2 of the trace events.
+ *
+ * Override the macros in <trace/trace_event_types.h> to include the following:
+ *
+ * enum print_line_t
+ * ftrace_raw_output_<call>(struct trace_iterator *iter, int flags)
+ * {
+ *      struct trace_seq *s = &iter->seq;
+ *      struct ftrace_raw_<call> *field; <-- defined in stage 1
+ *      struct trace_entry *entry;
+ *      int ret;
+ *
+ *      entry = iter->ent;
+ *
+ *      if (entry->type != event_<call>.id) {
+ *              WARN_ON_ONCE(1);
+ *              return TRACE_TYPE_UNHANDLED;
+ *      }
+ *
+ *      field = (typeof(field))entry;
+ *
+ *      ret = trace_seq_printf(s, <TP_printk> "\n");
+ *      if (!ret)
+ *              return TRACE_TYPE_PARTIAL_LINE;
+ *
+ *      return TRACE_TYPE_HANDLED;
+ * }
+ *
+ * This is the method used to print the raw event to the trace
+ * output format. Note, this is not needed if the data is read
+ * in binary.
+ */
+
+#undef __entry
+#define __entry field
+
+#undef TP_printk
+#define TP_printk(fmt, args...) fmt "\n", args
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(call, proto, args, tstruct, assign, print)          \
+enum print_line_t                                                       \
+ftrace_raw_output_##call(struct trace_iterator *iter, int flags)        \
+{                                                                       \
+        struct trace_seq *s = &iter->seq;                               \
+        struct ftrace_raw_##call *field;                                \
+        struct trace_entry *entry;                                      \
+        int ret;                                                        \
+                                                                        \
+        entry = iter->ent;                                              \
+                                                                        \
+        if (entry->type != event_##call.id) {                           \
+                WARN_ON_ONCE(1);                                        \
+                return TRACE_TYPE_UNHANDLED;                            \
+        }                                                               \
+                                                                        \
+        field = (typeof(field))entry;                                   \
+                                                                        \
+        ret = trace_seq_printf(s, #call ": " print);                    \
+        if (!ret)                                                       \
+                return TRACE_TYPE_PARTIAL_LINE;                         \
+                                                                        \
+        return TRACE_TYPE_HANDLED;                                      \
+}
+        
+#include <trace/trace_event_types.h>
+
+/*
+ * Setup the showing format of trace point.
+ *
+ * int
+ * ftrace_format_##call(struct trace_seq *s)
+ * {
+ *      struct ftrace_raw_##call field;
+ *      int ret;
+ *
+ *      ret = trace_seq_printf(s, #type " " #item ";"
+ *                             " offset:%u; size:%u;\n",
+ *                             offsetof(struct ftrace_raw_##call, item),
+ *                             sizeof(field.type));
+ *
+ * }
+ */
+
+#undef TP_STRUCT__entry
+#define TP_STRUCT__entry(args...) args
+
+#undef __field
+#define __field(type, item)                                     \
+        ret = trace_seq_printf(s, "\tfield:" #type " " #item ";\t"      \
+                               "offset:%u;\tsize:%u;\n",                \
+                               (unsigned int)offsetof(typeof(field), item), \
+                               (unsigned int)sizeof(field.item));       \
+        if (!ret)                                                       \
+                return 0;
+
+#undef __array
+#define __array(type, item, len)                                                \
+        ret = trace_seq_printf(s, "\tfield:" #type " " #item "[" #len "];\t"    \
+                               "offset:%u;\tsize:%u;\n",                \
+                               (unsigned int)offsetof(typeof(field), item), \
+                               (unsigned int)sizeof(field.item));       \
+        if (!ret)                                                       \
+                return 0;
+
+#undef __entry
+#define __entry "REC"
+
+#undef TP_printk
+#define TP_printk(fmt, args...) "%s, %s\n", #fmt, #args
+
+#undef TP_fast_assign
+#define TP_fast_assign(args...) args
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(call, proto, args, tstruct, func, print)            \
+static int                                                              \
+ftrace_format_##call(struct trace_seq *s)                               \
+{                                                                       \
+        struct ftrace_raw_##call field;                                 \
+        int ret;                                                        \
+                                                                        \
+        tstruct;                                                        \
+                                                                        \
+        trace_seq_printf(s, "\nprint fmt: " print);                     \
+                                                                        \
+        return ret;                                                     \
+}
+
+#include <trace/trace_event_types.h>
diff --git a/kernel/trace/trace_events_stage_3.h b/kernel/trace/trace_events_stage_3.h
new file mode 100644
index 000000000000..ae2e323df0c7
--- /dev/null
+++ b/kernel/trace/trace_events_stage_3.h
@@ -0,0 +1,217 @@
+/*
+ * Stage 3 of the trace events.
+ *
+ * Override the macros in <trace/trace_event_types.h> to include the following:
+ *
+ * static void ftrace_event_<call>(proto)
+ * {
+ *      event_trace_printk(_RET_IP_, "<call>: " <fmt>);
+ * }
+ *
+ * static int ftrace_reg_event_<call>(void)
+ * {
+ *      int ret;
+ *
+ *      ret = register_trace_<call>(ftrace_event_<call>);
+ *      if (!ret)
+ *              pr_info("event trace: Could not activate trace point "
+ *                      "probe to  <call>");
+ *      return ret;
+ * }
+ *
+ * static void ftrace_unreg_event_<call>(void)
+ * {
+ *      unregister_trace_<call>(ftrace_event_<call>);
+ * }
+ *
+ * For those macros defined with TRACE_FORMAT:
+ *
+ * static struct ftrace_event_call __used
+ * __attribute__((__aligned__(4)))
+ * __attribute__((section("_ftrace_events"))) event_<call> = {
+ *      .name                   = "<call>",
+ *      .regfunc                = ftrace_reg_event_<call>,
+ *      .unregfunc              = ftrace_unreg_event_<call>,
+ * }
+ *
+ *
+ * For those macros defined with TRACE_EVENT:
+ *
+ * static struct ftrace_event_call event_<call>;
+ *
+ * static void ftrace_raw_event_<call>(proto)
+ * {
+ *      struct ring_buffer_event *event;
+ *      struct ftrace_raw_<call> *entry; <-- defined in stage 1
+ *      unsigned long irq_flags;
+ *      int pc;
+ *
+ *      local_save_flags(irq_flags);
+ *      pc = preempt_count();
+ *
+ *      event = trace_current_buffer_lock_reserve(event_<call>.id,
+ *                                sizeof(struct ftrace_raw_<call>),
+ *                                irq_flags, pc);
+ *      if (!event)
+ *              return;
+ *      entry   = ring_buffer_event_data(event);
+ *
+ *      <assign>;  <-- Here we assign the entries by the __field and
+ *                      __array macros.
+ *
+ *      trace_current_buffer_unlock_commit(event, irq_flags, pc);
+ * }
+ *
+ * static int ftrace_raw_reg_event_<call>(void)
+ * {
+ *      int ret;
+ *
+ *      ret = register_trace_<call>(ftrace_raw_event_<call>);
+ *      if (!ret)
+ *              pr_info("event trace: Could not activate trace point "
+ *                      "probe to <call>");
+ *      return ret;
+ * }
+ *
+ * static void ftrace_unreg_event_<call>(void)
+ * {
+ *      unregister_trace_<call>(ftrace_raw_event_<call>);
+ * }
+ *
+ * static struct trace_event ftrace_event_type_<call> = {
+ *      .trace                  = ftrace_raw_output_<call>, <-- stage 2
+ * };
+ *
+ * static int ftrace_raw_init_event_<call>(void)
+ * {
+ *      int id;
+ *
+ *      id = register_ftrace_event(&ftrace_event_type_<call>);
+ *      if (!id)
+ *              return -ENODEV;
+ *      event_<call>.id = id;
+ *      return 0;
+ * }
+ *
+ * static struct ftrace_event_call __used
+ * __attribute__((__aligned__(4)))
+ * __attribute__((section("_ftrace_events"))) event_<call> = {
+ *      .name                   = "<call>",
+ *      .system                 = "<system>",
+ *      .raw_init               = ftrace_raw_init_event_<call>,
+ *      .regfunc                = ftrace_reg_event_<call>,
+ *      .unregfunc              = ftrace_unreg_event_<call>,
+ *      .show_format            = ftrace_format_<call>,
+ * }
+ *
+ */
+
+#undef TP_FMT
+#define TP_FMT(fmt, args...)    fmt "\n", ##args
+
+#define _TRACE_FORMAT(call, proto, args, fmt)                           \
+static void ftrace_event_##call(proto)                                  \
+{                                                                       \
+        event_trace_printk(_RET_IP_, #call ": " fmt);                   \
+}                                                                       \
+                                                                        \
+static int ftrace_reg_event_##call(void)                                \
+{                                                                       \
+        int ret;                                                        \
+                                                                        \
+        ret = register_trace_##call(ftrace_event_##call);               \
+        if (ret)                                                        \
+                pr_info("event trace: Could not activate trace point "  \
+                        "probe to " #call "\n");                        \
+        return ret;                                                     \
+}                                                                       \
+                                                                        \
+static void ftrace_unreg_event_##call(void)                             \
+{                                                                       \
+        unregister_trace_##call(ftrace_event_##call);                   \
+}                                                                       \
+
+
+#undef TRACE_FORMAT
+#define TRACE_FORMAT(call, proto, args, fmt)                            \
+_TRACE_FORMAT(call, PARAMS(proto), PARAMS(args), PARAMS(fmt))           \
+static struct ftrace_event_call __used                                  \
+__attribute__((__aligned__(4)))                                         \
+__attribute__((section("_ftrace_events"))) event_##call = {             \
+        .name                   = #call,                                \
+        .system                 = __stringify(TRACE_SYSTEM),            \
+        .regfunc                = ftrace_reg_event_##call,              \
+        .unregfunc              = ftrace_unreg_event_##call,            \
+}
+
+#undef __entry
+#define __entry entry
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(call, proto, args, tstruct, assign, print)          \
+                                                                        \
+static struct ftrace_event_call event_##call;                           \
+                                                                        \
+static void ftrace_raw_event_##call(proto)                              \
+{                                                                       \
+        struct ring_buffer_event *event;                                \
+        struct ftrace_raw_##call *entry;                                \
+        unsigned long irq_flags;                                        \
+        int pc;                                                         \
+                                                                        \
+        local_save_flags(irq_flags);                                    \
+        pc = preempt_count();                                           \
+                                                                        \
+        event = trace_current_buffer_lock_reserve(event_##call.id,      \
+                                  sizeof(struct ftrace_raw_##call),     \
+                                  irq_flags, pc);                       \
+        if (!event)                                                     \
+                return;                                                 \
+        entry   = ring_buffer_event_data(event);                        \
+                                                                        \
+        assign;                                                         \
+                                                                        \
+        trace_current_buffer_unlock_commit(event, irq_flags, pc);       \
+}                                                                       \
+                                                                        \
+static int ftrace_raw_reg_event_##call(void)                            \
+{                                                                       \
+        int ret;                                                        \
+                                                                        \
+        ret = register_trace_##call(ftrace_raw_event_##call);           \
+        if (ret)                                                        \
+                pr_info("event trace: Could not activate trace point "  \
+                        "probe to " #call "\n");                        \
+        return ret;                                                     \
+}                                                                       \
+                                                                        \
+static void ftrace_raw_unreg_event_##call(void)                         \
+{                                                                       \
+        unregister_trace_##call(ftrace_raw_event_##call);               \
+}                                                                       \
+                                                                        \
+static struct trace_event ftrace_event_type_##call = {                  \
+        .trace                  = ftrace_raw_output_##call,             \
+};                                                                      \
+                                                                        \
+static int ftrace_raw_init_event_##call(void)                           \
+{                                                                       \
+        int id;                                                         \
+                                                                        \
+        id = register_ftrace_event(&ftrace_event_type_##call);          \
+        if (!id)                                                        \
+                return -ENODEV;                                         \
+        event_##call.id = id;                                           \
+        return 0;                                                       \
+}                                                                       \
+                                                                        \
+static struct ftrace_event_call __used                                  \
+__attribute__((__aligned__(4)))                                         \
+__attribute__((section("_ftrace_events"))) event_##call = {             \
+        .name                   = #call,                                \
+        .system                 = __stringify(TRACE_SYSTEM),            \
+        .raw_init               = ftrace_raw_init_event_##call,         \
+        .regfunc                = ftrace_raw_reg_event_##call,          \
+        .unregfunc              = ftrace_raw_unreg_event_##call,        \
+        .show_format            = ftrace_format_##call,                 \
+}
diff --git a/kernel/trace/trace_export.c b/kernel/trace/trace_export.c
new file mode 100644
index 000000000000..4d9952d3df50
--- /dev/null
+++ b/kernel/trace/trace_export.c
@@ -0,0 +1,102 @@
+/*
+ * trace_export.c - export basic ftrace utilities to user space
+ *
+ * Copyright (C) 2009 Steven Rostedt <srostedt@redhat.com>
+ */
+#include <linux/stringify.h>
+#include <linux/kallsyms.h>
+#include <linux/seq_file.h>
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/ftrace.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+
+#include "trace_output.h"
+
+
+#undef TRACE_STRUCT
+#define TRACE_STRUCT(args...) args
+
+#undef TRACE_FIELD
+#define TRACE_FIELD(type, item, assign)                                 \
+        ret = trace_seq_printf(s, "\tfield:" #type " " #item ";\t"      \
+                               "offset:%u;\tsize:%u;\n",                \
+                               (unsigned int)offsetof(typeof(field), item), \
+                               (unsigned int)sizeof(field.item));       \
+        if (!ret)                                                       \
+                return 0;
+
+
+#undef TRACE_FIELD_SPECIAL
+#define TRACE_FIELD_SPECIAL(type_item, item, cmd)                       \
+        ret = trace_seq_printf(s, "\tfield special:" #type_item ";\t"   \
+                               "offset:%u;\tsize:%u;\n",                \
+                               (unsigned int)offsetof(typeof(field), item), \
+                               (unsigned int)sizeof(field.item));       \
+        if (!ret)                                                       \
+                return 0;
+
+#undef TRACE_FIELD_ZERO_CHAR
+#define TRACE_FIELD_ZERO_CHAR(item)                                     \
+        ret = trace_seq_printf(s, "\tfield: char " #item ";\t"          \
+                               "offset:%u;\tsize:0;\n",                 \
+                               (unsigned int)offsetof(typeof(field), item)); \
+        if (!ret)                                                       \
+                return 0;
+
+
+#undef TP_RAW_FMT
+#define TP_RAW_FMT(args...) args
+
+#undef TRACE_EVENT_FORMAT
+#define TRACE_EVENT_FORMAT(call, proto, args, fmt, tstruct, tpfmt)      \
+static int                                                              \
+ftrace_format_##call(struct trace_seq *s)                               \
+{                                                                       \
+        struct args field;                                              \
+        int ret;                                                        \
+                                                                        \
+        tstruct;                                                        \
+                                                                        \
+        trace_seq_printf(s, "\nprint fmt: \"%s\"\n", tpfmt);            \
+                                                                        \
+        return ret;                                                     \
+}
+
+#include "trace_event_types.h"
+
+#undef TRACE_ZERO_CHAR
+#define TRACE_ZERO_CHAR(arg)
+
+#undef TRACE_FIELD
+#define TRACE_FIELD(type, item, assign)\
+        entry->item = assign;
+
+#undef TRACE_FIELD
+#define TRACE_FIELD(type, item, assign)\
+        entry->item = assign;
+
+#undef TP_CMD
+#define TP_CMD(cmd...)  cmd
+
+#undef TRACE_ENTRY
+#define TRACE_ENTRY     entry
+
+#undef TRACE_FIELD_SPECIAL
+#define TRACE_FIELD_SPECIAL(type_item, item, cmd) \
+        cmd;
+
+#undef TRACE_EVENT_FORMAT
+#define TRACE_EVENT_FORMAT(call, proto, args, fmt, tstruct, tpfmt)      \
+                                                                        \
+static struct ftrace_event_call __used                                  \
+__attribute__((__aligned__(4)))                                         \
+__attribute__((section("_ftrace_events"))) event_##call = {             \
+        .name                   = #call,                                \
+        .id                     = proto,                                \
+        .system                 = __stringify(TRACE_SYSTEM),            \
+        .show_format            = ftrace_format_##call,                 \
+}
+#include "trace_event_types.h"
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index 9236d7e25a16..c9a0b7df44ff 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -9,6 +9,7 @@
  *  Copyright (C) 2004-2006 Ingo Molnar
  *  Copyright (C) 2004 William Lee Irwin III
  */
+#include <linux/ring_buffer.h>
 #include <linux/debugfs.h>
 #include <linux/uaccess.h>
 #include <linux/ftrace.h>
@@ -16,52 +17,388 @@
 
 #include "trace.h"
 
-static void start_function_trace(struct trace_array *tr)
+/* function tracing enabled */
+static int                      ftrace_function_enabled;
+
+static struct trace_array       *func_trace;
+
+static void tracing_start_function_trace(void);
+static void tracing_stop_function_trace(void);
+
+static int function_trace_init(struct trace_array *tr)
 {
+        func_trace = tr;
         tr->cpu = get_cpu();
-        tracing_reset_online_cpus(tr);
         put_cpu();
 
         tracing_start_cmdline_record();
         tracing_start_function_trace();
+        return 0;
 }
 
-static void stop_function_trace(struct trace_array *tr)
+static void function_trace_reset(struct trace_array *tr)
 {
         tracing_stop_function_trace();
         tracing_stop_cmdline_record();
 }
 
-static int function_trace_init(struct trace_array *tr)
+static void function_trace_start(struct trace_array *tr)
 {
-        start_function_trace(tr);
-        return 0;
+        tracing_reset_online_cpus(tr);
 }
 
-static void function_trace_reset(struct trace_array *tr)
+static void
+function_trace_call_preempt_only(unsigned long ip, unsigned long parent_ip)
+{
+        struct trace_array *tr = func_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu, resched;
+        int pc;
+
+        if (unlikely(!ftrace_function_enabled))
+                return;
+
+        pc = preempt_count();
+        resched = ftrace_preempt_disable();
+        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, ip, parent_ip, flags, pc);
+
+        atomic_dec(&data->disabled);
+        ftrace_preempt_enable(resched);
+}
+
+static void
+function_trace_call(unsigned long ip, unsigned long parent_ip)
 {
-        stop_function_trace(tr);
+        struct trace_array *tr = func_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+        int pc;
+
+        if (unlikely(!ftrace_function_enabled))
+                return;
+
+        /*
+         * Need to use raw, since this must be called before the
+         * recursive protection is performed.
+         */
+        local_irq_save(flags);
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+        disabled = atomic_inc_return(&data->disabled);
+
+        if (likely(disabled == 1)) {
+                pc = preempt_count();
+                trace_function(tr, ip, parent_ip, flags, pc);
+        }
+
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
 }
 
-static void function_trace_start(struct trace_array *tr)
+static void
+function_stack_trace_call(unsigned long ip, unsigned long parent_ip)
 {
-        tracing_reset_online_cpus(tr);
+        struct trace_array *tr = func_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+        int pc;
+
+        if (unlikely(!ftrace_function_enabled))
+                return;
+
+        /*
+         * Need to use raw, since this must be called before the
+         * recursive protection is performed.
+         */
+        local_irq_save(flags);
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+        disabled = atomic_inc_return(&data->disabled);
+
+        if (likely(disabled == 1)) {
+                pc = preempt_count();
+                trace_function(tr, ip, parent_ip, flags, pc);
+                /*
+                 * skip over 5 funcs:
+                 *    __ftrace_trace_stack,
+                 *    __trace_stack,
+                 *    function_stack_trace_call
+                 *    ftrace_list_func
+                 *    ftrace_call
+                 */
+                __trace_stack(tr, flags, 5, pc);
+        }
+
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
+}
+
+
+static struct ftrace_ops trace_ops __read_mostly =
+{
+        .func = function_trace_call,
+};
+
+static struct ftrace_ops trace_stack_ops __read_mostly =
+{
+        .func = function_stack_trace_call,
+};
+
+/* Our two options */
+enum {
+        TRACE_FUNC_OPT_STACK = 0x1,
+};
+
+static struct tracer_opt func_opts[] = {
+#ifdef CONFIG_STACKTRACE
+        { TRACER_OPT(func_stack_trace, TRACE_FUNC_OPT_STACK) },
+#endif
+        { } /* Always set a last empty entry */
+};
+
+static struct tracer_flags func_flags = {
+        .val = 0, /* By default: all flags disabled */
+        .opts = func_opts
+};
+
+static void tracing_start_function_trace(void)
+{
+        ftrace_function_enabled = 0;
+
+        if (trace_flags & TRACE_ITER_PREEMPTONLY)
+                trace_ops.func = function_trace_call_preempt_only;
+        else
+                trace_ops.func = function_trace_call;
+
+        if (func_flags.val & TRACE_FUNC_OPT_STACK)
+                register_ftrace_function(&trace_stack_ops);
+        else
+                register_ftrace_function(&trace_ops);
+
+        ftrace_function_enabled = 1;
+}
+
+static void tracing_stop_function_trace(void)
+{
+        ftrace_function_enabled = 0;
+        /* OK if they are not registered */
+        unregister_ftrace_function(&trace_stack_ops);
+        unregister_ftrace_function(&trace_ops);
+}
+
+static int func_set_flag(u32 old_flags, u32 bit, int set)
+{
+        if (bit == TRACE_FUNC_OPT_STACK) {
+                /* do nothing if already set */
+                if (!!set == !!(func_flags.val & TRACE_FUNC_OPT_STACK))
+                        return 0;
+
+                if (set) {
+                        unregister_ftrace_function(&trace_ops);
+                        register_ftrace_function(&trace_stack_ops);
+                } else {
+                        unregister_ftrace_function(&trace_stack_ops);
+                        register_ftrace_function(&trace_ops);
+                }
+
+                return 0;
+        }
+
+        return -EINVAL;
 }
 
 static struct tracer function_trace __read_mostly =
 {
-        .name        = "function",
-        .init        = function_trace_init,
-        .reset       = function_trace_reset,
-        .start       = function_trace_start,
+        .name           = "function",
+        .init           = function_trace_init,
+        .reset          = function_trace_reset,
+        .start          = function_trace_start,
+        .wait_pipe      = poll_wait_pipe,
+        .flags          = &func_flags,
+        .set_flag       = func_set_flag,
 #ifdef CONFIG_FTRACE_SELFTEST
-        .selftest    = trace_selftest_startup_function,
+        .selftest       = trace_selftest_startup_function,
 #endif
 };
 
+#ifdef CONFIG_DYNAMIC_FTRACE
+static void
+ftrace_traceon(unsigned long ip, unsigned long parent_ip, void **data)
+{
+        long *count = (long *)data;
+
+        if (tracing_is_on())
+                return;
+
+        if (!*count)
+                return;
+
+        if (*count != -1)
+                (*count)--;
+
+        tracing_on();
+}
+
+static void
+ftrace_traceoff(unsigned long ip, unsigned long parent_ip, void **data)
+{
+        long *count = (long *)data;
+
+        if (!tracing_is_on())
+                return;
+
+        if (!*count)
+                return;
+
+        if (*count != -1)
+                (*count)--;
+
+        tracing_off();
+}
+
+static int
+ftrace_trace_onoff_print(struct seq_file *m, unsigned long ip,
+                         struct ftrace_probe_ops *ops, void *data);
+
+static struct ftrace_probe_ops traceon_probe_ops = {
+        .func                   = ftrace_traceon,
+        .print                  = ftrace_trace_onoff_print,
+};
+
+static struct ftrace_probe_ops traceoff_probe_ops = {
+        .func                   = ftrace_traceoff,
+        .print                  = ftrace_trace_onoff_print,
+};
+
+static int
+ftrace_trace_onoff_print(struct seq_file *m, unsigned long ip,
+                         struct ftrace_probe_ops *ops, void *data)
+{
+        char str[KSYM_SYMBOL_LEN];
+        long count = (long)data;
+
+        kallsyms_lookup(ip, NULL, NULL, NULL, str);
+        seq_printf(m, "%s:", str);
+
+        if (ops == &traceon_probe_ops)
+                seq_printf(m, "traceon");
+        else
+                seq_printf(m, "traceoff");
+
+        if (count == -1)
+                seq_printf(m, ":unlimited\n");
+        else
+                seq_printf(m, ":count=%ld", count);
+        seq_putc(m, '\n');
+
+        return 0;
+}
+
+static int
+ftrace_trace_onoff_unreg(char *glob, char *cmd, char *param)
+{
+        struct ftrace_probe_ops *ops;
+
+        /* we register both traceon and traceoff to this callback */
+        if (strcmp(cmd, "traceon") == 0)
+                ops = &traceon_probe_ops;
+        else
+                ops = &traceoff_probe_ops;
+
+        unregister_ftrace_function_probe_func(glob, ops);
+
+        return 0;
+}
+
+static int
+ftrace_trace_onoff_callback(char *glob, char *cmd, char *param, int enable)
+{
+        struct ftrace_probe_ops *ops;
+        void *count = (void *)-1;
+        char *number;
+        int ret;
+
+        /* hash funcs only work with set_ftrace_filter */
+        if (!enable)
+                return -EINVAL;
+
+        if (glob[0] == '!')
+                return ftrace_trace_onoff_unreg(glob+1, cmd, param);
+
+        /* we register both traceon and traceoff to this callback */
+        if (strcmp(cmd, "traceon") == 0)
+                ops = &traceon_probe_ops;
+        else
+                ops = &traceoff_probe_ops;
+
+        if (!param)
+                goto out_reg;
+
+        number = strsep(&param, ":");
+
+        if (!strlen(number))
+                goto out_reg;
+
+        /*
+         * We use the callback data field (which is a pointer)
+         * as our counter.
+         */
+        ret = strict_strtoul(number, 0, (unsigned long *)&count);
+        if (ret)
+                return ret;
+
+ out_reg:
+        ret = register_ftrace_function_probe(glob, ops, count);
+
+        return ret;
+}
+
+static struct ftrace_func_command ftrace_traceon_cmd = {
+        .name                   = "traceon",
+        .func                   = ftrace_trace_onoff_callback,
+};
+
+static struct ftrace_func_command ftrace_traceoff_cmd = {
+        .name                   = "traceoff",
+        .func                   = ftrace_trace_onoff_callback,
+};
+
+static int __init init_func_cmd_traceon(void)
+{
+        int ret;
+
+        ret = register_ftrace_command(&ftrace_traceoff_cmd);
+        if (ret)
+                return ret;
+
+        ret = register_ftrace_command(&ftrace_traceon_cmd);
+        if (ret)
+                unregister_ftrace_command(&ftrace_traceoff_cmd);
+        return ret;
+}
+#else
+static inline int init_func_cmd_traceon(void)
+{
+        return 0;
+}
+#endif /* CONFIG_DYNAMIC_FTRACE */
+
 static __init int init_function_trace(void)
 {
+        init_func_cmd_traceon();
         return register_tracer(&function_trace);
 }
-
 device_initcall(init_function_trace);
+
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index 930c08e5b38e..6004ccac2dd7 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -1,7 +1,7 @@
 /*
  *
  * Function graph tracer.
- * Copyright (c) 2008 Frederic Weisbecker <fweisbec@gmail.com>
+ * Copyright (c) 2008-2009 Frederic Weisbecker <fweisbec@gmail.com>
  * Mostly borrowed from function tracer which
  * is Copyright (c) Steven Rostedt <srostedt@redhat.com>
  *
@@ -12,6 +12,7 @@
 #include <linux/fs.h>
 
 #include "trace.h"
+#include "trace_output.h"
 
 #define TRACE_GRAPH_INDENT      2
 
@@ -20,9 +21,11 @@
 #define TRACE_GRAPH_PRINT_CPU           0x2
 #define TRACE_GRAPH_PRINT_OVERHEAD      0x4
 #define TRACE_GRAPH_PRINT_PROC          0x8
+#define TRACE_GRAPH_PRINT_DURATION      0x10
+#define TRACE_GRAPH_PRINT_ABS_TIME      0X20
 
 static struct tracer_opt trace_opts[] = {
-        /* Display overruns ? */
+        /* Display overruns? (for self-debug purpose) */
         { TRACER_OPT(funcgraph-overrun, TRACE_GRAPH_PRINT_OVERRUN) },
         /* Display CPU ? */
         { TRACER_OPT(funcgraph-cpu, TRACE_GRAPH_PRINT_CPU) },
@@ -30,26 +33,101 @@ static struct tracer_opt trace_opts[] = {
         { TRACER_OPT(funcgraph-overhead, TRACE_GRAPH_PRINT_OVERHEAD) },
         /* Display proc name/pid */
         { TRACER_OPT(funcgraph-proc, TRACE_GRAPH_PRINT_PROC) },
+        /* Display duration of execution */
+        { TRACER_OPT(funcgraph-duration, TRACE_GRAPH_PRINT_DURATION) },
+        /* Display absolute time of an entry */
+        { TRACER_OPT(funcgraph-abstime, TRACE_GRAPH_PRINT_ABS_TIME) },
         { } /* Empty entry */
 };
 
 static struct tracer_flags tracer_flags = {
         /* Don't display overruns and proc by default */
-        .val = TRACE_GRAPH_PRINT_CPU | TRACE_GRAPH_PRINT_OVERHEAD,
+        .val = TRACE_GRAPH_PRINT_CPU | TRACE_GRAPH_PRINT_OVERHEAD |
+               TRACE_GRAPH_PRINT_DURATION,
         .opts = trace_opts
 };
 
 /* pid on the last trace processed */
-static pid_t last_pid[NR_CPUS] = { [0 ... NR_CPUS-1] = -1 };
 
-static int graph_trace_init(struct trace_array *tr)
+
+/* Add a function return address to the trace stack on thread info.*/
+int
+ftrace_push_return_trace(unsigned long ret, unsigned long long time,
+                         unsigned long func, int *depth)
 {
-        int cpu, ret;
+        int index;
 
-        for_each_online_cpu(cpu)
-                tracing_reset(tr, cpu);
+        if (!current->ret_stack)
+                return -EBUSY;
+
+        /* The return trace stack is full */
+        if (current->curr_ret_stack == FTRACE_RETFUNC_DEPTH - 1) {
+                atomic_inc(&current->trace_overrun);
+                return -EBUSY;
+        }
+
+        index = ++current->curr_ret_stack;
+        barrier();
+        current->ret_stack[index].ret = ret;
+        current->ret_stack[index].func = func;
+        current->ret_stack[index].calltime = time;
+        *depth = index;
+
+        return 0;
+}
+
+/* Retrieve a function return address to the trace stack on thread info.*/
+void
+ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret)
+{
+        int index;
+
+        index = current->curr_ret_stack;
+
+        if (unlikely(index < 0)) {
+                ftrace_graph_stop();
+                WARN_ON(1);
+                /* Might as well panic, otherwise we have no where to go */
+                *ret = (unsigned long)panic;
+                return;
+        }
 
-        ret = register_ftrace_graph(&trace_graph_return,
+        *ret = current->ret_stack[index].ret;
+        trace->func = current->ret_stack[index].func;
+        trace->calltime = current->ret_stack[index].calltime;
+        trace->overrun = atomic_read(&current->trace_overrun);
+        trace->depth = index;
+        barrier();
+        current->curr_ret_stack--;
+
+}
+
+/*
+ * Send the trace to the ring-buffer.
+ * @return the original return address.
+ */
+unsigned long ftrace_return_to_handler(void)
+{
+        struct ftrace_graph_ret trace;
+        unsigned long ret;
+
+        ftrace_pop_return_trace(&trace, &ret);
+        trace.rettime = trace_clock_local();
+        ftrace_graph_return(&trace);
+
+        if (unlikely(!ret)) {
+                ftrace_graph_stop();
+                WARN_ON(1);
+                /* Might as well panic. What else to do? */
+                ret = (unsigned long)panic;
+        }
+
+        return ret;
+}
+
+static int graph_trace_init(struct trace_array *tr)
+{
+        int ret = register_ftrace_graph(&trace_graph_return,
                                         &trace_graph_entry);
         if (ret)
                 return ret;
@@ -112,15 +190,15 @@ print_graph_cpu(struct trace_seq *s, int cpu)
 static enum print_line_t
 print_graph_proc(struct trace_seq *s, pid_t pid)
 {
-        int i;
-        int ret;
-        int len;
-        char comm[8];
-        int spaces = 0;
+        char comm[TASK_COMM_LEN];
         /* sign + log10(MAX_INT) + '\0' */
         char pid_str[11];
+        int spaces = 0;
+        int ret;
+        int len;
+        int i;
 
-        strncpy(comm, trace_find_cmdline(pid), 7);
+        trace_find_cmdline(pid, comm);
         comm[7] = '\0';
         sprintf(pid_str, "%d", pid);
 
@@ -153,17 +231,25 @@ print_graph_proc(struct trace_seq *s, pid_t pid)
 
 /* If the pid changed since the last trace, output this event */
 static enum print_line_t
-verif_pid(struct trace_seq *s, pid_t pid, int cpu)
+verif_pid(struct trace_seq *s, pid_t pid, int cpu, pid_t *last_pids_cpu)
 {
         pid_t prev_pid;
+        pid_t *last_pid;
         int ret;
 
-        if (last_pid[cpu] != -1 && last_pid[cpu] == pid)
+        if (!last_pids_cpu)
+                return TRACE_TYPE_HANDLED;
+
+        last_pid = per_cpu_ptr(last_pids_cpu, cpu);
+
+        if (*last_pid == pid)
                 return TRACE_TYPE_HANDLED;
 
-        prev_pid = last_pid[cpu];
-        last_pid[cpu] = pid;
+        prev_pid = *last_pid;
+        *last_pid = pid;
 
+        if (prev_pid == -1)
+                return TRACE_TYPE_HANDLED;
 /*
  * Context-switch trace line:
 
@@ -175,34 +261,34 @@ verif_pid(struct trace_seq *s, pid_t pid, int cpu)
         ret = trace_seq_printf(s,
                 " ------------------------------------------\n");
         if (!ret)
-                TRACE_TYPE_PARTIAL_LINE;
+                return TRACE_TYPE_PARTIAL_LINE;
 
         ret = print_graph_cpu(s, cpu);
         if (ret == TRACE_TYPE_PARTIAL_LINE)
-                TRACE_TYPE_PARTIAL_LINE;
+                return TRACE_TYPE_PARTIAL_LINE;
 
         ret = print_graph_proc(s, prev_pid);
         if (ret == TRACE_TYPE_PARTIAL_LINE)
-                TRACE_TYPE_PARTIAL_LINE;
+                return TRACE_TYPE_PARTIAL_LINE;
 
         ret = trace_seq_printf(s, " => ");
         if (!ret)
-                TRACE_TYPE_PARTIAL_LINE;
+                return TRACE_TYPE_PARTIAL_LINE;
 
         ret = print_graph_proc(s, pid);
         if (ret == TRACE_TYPE_PARTIAL_LINE)
-                TRACE_TYPE_PARTIAL_LINE;
+                return TRACE_TYPE_PARTIAL_LINE;
 
         ret = trace_seq_printf(s,
                 "\n ------------------------------------------\n\n");
         if (!ret)
-                TRACE_TYPE_PARTIAL_LINE;
+                return TRACE_TYPE_PARTIAL_LINE;
 
-        return ret;
+        return TRACE_TYPE_HANDLED;
 }
 
-static bool
-trace_branch_is_leaf(struct trace_iterator *iter,
+static struct ftrace_graph_ret_entry *
+get_return_for_leaf(struct trace_iterator *iter,
                 struct ftrace_graph_ent_entry *curr)
 {
         struct ring_buffer_iter *ring_iter;
@@ -211,65 +297,123 @@ trace_branch_is_leaf(struct trace_iterator *iter,
 
         ring_iter = iter->buffer_iter[iter->cpu];
 
-        if (!ring_iter)
-                return false;
-
-        event = ring_buffer_iter_peek(ring_iter, NULL);
+        /* First peek to compare current entry and the next one */
+        if (ring_iter)
+                event = ring_buffer_iter_peek(ring_iter, NULL);
+        else {
+        /* We need to consume the current entry to see the next one */
+                ring_buffer_consume(iter->tr->buffer, iter->cpu, NULL);
+                event = ring_buffer_peek(iter->tr->buffer, iter->cpu,
+                                        NULL);
+        }
 
         if (!event)
-                return false;
+                return NULL;
 
         next = ring_buffer_event_data(event);
 
         if (next->ent.type != TRACE_GRAPH_RET)
-                return false;
+                return NULL;
 
         if (curr->ent.pid != next->ent.pid ||
                         curr->graph_ent.func != next->ret.func)
-                return false;
+                return NULL;
+
+        /* this is a leaf, now advance the iterator */
+        if (ring_iter)
+                ring_buffer_read(ring_iter, NULL);
 
-        return true;
+        return next;
+}
+
+/* Signal a overhead of time execution to the output */
+static int
+print_graph_overhead(unsigned long long duration, struct trace_seq *s)
+{
+        /* If duration disappear, we don't need anything */
+        if (!(tracer_flags.val & TRACE_GRAPH_PRINT_DURATION))
+                return 1;
+
+        /* Non nested entry or return */
+        if (duration == -1)
+                return trace_seq_printf(s, "  ");
+
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
+                /* Duration exceeded 100 msecs */
+                if (duration > 100000ULL)
+                        return trace_seq_printf(s, "! ");
+
+                /* Duration exceeded 10 msecs */
+                if (duration > 10000ULL)
+                        return trace_seq_printf(s, "+ ");
+        }
+
+        return trace_seq_printf(s, "  ");
+}
+
+static int print_graph_abs_time(u64 t, struct trace_seq *s)
+{
+        unsigned long usecs_rem;
+
+        usecs_rem = do_div(t, NSEC_PER_SEC);
+        usecs_rem /= 1000;
+
+        return trace_seq_printf(s, "%5lu.%06lu |  ",
+                        (unsigned long)t, usecs_rem);
 }
 
 static enum print_line_t
-print_graph_irq(struct trace_seq *s, unsigned long addr,
-                                enum trace_type type, int cpu, pid_t pid)
+print_graph_irq(struct trace_iterator *iter, unsigned long addr,
+                enum trace_type type, int cpu, pid_t pid)
 {
         int ret;
+        struct trace_seq *s = &iter->seq;
 
         if (addr < (unsigned long)__irqentry_text_start ||
                 addr >= (unsigned long)__irqentry_text_end)
                 return TRACE_TYPE_UNHANDLED;
 
-        if (type == TRACE_GRAPH_ENT) {
-                ret = trace_seq_printf(s, "==========> |  ");
-        } else {
-                /* Cpu */
-                if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
-                        ret = print_graph_cpu(s, cpu);
-                        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                                return TRACE_TYPE_PARTIAL_LINE;
-                }
-                /* Proc */
-                if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
-                        ret = print_graph_proc(s, pid);
-                        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                                return TRACE_TYPE_PARTIAL_LINE;
+        /* Absolute time */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
+                ret = print_graph_abs_time(iter->ts, s);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
 
-                        ret = trace_seq_printf(s, " | ");
-                        if (!ret)
-                                return TRACE_TYPE_PARTIAL_LINE;
-                }
+        /* Cpu */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
+                ret = print_graph_cpu(s, cpu);
+                if (ret == TRACE_TYPE_PARTIAL_LINE)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+        /* Proc */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
+                ret = print_graph_proc(s, pid);
+                if (ret == TRACE_TYPE_PARTIAL_LINE)
+                        return TRACE_TYPE_PARTIAL_LINE;
+                ret = trace_seq_printf(s, " | ");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
 
-                /* No overhead */
-                if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
-                        ret = trace_seq_printf(s, "  ");
-                        if (!ret)
-                                return TRACE_TYPE_PARTIAL_LINE;
-                }
+        /* No overhead */
+        ret = print_graph_overhead(-1, s);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        if (type == TRACE_GRAPH_ENT)
+                ret = trace_seq_printf(s, "==========>");
+        else
+                ret = trace_seq_printf(s, "<==========");
+
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Don't close the duration column if haven't one */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
+                trace_seq_printf(s, " |");
+        ret = trace_seq_printf(s, "\n");
 
-                ret = trace_seq_printf(s, "<========== |\n");
-        }
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
         return TRACE_TYPE_HANDLED;
@@ -288,7 +432,7 @@ print_graph_duration(unsigned long long duration, struct trace_seq *s)
         sprintf(msecs_str, "%lu", (unsigned long) duration);
 
         /* Print msecs */
-        ret = trace_seq_printf(s, msecs_str);
+        ret = trace_seq_printf(s, "%s", msecs_str);
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
@@ -321,51 +465,33 @@ print_graph_duration(unsigned long long duration, struct trace_seq *s)
 
 }
 
-/* Signal a overhead of time execution to the output */
-static int
-print_graph_overhead(unsigned long long duration, struct trace_seq *s)
-{
-        /* Duration exceeded 100 msecs */
-        if (duration > 100000ULL)
-                return trace_seq_printf(s, "! ");
-
-        /* Duration exceeded 10 msecs */
-        if (duration > 10000ULL)
-                return trace_seq_printf(s, "+ ");
-
-        return trace_seq_printf(s, "  ");
-}
-
 /* Case of a leaf function on its call entry */
 static enum print_line_t
 print_graph_entry_leaf(struct trace_iterator *iter,
-                struct ftrace_graph_ent_entry *entry, struct trace_seq *s)
+                struct ftrace_graph_ent_entry *entry,
+                struct ftrace_graph_ret_entry *ret_entry, struct trace_seq *s)
 {
-        struct ftrace_graph_ret_entry *ret_entry;
         struct ftrace_graph_ret *graph_ret;
-        struct ring_buffer_event *event;
         struct ftrace_graph_ent *call;
         unsigned long long duration;
         int ret;
         int i;
 
-        event = ring_buffer_read(iter->buffer_iter[iter->cpu], NULL);
-        ret_entry = ring_buffer_event_data(event);
         graph_ret = &ret_entry->ret;
         call = &entry->graph_ent;
         duration = graph_ret->rettime - graph_ret->calltime;
 
         /* Overhead */
-        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
-                ret = print_graph_overhead(duration, s);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        ret = print_graph_overhead(duration, s);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
 
         /* Duration */
-        ret = print_graph_duration(duration, s);
-        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                return TRACE_TYPE_PARTIAL_LINE;
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
+                ret = print_graph_duration(duration, s);
+                if (ret == TRACE_TYPE_PARTIAL_LINE)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
 
         /* Function */
         for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
@@ -394,25 +520,17 @@ print_graph_entry_nested(struct ftrace_graph_ent_entry *entry,
         struct ftrace_graph_ent *call = &entry->graph_ent;
 
         /* No overhead */
-        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
-                ret = trace_seq_printf(s, "  ");
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        ret = print_graph_overhead(-1, s);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
 
-        /* Interrupt */
-        ret = print_graph_irq(s, call->func, TRACE_GRAPH_ENT, cpu, pid);
-        if (ret == TRACE_TYPE_UNHANDLED) {
-                /* No time */
+        /* No time */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
                 ret = trace_seq_printf(s, "            |  ");
                 if (!ret)
                         return TRACE_TYPE_PARTIAL_LINE;
-        } else {
-                if (ret == TRACE_TYPE_PARTIAL_LINE)
-                        return TRACE_TYPE_PARTIAL_LINE;
         }
 
-
         /* Function */
         for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
                 ret = trace_seq_printf(s, " ");
@@ -428,20 +546,40 @@ print_graph_entry_nested(struct ftrace_graph_ent_entry *entry,
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
-        return TRACE_TYPE_HANDLED;
+        /*
+         * we already consumed the current entry to check the next one
+         * and see if this is a leaf.
+         */
+        return TRACE_TYPE_NO_CONSUME;
 }
 
 static enum print_line_t
 print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s,
-                        struct trace_iterator *iter, int cpu)
+                        struct trace_iterator *iter)
 {
         int ret;
+        int cpu = iter->cpu;
+        pid_t *last_entry = iter->private;
         struct trace_entry *ent = iter->ent;
+        struct ftrace_graph_ent *call = &field->graph_ent;
+        struct ftrace_graph_ret_entry *leaf_ret;
 
         /* Pid */
-        if (verif_pid(s, ent->pid, cpu) == TRACE_TYPE_PARTIAL_LINE)
+        if (verif_pid(s, ent->pid, cpu, last_entry) == TRACE_TYPE_PARTIAL_LINE)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* Interrupt */
+        ret = print_graph_irq(iter, call->func, TRACE_GRAPH_ENT, cpu, ent->pid);
+        if (ret == TRACE_TYPE_PARTIAL_LINE)
                 return TRACE_TYPE_PARTIAL_LINE;
 
+        /* Absolute time */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
+                ret = print_graph_abs_time(iter->ts, s);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
         /* Cpu */
         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
                 ret = print_graph_cpu(s, cpu);
@@ -460,8 +598,9 @@ print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s,
                         return TRACE_TYPE_PARTIAL_LINE;
         }
 
-        if (trace_branch_is_leaf(iter, field))
-                return print_graph_entry_leaf(iter, field, s);
+        leaf_ret = get_return_for_leaf(iter, field);
+        if (leaf_ret)
+                return print_graph_entry_leaf(iter, field, leaf_ret, s);
         else
                 return print_graph_entry_nested(field, s, iter->ent->pid, cpu);
 
@@ -469,16 +608,25 @@ print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s,
 
 static enum print_line_t
 print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
-                   struct trace_entry *ent, int cpu)
+                   struct trace_entry *ent, struct trace_iterator *iter)
 {
         int i;
         int ret;
+        int cpu = iter->cpu;
+        pid_t *last_pid = iter->private, pid = ent->pid;
         unsigned long long duration = trace->rettime - trace->calltime;
 
         /* Pid */
-        if (verif_pid(s, ent->pid, cpu) == TRACE_TYPE_PARTIAL_LINE)
+        if (verif_pid(s, pid, cpu, last_pid) == TRACE_TYPE_PARTIAL_LINE)
                 return TRACE_TYPE_PARTIAL_LINE;
 
+        /* Absolute time */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
+                ret = print_graph_abs_time(iter->ts, s);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
         /* Cpu */
         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
                 ret = print_graph_cpu(s, cpu);
@@ -498,16 +646,16 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
         }
 
         /* Overhead */
-        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
-                ret = print_graph_overhead(duration, s);
-                if (!ret)
-                        return TRACE_TYPE_PARTIAL_LINE;
-        }
+        ret = print_graph_overhead(duration, s);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
 
         /* Duration */
-        ret = print_graph_duration(duration, s);
-        if (ret == TRACE_TYPE_PARTIAL_LINE)
-                return TRACE_TYPE_PARTIAL_LINE;
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
+                ret = print_graph_duration(duration, s);
+                if (ret == TRACE_TYPE_PARTIAL_LINE)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
 
         /* Closing brace */
         for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++) {
@@ -528,7 +676,7 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
                         return TRACE_TYPE_PARTIAL_LINE;
         }
 
-        ret = print_graph_irq(s, trace->func, TRACE_GRAPH_RET, cpu, ent->pid);
+        ret = print_graph_irq(iter, trace->func, TRACE_GRAPH_RET, cpu, pid);
         if (ret == TRACE_TYPE_PARTIAL_LINE)
                 return TRACE_TYPE_PARTIAL_LINE;
 
@@ -536,19 +684,28 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
 }
 
 static enum print_line_t
-print_graph_comment(struct print_entry *trace, struct trace_seq *s,
+print_graph_comment(struct bprint_entry *trace, struct trace_seq *s,
                    struct trace_entry *ent, struct trace_iterator *iter)
 {
         int i;
         int ret;
+        int cpu = iter->cpu;
+        pid_t *last_pid = iter->private;
 
         /* Pid */
-        if (verif_pid(s, ent->pid, iter->cpu) == TRACE_TYPE_PARTIAL_LINE)
+        if (verif_pid(s, ent->pid, cpu, last_pid) == TRACE_TYPE_PARTIAL_LINE)
                 return TRACE_TYPE_PARTIAL_LINE;
 
+        /* Absolute time */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
+                ret = print_graph_abs_time(iter->ts, s);
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
         /* Cpu */
         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
-                ret = print_graph_cpu(s, iter->cpu);
+                ret = print_graph_cpu(s, cpu);
                 if (ret == TRACE_TYPE_PARTIAL_LINE)
                         return TRACE_TYPE_PARTIAL_LINE;
         }
@@ -565,17 +722,17 @@ print_graph_comment(struct print_entry *trace, struct trace_seq *s,
         }
 
         /* No overhead */
-        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
-                ret = trace_seq_printf(s, "  ");
+        ret = print_graph_overhead(-1, s);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        /* No time */
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
+                ret = trace_seq_printf(s, "            |  ");
                 if (!ret)
                         return TRACE_TYPE_PARTIAL_LINE;
         }
 
-        /* No time */
-        ret = trace_seq_printf(s, "            |  ");
-        if (!ret)
-                return TRACE_TYPE_PARTIAL_LINE;
-
         /* Indentation */
         if (trace->depth > 0)
                 for (i = 0; i < (trace->depth + 1) * TRACE_GRAPH_INDENT; i++) {
@@ -585,12 +742,19 @@ print_graph_comment(struct print_entry *trace, struct trace_seq *s,
                 }
 
         /* The comment */
-        ret = trace_seq_printf(s, "/* %s", trace->buf);
+        ret = trace_seq_printf(s, "/* ");
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        ret = trace_seq_bprintf(s, trace->fmt, trace->buf);
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
-        if (ent->flags & TRACE_FLAG_CONT)
-                trace_seq_print_cont(s, iter);
+        /* Strip ending newline */
+        if (s->buffer[s->len - 1] == '\n') {
+                s->buffer[s->len - 1] = '\0';
+                s->len--;
+        }
 
         ret = trace_seq_printf(s, " */\n");
         if (!ret)
@@ -610,16 +774,15 @@ print_graph_function(struct trace_iterator *iter)
         case TRACE_GRAPH_ENT: {
                 struct ftrace_graph_ent_entry *field;
                 trace_assign_type(field, entry);
-                return print_graph_entry(field, s, iter,
-                                         iter->cpu);
+                return print_graph_entry(field, s, iter);
         }
         case TRACE_GRAPH_RET: {
                 struct ftrace_graph_ret_entry *field;
                 trace_assign_type(field, entry);
-                return print_graph_return(&field->ret, s, entry, iter->cpu);
+                return print_graph_return(&field->ret, s, entry, iter);
         }
-        case TRACE_PRINT: {
-                struct print_entry *field;
+        case TRACE_BPRINT: {
+                struct bprint_entry *field;
                 trace_assign_type(field, entry);
                 return print_graph_comment(field, s, entry, iter);
         }
@@ -632,33 +795,64 @@ static void print_graph_headers(struct seq_file *s)
 {
         /* 1st line */
         seq_printf(s, "# ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)
+                seq_printf(s, "     TIME       ");
         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
-                seq_printf(s, "CPU ");
+                seq_printf(s, "CPU");
         if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
-                seq_printf(s, "TASK/PID     ");
-        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD)
-                seq_printf(s, "OVERHEAD/");
-        seq_printf(s, "DURATION            FUNCTION CALLS\n");
+                seq_printf(s, "  TASK/PID      ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
+                seq_printf(s, "  DURATION   ");
+        seq_printf(s, "               FUNCTION CALLS\n");
 
         /* 2nd line */
         seq_printf(s, "# ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)
+                seq_printf(s, "      |         ");
         if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
-                seq_printf(s, "|   ");
+                seq_printf(s, "|  ");
         if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
-                seq_printf(s, "|      |     ");
-        if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
-                seq_printf(s, "|        ");
-                seq_printf(s, "|                   |   |   |   |\n");
-        } else
-                seq_printf(s, "    |               |   |   |   |\n");
+                seq_printf(s, "  |    |        ");
+        if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
+                seq_printf(s, "   |   |      ");
+        seq_printf(s, "               |   |   |   |\n");
+}
+
+static void graph_trace_open(struct trace_iterator *iter)
+{
+        /* pid on the last trace processed */
+        pid_t *last_pid = alloc_percpu(pid_t);
+        int cpu;
+
+        if (!last_pid)
+                pr_warning("function graph tracer: not enough memory\n");
+        else
+                for_each_possible_cpu(cpu) {
+                        pid_t *pid = per_cpu_ptr(last_pid, cpu);
+                        *pid = -1;
+                }
+
+        iter->private = last_pid;
+}
+
+static void graph_trace_close(struct trace_iterator *iter)
+{
+        free_percpu(iter->private);
 }
+
 static struct tracer graph_trace __read_mostly = {
-        .name           = "function_graph",
-        .init           = graph_trace_init,
-        .reset          = graph_trace_reset,
+        .name           = "function_graph",
+        .open           = graph_trace_open,
+        .close          = graph_trace_close,
+        .wait_pipe      = poll_wait_pipe,
+        .init           = graph_trace_init,
+        .reset          = graph_trace_reset,
         .print_line     = print_graph_function,
         .print_header   = print_graph_headers,
         .flags          = &tracer_flags,
+#ifdef CONFIG_FTRACE_SELFTEST
+        .selftest       = trace_selftest_startup_function_graph,
+#endif
 };
 
 static __init int init_graph_trace(void)
diff --git a/kernel/trace/trace_hw_branches.c b/kernel/trace/trace_hw_branches.c
index 649df22d435f..7bfdf4c2347f 100644
--- a/kernel/trace/trace_hw_branches.c
+++ b/kernel/trace/trace_hw_branches.c
@@ -1,30 +1,53 @@
 /*
  * h/w branch tracer for x86 based on bts
  *
- * Copyright (C) 2008 Markus Metzger <markus.t.metzger@gmail.com>
- *
+ * Copyright (C) 2008-2009 Intel Corporation.
+ * Markus Metzger <markus.t.metzger@gmail.com>, 2008-2009
  */
-
-#include <linux/module.h>
-#include <linux/fs.h>
+#include <linux/spinlock.h>
+#include <linux/kallsyms.h>
 #include <linux/debugfs.h>
 #include <linux/ftrace.h>
-#include <linux/kallsyms.h>
+#include <linux/module.h>
+#include <linux/cpu.h>
+#include <linux/smp.h>
+#include <linux/fs.h>
 
 #include <asm/ds.h>
 
 #include "trace.h"
+#include "trace_output.h"
 
 
 #define SIZEOF_BTS (1 << 13)
 
+/*
+ * The tracer lock protects the below per-cpu tracer array.
+ * It needs to be held to:
+ * - start tracing on all cpus
+ * - stop tracing on all cpus
+ * - start tracing on a single hotplug cpu
+ * - stop tracing on a single hotplug cpu
+ * - read the trace from all cpus
+ * - read the trace from a single cpu
+ */
+static DEFINE_SPINLOCK(bts_tracer_lock);
 static DEFINE_PER_CPU(struct bts_tracer *, tracer);
 static DEFINE_PER_CPU(unsigned char[SIZEOF_BTS], buffer);
 
 #define this_tracer per_cpu(tracer, smp_processor_id())
 #define this_buffer per_cpu(buffer, smp_processor_id())
 
+static int __read_mostly trace_hw_branches_enabled;
+static struct trace_array *hw_branch_trace __read_mostly;
+
 
+/*
+ * Start tracing on the current cpu.
+ * The argument is ignored.
+ *
+ * pre: bts_tracer_lock must be locked.
+ */
 static void bts_trace_start_cpu(void *arg)
 {
         if (this_tracer)
@@ -42,14 +65,20 @@ static void bts_trace_start_cpu(void *arg)
 
 static void bts_trace_start(struct trace_array *tr)
 {
-        int cpu;
+        spin_lock(&bts_tracer_lock);
 
-        tracing_reset_online_cpus(tr);
+        on_each_cpu(bts_trace_start_cpu, NULL, 1);
+        trace_hw_branches_enabled = 1;
 
-        for_each_cpu(cpu, cpu_possible_mask)
-                smp_call_function_single(cpu, bts_trace_start_cpu, NULL, 1);
+        spin_unlock(&bts_tracer_lock);
 }
 
+/*
+ * Stop tracing on the current cpu.
+ * The argument is ignored.
+ *
+ * pre: bts_tracer_lock must be locked.
+ */
 static void bts_trace_stop_cpu(void *arg)
 {
         if (this_tracer) {
@@ -60,26 +89,60 @@ static void bts_trace_stop_cpu(void *arg)
 
 static void bts_trace_stop(struct trace_array *tr)
 {
-        int cpu;
+        spin_lock(&bts_tracer_lock);
+
+        trace_hw_branches_enabled = 0;
+        on_each_cpu(bts_trace_stop_cpu, NULL, 1);
+
+        spin_unlock(&bts_tracer_lock);
+}
+
+static int __cpuinit bts_hotcpu_handler(struct notifier_block *nfb,
+                                     unsigned long action, void *hcpu)
+{
+        unsigned int cpu = (unsigned long)hcpu;
 
-        for_each_cpu(cpu, cpu_possible_mask)
+        spin_lock(&bts_tracer_lock);
+
+        if (!trace_hw_branches_enabled)
+                goto out;
+
+        switch (action) {
+        case CPU_ONLINE:
+        case CPU_DOWN_FAILED:
+                smp_call_function_single(cpu, bts_trace_start_cpu, NULL, 1);
+                break;
+        case CPU_DOWN_PREPARE:
                 smp_call_function_single(cpu, bts_trace_stop_cpu, NULL, 1);
+                break;
+        }
+
+ out:
+        spin_unlock(&bts_tracer_lock);
+        return NOTIFY_DONE;
 }
 
+static struct notifier_block bts_hotcpu_notifier __cpuinitdata = {
+        .notifier_call = bts_hotcpu_handler
+};
+
 static int bts_trace_init(struct trace_array *tr)
 {
-        tracing_reset_online_cpus(tr);
+        hw_branch_trace = tr;
+
         bts_trace_start(tr);
 
         return 0;
 }
 
+static void bts_trace_reset(struct trace_array *tr)
+{
+        bts_trace_stop(tr);
+}
+
 static void bts_trace_print_header(struct seq_file *m)
 {
-        seq_puts(m,
-                 "# CPU#        FROM                   TO         FUNCTION\n");
-        seq_puts(m,
-                 "#  |           |                     |             |\n");
+        seq_puts(m, "# CPU#        TO  <-  FROM\n");
 }
 
 static enum print_line_t bts_trace_print_line(struct trace_iterator *iter)
@@ -87,15 +150,15 @@ static enum print_line_t bts_trace_print_line(struct trace_iterator *iter)
         struct trace_entry *entry = iter->ent;
         struct trace_seq *seq = &iter->seq;
         struct hw_branch_entry *it;
+        unsigned long symflags = TRACE_ITER_SYM_OFFSET;
 
         trace_assign_type(it, entry);
 
         if (entry->type == TRACE_HW_BRANCHES) {
-                if (trace_seq_printf(seq, "%4d  ", entry->cpu) &&
-                    trace_seq_printf(seq, "0x%016llx -> 0x%016llx ",
-                                     it->from, it->to) &&
-                    (!it->from ||
-                     seq_print_ip_sym(seq, it->from, /* sym_flags = */ 0)) &&
+                if (trace_seq_printf(seq, "%4d  ", iter->cpu) &&
+                    seq_print_ip_sym(seq, it->to, symflags) &&
+                    trace_seq_printf(seq, "\t  <-  ") &&
+                    seq_print_ip_sym(seq, it->from, symflags) &&
                     trace_seq_printf(seq, "\n"))
                         return TRACE_TYPE_HANDLED;
                 return TRACE_TYPE_PARTIAL_LINE;;
@@ -103,26 +166,42 @@ static enum print_line_t bts_trace_print_line(struct trace_iterator *iter)
         return TRACE_TYPE_UNHANDLED;
 }
 
-void trace_hw_branch(struct trace_array *tr, u64 from, u64 to)
+void trace_hw_branch(u64 from, u64 to)
 {
+        struct trace_array *tr = hw_branch_trace;
         struct ring_buffer_event *event;
         struct hw_branch_entry *entry;
-        unsigned long irq;
+        unsigned long irq1;
+        int cpu;
 
-        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry), &irq);
-        if (!event)
+        if (unlikely(!tr))
                 return;
+
+        if (unlikely(!trace_hw_branches_enabled))
+                return;
+
+        local_irq_save(irq1);
+        cpu = raw_smp_processor_id();
+        if (atomic_inc_return(&tr->data[cpu]->disabled) != 1)
+                goto out;
+
+        event = trace_buffer_lock_reserve(tr, TRACE_HW_BRANCHES,
+                                          sizeof(*entry), 0, 0);
+        if (!event)
+                goto out;
         entry   = ring_buffer_event_data(event);
         tracing_generic_entry_update(&entry->ent, 0, from);
         entry->ent.type = TRACE_HW_BRANCHES;
-        entry->ent.cpu = smp_processor_id();
         entry->from = from;
         entry->to   = to;
-        ring_buffer_unlock_commit(tr->buffer, event, irq);
+        trace_buffer_unlock_commit(tr, event, 0, 0);
+
+ out:
+        atomic_dec(&tr->data[cpu]->disabled);
+        local_irq_restore(irq1);
 }
 
-static void trace_bts_at(struct trace_array *tr,
-                         const struct bts_trace *trace, void *at)
+static void trace_bts_at(const struct bts_trace *trace, void *at)
 {
         struct bts_struct bts;
         int err = 0;
@@ -137,18 +216,29 @@ static void trace_bts_at(struct trace_array *tr,
 
         switch (bts.qualifier) {
         case BTS_BRANCH:
-                trace_hw_branch(tr, bts.variant.lbr.from, bts.variant.lbr.to);
+                trace_hw_branch(bts.variant.lbr.from, bts.variant.lbr.to);
                 break;
         }
 }
 
+/*
+ * Collect the trace on the current cpu and write it into the ftrace buffer.
+ *
+ * pre: bts_tracer_lock must be locked
+ */
 static void trace_bts_cpu(void *arg)
 {
         struct trace_array *tr = (struct trace_array *) arg;
         const struct bts_trace *trace;
         unsigned char *at;
 
-        if (!this_tracer)
+        if (unlikely(!tr))
+                return;
+
+        if (unlikely(atomic_read(&tr->data[raw_smp_processor_id()]->disabled)))
+                return;
+
+        if (unlikely(!this_tracer))
                 return;
 
         ds_suspend_bts(this_tracer);
@@ -158,11 +248,11 @@ static void trace_bts_cpu(void *arg)
 
         for (at = trace->ds.top; (void *)at < trace->ds.end;
              at += trace->ds.size)
-                trace_bts_at(tr, trace, at);
+                trace_bts_at(trace, at);
 
         for (at = trace->ds.begin; (void *)at < trace->ds.top;
              at += trace->ds.size)
-                trace_bts_at(tr, trace, at);
+                trace_bts_at(trace, at);
 
 out:
         ds_resume_bts(this_tracer);
@@ -170,26 +260,43 @@ out:
 
 static void trace_bts_prepare(struct trace_iterator *iter)
 {
-        int cpu;
+        spin_lock(&bts_tracer_lock);
+
+        on_each_cpu(trace_bts_cpu, iter->tr, 1);
+
+        spin_unlock(&bts_tracer_lock);
+}
+
+static void trace_bts_close(struct trace_iterator *iter)
+{
+        tracing_reset_online_cpus(iter->tr);
+}
+
+void trace_hw_branch_oops(void)
+{
+        spin_lock(&bts_tracer_lock);
+
+        trace_bts_cpu(hw_branch_trace);
 
-        for_each_cpu(cpu, cpu_possible_mask)
-                smp_call_function_single(cpu, trace_bts_cpu, iter->tr, 1);
+        spin_unlock(&bts_tracer_lock);
 }
 
 struct tracer bts_tracer __read_mostly =
 {
         .name           = "hw-branch-tracer",
         .init           = bts_trace_init,
-        .reset          = bts_trace_stop,
+        .reset          = bts_trace_reset,
         .print_header   = bts_trace_print_header,
         .print_line     = bts_trace_print_line,
         .start          = bts_trace_start,
         .stop           = bts_trace_stop,
-        .open           = trace_bts_prepare
+        .open           = trace_bts_prepare,
+        .close          = trace_bts_close
 };
 
 __init static int init_bts_trace(void)
 {
+        register_hotcpu_notifier(&bts_hotcpu_notifier);
         return register_tracer(&bts_tracer);
 }
 device_initcall(init_bts_trace);
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index 62a78d943534..b923d13e2fad 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -1,5 +1,5 @@
 /*
- * trace irqs off criticall timings
+ * trace irqs off critical timings
  *
  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
  * Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>
@@ -32,6 +32,8 @@ enum {
 
 static int trace_type __read_mostly;
 
+static int save_lat_flag;
+
 #ifdef CONFIG_PREEMPT_TRACER
 static inline int
 preempt_trace(void)
@@ -95,7 +97,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, preempt_count());
+                trace_function(tr, ip, parent_ip, flags, preempt_count());
 
         atomic_dec(&data->disabled);
 }
@@ -153,7 +155,7 @@ check_critical_timing(struct trace_array *tr,
         if (!report_latency(delta))
                 goto out_unlock;
 
-        trace_function(tr, data, CALLER_ADDR0, parent_ip, flags, pc);
+        trace_function(tr, CALLER_ADDR0, parent_ip, flags, pc);
 
         latency = nsecs_to_usecs(delta);
 
@@ -177,7 +179,7 @@ out:
         data->critical_sequence = max_sequence;
         data->preempt_timestamp = ftrace_now(cpu);
         tracing_reset(tr, cpu);
-        trace_function(tr, data, CALLER_ADDR0, parent_ip, flags, pc);
+        trace_function(tr, CALLER_ADDR0, parent_ip, flags, pc);
 }
 
 static inline void
@@ -210,7 +212,7 @@ start_critical_timing(unsigned long ip, unsigned long parent_ip)
 
         local_save_flags(flags);
 
-        trace_function(tr, data, ip, parent_ip, flags, preempt_count());
+        trace_function(tr, ip, parent_ip, flags, preempt_count());
 
         per_cpu(tracing_cpu, cpu) = 1;
 
@@ -244,7 +246,7 @@ stop_critical_timing(unsigned long ip, unsigned long parent_ip)
         atomic_inc(&data->disabled);
 
         local_save_flags(flags);
-        trace_function(tr, data, ip, parent_ip, flags, preempt_count());
+        trace_function(tr, ip, parent_ip, flags, preempt_count());
         check_critical_timing(tr, data, parent_ip ? : ip, cpu);
         data->critical_start = 0;
         atomic_dec(&data->disabled);
@@ -353,33 +355,26 @@ void trace_preempt_off(unsigned long a0, unsigned long a1)
 }
 #endif /* CONFIG_PREEMPT_TRACER */
 
-/*
- * save_tracer_enabled is used to save the state of the tracer_enabled
- * variable when we disable it when we open a trace output file.
- */
-static int save_tracer_enabled;
-
 static void start_irqsoff_tracer(struct trace_array *tr)
 {
         register_ftrace_function(&trace_ops);
-        if (tracing_is_enabled()) {
+        if (tracing_is_enabled())
                 tracer_enabled = 1;
-                save_tracer_enabled = 1;
-        } else {
+        else
                 tracer_enabled = 0;
-                save_tracer_enabled = 0;
-        }
 }
 
 static void stop_irqsoff_tracer(struct trace_array *tr)
 {
         tracer_enabled = 0;
-        save_tracer_enabled = 0;
         unregister_ftrace_function(&trace_ops);
 }
 
 static void __irqsoff_tracer_init(struct trace_array *tr)
 {
+        save_lat_flag = trace_flags & TRACE_ITER_LATENCY_FMT;
+        trace_flags |= TRACE_ITER_LATENCY_FMT;
+
         tracing_max_latency = 0;
         irqsoff_trace = tr;
         /* make sure that the tracer is visible */
@@ -390,30 +385,19 @@ static void __irqsoff_tracer_init(struct trace_array *tr)
 static void irqsoff_tracer_reset(struct trace_array *tr)
 {
         stop_irqsoff_tracer(tr);
+
+        if (!save_lat_flag)
+                trace_flags &= ~TRACE_ITER_LATENCY_FMT;
 }
 
 static void irqsoff_tracer_start(struct trace_array *tr)
 {
         tracer_enabled = 1;
-        save_tracer_enabled = 1;
 }
 
 static void irqsoff_tracer_stop(struct trace_array *tr)
 {
         tracer_enabled = 0;
-        save_tracer_enabled = 0;
-}
-
-static void irqsoff_tracer_open(struct trace_iterator *iter)
-{
-        /* stop the trace while dumping */
-        tracer_enabled = 0;
-}
-
-static void irqsoff_tracer_close(struct trace_iterator *iter)
-{
-        /* restart tracing */
-        tracer_enabled = save_tracer_enabled;
 }
 
 #ifdef CONFIG_IRQSOFF_TRACER
@@ -431,8 +415,6 @@ static struct tracer irqsoff_tracer __read_mostly =
         .reset          = irqsoff_tracer_reset,
         .start          = irqsoff_tracer_start,
         .stop           = irqsoff_tracer_stop,
-        .open           = irqsoff_tracer_open,
-        .close          = irqsoff_tracer_close,
         .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_irqsoff,
@@ -459,8 +441,6 @@ static struct tracer preemptoff_tracer __read_mostly =
         .reset          = irqsoff_tracer_reset,
         .start          = irqsoff_tracer_start,
         .stop           = irqsoff_tracer_stop,
-        .open           = irqsoff_tracer_open,
-        .close          = irqsoff_tracer_close,
         .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_preemptoff,
@@ -489,8 +469,6 @@ static struct tracer preemptirqsoff_tracer __read_mostly =
         .reset          = irqsoff_tracer_reset,
         .start          = irqsoff_tracer_start,
         .stop           = irqsoff_tracer_stop,
-        .open           = irqsoff_tracer_open,
-        .close          = irqsoff_tracer_close,
         .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_preemptirqsoff,
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index 80e503ef6136..f095916e477f 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -12,6 +12,7 @@
 #include <asm/atomic.h>
 
 #include "trace.h"
+#include "trace_output.h"
 
 struct header_iter {
         struct pci_dev *dev;
@@ -183,21 +184,22 @@ static enum print_line_t mmio_print_rw(struct trace_iterator *iter)
         switch (rw->opcode) {
         case MMIO_READ:
                 ret = trace_seq_printf(s,
-                        "R %d %lu.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
+                        "R %d %u.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
                         rw->width, secs, usec_rem, rw->map_id,
                         (unsigned long long)rw->phys,
                         rw->value, rw->pc, 0);
                 break;
         case MMIO_WRITE:
                 ret = trace_seq_printf(s,
-                        "W %d %lu.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
+                        "W %d %u.%06lu %d 0x%llx 0x%lx 0x%lx %d\n",
                         rw->width, secs, usec_rem, rw->map_id,
                         (unsigned long long)rw->phys,
                         rw->value, rw->pc, 0);
                 break;
         case MMIO_UNKNOWN_OP:
                 ret = trace_seq_printf(s,
-                        "UNKNOWN %lu.%06lu %d 0x%llx %02x,%02x,%02x 0x%lx %d\n",
+                        "UNKNOWN %u.%06lu %d 0x%llx %02lx,%02lx,"
+                        "%02lx 0x%lx %d\n",
                         secs, usec_rem, rw->map_id,
                         (unsigned long long)rw->phys,
                         (rw->value >> 16) & 0xff, (rw->value >> 8) & 0xff,
@@ -229,14 +231,14 @@ static enum print_line_t mmio_print_map(struct trace_iterator *iter)
         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",
+                        "MAP %u.%06lu %d 0x%llx 0x%lx 0x%lx 0x%lx %d\n",
                         secs, usec_rem, m->map_id,
                         (unsigned long long)m->phys, m->virt, m->len,
                         0UL, 0);
                 break;
         case MMIO_UNPROBE:
                 ret = trace_seq_printf(s,
-                        "UNMAP %lu.%06lu %d 0x%lx %d\n",
+                        "UNMAP %u.%06lu %d 0x%lx %d\n",
                         secs, usec_rem, m->map_id, 0UL, 0);
                 break;
         default:
@@ -255,18 +257,15 @@ static enum print_line_t mmio_print_mark(struct trace_iterator *iter)
         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 long usec_rem  = do_div(t, USEC_PER_SEC);
         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);
+        ret = trace_seq_printf(s, "MARK %u.%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;
 }
 
@@ -308,21 +307,17 @@ static void __trace_mmiotrace_rw(struct trace_array *tr,
 {
         struct ring_buffer_event *event;
         struct trace_mmiotrace_rw *entry;
-        unsigned long irq_flags;
+        int pc = preempt_count();
 
-        event   = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
-                                           &irq_flags);
+        event = trace_buffer_lock_reserve(tr, TRACE_MMIO_RW,
+                                          sizeof(*entry), 0, pc);
         if (!event) {
                 atomic_inc(&dropped_count);
                 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();
+        trace_buffer_unlock_commit(tr, event, 0, pc);
 }
 
 void mmio_trace_rw(struct mmiotrace_rw *rw)
@@ -338,21 +333,17 @@ static void __trace_mmiotrace_map(struct trace_array *tr,
 {
         struct ring_buffer_event *event;
         struct trace_mmiotrace_map *entry;
-        unsigned long irq_flags;
+        int pc = preempt_count();
 
-        event   = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
-                                           &irq_flags);
+        event = trace_buffer_lock_reserve(tr, TRACE_MMIO_MAP,
+                                          sizeof(*entry), 0, pc);
         if (!event) {
                 atomic_inc(&dropped_count);
                 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();
+        trace_buffer_unlock_commit(tr, event, 0, pc);
 }
 
 void mmio_trace_mapping(struct mmiotrace_map *map)
diff --git a/kernel/trace/trace_nop.c b/kernel/trace/trace_nop.c
index b9767acd30ac..9aa84bde23cd 100644
--- a/kernel/trace/trace_nop.c
+++ b/kernel/trace/trace_nop.c
@@ -47,12 +47,7 @@ static void stop_nop_trace(struct trace_array *tr)
 
 static int nop_trace_init(struct trace_array *tr)
 {
-        int cpu;
         ctx_trace = tr;
-
-        for_each_online_cpu(cpu)
-                tracing_reset(tr, cpu);
-
         start_nop_trace(tr);
         return 0;
 }
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
new file mode 100644
index 000000000000..6a4c9dea191e
--- /dev/null
+++ b/kernel/trace/trace_output.c
@@ -0,0 +1,967 @@
+/*
+ * trace_output.c
+ *
+ * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/ftrace.h>
+
+#include "trace_output.h"
+
+/* must be a power of 2 */
+#define EVENT_HASHSIZE  128
+
+static DEFINE_MUTEX(trace_event_mutex);
+static struct hlist_head event_hash[EVENT_HASHSIZE] __read_mostly;
+
+static int next_event_type = __TRACE_LAST_TYPE + 1;
+
+/**
+ * trace_seq_printf - sequence printing of trace information
+ * @s: trace sequence descriptor
+ * @fmt: printf format string
+ *
+ * The tracer may use either sequence operations or its own
+ * copy to user routines. To simplify formating of a trace
+ * trace_seq_printf is used to store strings into a special
+ * buffer (@s). Then the output may be either used by
+ * the sequencer or pulled into another buffer.
+ */
+int
+trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+{
+        int len = (PAGE_SIZE - 1) - s->len;
+        va_list ap;
+        int ret;
+
+        if (!len)
+                return 0;
+
+        va_start(ap, fmt);
+        ret = vsnprintf(s->buffer + s->len, len, fmt, ap);
+        va_end(ap);
+
+        /* If we can't write it all, don't bother writing anything */
+        if (ret >= len)
+                return 0;
+
+        s->len += ret;
+
+        return len;
+}
+
+int trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary)
+{
+        int len = (PAGE_SIZE - 1) - s->len;
+        int ret;
+
+        if (!len)
+                return 0;
+
+        ret = bstr_printf(s->buffer + s->len, len, fmt, binary);
+
+        /* If we can't write it all, don't bother writing anything */
+        if (ret >= len)
+                return 0;
+
+        s->len += ret;
+
+        return len;
+}
+
+/**
+ * trace_seq_puts - trace sequence printing of simple string
+ * @s: trace sequence descriptor
+ * @str: simple string to record
+ *
+ * The tracer may use either the sequence operations or its own
+ * copy to user routines. This function records a simple string
+ * into a special buffer (@s) for later retrieval by a sequencer
+ * or other mechanism.
+ */
+int trace_seq_puts(struct trace_seq *s, const char *str)
+{
+        int len = strlen(str);
+
+        if (len > ((PAGE_SIZE - 1) - s->len))
+                return 0;
+
+        memcpy(s->buffer + s->len, str, len);
+        s->len += len;
+
+        return len;
+}
+
+int trace_seq_putc(struct trace_seq *s, unsigned char c)
+{
+        if (s->len >= (PAGE_SIZE - 1))
+                return 0;
+
+        s->buffer[s->len++] = c;
+
+        return 1;
+}
+
+int trace_seq_putmem(struct trace_seq *s, void *mem, size_t len)
+{
+        if (len > ((PAGE_SIZE - 1) - s->len))
+                return 0;
+
+        memcpy(s->buffer + s->len, mem, len);
+        s->len += len;
+
+        return len;
+}
+
+int trace_seq_putmem_hex(struct trace_seq *s, void *mem, size_t len)
+{
+        unsigned char hex[HEX_CHARS];
+        unsigned char *data = mem;
+        int i, j;
+
+#ifdef __BIG_ENDIAN
+        for (i = 0, j = 0; i < len; i++) {
+#else
+        for (i = len-1, j = 0; i >= 0; i--) {
+#endif
+                hex[j++] = hex_asc_hi(data[i]);
+                hex[j++] = hex_asc_lo(data[i]);
+        }
+        hex[j++] = ' ';
+
+        return trace_seq_putmem(s, hex, j);
+}
+
+int trace_seq_path(struct trace_seq *s, struct path *path)
+{
+        unsigned char *p;
+
+        if (s->len >= (PAGE_SIZE - 1))
+                return 0;
+        p = d_path(path, s->buffer + s->len, PAGE_SIZE - s->len);
+        if (!IS_ERR(p)) {
+                p = mangle_path(s->buffer + s->len, p, "\n");
+                if (p) {
+                        s->len = p - s->buffer;
+                        return 1;
+                }
+        } else {
+                s->buffer[s->len++] = '?';
+                return 1;
+        }
+
+        return 0;
+}
+
+#ifdef CONFIG_KRETPROBES
+static inline const char *kretprobed(const char *name)
+{
+        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 const char *kretprobed(const char *name)
+{
+        return name;
+}
+#endif /* CONFIG_KRETPROBES */
+
+static int
+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);
+
+        name = kretprobed(str);
+
+        return trace_seq_printf(s, fmt, name);
+#endif
+        return 1;
+}
+
+static int
+seq_print_sym_offset(struct trace_seq *s, const char *fmt,
+                     unsigned long address)
+{
+#ifdef CONFIG_KALLSYMS
+        char str[KSYM_SYMBOL_LEN];
+        const char *name;
+
+        sprint_symbol(str, address);
+        name = kretprobed(str);
+
+        return trace_seq_printf(s, fmt, name);
+#endif
+        return 1;
+}
+
+#ifndef CONFIG_64BIT
+# define IP_FMT "%08lx"
+#else
+# define IP_FMT "%016lx"
+#endif
+
+int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,
+                      unsigned long ip, unsigned long sym_flags)
+{
+        struct file *file = NULL;
+        unsigned long vmstart = 0;
+        int ret = 1;
+
+        if (mm) {
+                const struct vm_area_struct *vma;
+
+                down_read(&mm->mmap_sem);
+                vma = find_vma(mm, ip);
+                if (vma) {
+                        file = vma->vm_file;
+                        vmstart = vma->vm_start;
+                }
+                if (file) {
+                        ret = trace_seq_path(s, &file->f_path);
+                        if (ret)
+                                ret = trace_seq_printf(s, "[+0x%lx]",
+                                                       ip - vmstart);
+                }
+                up_read(&mm->mmap_sem);
+        }
+        if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))
+                ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
+        return ret;
+}
+
+int
+seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,
+                      unsigned long sym_flags)
+{
+        struct mm_struct *mm = NULL;
+        int ret = 1;
+        unsigned int i;
+
+        if (trace_flags & TRACE_ITER_SYM_USEROBJ) {
+                struct task_struct *task;
+                /*
+                 * we do the lookup on the thread group leader,
+                 * since individual threads might have already quit!
+                 */
+                rcu_read_lock();
+                task = find_task_by_vpid(entry->ent.tgid);
+                if (task)
+                        mm = get_task_mm(task);
+                rcu_read_unlock();
+        }
+
+        for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
+                unsigned long ip = entry->caller[i];
+
+                if (ip == ULONG_MAX || !ret)
+                        break;
+                if (i && ret)
+                        ret = trace_seq_puts(s, " <- ");
+                if (!ip) {
+                        if (ret)
+                                ret = trace_seq_puts(s, "??");
+                        continue;
+                }
+                if (!ret)
+                        break;
+                if (ret)
+                        ret = seq_print_user_ip(s, mm, ip, sym_flags);
+        }
+
+        if (mm)
+                mmput(mm);
+        return ret;
+}
+
+int
+seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
+{
+        int ret;
+
+        if (!ip)
+                return trace_seq_printf(s, "0");
+
+        if (sym_flags & TRACE_ITER_SYM_OFFSET)
+                ret = seq_print_sym_offset(s, "%s", ip);
+        else
+                ret = seq_print_sym_short(s, "%s", ip);
+
+        if (!ret)
+                return 0;
+
+        if (sym_flags & TRACE_ITER_SYM_ADDR)
+                ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
+        return ret;
+}
+
+static int
+lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
+{
+        int hardirq, softirq;
+        char comm[TASK_COMM_LEN];
+
+        trace_find_cmdline(entry->pid, comm);
+        hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
+        softirq = entry->flags & TRACE_FLAG_SOFTIRQ;
+
+        if (!trace_seq_printf(s, "%8.8s-%-5d %3d%c%c%c",
+                              comm, entry->pid, cpu,
+                              (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
+                                (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
+                                  'X' : '.',
+                              (entry->flags & TRACE_FLAG_NEED_RESCHED) ?
+                                'N' : '.',
+                              (hardirq && softirq) ? 'H' :
+                                hardirq ? 'h' : softirq ? 's' : '.'))
+                return 0;
+
+        if (entry->preempt_count)
+                return trace_seq_printf(s, "%x", entry->preempt_count);
+        return trace_seq_puts(s, ".");
+}
+
+static unsigned long preempt_mark_thresh = 100;
+
+static int
+lat_print_timestamp(struct trace_seq *s, u64 abs_usecs,
+                    unsigned long rel_usecs)
+{
+        return trace_seq_printf(s, " %4lldus%c: ", abs_usecs,
+                                rel_usecs > preempt_mark_thresh ? '!' :
+                                  rel_usecs > 1 ? '+' : ' ');
+}
+
+int trace_print_context(struct trace_iterator *iter)
+{
+        struct trace_seq *s = &iter->seq;
+        struct trace_entry *entry = iter->ent;
+        unsigned long long t = ns2usecs(iter->ts);
+        unsigned long usec_rem = do_div(t, USEC_PER_SEC);
+        unsigned long secs = (unsigned long)t;
+        char comm[TASK_COMM_LEN];
+
+        trace_find_cmdline(entry->pid, comm);
+
+        return trace_seq_printf(s, "%16s-%-5d [%03d] %5lu.%06lu: ",
+                                comm, entry->pid, iter->cpu, secs, usec_rem);
+}
+
+int trace_print_lat_context(struct trace_iterator *iter)
+{
+        u64 next_ts;
+        int ret;
+        struct trace_seq *s = &iter->seq;
+        struct trace_entry *entry = iter->ent,
+                           *next_entry = trace_find_next_entry(iter, NULL,
+                                                               &next_ts);
+        unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE);
+        unsigned long abs_usecs = ns2usecs(iter->ts - iter->tr->time_start);
+        unsigned long rel_usecs;
+
+        if (!next_entry)
+                next_ts = iter->ts;
+        rel_usecs = ns2usecs(next_ts - iter->ts);
+
+        if (verbose) {
+                char comm[TASK_COMM_LEN];
+
+                trace_find_cmdline(entry->pid, comm);
+
+                ret = trace_seq_printf(s, "%16s %5d %3d %d %08x %08lx [%08lx]"
+                                       " %ld.%03ldms (+%ld.%03ldms): ", comm,
+                                       entry->pid, iter->cpu, entry->flags,
+                                       entry->preempt_count, iter->idx,
+                                       ns2usecs(iter->ts),
+                                       abs_usecs / USEC_PER_MSEC,
+                                       abs_usecs % USEC_PER_MSEC,
+                                       rel_usecs / USEC_PER_MSEC,
+                                       rel_usecs % USEC_PER_MSEC);
+        } else {
+                ret = lat_print_generic(s, entry, iter->cpu);
+                if (ret)
+                        ret = lat_print_timestamp(s, abs_usecs, rel_usecs);
+        }
+
+        return ret;
+}
+
+static const char state_to_char[] = TASK_STATE_TO_CHAR_STR;
+
+static int task_state_char(unsigned long state)
+{
+        int bit = state ? __ffs(state) + 1 : 0;
+
+        return bit < sizeof(state_to_char) - 1 ? state_to_char[bit] : '?';
+}
+
+/**
+ * ftrace_find_event - find a registered event
+ * @type: the type of event to look for
+ *
+ * Returns an event of type @type otherwise NULL
+ */
+struct trace_event *ftrace_find_event(int type)
+{
+        struct trace_event *event;
+        struct hlist_node *n;
+        unsigned key;
+
+        key = type & (EVENT_HASHSIZE - 1);
+
+        hlist_for_each_entry_rcu(event, n, &event_hash[key], node) {
+                if (event->type == type)
+                        return event;
+        }
+
+        return NULL;
+}
+
+/**
+ * register_ftrace_event - register output for an event type
+ * @event: the event type to register
+ *
+ * Event types are stored in a hash and this hash is used to
+ * find a way to print an event. If the @event->type is set
+ * then it will use that type, otherwise it will assign a
+ * type to use.
+ *
+ * If you assign your own type, please make sure it is added
+ * to the trace_type enum in trace.h, to avoid collisions
+ * with the dynamic types.
+ *
+ * Returns the event type number or zero on error.
+ */
+int register_ftrace_event(struct trace_event *event)
+{
+        unsigned key;
+        int ret = 0;
+
+        mutex_lock(&trace_event_mutex);
+
+        if (!event->type)
+                event->type = next_event_type++;
+        else if (event->type > __TRACE_LAST_TYPE) {
+                printk(KERN_WARNING "Need to add type to trace.h\n");
+                WARN_ON(1);
+        }
+
+        if (ftrace_find_event(event->type))
+                goto out;
+
+        if (event->trace == NULL)
+                event->trace = trace_nop_print;
+        if (event->raw == NULL)
+                event->raw = trace_nop_print;
+        if (event->hex == NULL)
+                event->hex = trace_nop_print;
+        if (event->binary == NULL)
+                event->binary = trace_nop_print;
+
+        key = event->type & (EVENT_HASHSIZE - 1);
+
+        hlist_add_head_rcu(&event->node, &event_hash[key]);
+
+        ret = event->type;
+ out:
+        mutex_unlock(&trace_event_mutex);
+
+        return ret;
+}
+
+/**
+ * unregister_ftrace_event - remove a no longer used event
+ * @event: the event to remove
+ */
+int unregister_ftrace_event(struct trace_event *event)
+{
+        mutex_lock(&trace_event_mutex);
+        hlist_del(&event->node);
+        mutex_unlock(&trace_event_mutex);
+
+        return 0;
+}
+
+/*
+ * Standard events
+ */
+
+enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags)
+{
+        return TRACE_TYPE_HANDLED;
+}
+
+/* TRACE_FN */
+static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags)
+{
+        struct ftrace_entry *field;
+        struct trace_seq *s = &iter->seq;
+
+        trace_assign_type(field, iter->ent);
+
+        if (!seq_print_ip_sym(s, field->ip, flags))
+                goto partial;
+
+        if ((flags & TRACE_ITER_PRINT_PARENT) && field->parent_ip) {
+                if (!trace_seq_printf(s, " <-"))
+                        goto partial;
+                if (!seq_print_ip_sym(s,
+                                      field->parent_ip,
+                                      flags))
+                        goto partial;
+        }
+        if (!trace_seq_printf(s, "\n"))
+                goto partial;
+
+        return TRACE_TYPE_HANDLED;
+
+ partial:
+        return TRACE_TYPE_PARTIAL_LINE;
+}
+
+static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags)
+{
+        struct ftrace_entry *field;
+
+        trace_assign_type(field, iter->ent);
+
+        if (!trace_seq_printf(&iter->seq, "%lx %lx\n",
+                              field->ip,
+                              field->parent_ip))
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags)
+{
+        struct ftrace_entry *field;
+        struct trace_seq *s = &iter->seq;
+
+        trace_assign_type(field, iter->ent);
+
+        SEQ_PUT_HEX_FIELD_RET(s, field->ip);
+        SEQ_PUT_HEX_FIELD_RET(s, field->parent_ip);
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags)
+{
+        struct ftrace_entry *field;
+        struct trace_seq *s = &iter->seq;
+
+        trace_assign_type(field, iter->ent);
+
+        SEQ_PUT_FIELD_RET(s, field->ip);
+        SEQ_PUT_FIELD_RET(s, field->parent_ip);
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static struct trace_event trace_fn_event = {
+        .type           = TRACE_FN,
+        .trace          = trace_fn_trace,
+        .raw            = trace_fn_raw,
+        .hex            = trace_fn_hex,
+        .binary         = trace_fn_bin,
+};
+
+/* TRACE_CTX an TRACE_WAKE */
+static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter,
+                                             char *delim)
+{
+        struct ctx_switch_entry *field;
+        char comm[TASK_COMM_LEN];
+        int S, T;
+
+
+        trace_assign_type(field, iter->ent);
+
+        T = task_state_char(field->next_state);
+        S = task_state_char(field->prev_state);
+        trace_find_cmdline(field->next_pid, comm);
+        if (!trace_seq_printf(&iter->seq,
+                              " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n",
+                              field->prev_pid,
+                              field->prev_prio,
+                              S, delim,
+                              field->next_cpu,
+                              field->next_pid,
+                              field->next_prio,
+                              T, comm))
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags)
+{
+        return trace_ctxwake_print(iter, "==>");
+}
+
+static enum print_line_t trace_wake_print(struct trace_iterator *iter,
+                                          int flags)
+{
+        return trace_ctxwake_print(iter, "  +");
+}
+
+static int trace_ctxwake_raw(struct trace_iterator *iter, char S)
+{
+        struct ctx_switch_entry *field;
+        int T;
+
+        trace_assign_type(field, iter->ent);
+
+        if (!S)
+                task_state_char(field->prev_state);
+        T = task_state_char(field->next_state);
+        if (!trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n",
+                              field->prev_pid,
+                              field->prev_prio,
+                              S,
+                              field->next_cpu,
+                              field->next_pid,
+                              field->next_prio,
+                              T))
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags)
+{
+        return trace_ctxwake_raw(iter, 0);
+}
+
+static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags)
+{
+        return trace_ctxwake_raw(iter, '+');
+}
+
+
+static int trace_ctxwake_hex(struct trace_iterator *iter, char S)
+{
+        struct ctx_switch_entry *field;
+        struct trace_seq *s = &iter->seq;
+        int T;
+
+        trace_assign_type(field, iter->ent);
+
+        if (!S)
+                task_state_char(field->prev_state);
+        T = task_state_char(field->next_state);
+
+        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, 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);
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags)
+{
+        return trace_ctxwake_hex(iter, 0);
+}
+
+static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags)
+{
+        return trace_ctxwake_hex(iter, '+');
+}
+
+static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter,
+                                           int flags)
+{
+        struct ctx_switch_entry *field;
+        struct trace_seq *s = &iter->seq;
+
+        trace_assign_type(field, iter->ent);
+
+        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);
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static struct trace_event trace_ctx_event = {
+        .type           = TRACE_CTX,
+        .trace          = trace_ctx_print,
+        .raw            = trace_ctx_raw,
+        .hex            = trace_ctx_hex,
+        .binary         = trace_ctxwake_bin,
+};
+
+static struct trace_event trace_wake_event = {
+        .type           = TRACE_WAKE,
+        .trace          = trace_wake_print,
+        .raw            = trace_wake_raw,
+        .hex            = trace_wake_hex,
+        .binary         = trace_ctxwake_bin,
+};
+
+/* TRACE_SPECIAL */
+static enum print_line_t trace_special_print(struct trace_iterator *iter,
+                                             int flags)
+{
+        struct special_entry *field;
+
+        trace_assign_type(field, iter->ent);
+
+        if (!trace_seq_printf(&iter->seq, "# %ld %ld %ld\n",
+                              field->arg1,
+                              field->arg2,
+                              field->arg3))
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t trace_special_hex(struct trace_iterator *iter,
+                                           int flags)
+{
+        struct special_entry *field;
+        struct trace_seq *s = &iter->seq;
+
+        trace_assign_type(field, iter->ent);
+
+        SEQ_PUT_HEX_FIELD_RET(s, field->arg1);
+        SEQ_PUT_HEX_FIELD_RET(s, field->arg2);
+        SEQ_PUT_HEX_FIELD_RET(s, field->arg3);
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static enum print_line_t trace_special_bin(struct trace_iterator *iter,
+                                           int flags)
+{
+        struct special_entry *field;
+        struct trace_seq *s = &iter->seq;
+
+        trace_assign_type(field, iter->ent);
+
+        SEQ_PUT_FIELD_RET(s, field->arg1);
+        SEQ_PUT_FIELD_RET(s, field->arg2);
+        SEQ_PUT_FIELD_RET(s, field->arg3);
+
+        return TRACE_TYPE_HANDLED;
+}
+
+static struct trace_event trace_special_event = {
+        .type           = TRACE_SPECIAL,
+        .trace          = trace_special_print,
+        .raw            = trace_special_print,
+        .hex            = trace_special_hex,
+        .binary         = trace_special_bin,
+};
+
+/* TRACE_STACK */
+
+static enum print_line_t trace_stack_print(struct trace_iterator *iter,
+                                           int flags)
+{
+        struct stack_entry *field;
+        struct trace_seq *s = &iter->seq;
+        int i;
+
+        trace_assign_type(field, iter->ent);
+
+        for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
+                if (i) {
+                        if (!trace_seq_puts(s, " <= "))
+                                goto partial;
+
+                        if (!seq_print_ip_sym(s, field->caller[i], flags))
+                                goto partial;
+                }
+                if (!trace_seq_puts(s, "\n"))
+                        goto partial;
+        }
+
+        return TRACE_TYPE_HANDLED;
+
+ partial:
+        return TRACE_TYPE_PARTIAL_LINE;
+}
+
+static struct trace_event trace_stack_event = {
+        .type           = TRACE_STACK,
+        .trace          = trace_stack_print,
+        .raw            = trace_special_print,
+        .hex            = trace_special_hex,
+        .binary         = trace_special_bin,
+};
+
+/* TRACE_USER_STACK */
+static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,
+                                                int flags)
+{
+        struct userstack_entry *field;
+        struct trace_seq *s = &iter->seq;
+
+        trace_assign_type(field, iter->ent);
+
+        if (!seq_print_userip_objs(field, s, flags))
+                goto partial;
+
+        if (!trace_seq_putc(s, '\n'))
+                goto partial;
+
+        return TRACE_TYPE_HANDLED;
+
+ partial:
+        return TRACE_TYPE_PARTIAL_LINE;
+}
+
+static struct trace_event trace_user_stack_event = {
+        .type           = TRACE_USER_STACK,
+        .trace          = trace_user_stack_print,
+        .raw            = trace_special_print,
+        .hex            = trace_special_hex,
+        .binary         = trace_special_bin,
+};
+
+/* TRACE_BPRINT */
+static enum print_line_t
+trace_bprint_print(struct trace_iterator *iter, int flags)
+{
+        struct trace_entry *entry = iter->ent;
+        struct trace_seq *s = &iter->seq;
+        struct bprint_entry *field;
+
+        trace_assign_type(field, entry);
+
+        if (!seq_print_ip_sym(s, field->ip, flags))
+                goto partial;
+
+        if (!trace_seq_puts(s, ": "))
+                goto partial;
+
+        if (!trace_seq_bprintf(s, field->fmt, field->buf))
+                goto partial;
+
+        return TRACE_TYPE_HANDLED;
+
+ partial:
+        return TRACE_TYPE_PARTIAL_LINE;
+}
+
+
+static enum print_line_t
+trace_bprint_raw(struct trace_iterator *iter, int flags)
+{
+        struct bprint_entry *field;
+        struct trace_seq *s = &iter->seq;
+
+        trace_assign_type(field, iter->ent);
+
+        if (!trace_seq_printf(s, ": %lx : ", field->ip))
+                goto partial;
+
+        if (!trace_seq_bprintf(s, field->fmt, field->buf))
+                goto partial;
+
+        return TRACE_TYPE_HANDLED;
+
+ partial:
+        return TRACE_TYPE_PARTIAL_LINE;
+}
+
+
+static struct trace_event trace_bprint_event = {
+        .type           = TRACE_BPRINT,
+        .trace          = trace_bprint_print,
+        .raw            = trace_bprint_raw,
+};
+
+/* TRACE_PRINT */
+static enum print_line_t trace_print_print(struct trace_iterator *iter,
+                                           int flags)
+{
+        struct print_entry *field;
+        struct trace_seq *s = &iter->seq;
+
+        trace_assign_type(field, iter->ent);
+
+        if (!seq_print_ip_sym(s, field->ip, flags))
+                goto partial;
+
+        if (!trace_seq_printf(s, ": %s", field->buf))
+                goto partial;
+
+        return TRACE_TYPE_HANDLED;
+
+ partial:
+        return TRACE_TYPE_PARTIAL_LINE;
+}
+
+static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags)
+{
+        struct print_entry *field;
+
+        trace_assign_type(field, iter->ent);
+
+        if (!trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf))
+                goto partial;
+
+        return TRACE_TYPE_HANDLED;
+
+ partial:
+        return TRACE_TYPE_PARTIAL_LINE;
+}
+
+static struct trace_event trace_print_event = {
+        .type           = TRACE_PRINT,
+        .trace          = trace_print_print,
+        .raw            = trace_print_raw,
+};
+
+
+static struct trace_event *events[] __initdata = {
+        &trace_fn_event,
+        &trace_ctx_event,
+        &trace_wake_event,
+        &trace_special_event,
+        &trace_stack_event,
+        &trace_user_stack_event,
+        &trace_bprint_event,
+        &trace_print_event,
+        NULL
+};
+
+__init static int init_events(void)
+{
+        struct trace_event *event;
+        int i, ret;
+
+        for (i = 0; events[i]; i++) {
+                event = events[i];
+
+                ret = register_ftrace_event(event);
+                if (!ret) {
+                        printk(KERN_WARNING "event %d failed to register\n",
+                               event->type);
+                        WARN_ON_ONCE(1);
+                }
+        }
+
+        return 0;
+}
+device_initcall(init_events);
diff --git a/kernel/trace/trace_output.h b/kernel/trace/trace_output.h
new file mode 100644
index 000000000000..3b90e6ade1aa
--- /dev/null
+++ b/kernel/trace/trace_output.h
@@ -0,0 +1,63 @@
+#ifndef __TRACE_EVENTS_H
+#define __TRACE_EVENTS_H
+
+#include "trace.h"
+
+typedef enum print_line_t (*trace_print_func)(struct trace_iterator *iter,
+                                              int flags);
+
+struct trace_event {
+        struct hlist_node       node;
+        int                     type;
+        trace_print_func        trace;
+        trace_print_func        raw;
+        trace_print_func        hex;
+        trace_print_func        binary;
+};
+
+extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int
+trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary);
+extern int
+seq_print_ip_sym(struct trace_seq *s, unsigned long ip,
+                unsigned long sym_flags);
+extern ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf,
+                                 size_t cnt);
+int trace_seq_puts(struct trace_seq *s, const char *str);
+int trace_seq_putc(struct trace_seq *s, unsigned char c);
+int trace_seq_putmem(struct trace_seq *s, void *mem, size_t len);
+int trace_seq_putmem_hex(struct trace_seq *s, void *mem, size_t len);
+int trace_seq_path(struct trace_seq *s, struct path *path);
+int seq_print_userip_objs(const struct userstack_entry *entry,
+                          struct trace_seq *s, unsigned long sym_flags);
+int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,
+                      unsigned long ip, unsigned long sym_flags);
+
+int trace_print_context(struct trace_iterator *iter);
+int trace_print_lat_context(struct trace_iterator *iter);
+
+struct trace_event *ftrace_find_event(int type);
+int register_ftrace_event(struct trace_event *event);
+int unregister_ftrace_event(struct trace_event *event);
+
+enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags);
+
+#define MAX_MEMHEX_BYTES        8
+#define HEX_CHARS               (MAX_MEMHEX_BYTES*2 + 1)
+
+#define SEQ_PUT_FIELD_RET(s, x)                         \
+do {                                                    \
+        if (!trace_seq_putmem(s, &(x), sizeof(x)))      \
+                return TRACE_TYPE_PARTIAL_LINE;         \
+} while (0)
+
+#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 TRACE_TYPE_PARTIAL_LINE;         \
+} while (0)
+
+#endif
+
diff --git a/kernel/trace/trace_power.c b/kernel/trace/trace_power.c
index 7bda248daf55..91ce672fb037 100644
--- a/kernel/trace/trace_power.c
+++ b/kernel/trace/trace_power.c
@@ -11,24 +11,126 @@
 
 #include <linux/init.h>
 #include <linux/debugfs.h>
-#include <linux/ftrace.h>
+#include <trace/power.h>
 #include <linux/kallsyms.h>
 #include <linux/module.h>
 
 #include "trace.h"
+#include "trace_output.h"
 
 static struct trace_array *power_trace;
 static int __read_mostly trace_power_enabled;
 
+static void probe_power_start(struct power_trace *it, unsigned int type,
+                                unsigned int level)
+{
+        if (!trace_power_enabled)
+                return;
+
+        memset(it, 0, sizeof(struct power_trace));
+        it->state = level;
+        it->type = type;
+        it->stamp = ktime_get();
+}
+
+
+static void probe_power_end(struct power_trace *it)
+{
+        struct ring_buffer_event *event;
+        struct trace_power *entry;
+        struct trace_array_cpu *data;
+        struct trace_array *tr = power_trace;
+
+        if (!trace_power_enabled)
+                return;
+
+        preempt_disable();
+        it->end = ktime_get();
+        data = tr->data[smp_processor_id()];
+
+        event = trace_buffer_lock_reserve(tr, TRACE_POWER,
+                                          sizeof(*entry), 0, 0);
+        if (!event)
+                goto out;
+        entry   = ring_buffer_event_data(event);
+        entry->state_data = *it;
+        trace_buffer_unlock_commit(tr, event, 0, 0);
+ out:
+        preempt_enable();
+}
+
+static void probe_power_mark(struct power_trace *it, unsigned int type,
+                                unsigned int level)
+{
+        struct ring_buffer_event *event;
+        struct trace_power *entry;
+        struct trace_array_cpu *data;
+        struct trace_array *tr = power_trace;
+
+        if (!trace_power_enabled)
+                return;
+
+        memset(it, 0, sizeof(struct power_trace));
+        it->state = level;
+        it->type = type;
+        it->stamp = ktime_get();
+        preempt_disable();
+        it->end = it->stamp;
+        data = tr->data[smp_processor_id()];
+
+        event = trace_buffer_lock_reserve(tr, TRACE_POWER,
+                                          sizeof(*entry), 0, 0);
+        if (!event)
+                goto out;
+        entry   = ring_buffer_event_data(event);
+        entry->state_data = *it;
+        trace_buffer_unlock_commit(tr, event, 0, 0);
+ out:
+        preempt_enable();
+}
+
+static int tracing_power_register(void)
+{
+        int ret;
+
+        ret = register_trace_power_start(probe_power_start);
+        if (ret) {
+                pr_info("power trace: Couldn't activate tracepoint"
+                        " probe to trace_power_start\n");
+                return ret;
+        }
+        ret = register_trace_power_end(probe_power_end);
+        if (ret) {
+                pr_info("power trace: Couldn't activate tracepoint"
+                        " probe to trace_power_end\n");
+                goto fail_start;
+        }
+        ret = register_trace_power_mark(probe_power_mark);
+        if (ret) {
+                pr_info("power trace: Couldn't activate tracepoint"
+                        " probe to trace_power_mark\n");
+                goto fail_end;
+        }
+        return ret;
+fail_end:
+        unregister_trace_power_end(probe_power_end);
+fail_start:
+        unregister_trace_power_start(probe_power_start);
+        return ret;
+}
 
 static void start_power_trace(struct trace_array *tr)
 {
         trace_power_enabled = 1;
+        tracing_power_register();
 }
 
 static void stop_power_trace(struct trace_array *tr)
 {
         trace_power_enabled = 0;
+        unregister_trace_power_start(probe_power_start);
+        unregister_trace_power_end(probe_power_end);
+        unregister_trace_power_mark(probe_power_mark);
 }
 
 
@@ -38,6 +140,7 @@ static int power_trace_init(struct trace_array *tr)
         power_trace = tr;
 
         trace_power_enabled = 1;
+        tracing_power_register();
 
         for_each_cpu(cpu, cpu_possible_mask)
                 tracing_reset(tr, cpu);
@@ -94,86 +197,3 @@ static int init_power_trace(void)
         return register_tracer(&power_tracer);
 }
 device_initcall(init_power_trace);
-
-void trace_power_start(struct power_trace *it, unsigned int type,
-                         unsigned int level)
-{
-        if (!trace_power_enabled)
-                return;
-
-        memset(it, 0, sizeof(struct power_trace));
-        it->state = level;
-        it->type = type;
-        it->stamp = ktime_get();
-}
-EXPORT_SYMBOL_GPL(trace_power_start);
-
-
-void trace_power_end(struct power_trace *it)
-{
-        struct ring_buffer_event *event;
-        struct trace_power *entry;
-        struct trace_array_cpu *data;
-        unsigned long irq_flags;
-        struct trace_array *tr = power_trace;
-
-        if (!trace_power_enabled)
-                return;
-
-        preempt_disable();
-        it->end = ktime_get();
-        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_POWER;
-        entry->state_data = *it;
-        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
-
-        trace_wake_up();
-
- out:
-        preempt_enable();
-}
-EXPORT_SYMBOL_GPL(trace_power_end);
-
-void trace_power_mark(struct power_trace *it, unsigned int type,
-                         unsigned int level)
-{
-        struct ring_buffer_event *event;
-        struct trace_power *entry;
-        struct trace_array_cpu *data;
-        unsigned long irq_flags;
-        struct trace_array *tr = power_trace;
-
-        if (!trace_power_enabled)
-                return;
-
-        memset(it, 0, sizeof(struct power_trace));
-        it->state = level;
-        it->type = type;
-        it->stamp = ktime_get();
-        preempt_disable();
-        it->end = it->stamp;
-        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_POWER;
-        entry->state_data = *it;
-        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
-
-        trace_wake_up();
-
- out:
-        preempt_enable();
-}
-EXPORT_SYMBOL_GPL(trace_power_mark);
diff --git a/kernel/trace/trace_printk.c b/kernel/trace/trace_printk.c
new file mode 100644
index 000000000000..486785214e3e
--- /dev/null
+++ b/kernel/trace/trace_printk.c
@@ -0,0 +1,270 @@
+/*
+ * trace binary printk
+ *
+ * Copyright (C) 2008 Lai Jiangshan <laijs@cn.fujitsu.com>
+ *
+ */
+#include <linux/seq_file.h>
+#include <linux/debugfs.h>
+#include <linux/uaccess.h>
+#include <linux/kernel.h>
+#include <linux/ftrace.h>
+#include <linux/string.h>
+#include <linux/module.h>
+#include <linux/marker.h>
+#include <linux/mutex.h>
+#include <linux/ctype.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+
+#include "trace.h"
+
+#ifdef CONFIG_MODULES
+
+/*
+ * modules trace_printk()'s formats are autosaved in struct trace_bprintk_fmt
+ * which are queued on trace_bprintk_fmt_list.
+ */
+static LIST_HEAD(trace_bprintk_fmt_list);
+
+/* serialize accesses to trace_bprintk_fmt_list */
+static DEFINE_MUTEX(btrace_mutex);
+
+struct trace_bprintk_fmt {
+        struct list_head list;
+        char fmt[0];
+};
+
+static inline struct trace_bprintk_fmt *lookup_format(const char *fmt)
+{
+        struct trace_bprintk_fmt *pos;
+        list_for_each_entry(pos, &trace_bprintk_fmt_list, list) {
+                if (!strcmp(pos->fmt, fmt))
+                        return pos;
+        }
+        return NULL;
+}
+
+static
+void hold_module_trace_bprintk_format(const char **start, const char **end)
+{
+        const char **iter;
+
+        mutex_lock(&btrace_mutex);
+        for (iter = start; iter < end; iter++) {
+                struct trace_bprintk_fmt *tb_fmt = lookup_format(*iter);
+                if (tb_fmt) {
+                        *iter = tb_fmt->fmt;
+                        continue;
+                }
+
+                tb_fmt = kmalloc(offsetof(struct trace_bprintk_fmt, fmt)
+                                + strlen(*iter) + 1, GFP_KERNEL);
+                if (tb_fmt) {
+                        list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
+                        strcpy(tb_fmt->fmt, *iter);
+                        *iter = tb_fmt->fmt;
+                } else
+                        *iter = NULL;
+        }
+        mutex_unlock(&btrace_mutex);
+}
+
+static int module_trace_bprintk_format_notify(struct notifier_block *self,
+                unsigned long val, void *data)
+{
+        struct module *mod = data;
+        if (mod->num_trace_bprintk_fmt) {
+                const char **start = mod->trace_bprintk_fmt_start;
+                const char **end = start + mod->num_trace_bprintk_fmt;
+
+                if (val == MODULE_STATE_COMING)
+                        hold_module_trace_bprintk_format(start, end);
+        }
+        return 0;
+}
+
+#else /* !CONFIG_MODULES */
+__init static int
+module_trace_bprintk_format_notify(struct notifier_block *self,
+                unsigned long val, void *data)
+{
+        return 0;
+}
+#endif /* CONFIG_MODULES */
+
+
+__initdata_or_module static
+struct notifier_block module_trace_bprintk_format_nb = {
+        .notifier_call = module_trace_bprintk_format_notify,
+};
+
+int __trace_bprintk(unsigned long ip, const char *fmt, ...)
+ {
+        int ret;
+        va_list ap;
+
+        if (unlikely(!fmt))
+                return 0;
+
+        if (!(trace_flags & TRACE_ITER_PRINTK))
+                return 0;
+
+        va_start(ap, fmt);
+        ret = trace_vbprintk(ip, task_curr_ret_stack(current), fmt, ap);
+        va_end(ap);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(__trace_bprintk);
+
+int __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap)
+ {
+        if (unlikely(!fmt))
+                return 0;
+
+        if (!(trace_flags & TRACE_ITER_PRINTK))
+                return 0;
+
+        return trace_vbprintk(ip, task_curr_ret_stack(current), fmt, ap);
+}
+EXPORT_SYMBOL_GPL(__ftrace_vbprintk);
+
+int __trace_printk(unsigned long ip, const char *fmt, ...)
+{
+        int ret;
+        va_list ap;
+
+        if (!(trace_flags & TRACE_ITER_PRINTK))
+                return 0;
+
+        va_start(ap, fmt);
+        ret = trace_vprintk(ip, task_curr_ret_stack(current), fmt, ap);
+        va_end(ap);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(__trace_printk);
+
+int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
+{
+        if (!(trace_flags & TRACE_ITER_PRINTK))
+                return 0;
+
+        return trace_vprintk(ip, task_curr_ret_stack(current), fmt, ap);
+}
+EXPORT_SYMBOL_GPL(__ftrace_vprintk);
+
+static void *
+t_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        const char **fmt = m->private;
+        const char **next = fmt;
+
+        (*pos)++;
+
+        if ((unsigned long)fmt >= (unsigned long)__stop___trace_bprintk_fmt)
+                return NULL;
+
+        next = fmt;
+        m->private = ++next;
+
+        return fmt;
+}
+
+static void *t_start(struct seq_file *m, loff_t *pos)
+{
+        return t_next(m, NULL, pos);
+}
+
+static int t_show(struct seq_file *m, void *v)
+{
+        const char **fmt = v;
+        const char *str = *fmt;
+        int i;
+
+        seq_printf(m, "0x%lx : \"", (unsigned long)fmt);
+
+        /*
+         * Tabs and new lines need to be converted.
+         */
+        for (i = 0; str[i]; i++) {
+                switch (str[i]) {
+                case '\n':
+                        seq_puts(m, "\\n");
+                        break;
+                case '\t':
+                        seq_puts(m, "\\t");
+                        break;
+                case '\\':
+                        seq_puts(m, "\\");
+                        break;
+                case '"':
+                        seq_puts(m, "\\\"");
+                        break;
+                default:
+                        seq_putc(m, str[i]);
+                }
+        }
+        seq_puts(m, "\"\n");
+
+        return 0;
+}
+
+static void t_stop(struct seq_file *m, void *p)
+{
+}
+
+static const struct seq_operations show_format_seq_ops = {
+        .start = t_start,
+        .next = t_next,
+        .show = t_show,
+        .stop = t_stop,
+};
+
+static int
+ftrace_formats_open(struct inode *inode, struct file *file)
+{
+        int ret;
+
+        ret = seq_open(file, &show_format_seq_ops);
+        if (!ret) {
+                struct seq_file *m = file->private_data;
+
+                m->private = __start___trace_bprintk_fmt;
+        }
+        return ret;
+}
+
+static const struct file_operations ftrace_formats_fops = {
+        .open = ftrace_formats_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = seq_release,
+};
+
+static __init int init_trace_printk_function_export(void)
+{
+        struct dentry *d_tracer;
+        struct dentry *entry;
+
+        d_tracer = tracing_init_dentry();
+        if (!d_tracer)
+                return 0;
+
+        entry = debugfs_create_file("printk_formats", 0444, d_tracer,
+                                    NULL, &ftrace_formats_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs "
+                           "'printk_formats' entry\n");
+
+        return 0;
+}
+
+fs_initcall(init_trace_printk_function_export);
+
+static __init int init_trace_printk(void)
+{
+        return register_module_notifier(&module_trace_bprintk_format_nb);
+}
+
+early_initcall(init_trace_printk);
diff --git a/kernel/trace/trace_sched_switch.c b/kernel/trace/trace_sched_switch.c
index df175cb4564f..77132c2cf3d9 100644
--- a/kernel/trace/trace_sched_switch.c
+++ b/kernel/trace/trace_sched_switch.c
@@ -43,7 +43,7 @@ probe_sched_switch(struct rq *__rq, struct task_struct *prev,
         data = ctx_trace->data[cpu];
 
         if (likely(!atomic_read(&data->disabled)))
-                tracing_sched_switch_trace(ctx_trace, data, prev, next, flags, pc);
+                tracing_sched_switch_trace(ctx_trace, prev, next, flags, pc);
 
         local_irq_restore(flags);
 }
@@ -66,7 +66,7 @@ probe_sched_wakeup(struct rq *__rq, struct task_struct *wakee, int success)
         data = ctx_trace->data[cpu];
 
         if (likely(!atomic_read(&data->disabled)))
-                tracing_sched_wakeup_trace(ctx_trace, data, wakee, current,
+                tracing_sched_wakeup_trace(ctx_trace, wakee, current,
                                            flags, pc);
 
         local_irq_restore(flags);
@@ -93,7 +93,7 @@ static int tracing_sched_register(void)
         ret = register_trace_sched_switch(probe_sched_switch);
         if (ret) {
                 pr_info("sched trace: Couldn't activate tracepoint"
-                        " probe to kernel_sched_schedule\n");
+                        " probe to kernel_sched_switch\n");
                 goto fail_deprobe_wake_new;
         }
 
@@ -185,12 +185,6 @@ void tracing_sched_switch_assign_trace(struct trace_array *tr)
         ctx_trace = tr;
 }
 
-static void start_sched_trace(struct trace_array *tr)
-{
-        tracing_reset_online_cpus(tr);
-        tracing_start_sched_switch_record();
-}
-
 static void stop_sched_trace(struct trace_array *tr)
 {
         tracing_stop_sched_switch_record();
@@ -199,7 +193,7 @@ static void stop_sched_trace(struct trace_array *tr)
 static int sched_switch_trace_init(struct trace_array *tr)
 {
         ctx_trace = tr;
-        start_sched_trace(tr);
+        tracing_start_sched_switch_record();
         return 0;
 }
 
@@ -227,6 +221,7 @@ static struct tracer sched_switch_trace __read_mostly =
         .reset          = sched_switch_trace_reset,
         .start          = sched_switch_trace_start,
         .stop           = sched_switch_trace_stop,
+        .wait_pipe      = poll_wait_pipe,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_sched_switch,
 #endif
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index 42ae1e77b6b3..3c5ad6b2ec84 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -25,12 +25,15 @@ static int __read_mostly	tracer_enabled;
 static struct task_struct       *wakeup_task;
 static int                      wakeup_cpu;
 static unsigned                 wakeup_prio = -1;
+static int                      wakeup_rt;
 
 static raw_spinlock_t wakeup_lock =
         (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
 
 static void __wakeup_reset(struct trace_array *tr);
 
+static int save_lat_flag;
+
 #ifdef CONFIG_FUNCTION_TRACER
 /*
  * irqsoff uses its own tracer function to keep the overhead down:
@@ -71,7 +74,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, pc);
+        trace_function(tr, ip, parent_ip, flags, pc);
 
  unlock:
         __raw_spin_unlock(&wakeup_lock);
@@ -151,7 +154,8 @@ probe_wakeup_sched_switch(struct rq *rq, struct task_struct *prev,
         if (unlikely(!tracer_enabled || next != wakeup_task))
                 goto out_unlock;
 
-        trace_function(wakeup_trace, data, CALLER_ADDR1, CALLER_ADDR2, flags, pc);
+        trace_function(wakeup_trace, CALLER_ADDR1, CALLER_ADDR2, flags, pc);
+        tracing_sched_switch_trace(wakeup_trace, prev, next, flags, pc);
 
         /*
          * usecs conversion is slow so we try to delay the conversion
@@ -182,13 +186,10 @@ out:
 
 static void __wakeup_reset(struct trace_array *tr)
 {
-        struct trace_array_cpu *data;
         int cpu;
 
-        for_each_possible_cpu(cpu) {
-                data = tr->data[cpu];
+        for_each_possible_cpu(cpu)
                 tracing_reset(tr, cpu);
-        }
 
         wakeup_cpu = -1;
         wakeup_prio = -1;
@@ -213,6 +214,7 @@ static void wakeup_reset(struct trace_array *tr)
 static void
 probe_wakeup(struct rq *rq, struct task_struct *p, int success)
 {
+        struct trace_array_cpu *data;
         int cpu = smp_processor_id();
         unsigned long flags;
         long disabled;
@@ -224,7 +226,7 @@ probe_wakeup(struct rq *rq, struct task_struct *p, int success)
         tracing_record_cmdline(p);
         tracing_record_cmdline(current);
 
-        if (likely(!rt_task(p)) ||
+        if ((wakeup_rt && !rt_task(p)) ||
                         p->prio >= wakeup_prio ||
                         p->prio >= current->prio)
                 return;
@@ -252,9 +254,10 @@ probe_wakeup(struct rq *rq, struct task_struct *p, int success)
 
         local_save_flags(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);
+        data = wakeup_trace->data[wakeup_cpu];
+        data->preempt_timestamp = ftrace_now(cpu);
+        tracing_sched_wakeup_trace(wakeup_trace, p, current, flags, pc);
+        trace_function(wakeup_trace, CALLER_ADDR1, CALLER_ADDR2, flags, pc);
 
 out_locked:
         __raw_spin_unlock(&wakeup_lock);
@@ -262,12 +265,6 @@ out:
         atomic_dec(&wakeup_trace->data[cpu]->disabled);
 }
 
-/*
- * save_tracer_enabled is used to save the state of the tracer_enabled
- * variable when we disable it when we open a trace output file.
- */
-static int save_tracer_enabled;
-
 static void start_wakeup_tracer(struct trace_array *tr)
 {
         int ret;
@@ -289,7 +286,7 @@ static void start_wakeup_tracer(struct trace_array *tr)
         ret = register_trace_sched_switch(probe_wakeup_sched_switch);
         if (ret) {
                 pr_info("sched trace: Couldn't activate tracepoint"
-                        " probe to kernel_sched_schedule\n");
+                        " probe to kernel_sched_switch\n");
                 goto fail_deprobe_wake_new;
         }
 
@@ -306,13 +303,10 @@ static void start_wakeup_tracer(struct trace_array *tr)
 
         register_ftrace_function(&trace_ops);
 
-        if (tracing_is_enabled()) {
+        if (tracing_is_enabled())
                 tracer_enabled = 1;
-                save_tracer_enabled = 1;
-        } else {
+        else
                 tracer_enabled = 0;
-                save_tracer_enabled = 0;
-        }
 
         return;
 fail_deprobe_wake_new:
@@ -324,54 +318,54 @@ fail_deprobe:
 static void stop_wakeup_tracer(struct trace_array *tr)
 {
         tracer_enabled = 0;
-        save_tracer_enabled = 0;
         unregister_ftrace_function(&trace_ops);
         unregister_trace_sched_switch(probe_wakeup_sched_switch);
         unregister_trace_sched_wakeup_new(probe_wakeup);
         unregister_trace_sched_wakeup(probe_wakeup);
 }
 
-static int wakeup_tracer_init(struct trace_array *tr)
+static int __wakeup_tracer_init(struct trace_array *tr)
 {
+        save_lat_flag = trace_flags & TRACE_ITER_LATENCY_FMT;
+        trace_flags |= TRACE_ITER_LATENCY_FMT;
+
         tracing_max_latency = 0;
         wakeup_trace = tr;
         start_wakeup_tracer(tr);
         return 0;
 }
 
+static int wakeup_tracer_init(struct trace_array *tr)
+{
+        wakeup_rt = 0;
+        return __wakeup_tracer_init(tr);
+}
+
+static int wakeup_rt_tracer_init(struct trace_array *tr)
+{
+        wakeup_rt = 1;
+        return __wakeup_tracer_init(tr);
+}
+
 static void wakeup_tracer_reset(struct trace_array *tr)
 {
         stop_wakeup_tracer(tr);
         /* make sure we put back any tasks we are tracing */
         wakeup_reset(tr);
+
+        if (!save_lat_flag)
+                trace_flags &= ~TRACE_ITER_LATENCY_FMT;
 }
 
 static void wakeup_tracer_start(struct trace_array *tr)
 {
         wakeup_reset(tr);
         tracer_enabled = 1;
-        save_tracer_enabled = 1;
 }
 
 static void wakeup_tracer_stop(struct trace_array *tr)
 {
         tracer_enabled = 0;
-        save_tracer_enabled = 0;
-}
-
-static void wakeup_tracer_open(struct trace_iterator *iter)
-{
-        /* stop the trace while dumping */
-        tracer_enabled = 0;
-}
-
-static void wakeup_tracer_close(struct trace_iterator *iter)
-{
-        /* forget about any processes we were recording */
-        if (save_tracer_enabled) {
-                wakeup_reset(iter->tr);
-                tracer_enabled = 1;
-        }
 }
 
 static struct tracer wakeup_tracer __read_mostly =
@@ -381,8 +375,20 @@ static struct tracer wakeup_tracer __read_mostly =
         .reset          = wakeup_tracer_reset,
         .start          = wakeup_tracer_start,
         .stop           = wakeup_tracer_stop,
-        .open           = wakeup_tracer_open,
-        .close          = wakeup_tracer_close,
+        .print_max      = 1,
+#ifdef CONFIG_FTRACE_SELFTEST
+        .selftest    = trace_selftest_startup_wakeup,
+#endif
+};
+
+static struct tracer wakeup_rt_tracer __read_mostly =
+{
+        .name           = "wakeup_rt",
+        .init           = wakeup_rt_tracer_init,
+        .reset          = wakeup_tracer_reset,
+        .start          = wakeup_tracer_start,
+        .stop           = wakeup_tracer_stop,
+        .wait_pipe      = poll_wait_pipe,
         .print_max      = 1,
 #ifdef CONFIG_FTRACE_SELFTEST
         .selftest    = trace_selftest_startup_wakeup,
@@ -397,6 +403,10 @@ __init static int init_wakeup_tracer(void)
         if (ret)
                 return ret;
 
+        ret = register_tracer(&wakeup_rt_tracer);
+        if (ret)
+                return ret;
+
         return 0;
 }
 device_initcall(init_wakeup_tracer);
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index bc8e80a86bca..a2ca6f0fef9b 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -1,5 +1,6 @@
 /* Include in trace.c */
 
+#include <linux/stringify.h>
 #include <linux/kthread.h>
 #include <linux/delay.h>
 
@@ -9,11 +10,12 @@ 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:
         case TRACE_BRANCH:
+        case TRACE_GRAPH_ENT:
+        case TRACE_GRAPH_RET:
                 return 1;
         }
         return 0;
@@ -99,9 +101,6 @@ static inline void warn_failed_init_tracer(struct tracer *trace, int init_ret)
 
 #ifdef CONFIG_DYNAMIC_FTRACE
 
-#define __STR(x) #x
-#define STR(x) __STR(x)
-
 /* Test dynamic code modification and ftrace filters */
 int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
                                            struct trace_array *tr,
@@ -125,17 +124,17 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
         func();
 
         /*
-         * Some archs *cough*PowerPC*cough* add charachters to the
+         * Some archs *cough*PowerPC*cough* add characters to the
          * start of the function names. We simply put a '*' to
-         * accomodate them.
+         * accommodate them.
          */
-        func_name = "*" STR(DYN_FTRACE_TEST_NAME);
+        func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
 
         /* filter only on our function */
         ftrace_set_filter(func_name, strlen(func_name), 1);
 
         /* enable tracing */
-        ret = trace->init(tr);
+        ret = tracer_init(trace, tr);
         if (ret) {
                 warn_failed_init_tracer(trace, ret);
                 goto out;
@@ -209,7 +208,7 @@ trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
         ftrace_enabled = 1;
         tracer_enabled = 1;
 
-        ret = trace->init(tr);
+        ret = tracer_init(trace, tr);
         if (ret) {
                 warn_failed_init_tracer(trace, ret);
                 goto out;
@@ -247,6 +246,54 @@ trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
 }
 #endif /* CONFIG_FUNCTION_TRACER */
 
+
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+/*
+ * Pretty much the same than for the function tracer from which the selftest
+ * has been borrowed.
+ */
+int
+trace_selftest_startup_function_graph(struct tracer *trace,
+                                        struct trace_array *tr)
+{
+        int ret;
+        unsigned long count;
+
+        ret = tracer_init(trace, tr);
+        if (ret) {
+                warn_failed_init_tracer(trace, ret);
+                goto out;
+        }
+
+        /* Sleep for a 1/10 of a second */
+        msleep(100);
+
+        tracing_stop();
+
+        /* check the trace buffer */
+        ret = trace_test_buffer(tr, &count);
+
+        trace->reset(tr);
+        tracing_start();
+
+        if (!ret && !count) {
+                printk(KERN_CONT ".. no entries found ..");
+                ret = -1;
+                goto out;
+        }
+
+        /* Don't test dynamic tracing, the function tracer already did */
+
+out:
+        /* Stop it if we failed */
+        if (ret)
+                ftrace_graph_stop();
+
+        return ret;
+}
+#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
+
+
 #ifdef CONFIG_IRQSOFF_TRACER
 int
 trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
@@ -256,7 +303,7 @@ trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
         int ret;
 
         /* start the tracing */
-        ret = trace->init(tr);
+        ret = tracer_init(trace, tr);
         if (ret) {
                 warn_failed_init_tracer(trace, ret);
                 return ret;
@@ -310,7 +357,7 @@ trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
         }
 
         /* start the tracing */
-        ret = trace->init(tr);
+        ret = tracer_init(trace, tr);
         if (ret) {
                 warn_failed_init_tracer(trace, ret);
                 return ret;
@@ -364,10 +411,10 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
         }
 
         /* start the tracing */
-        ret = trace->init(tr);
+        ret = tracer_init(trace, tr);
         if (ret) {
                 warn_failed_init_tracer(trace, ret);
-                goto out;
+                goto out_no_start;
         }
 
         /* reset the max latency */
@@ -385,21 +432,16 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
         tracing_stop();
         /* check both trace buffers */
         ret = trace_test_buffer(tr, NULL);
-        if (ret) {
-                tracing_start();
+        if (ret)
                 goto out;
-        }
 
         ret = trace_test_buffer(&max_tr, &count);
-        if (ret) {
-                tracing_start();
+        if (ret)
                 goto out;
-        }
 
         if (!ret && !count) {
                 printk(KERN_CONT ".. no entries found ..");
                 ret = -1;
-                tracing_start();
                 goto out;
         }
 
@@ -428,9 +470,10 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
                 goto out;
         }
 
- out:
-        trace->reset(tr);
+out:
         tracing_start();
+out_no_start:
+        trace->reset(tr);
         tracing_max_latency = save_max;
 
         return ret;
@@ -496,7 +539,7 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
         wait_for_completion(&isrt);
 
         /* start the tracing */
-        ret = trace->init(tr);
+        ret = tracer_init(trace, tr);
         if (ret) {
                 warn_failed_init_tracer(trace, ret);
                 return ret;
@@ -557,7 +600,7 @@ trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr
         int ret;
 
         /* start the tracing */
-        ret = trace->init(tr);
+        ret = tracer_init(trace, tr);
         if (ret) {
                 warn_failed_init_tracer(trace, ret);
                 return ret;
@@ -589,10 +632,10 @@ trace_selftest_startup_sysprof(struct tracer *trace, struct trace_array *tr)
         int ret;
 
         /* start the tracing */
-        ret = trace->init(tr);
+        ret = tracer_init(trace, tr);
         if (ret) {
                 warn_failed_init_tracer(trace, ret);
-                return 0;
+                return ret;
         }
 
         /* Sleep for a 1/10 of a second */
@@ -604,6 +647,11 @@ trace_selftest_startup_sysprof(struct tracer *trace, struct trace_array *tr)
         trace->reset(tr);
         tracing_start();
 
+        if (!ret && !count) {
+                printk(KERN_CONT ".. no entries found ..");
+                ret = -1;
+        }
+
         return ret;
 }
 #endif /* CONFIG_SYSPROF_TRACER */
@@ -616,7 +664,7 @@ trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
         int ret;
 
         /* start the tracing */
-        ret = trace->init(tr);
+        ret = tracer_init(trace, tr);
         if (ret) {
                 warn_failed_init_tracer(trace, ret);
                 return ret;
@@ -631,6 +679,11 @@ trace_selftest_startup_branch(struct tracer *trace, struct trace_array *tr)
         trace->reset(tr);
         tracing_start();
 
+        if (!ret && !count) {
+                printk(KERN_CONT ".. no entries found ..");
+                ret = -1;
+        }
+
         return ret;
 }
 #endif /* CONFIG_BRANCH_TRACER */
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index d0871bc0aca5..c750f65f9661 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -245,16 +245,31 @@ static int trace_lookup_stack(struct seq_file *m, long i)
 #endif
 }
 
+static void print_disabled(struct seq_file *m)
+{
+        seq_puts(m, "#\n"
+                 "#  Stack tracer disabled\n"
+                 "#\n"
+                 "# To enable the stack tracer, either add 'stacktrace' to the\n"
+                 "# kernel command line\n"
+                 "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
+                 "#\n");
+}
+
 static int t_show(struct seq_file *m, void *v)
 {
         long i;
         int size;
 
         if (v == SEQ_START_TOKEN) {
-                seq_printf(m, "        Depth   Size      Location"
+                seq_printf(m, "        Depth    Size   Location"
                            "    (%d entries)\n"
-                           "        -----   ----      --------\n",
+                           "        -----    ----   --------\n",
                            max_stack_trace.nr_entries);
+
+                if (!stack_tracer_enabled && !max_stack_size)
+                        print_disabled(m);
+
                 return 0;
         }
 
diff --git a/kernel/trace/trace_stat.c b/kernel/trace/trace_stat.c
new file mode 100644
index 000000000000..39310e3434ee
--- /dev/null
+++ b/kernel/trace/trace_stat.c
@@ -0,0 +1,319 @@
+/*
+ * Infrastructure for statistic tracing (histogram output).
+ *
+ * Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>
+ *
+ * Based on the code from trace_branch.c which is
+ * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
+ *
+ */
+
+
+#include <linux/list.h>
+#include <linux/debugfs.h>
+#include "trace_stat.h"
+#include "trace.h"
+
+
+/* List of stat entries from a tracer */
+struct trace_stat_list {
+        struct list_head        list;
+        void                    *stat;
+};
+
+/* A stat session is the stats output in one file */
+struct tracer_stat_session {
+        struct list_head        session_list;
+        struct tracer_stat      *ts;
+        struct list_head        stat_list;
+        struct mutex            stat_mutex;
+        struct dentry           *file;
+};
+
+/* All of the sessions currently in use. Each stat file embed one session */
+static LIST_HEAD(all_stat_sessions);
+static DEFINE_MUTEX(all_stat_sessions_mutex);
+
+/* The root directory for all stat files */
+static struct dentry            *stat_dir;
+
+
+static void reset_stat_session(struct tracer_stat_session *session)
+{
+        struct trace_stat_list *node, *next;
+
+        list_for_each_entry_safe(node, next, &session->stat_list, list)
+                kfree(node);
+
+        INIT_LIST_HEAD(&session->stat_list);
+}
+
+static void destroy_session(struct tracer_stat_session *session)
+{
+        debugfs_remove(session->file);
+        reset_stat_session(session);
+        mutex_destroy(&session->stat_mutex);
+        kfree(session);
+}
+
+/*
+ * For tracers that don't provide a stat_cmp callback.
+ * This one will force an immediate insertion on tail of
+ * the list.
+ */
+static int dummy_cmp(void *p1, void *p2)
+{
+        return 1;
+}
+
+/*
+ * Initialize the stat list at each trace_stat file opening.
+ * All of these copies and sorting are required on all opening
+ * since the stats could have changed between two file sessions.
+ */
+static int stat_seq_init(struct tracer_stat_session *session)
+{
+        struct trace_stat_list *iter_entry, *new_entry;
+        struct tracer_stat *ts = session->ts;
+        void *prev_stat;
+        int ret = 0;
+        int i;
+
+        mutex_lock(&session->stat_mutex);
+        reset_stat_session(session);
+
+        if (!ts->stat_cmp)
+                ts->stat_cmp = dummy_cmp;
+
+        /*
+         * The first entry. Actually this is the second, but the first
+         * one (the stat_list head) is pointless.
+         */
+        new_entry = kmalloc(sizeof(struct trace_stat_list), GFP_KERNEL);
+        if (!new_entry) {
+                ret = -ENOMEM;
+                goto exit;
+        }
+
+        INIT_LIST_HEAD(&new_entry->list);
+
+        list_add(&new_entry->list, &session->stat_list);
+
+        new_entry->stat = ts->stat_start();
+        prev_stat = new_entry->stat;
+
+        /*
+         * Iterate over the tracer stat entries and store them in a sorted
+         * list.
+         */
+        for (i = 1; ; i++) {
+                new_entry = kmalloc(sizeof(struct trace_stat_list), GFP_KERNEL);
+                if (!new_entry) {
+                        ret = -ENOMEM;
+                        goto exit_free_list;
+                }
+
+                INIT_LIST_HEAD(&new_entry->list);
+                new_entry->stat = ts->stat_next(prev_stat, i);
+
+                /* End of insertion */
+                if (!new_entry->stat)
+                        break;
+
+                list_for_each_entry(iter_entry, &session->stat_list, list) {
+
+                        /* Insertion with a descendent sorting */
+                        if (ts->stat_cmp(new_entry->stat,
+                                                iter_entry->stat) > 0) {
+
+                                list_add_tail(&new_entry->list,
+                                                &iter_entry->list);
+                                break;
+
+                        /* The current smaller value */
+                        } else if (list_is_last(&iter_entry->list,
+                                                &session->stat_list)) {
+                                list_add(&new_entry->list, &iter_entry->list);
+                                break;
+                        }
+                }
+
+                prev_stat = new_entry->stat;
+        }
+exit:
+        mutex_unlock(&session->stat_mutex);
+        return ret;
+
+exit_free_list:
+        reset_stat_session(session);
+        mutex_unlock(&session->stat_mutex);
+        return ret;
+}
+
+
+static void *stat_seq_start(struct seq_file *s, loff_t *pos)
+{
+        struct tracer_stat_session *session = s->private;
+
+        /* Prevent from tracer switch or stat_list modification */
+        mutex_lock(&session->stat_mutex);
+
+        /* If we are in the beginning of the file, print the headers */
+        if (!*pos && session->ts->stat_headers)
+                session->ts->stat_headers(s);
+
+        return seq_list_start(&session->stat_list, *pos);
+}
+
+static void *stat_seq_next(struct seq_file *s, void *p, loff_t *pos)
+{
+        struct tracer_stat_session *session = s->private;
+
+        return seq_list_next(p, &session->stat_list, pos);
+}
+
+static void stat_seq_stop(struct seq_file *s, void *p)
+{
+        struct tracer_stat_session *session = s->private;
+        mutex_unlock(&session->stat_mutex);
+}
+
+static int stat_seq_show(struct seq_file *s, void *v)
+{
+        struct tracer_stat_session *session = s->private;
+        struct trace_stat_list *l = list_entry(v, struct trace_stat_list, list);
+
+        return session->ts->stat_show(s, l->stat);
+}
+
+static const struct seq_operations trace_stat_seq_ops = {
+        .start          = stat_seq_start,
+        .next           = stat_seq_next,
+        .stop           = stat_seq_stop,
+        .show           = stat_seq_show
+};
+
+/* The session stat is refilled and resorted at each stat file opening */
+static int tracing_stat_open(struct inode *inode, struct file *file)
+{
+        int ret;
+
+        struct tracer_stat_session *session = inode->i_private;
+
+        ret = seq_open(file, &trace_stat_seq_ops);
+        if (!ret) {
+                struct seq_file *m = file->private_data;
+                m->private = session;
+                ret = stat_seq_init(session);
+        }
+
+        return ret;
+}
+
+/*
+ * Avoid consuming memory with our now useless list.
+ */
+static int tracing_stat_release(struct inode *i, struct file *f)
+{
+        struct tracer_stat_session *session = i->i_private;
+
+        mutex_lock(&session->stat_mutex);
+        reset_stat_session(session);
+        mutex_unlock(&session->stat_mutex);
+
+        return 0;
+}
+
+static const struct file_operations tracing_stat_fops = {
+        .open           = tracing_stat_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = tracing_stat_release
+};
+
+static int tracing_stat_init(void)
+{
+        struct dentry *d_tracing;
+
+        d_tracing = tracing_init_dentry();
+
+        stat_dir = debugfs_create_dir("trace_stat", d_tracing);
+        if (!stat_dir)
+                pr_warning("Could not create debugfs "
+                           "'trace_stat' entry\n");
+        return 0;
+}
+
+static int init_stat_file(struct tracer_stat_session *session)
+{
+        if (!stat_dir && tracing_stat_init())
+                return -ENODEV;
+
+        session->file = debugfs_create_file(session->ts->name, 0644,
+                                            stat_dir,
+                                            session, &tracing_stat_fops);
+        if (!session->file)
+                return -ENOMEM;
+        return 0;
+}
+
+int register_stat_tracer(struct tracer_stat *trace)
+{
+        struct tracer_stat_session *session, *node, *tmp;
+        int ret;
+
+        if (!trace)
+                return -EINVAL;
+
+        if (!trace->stat_start || !trace->stat_next || !trace->stat_show)
+                return -EINVAL;
+
+        /* Already registered? */
+        mutex_lock(&all_stat_sessions_mutex);
+        list_for_each_entry_safe(node, tmp, &all_stat_sessions, session_list) {
+                if (node->ts == trace) {
+                        mutex_unlock(&all_stat_sessions_mutex);
+                        return -EINVAL;
+                }
+        }
+        mutex_unlock(&all_stat_sessions_mutex);
+
+        /* Init the session */
+        session = kmalloc(sizeof(struct tracer_stat_session), GFP_KERNEL);
+        if (!session)
+                return -ENOMEM;
+
+        session->ts = trace;
+        INIT_LIST_HEAD(&session->session_list);
+        INIT_LIST_HEAD(&session->stat_list);
+        mutex_init(&session->stat_mutex);
+        session->file = NULL;
+
+        ret = init_stat_file(session);
+        if (ret) {
+                destroy_session(session);
+                return ret;
+        }
+
+        /* Register */
+        mutex_lock(&all_stat_sessions_mutex);
+        list_add_tail(&session->session_list, &all_stat_sessions);
+        mutex_unlock(&all_stat_sessions_mutex);
+
+        return 0;
+}
+
+void unregister_stat_tracer(struct tracer_stat *trace)
+{
+        struct tracer_stat_session *node, *tmp;
+
+        mutex_lock(&all_stat_sessions_mutex);
+        list_for_each_entry_safe(node, tmp, &all_stat_sessions, session_list) {
+                if (node->ts == trace) {
+                        list_del(&node->session_list);
+                        destroy_session(node);
+                        break;
+                }
+        }
+        mutex_unlock(&all_stat_sessions_mutex);
+}
diff --git a/kernel/trace/trace_stat.h b/kernel/trace/trace_stat.h
new file mode 100644
index 000000000000..202274cf7f3d
--- /dev/null
+++ b/kernel/trace/trace_stat.h
@@ -0,0 +1,31 @@
+#ifndef __TRACE_STAT_H
+#define __TRACE_STAT_H
+
+#include <linux/seq_file.h>
+
+/*
+ * If you want to provide a stat file (one-shot statistics), fill
+ * an iterator with stat_start/stat_next and a stat_show callbacks.
+ * The others callbacks are optional.
+ */
+struct tracer_stat {
+        /* The name of your stat file */
+        const char              *name;
+        /* Iteration over statistic entries */
+        void                    *(*stat_start)(void);
+        void                    *(*stat_next)(void *prev, int idx);
+        /* Compare two entries for stats sorting */
+        int                     (*stat_cmp)(void *p1, void *p2);
+        /* Print a stat entry */
+        int                     (*stat_show)(struct seq_file *s, void *p);
+        /* Print the headers of your stat entries */
+        int                     (*stat_headers)(struct seq_file *s);
+};
+
+/*
+ * Destroy or create a stat file
+ */
+extern int register_stat_tracer(struct tracer_stat *trace);
+extern void unregister_stat_tracer(struct tracer_stat *trace);
+
+#endif /* __TRACE_STAT_H */
diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
new file mode 100644
index 000000000000..a2a3af29c943
--- /dev/null
+++ b/kernel/trace/trace_syscalls.c
@@ -0,0 +1,250 @@
+#include <linux/kernel.h>
+#include <linux/ftrace.h>
+#include <asm/syscall.h>
+
+#include "trace_output.h"
+#include "trace.h"
+
+/* Keep a counter of the syscall tracing users */
+static int refcount;
+
+/* Prevent from races on thread flags toggling */
+static DEFINE_MUTEX(syscall_trace_lock);
+
+/* Option to display the parameters types */
+enum {
+        TRACE_SYSCALLS_OPT_TYPES = 0x1,
+};
+
+static struct tracer_opt syscalls_opts[] = {
+        { TRACER_OPT(syscall_arg_type, TRACE_SYSCALLS_OPT_TYPES) },
+        { }
+};
+
+static struct tracer_flags syscalls_flags = {
+        .val = 0, /* By default: no parameters types */
+        .opts = syscalls_opts
+};
+
+enum print_line_t
+print_syscall_enter(struct trace_iterator *iter, int flags)
+{
+        struct trace_seq *s = &iter->seq;
+        struct trace_entry *ent = iter->ent;
+        struct syscall_trace_enter *trace;
+        struct syscall_metadata *entry;
+        int i, ret, syscall;
+
+        trace_assign_type(trace, ent);
+
+        syscall = trace->nr;
+
+        entry = syscall_nr_to_meta(syscall);
+        if (!entry)
+                goto end;
+
+        ret = trace_seq_printf(s, "%s(", entry->name);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        for (i = 0; i < entry->nb_args; i++) {
+                /* parameter types */
+                if (syscalls_flags.val & TRACE_SYSCALLS_OPT_TYPES) {
+                        ret = trace_seq_printf(s, "%s ", entry->types[i]);
+                        if (!ret)
+                                return TRACE_TYPE_PARTIAL_LINE;
+                }
+                /* parameter values */
+                ret = trace_seq_printf(s, "%s: %lx%s ", entry->args[i],
+                                       trace->args[i],
+                                       i == entry->nb_args - 1 ? ")" : ",");
+                if (!ret)
+                        return TRACE_TYPE_PARTIAL_LINE;
+        }
+
+end:
+        trace_seq_printf(s, "\n");
+        return TRACE_TYPE_HANDLED;
+}
+
+enum print_line_t
+print_syscall_exit(struct trace_iterator *iter, int flags)
+{
+        struct trace_seq *s = &iter->seq;
+        struct trace_entry *ent = iter->ent;
+        struct syscall_trace_exit *trace;
+        int syscall;
+        struct syscall_metadata *entry;
+        int ret;
+
+        trace_assign_type(trace, ent);
+
+        syscall = trace->nr;
+
+        entry = syscall_nr_to_meta(syscall);
+        if (!entry) {
+                trace_seq_printf(s, "\n");
+                return TRACE_TYPE_HANDLED;
+        }
+
+        ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
+                                trace->ret);
+        if (!ret)
+                return TRACE_TYPE_PARTIAL_LINE;
+
+        return TRACE_TYPE_HANDLED;
+}
+
+void start_ftrace_syscalls(void)
+{
+        unsigned long flags;
+        struct task_struct *g, *t;
+
+        mutex_lock(&syscall_trace_lock);
+
+        /* Don't enable the flag on the tasks twice */
+        if (++refcount != 1)
+                goto unlock;
+
+        arch_init_ftrace_syscalls();
+        read_lock_irqsave(&tasklist_lock, flags);
+
+        do_each_thread(g, t) {
+                set_tsk_thread_flag(t, TIF_SYSCALL_FTRACE);
+        } while_each_thread(g, t);
+
+        read_unlock_irqrestore(&tasklist_lock, flags);
+
+unlock:
+        mutex_unlock(&syscall_trace_lock);
+}
+
+void stop_ftrace_syscalls(void)
+{
+        unsigned long flags;
+        struct task_struct *g, *t;
+
+        mutex_lock(&syscall_trace_lock);
+
+        /* There are perhaps still some users */
+        if (--refcount)
+                goto unlock;
+
+        read_lock_irqsave(&tasklist_lock, flags);
+
+        do_each_thread(g, t) {
+                clear_tsk_thread_flag(t, TIF_SYSCALL_FTRACE);
+        } while_each_thread(g, t);
+
+        read_unlock_irqrestore(&tasklist_lock, flags);
+
+unlock:
+        mutex_unlock(&syscall_trace_lock);
+}
+
+void ftrace_syscall_enter(struct pt_regs *regs)
+{
+        struct syscall_trace_enter *entry;
+        struct syscall_metadata *sys_data;
+        struct ring_buffer_event *event;
+        int size;
+        int syscall_nr;
+
+        syscall_nr = syscall_get_nr(current, regs);
+
+        sys_data = syscall_nr_to_meta(syscall_nr);
+        if (!sys_data)
+                return;
+
+        size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
+
+        event = trace_current_buffer_lock_reserve(TRACE_SYSCALL_ENTER, size,
+                                                        0, 0);
+        if (!event)
+                return;
+
+        entry = ring_buffer_event_data(event);
+        entry->nr = syscall_nr;
+        syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
+
+        trace_current_buffer_unlock_commit(event, 0, 0);
+        trace_wake_up();
+}
+
+void ftrace_syscall_exit(struct pt_regs *regs)
+{
+        struct syscall_trace_exit *entry;
+        struct syscall_metadata *sys_data;
+        struct ring_buffer_event *event;
+        int syscall_nr;
+
+        syscall_nr = syscall_get_nr(current, regs);
+
+        sys_data = syscall_nr_to_meta(syscall_nr);
+        if (!sys_data)
+                return;
+
+        event = trace_current_buffer_lock_reserve(TRACE_SYSCALL_EXIT,
+                                sizeof(*entry), 0, 0);
+        if (!event)
+                return;
+
+        entry = ring_buffer_event_data(event);
+        entry->nr = syscall_nr;
+        entry->ret = syscall_get_return_value(current, regs);
+
+        trace_current_buffer_unlock_commit(event, 0, 0);
+        trace_wake_up();
+}
+
+static int init_syscall_tracer(struct trace_array *tr)
+{
+        start_ftrace_syscalls();
+
+        return 0;
+}
+
+static void reset_syscall_tracer(struct trace_array *tr)
+{
+        stop_ftrace_syscalls();
+        tracing_reset_online_cpus(tr);
+}
+
+static struct trace_event syscall_enter_event = {
+        .type           = TRACE_SYSCALL_ENTER,
+        .trace          = print_syscall_enter,
+};
+
+static struct trace_event syscall_exit_event = {
+        .type           = TRACE_SYSCALL_EXIT,
+        .trace          = print_syscall_exit,
+};
+
+static struct tracer syscall_tracer __read_mostly = {
+        .name           = "syscall",
+        .init           = init_syscall_tracer,
+        .reset          = reset_syscall_tracer,
+        .flags          = &syscalls_flags,
+};
+
+__init int register_ftrace_syscalls(void)
+{
+        int ret;
+
+        ret = register_ftrace_event(&syscall_enter_event);
+        if (!ret) {
+                printk(KERN_WARNING "event %d failed to register\n",
+                       syscall_enter_event.type);
+                WARN_ON_ONCE(1);
+        }
+
+        ret = register_ftrace_event(&syscall_exit_event);
+        if (!ret) {
+                printk(KERN_WARNING "event %d failed to register\n",
+                       syscall_exit_event.type);
+                WARN_ON_ONCE(1);
+        }
+
+        return register_tracer(&syscall_tracer);
+}
+device_initcall(register_ftrace_syscalls);
diff --git a/kernel/trace/trace_sysprof.c b/kernel/trace/trace_sysprof.c
index eaca5ad803ff..91fd19c2149f 100644
--- a/kernel/trace/trace_sysprof.c
+++ b/kernel/trace/trace_sysprof.c
@@ -88,7 +88,7 @@ static void backtrace_address(void *data, unsigned long addr, int reliable)
         }
 }
 
-const static struct stacktrace_ops backtrace_ops = {
+static const struct stacktrace_ops backtrace_ops = {
         .warning                = backtrace_warning,
         .warning_symbol         = backtrace_warning_symbol,
         .stack                  = backtrace_stack,
@@ -226,15 +226,6 @@ static void stop_stack_timers(void)
                 stop_stack_timer(cpu);
 }
 
-static void start_stack_trace(struct trace_array *tr)
-{
-        mutex_lock(&sample_timer_lock);
-        tracing_reset_online_cpus(tr);
-        start_stack_timers();
-        tracer_enabled = 1;
-        mutex_unlock(&sample_timer_lock);
-}
-
 static void stop_stack_trace(struct trace_array *tr)
 {
         mutex_lock(&sample_timer_lock);
@@ -247,12 +238,18 @@ static int stack_trace_init(struct trace_array *tr)
 {
         sysprof_trace = tr;
 
-        start_stack_trace(tr);
+        tracing_start_cmdline_record();
+
+        mutex_lock(&sample_timer_lock);
+        start_stack_timers();
+        tracer_enabled = 1;
+        mutex_unlock(&sample_timer_lock);
         return 0;
 }
 
 static void stack_trace_reset(struct trace_array *tr)
 {
+        tracing_stop_cmdline_record();
         stop_stack_trace(tr);
 }
 
@@ -317,7 +314,7 @@ sysprof_sample_write(struct file *filp, const char __user *ubuf,
         return cnt;
 }
 
-static struct file_operations sysprof_sample_fops = {
+static const struct file_operations sysprof_sample_fops = {
         .read           = sysprof_sample_read,
         .write          = sysprof_sample_write,
 };
@@ -330,5 +327,5 @@ void init_tracer_sysprof_debugfs(struct dentry *d_tracer)
                         d_tracer, NULL, &sysprof_sample_fops);
         if (entry)
                 return;
-        pr_warning("Could not create debugfs 'dyn_ftrace_total_info' entry\n");
+        pr_warning("Could not create debugfs 'sysprof_sample_period' entry\n");
 }
diff --git a/kernel/trace/trace_workqueue.c b/kernel/trace/trace_workqueue.c
new file mode 100644
index 000000000000..9ab035b58cf1
--- /dev/null
+++ b/kernel/trace/trace_workqueue.c
@@ -0,0 +1,288 @@
+/*
+ * Workqueue statistical tracer.
+ *
+ * Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>
+ *
+ */
+
+
+#include <trace/workqueue.h>
+#include <linux/list.h>
+#include <linux/percpu.h>
+#include "trace_stat.h"
+#include "trace.h"
+
+
+/* A cpu workqueue thread */
+struct cpu_workqueue_stats {
+        struct list_head            list;
+/* Useful to know if we print the cpu headers */
+        bool                        first_entry;
+        int                         cpu;
+        pid_t                       pid;
+/* Can be inserted from interrupt or user context, need to be atomic */
+        atomic_t                    inserted;
+/*
+ *  Don't need to be atomic, works are serialized in a single workqueue thread
+ *  on a single CPU.
+ */
+        unsigned int                executed;
+};
+
+/* List of workqueue threads on one cpu */
+struct workqueue_global_stats {
+        struct list_head        list;
+        spinlock_t              lock;
+};
+
+/* Don't need a global lock because allocated before the workqueues, and
+ * never freed.
+ */
+static DEFINE_PER_CPU(struct workqueue_global_stats, all_workqueue_stat);
+#define workqueue_cpu_stat(cpu) (&per_cpu(all_workqueue_stat, cpu))
+
+/* Insertion of a work */
+static void
+probe_workqueue_insertion(struct task_struct *wq_thread,
+                          struct work_struct *work)
+{
+        int cpu = cpumask_first(&wq_thread->cpus_allowed);
+        struct cpu_workqueue_stats *node, *next;
+        unsigned long flags;
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+        list_for_each_entry_safe(node, next, &workqueue_cpu_stat(cpu)->list,
+                                                        list) {
+                if (node->pid == wq_thread->pid) {
+                        atomic_inc(&node->inserted);
+                        goto found;
+                }
+        }
+        pr_debug("trace_workqueue: entry not found\n");
+found:
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+}
+
+/* Execution of a work */
+static void
+probe_workqueue_execution(struct task_struct *wq_thread,
+                          struct work_struct *work)
+{
+        int cpu = cpumask_first(&wq_thread->cpus_allowed);
+        struct cpu_workqueue_stats *node, *next;
+        unsigned long flags;
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+        list_for_each_entry_safe(node, next, &workqueue_cpu_stat(cpu)->list,
+                                                        list) {
+                if (node->pid == wq_thread->pid) {
+                        node->executed++;
+                        goto found;
+                }
+        }
+        pr_debug("trace_workqueue: entry not found\n");
+found:
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+}
+
+/* Creation of a cpu workqueue thread */
+static void probe_workqueue_creation(struct task_struct *wq_thread, int cpu)
+{
+        struct cpu_workqueue_stats *cws;
+        unsigned long flags;
+
+        WARN_ON(cpu < 0);
+
+        /* Workqueues are sometimes created in atomic context */
+        cws = kzalloc(sizeof(struct cpu_workqueue_stats), GFP_ATOMIC);
+        if (!cws) {
+                pr_warning("trace_workqueue: not enough memory\n");
+                return;
+        }
+        INIT_LIST_HEAD(&cws->list);
+        cws->cpu = cpu;
+
+        cws->pid = wq_thread->pid;
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+        if (list_empty(&workqueue_cpu_stat(cpu)->list))
+                cws->first_entry = true;
+        list_add_tail(&cws->list, &workqueue_cpu_stat(cpu)->list);
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+}
+
+/* Destruction of a cpu workqueue thread */
+static void probe_workqueue_destruction(struct task_struct *wq_thread)
+{
+        /* Workqueue only execute on one cpu */
+        int cpu = cpumask_first(&wq_thread->cpus_allowed);
+        struct cpu_workqueue_stats *node, *next;
+        unsigned long flags;
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+        list_for_each_entry_safe(node, next, &workqueue_cpu_stat(cpu)->list,
+                                                        list) {
+                if (node->pid == wq_thread->pid) {
+                        list_del(&node->list);
+                        kfree(node);
+                        goto found;
+                }
+        }
+
+        pr_debug("trace_workqueue: don't find workqueue to destroy\n");
+found:
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+
+}
+
+static struct cpu_workqueue_stats *workqueue_stat_start_cpu(int cpu)
+{
+        unsigned long flags;
+        struct cpu_workqueue_stats *ret = NULL;
+
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+
+        if (!list_empty(&workqueue_cpu_stat(cpu)->list))
+                ret = list_entry(workqueue_cpu_stat(cpu)->list.next,
+                                 struct cpu_workqueue_stats, list);
+
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+
+        return ret;
+}
+
+static void *workqueue_stat_start(void)
+{
+        int cpu;
+        void *ret = NULL;
+
+        for_each_possible_cpu(cpu) {
+                ret = workqueue_stat_start_cpu(cpu);
+                if (ret)
+                        return ret;
+        }
+        return NULL;
+}
+
+static void *workqueue_stat_next(void *prev, int idx)
+{
+        struct cpu_workqueue_stats *prev_cws = prev;
+        int cpu = prev_cws->cpu;
+        unsigned long flags;
+        void *ret = NULL;
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+        if (list_is_last(&prev_cws->list, &workqueue_cpu_stat(cpu)->list)) {
+                spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+                do {
+                        cpu = cpumask_next(cpu, cpu_possible_mask);
+                        if (cpu >= nr_cpu_ids)
+                                return NULL;
+                } while (!(ret = workqueue_stat_start_cpu(cpu)));
+                return ret;
+        }
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+
+        return list_entry(prev_cws->list.next, struct cpu_workqueue_stats,
+                          list);
+}
+
+static int workqueue_stat_show(struct seq_file *s, void *p)
+{
+        struct cpu_workqueue_stats *cws = p;
+        unsigned long flags;
+        int cpu = cws->cpu;
+        struct pid *pid;
+        struct task_struct *tsk;
+
+        pid = find_get_pid(cws->pid);
+        if (pid) {
+                tsk = get_pid_task(pid, PIDTYPE_PID);
+                if (tsk) {
+                        seq_printf(s, "%3d %6d     %6u       %s\n", cws->cpu,
+                                   atomic_read(&cws->inserted), cws->executed,
+                                   tsk->comm);
+                        put_task_struct(tsk);
+                }
+                put_pid(pid);
+        }
+
+        spin_lock_irqsave(&workqueue_cpu_stat(cpu)->lock, flags);
+        if (&cws->list == workqueue_cpu_stat(cpu)->list.next)
+                seq_printf(s, "\n");
+        spin_unlock_irqrestore(&workqueue_cpu_stat(cpu)->lock, flags);
+
+        return 0;
+}
+
+static int workqueue_stat_headers(struct seq_file *s)
+{
+        seq_printf(s, "# CPU  INSERTED  EXECUTED   NAME\n");
+        seq_printf(s, "# |      |         |          |\n\n");
+        return 0;
+}
+
+struct tracer_stat workqueue_stats __read_mostly = {
+        .name = "workqueues",
+        .stat_start = workqueue_stat_start,
+        .stat_next = workqueue_stat_next,
+        .stat_show = workqueue_stat_show,
+        .stat_headers = workqueue_stat_headers
+};
+
+
+int __init stat_workqueue_init(void)
+{
+        if (register_stat_tracer(&workqueue_stats)) {
+                pr_warning("Unable to register workqueue stat tracer\n");
+                return 1;
+        }
+
+        return 0;
+}
+fs_initcall(stat_workqueue_init);
+
+/*
+ * Workqueues are created very early, just after pre-smp initcalls.
+ * So we must register our tracepoints at this stage.
+ */
+int __init trace_workqueue_early_init(void)
+{
+        int ret, cpu;
+
+        ret = register_trace_workqueue_insertion(probe_workqueue_insertion);
+        if (ret)
+                goto out;
+
+        ret = register_trace_workqueue_execution(probe_workqueue_execution);
+        if (ret)
+                goto no_insertion;
+
+        ret = register_trace_workqueue_creation(probe_workqueue_creation);
+        if (ret)
+                goto no_execution;
+
+        ret = register_trace_workqueue_destruction(probe_workqueue_destruction);
+        if (ret)
+                goto no_creation;
+
+        for_each_possible_cpu(cpu) {
+                spin_lock_init(&workqueue_cpu_stat(cpu)->lock);
+                INIT_LIST_HEAD(&workqueue_cpu_stat(cpu)->list);
+        }
+
+        return 0;
+
+no_creation:
+        unregister_trace_workqueue_creation(probe_workqueue_creation);
+no_execution:
+        unregister_trace_workqueue_execution(probe_workqueue_execution);
+no_insertion:
+        unregister_trace_workqueue_insertion(probe_workqueue_insertion);
+out:
+        pr_warning("trace_workqueue: unable to trace workqueues\n");
+
+        return 1;
+}
+early_initcall(trace_workqueue_early_init);
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 1f0c509b40d3..e53ee18ef431 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -33,6 +33,7 @@
 #include <linux/kallsyms.h>
 #include <linux/debug_locks.h>
 #include <linux/lockdep.h>
+#include <trace/workqueue.h>
 
 /*
  * The per-CPU workqueue (if single thread, we always use the first
@@ -125,9 +126,13 @@ struct cpu_workqueue_struct *get_wq_data(struct work_struct *work)
         return (void *) (atomic_long_read(&work->data) & WORK_STRUCT_WQ_DATA_MASK);
 }
 
+DEFINE_TRACE(workqueue_insertion);
+
 static void insert_work(struct cpu_workqueue_struct *cwq,
                         struct work_struct *work, struct list_head *head)
 {
+        trace_workqueue_insertion(cwq->thread, work);
+
         set_wq_data(work, cwq);
         /*
          * Ensure that we get the right work->data if we see the
@@ -259,6 +264,8 @@ int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
 }
 EXPORT_SYMBOL_GPL(queue_delayed_work_on);
 
+DEFINE_TRACE(workqueue_execution);
+
 static void run_workqueue(struct cpu_workqueue_struct *cwq)
 {
         spin_lock_irq(&cwq->lock);
@@ -284,7 +291,7 @@ static void run_workqueue(struct cpu_workqueue_struct *cwq)
                  */
                 struct lockdep_map lockdep_map = work->lockdep_map;
 #endif
-
+                trace_workqueue_execution(cwq->thread, work);
                 cwq->current_work = work;
                 list_del_init(cwq->worklist.next);
                 spin_unlock_irq(&cwq->lock);
@@ -765,6 +772,8 @@ init_cpu_workqueue(struct workqueue_struct *wq, int cpu)
         return cwq;
 }
 
+DEFINE_TRACE(workqueue_creation);
+
 static int create_workqueue_thread(struct cpu_workqueue_struct *cwq, int cpu)
 {
         struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
@@ -787,6 +796,8 @@ static int create_workqueue_thread(struct cpu_workqueue_struct *cwq, int cpu)
                 sched_setscheduler_nocheck(p, SCHED_FIFO, &param);
         cwq->thread = p;
 
+        trace_workqueue_creation(cwq->thread, cpu);
+
         return 0;
 }
 
@@ -868,6 +879,8 @@ struct workqueue_struct *__create_workqueue_key(const char *name,
 }
 EXPORT_SYMBOL_GPL(__create_workqueue_key);
 
+DEFINE_TRACE(workqueue_destruction);
+
 static void cleanup_workqueue_thread(struct cpu_workqueue_struct *cwq)
 {
         /*
@@ -891,6 +904,7 @@ static void cleanup_workqueue_thread(struct cpu_workqueue_struct *cwq)
          * checks list_empty(), and a "normal" queue_work() can't use
          * a dead CPU.
          */
+        trace_workqueue_destruction(cwq->thread);
         kthread_stop(cwq->thread);
         cwq->thread = NULL;
 }