1 files changed, 762 insertions, 144 deletions

diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 697eda36b86a..6adf660fc816 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -30,6 +30,7 @@
 #include <linux/gfp.h>
 #include <linux/fs.h>
 #include <linux/kprobes.h>
+#include <linux/seq_file.h>
 #include <linux/writeback.h>
 
 #include <linux/stacktrace.h>
@@ -43,6 +44,38 @@
 unsigned long __read_mostly     tracing_max_latency = (cycle_t)ULONG_MAX;
 unsigned long __read_mostly     tracing_thresh;
 
+/*
+ * 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
+ * at the same time, giving false positive or negative results.
+ */
+static bool __read_mostly tracing_selftest_running;
+
+/* For tracers that don't implement custom flags */
+static struct tracer_opt dummy_tracer_opt[] = {
+        { }
+};
+
+static struct tracer_flags dummy_tracer_flags = {
+        .val = 0,
+        .opts = dummy_tracer_opt
+};
+
+static int dummy_set_flag(u32 old_flags, u32 bit, int set)
+{
+        return 0;
+}
+
+/*
+ * Kill all tracing for good (never come back).
+ * It is initialized to 1 but will turn to zero if the initialization
+ * of the tracer is successful. But that is the only place that sets
+ * this back to zero.
+ */
+int tracing_disabled = 1;
+
 static DEFINE_PER_CPU(local_t, ftrace_cpu_disabled);
 
 static inline void ftrace_disable_cpu(void)
@@ -62,7 +95,36 @@ static cpumask_t __read_mostly		tracing_buffer_mask;
 #define for_each_tracing_cpu(cpu)       \
         for_each_cpu_mask(cpu, tracing_buffer_mask)
 
-static int tracing_disabled = 1;
+/*
+ * ftrace_dump_on_oops - variable to dump ftrace buffer on oops
+ *
+ * If there is an oops (or kernel panic) and the ftrace_dump_on_oops
+ * is set, then ftrace_dump is called. This will output the contents
+ * of the ftrace buffers to the console.  This is very useful for
+ * capturing traces that lead to crashes and outputing it to a
+ * serial console.
+ *
+ * It is default off, but you can enable it with either specifying
+ * "ftrace_dump_on_oops" in the kernel command line, or setting
+ * /proc/sys/kernel/ftrace_dump_on_oops to true.
+ */
+int ftrace_dump_on_oops;
+
+static int tracing_set_tracer(char *buf);
+
+static int __init set_ftrace(char *str)
+{
+        tracing_set_tracer(str);
+        return 1;
+}
+__setup("ftrace", set_ftrace);
+
+static int __init set_ftrace_dump_on_oops(char *str)
+{
+        ftrace_dump_on_oops = 1;
+        return 1;
+}
+__setup("ftrace_dump_on_oops", set_ftrace_dump_on_oops);
 
 long
 ns2usecs(cycle_t nsec)
@@ -112,6 +174,19 @@ static DEFINE_PER_CPU(struct trace_array_cpu, max_data);
 /* tracer_enabled is used to toggle activation of a tracer */
 static int                      tracer_enabled = 1;
 
+/**
+ * tracing_is_enabled - return tracer_enabled status
+ *
+ * This function is used by other tracers to know the status
+ * of the tracer_enabled flag.  Tracers may use this function
+ * to know if it should enable their features when starting
+ * up. See irqsoff tracer for an example (start_irqsoff_tracer).
+ */
+int tracing_is_enabled(void)
+{
+        return tracer_enabled;
+}
+
 /* function tracing enabled */
 int                             ftrace_function_enabled;
 
@@ -153,8 +228,9 @@ static DEFINE_MUTEX(trace_types_lock);
 /* trace_wait is a waitqueue for tasks blocked on trace_poll */
 static DECLARE_WAIT_QUEUE_HEAD(trace_wait);
 
-/* trace_flags holds iter_ctrl options */
-unsigned long trace_flags = TRACE_ITER_PRINT_PARENT;
+/* trace_flags holds trace_options default values */
+unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
+        TRACE_ITER_ANNOTATE;
 
 /**
  * trace_wake_up - wake up tasks waiting for trace input
@@ -193,13 +269,6 @@ unsigned long nsecs_to_usecs(unsigned long nsecs)
         return nsecs / 1000;
 }
 
-/*
- * TRACE_ITER_SYM_MASK masks the options in trace_flags that
- * control the output of kernel symbols.
- */
-#define TRACE_ITER_SYM_MASK \
-        (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)
-
 /* These must match the bit postions in trace_iterator_flags */
 static const char *trace_options[] = {
         "print-parent",
@@ -213,6 +282,11 @@ static const char *trace_options[] = {
         "stacktrace",
         "sched-tree",
         "ftrace_printk",
+        "ftrace_preempt",
+        "branch",
+        "annotate",
+        "userstacktrace",
+        "sym-userobj",
         NULL
 };
 
@@ -359,6 +433,28 @@ trace_seq_putmem_hex(struct trace_seq *s, void *mem, size_t len)
         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 >= (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;
+}
+
 static void
 trace_seq_reset(struct trace_seq *s)
 {
@@ -470,7 +566,17 @@ int register_tracer(struct tracer *type)
                 return -1;
         }
 
+        /*
+         * When this gets called we hold the BKL which means that
+         * preemption is disabled. Various trace selftests however
+         * need to disable and enable preemption for successful tests.
+         * So we drop the BKL here and grab it after the tests again.
+         */
+        unlock_kernel();
         mutex_lock(&trace_types_lock);
+
+        tracing_selftest_running = true;
+
         for (t = trace_types; t; t = t->next) {
                 if (strcmp(type->name, t->name) == 0) {
                         /* already found */
@@ -481,12 +587,20 @@ int register_tracer(struct tracer *type)
                 }
         }
 
+        if (!type->set_flag)
+                type->set_flag = &dummy_set_flag;
+        if (!type->flags)
+                type->flags = &dummy_tracer_flags;
+        else
+                if (!type->flags->opts)
+                        type->flags->opts = dummy_tracer_opt;
+
 #ifdef CONFIG_FTRACE_STARTUP_TEST
         if (type->selftest) {
                 struct tracer *saved_tracer = current_trace;
                 struct trace_array *tr = &global_trace;
-                int saved_ctrl = tr->ctrl;
                 int i;
+
                 /*
                  * Run a selftest on this tracer.
                  * Here we reset the trace buffer, and set the current
@@ -494,25 +608,23 @@ int register_tracer(struct tracer *type)
                  * internal tracing to verify that everything is in order.
                  * If we fail, we do not register this tracer.
                  */
-                for_each_tracing_cpu(i) {
+                for_each_tracing_cpu(i)
                         tracing_reset(tr, i);
-                }
+
                 current_trace = type;
-                tr->ctrl = 0;
                 /* the test is responsible for initializing and enabling */
                 pr_info("Testing tracer %s: ", type->name);
                 ret = type->selftest(type, tr);
                 /* the test is responsible for resetting too */
                 current_trace = saved_tracer;
-                tr->ctrl = saved_ctrl;
                 if (ret) {
                         printk(KERN_CONT "FAILED!\n");
                         goto out;
                 }
                 /* Only reset on passing, to avoid touching corrupted buffers */
-                for_each_tracing_cpu(i) {
+                for_each_tracing_cpu(i)
                         tracing_reset(tr, i);
-                }
+
                 printk(KERN_CONT "PASSED\n");
         }
 #endif
@@ -524,7 +636,9 @@ int register_tracer(struct tracer *type)
                 max_tracer_type_len = len;
 
  out:
+        tracing_selftest_running = false;
         mutex_unlock(&trace_types_lock);
+        lock_kernel();
 
         return ret;
 }
@@ -581,6 +695,91 @@ static void trace_init_cmdlines(void)
         cmdline_idx = 0;
 }
 
+static int trace_stop_count;
+static DEFINE_SPINLOCK(tracing_start_lock);
+
+/**
+ * ftrace_off_permanent - disable all ftrace code permanently
+ *
+ * This should only be called when a serious anomally has
+ * been detected.  This will turn off the function tracing,
+ * ring buffers, and other tracing utilites. It takes no
+ * locks and can be called from any context.
+ */
+void ftrace_off_permanent(void)
+{
+        tracing_disabled = 1;
+        ftrace_stop();
+        tracing_off_permanent();
+}
+
+/**
+ * tracing_start - quick start of the tracer
+ *
+ * If tracing is enabled but was stopped by tracing_stop,
+ * this will start the tracer back up.
+ */
+void tracing_start(void)
+{
+        struct ring_buffer *buffer;
+        unsigned long flags;
+
+        if (tracing_disabled)
+                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;
+                goto out;
+        }
+
+
+        buffer = global_trace.buffer;
+        if (buffer)
+                ring_buffer_record_enable(buffer);
+
+        buffer = max_tr.buffer;
+        if (buffer)
+                ring_buffer_record_enable(buffer);
+
+        ftrace_start();
+ out:
+        spin_unlock_irqrestore(&tracing_start_lock, flags);
+}
+
+/**
+ * tracing_stop - quick stop of the tracer
+ *
+ * Light weight way to stop tracing. Use in conjunction with
+ * tracing_start.
+ */
+void tracing_stop(void)
+{
+        struct ring_buffer *buffer;
+        unsigned long flags;
+
+        ftrace_stop();
+        spin_lock_irqsave(&tracing_start_lock, flags);
+        if (trace_stop_count++)
+                goto out;
+
+        buffer = global_trace.buffer;
+        if (buffer)
+                ring_buffer_record_disable(buffer);
+
+        buffer = max_tr.buffer;
+        if (buffer)
+                ring_buffer_record_disable(buffer);
+
+ out:
+        spin_unlock_irqrestore(&tracing_start_lock, flags);
+}
+
 void trace_stop_cmdline_recording(void);
 
 static void trace_save_cmdline(struct task_struct *tsk)
@@ -618,7 +817,7 @@ static void trace_save_cmdline(struct task_struct *tsk)
         spin_unlock(&trace_cmdline_lock);
 }
 
-static char *trace_find_cmdline(int pid)
+char *trace_find_cmdline(int pid)
 {
         char *cmdline = "<...>";
         unsigned map;
@@ -655,6 +854,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->flags =
 #ifdef CONFIG_TRACE_IRQFLAGS_SUPPORT
                 (irqs_disabled_flags(flags) ? TRACE_FLAG_IRQS_OFF : 0) |
@@ -691,6 +891,56 @@ trace_function(struct trace_array *tr, struct trace_array_cpu *data,
         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
 }
 
+#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);
+        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);
+}
+
+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);
+        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);
+}
+#endif
+
 void
 ftrace(struct trace_array *tr, struct trace_array_cpu *data,
        unsigned long ip, unsigned long parent_ip, unsigned long flags,
@@ -742,6 +992,46 @@ void __trace_stack(struct trace_array *tr,
         ftrace_trace_stack(tr, data, flags, skip, preempt_count());
 }
 
+static void ftrace_trace_userstack(struct trace_array *tr,
+                   struct trace_array_cpu *data,
+                   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);
+        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));
+
+        trace.nr_entries        = 0;
+        trace.max_entries       = FTRACE_STACK_ENTRIES;
+        trace.skip              = 0;
+        trace.entries           = entry->caller;
+
+        save_stack_trace_user(&trace);
+        ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+#endif
+}
+
+void __trace_userstack(struct trace_array *tr,
+                   struct trace_array_cpu *data,
+                   unsigned long flags)
+{
+        ftrace_trace_userstack(tr, data, flags, preempt_count());
+}
+
 static void
 ftrace_trace_special(void *__tr, void *__data,
                      unsigned long arg1, unsigned long arg2, unsigned long arg3,
@@ -765,6 +1055,7 @@ ftrace_trace_special(void *__tr, void *__data,
         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();
 }
@@ -803,6 +1094,7 @@ tracing_sched_switch_trace(struct trace_array *tr,
         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);
 }
 
 void
@@ -832,6 +1124,7 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
         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();
 }
@@ -841,26 +1134,28 @@ ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
 {
         struct trace_array *tr = &global_trace;
         struct trace_array_cpu *data;
+        unsigned long flags;
         int cpu;
         int pc;
 
-        if (tracing_disabled || !tr->ctrl)
+        if (tracing_disabled)
                 return;
 
         pc = preempt_count();
-        preempt_disable_notrace();
+        local_irq_save(flags);
         cpu = raw_smp_processor_id();
         data = tr->data[cpu];
 
-        if (likely(!atomic_read(&data->disabled)))
+        if (likely(atomic_inc_return(&data->disabled) == 1))
                 ftrace_trace_special(tr, data, arg1, arg2, arg3, pc);
 
-        preempt_enable_notrace();
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
 }
 
 #ifdef CONFIG_FUNCTION_TRACER
 static void
-function_trace_call(unsigned long ip, unsigned long parent_ip)
+function_trace_call_preempt_only(unsigned long ip, unsigned long parent_ip)
 {
         struct trace_array *tr = &global_trace;
         struct trace_array_cpu *data;
@@ -873,8 +1168,7 @@ function_trace_call(unsigned long ip, unsigned long parent_ip)
                 return;
 
         pc = preempt_count();
-        resched = need_resched();
-        preempt_disable_notrace();
+        resched = ftrace_preempt_disable();
         local_save_flags(flags);
         cpu = raw_smp_processor_id();
         data = tr->data[cpu];
@@ -884,12 +1178,97 @@ function_trace_call(unsigned long ip, unsigned long parent_ip)
                 trace_function(tr, data, ip, parent_ip, flags, pc);
 
         atomic_dec(&data->disabled);
-        if (resched)
-                preempt_enable_no_resched_notrace();
-        else
-                preempt_enable_notrace();
+        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);
+        }
+
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
 }
 
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+int trace_graph_entry(struct ftrace_graph_ent *trace)
+{
+        struct trace_array *tr = &global_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+        int pc;
+
+        if (!ftrace_trace_task(current))
+                return 0;
+
+        if (!ftrace_graph_addr(trace->func))
+                return 0;
+
+        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_graph_entry(tr, data, trace, flags, pc);
+        }
+        /* Only do the atomic if it is not already set */
+        if (!test_tsk_trace_graph(current))
+                set_tsk_trace_graph(current);
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
+
+        return 1;
+}
+
+void trace_graph_return(struct ftrace_graph_ret *trace)
+{
+        struct trace_array *tr = &global_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+        int pc;
+
+        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_graph_return(tr, data, trace, flags, pc);
+        }
+        if (!trace->depth)
+                clear_tsk_trace_graph(current);
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
+}
+#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
+
 static struct ftrace_ops trace_ops __read_mostly =
 {
         .func = function_trace_call,
@@ -898,9 +1277,14 @@ static struct ftrace_ops trace_ops __read_mostly =
 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;
+
         register_ftrace_function(&trace_ops);
-        if (tracer_enabled)
-                ftrace_function_enabled = 1;
+        ftrace_function_enabled = 1;
 }
 
 void tracing_stop_function_trace(void)
@@ -912,6 +1296,7 @@ void tracing_stop_function_trace(void)
 
 enum trace_file_type {
         TRACE_FILE_LAT_FMT      = 1,
+        TRACE_FILE_ANNOTATE     = 2,
 };
 
 static void trace_iterator_increment(struct trace_iterator *iter, int cpu)
@@ -1047,10 +1432,6 @@ static void *s_start(struct seq_file *m, loff_t *pos)
 
         atomic_inc(&trace_record_cmdline_disabled);
 
-        /* let the tracer grab locks here if needed */
-        if (current_trace->start)
-                current_trace->start(iter);
-
         if (*pos != iter->pos) {
                 iter->ent = NULL;
                 iter->cpu = 0;
@@ -1077,14 +1458,7 @@ static void *s_start(struct seq_file *m, loff_t *pos)
 
 static void s_stop(struct seq_file *m, void *p)
 {
-        struct trace_iterator *iter = m->private;
-
         atomic_dec(&trace_record_cmdline_disabled);
-
-        /* let the tracer release locks here if needed */
-        if (current_trace && current_trace == iter->trace && iter->trace->stop)
-                iter->trace->stop(iter);
-
         mutex_unlock(&trace_types_lock);
 }
 
@@ -1143,7 +1517,7 @@ seq_print_sym_offset(struct trace_seq *s, const char *fmt,
 # define IP_FMT "%016lx"
 #endif
 
-static int
+int
 seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
 {
         int ret;
@@ -1164,6 +1538,78 @@ seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
         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)
 {
         seq_puts(m, "#                  _------=> CPU#            \n");
@@ -1338,6 +1784,23 @@ void trace_seq_print_cont(struct trace_seq *s, struct trace_iterator *iter)
                 trace_seq_putc(s, '\n');
 }
 
+static void test_cpu_buff_start(struct trace_iterator *iter)
+{
+        struct trace_seq *s = &iter->seq;
+
+        if (!(trace_flags & TRACE_ITER_ANNOTATE))
+                return;
+
+        if (!(iter->iter_flags & TRACE_FILE_ANNOTATE))
+                return;
+
+        if (cpu_isset(iter->cpu, iter->started))
+                return;
+
+        cpu_set(iter->cpu, iter->started);
+        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)
 {
@@ -1357,6 +1820,8 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
         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;
@@ -1448,6 +1913,27 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
                         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);
         }
@@ -1472,6 +1958,8 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
         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);
@@ -1581,6 +2069,37 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
                         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;
+
+                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);
+
+                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;
 }
@@ -1640,6 +2159,7 @@ static enum print_line_t print_raw_fmt(struct trace_iterator *iter)
                 break;
         }
         case TRACE_SPECIAL:
+        case TRACE_USER_STACK:
         case TRACE_STACK: {
                 struct special_entry *field;
 
@@ -1728,6 +2248,7 @@ static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
                 break;
         }
         case TRACE_SPECIAL:
+        case TRACE_USER_STACK:
         case TRACE_STACK: {
                 struct special_entry *field;
 
@@ -1782,6 +2303,7 @@ static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
                 break;
         }
         case TRACE_SPECIAL:
+        case TRACE_USER_STACK:
         case TRACE_STACK: {
                 struct special_entry *field;
 
@@ -1847,7 +2369,9 @@ static int s_show(struct seq_file *m, void *v)
                         seq_printf(m, "# tracer: %s\n", iter->trace->name);
                         seq_puts(m, "#\n");
                 }
-                if (iter->iter_flags & TRACE_FILE_LAT_FMT) {
+                if (iter->trace && iter->trace->print_header)
+                        iter->trace->print_header(m);
+                else if (iter->iter_flags & TRACE_FILE_LAT_FMT) {
                         /* print nothing if the buffers are empty */
                         if (trace_empty(iter))
                                 return 0;
@@ -1899,6 +2423,15 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
         iter->trace = current_trace;
         iter->pos = -1;
 
+        /* Notify the tracer early; before we stop tracing. */
+        if (iter->trace && iter->trace->open)
+                        iter->trace->open(iter);
+
+        /* Annotate start of buffers if we had overruns */
+        if (ring_buffer_overruns(iter->tr->buffer))
+                iter->iter_flags |= TRACE_FILE_ANNOTATE;
+
+
         for_each_tracing_cpu(cpu) {
 
                 iter->buffer_iter[cpu] =
@@ -1917,13 +2450,7 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
         m->private = iter;
 
         /* stop the trace while dumping */
-        if (iter->tr->ctrl) {
-                tracer_enabled = 0;
-                ftrace_function_enabled = 0;
-        }
-
-        if (iter->trace && iter->trace->open)
-                        iter->trace->open(iter);
+        tracing_stop();
 
         mutex_unlock(&trace_types_lock);
 
@@ -1936,6 +2463,7 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
                         ring_buffer_read_finish(iter->buffer_iter[cpu]);
         }
         mutex_unlock(&trace_types_lock);
+        kfree(iter);
 
         return ERR_PTR(-ENOMEM);
 }
@@ -1965,14 +2493,7 @@ int tracing_release(struct inode *inode, struct file *file)
                 iter->trace->close(iter);
 
         /* reenable tracing if it was previously enabled */
-        if (iter->tr->ctrl) {
-                tracer_enabled = 1;
-                /*
-                 * It is safe to enable function tracing even if it
-                 * isn't used
-                 */
-                ftrace_function_enabled = 1;
-        }
+        tracing_start();
         mutex_unlock(&trace_types_lock);
 
         seq_release(inode, file);
@@ -2125,7 +2646,7 @@ tracing_cpumask_read(struct file *filp, char __user *ubuf,
 
         mutex_lock(&tracing_cpumask_update_lock);
 
-        len = cpumask_scnprintf(mask_str, count, tracing_cpumask);
+        len = cpumask_scnprintf(mask_str, count, &tracing_cpumask);
         if (count - len < 2) {
                 count = -EINVAL;
                 goto out_err;
@@ -2146,11 +2667,11 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
         int err, cpu;
 
         mutex_lock(&tracing_cpumask_update_lock);
-        err = cpumask_parse_user(ubuf, count, tracing_cpumask_new);
+        err = cpumask_parse_user(ubuf, count, &tracing_cpumask_new);
         if (err)
                 goto err_unlock;
 
-        raw_local_irq_disable();
+        local_irq_disable();
         __raw_spin_lock(&ftrace_max_lock);
         for_each_tracing_cpu(cpu) {
                 /*
@@ -2167,7 +2688,7 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
                 }
         }
         __raw_spin_unlock(&ftrace_max_lock);
-        raw_local_irq_enable();
+        local_irq_enable();
 
         tracing_cpumask = tracing_cpumask_new;
 
@@ -2188,13 +2709,16 @@ static struct file_operations tracing_cpumask_fops = {
 };
 
 static ssize_t
-tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
+tracing_trace_options_read(struct file *filp, char __user *ubuf,
                        size_t cnt, loff_t *ppos)
 {
+        int i;
         char *buf;
         int r = 0;
         int len = 0;
-        int i;
+        u32 tracer_flags = current_trace->flags->val;
+        struct tracer_opt *trace_opts = current_trace->flags->opts;
+
 
         /* calulate max size */
         for (i = 0; trace_options[i]; i++) {
@@ -2202,6 +2726,15 @@ tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
                 len += 3; /* "no" and space */
         }
 
+        /*
+         * 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 */
+        }
+
         /* +2 for \n and \0 */
         buf = kmalloc(len + 2, GFP_KERNEL);
         if (!buf)
@@ -2214,6 +2747,15 @@ tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
                         r += sprintf(buf + r, "no%s ", trace_options[i]);
         }
 
+        for (i = 0; trace_opts[i].name; i++) {
+                if (tracer_flags & trace_opts[i].bit)
+                        r += sprintf(buf + r, "%s ",
+                                trace_opts[i].name);
+                else
+                        r += sprintf(buf + r, "no%s ",
+                                trace_opts[i].name);
+        }
+
         r += sprintf(buf + r, "\n");
         WARN_ON(r >= len + 2);
 
@@ -2224,13 +2766,48 @@ tracing_iter_ctrl_read(struct file *filp, char __user *ubuf,
         return r;
 }
 
+/* Try to assign a tracer specific option */
+static int set_tracer_option(struct tracer *trace, char *cmp, int neg)
+{
+        struct tracer_flags *trace_flags = trace->flags;
+        struct tracer_opt *opts = NULL;
+        int ret = 0, i = 0;
+        int len;
+
+        for (i = 0; trace_flags->opts[i].name; i++) {
+                opts = &trace_flags->opts[i];
+                len = strlen(opts->name);
+
+                if (strncmp(cmp, opts->name, len) == 0) {
+                        ret = trace->set_flag(trace_flags->val,
+                                opts->bit, !neg);
+                        break;
+                }
+        }
+        /* Not found */
+        if (!trace_flags->opts[i].name)
+                return -EINVAL;
+
+        /* Refused to handle */
+        if (ret)
+                return ret;
+
+        if (neg)
+                trace_flags->val &= ~opts->bit;
+        else
+                trace_flags->val |= opts->bit;
+
+        return 0;
+}
+
 static ssize_t
-tracing_iter_ctrl_write(struct file *filp, const char __user *ubuf,
+tracing_trace_options_write(struct file *filp, const char __user *ubuf,
                         size_t cnt, loff_t *ppos)
 {
         char buf[64];
         char *cmp = buf;
         int neg = 0;
+        int ret;
         int i;
 
         if (cnt >= sizeof(buf))
@@ -2257,11 +2834,13 @@ tracing_iter_ctrl_write(struct file *filp, const char __user *ubuf,
                         break;
                 }
         }
-        /*
-         * If no option could be set, return an error:
-         */
-        if (!trace_options[i])
-                return -EINVAL;
+
+        /* If no option could be set, test the specific tracer options */
+        if (!trace_options[i]) {
+                ret = set_tracer_option(current_trace, cmp, neg);
+                if (ret)
+                        return ret;
+        }
 
         filp->f_pos += cnt;
 
@@ -2270,8 +2849,8 @@ tracing_iter_ctrl_write(struct file *filp, const char __user *ubuf,
 
 static struct file_operations tracing_iter_fops = {
         .open           = tracing_open_generic,
-        .read           = tracing_iter_ctrl_read,
-        .write          = tracing_iter_ctrl_write,
+        .read           = tracing_trace_options_read,
+        .write          = tracing_trace_options_write,
 };
 
 static const char readme_msg[] =
@@ -2285,9 +2864,9 @@ static const char readme_msg[] =
         "# echo sched_switch > /debug/tracing/current_tracer\n"
         "# cat /debug/tracing/current_tracer\n"
         "sched_switch\n"
-        "# cat /debug/tracing/iter_ctrl\n"
+        "# cat /debug/tracing/trace_options\n"
         "noprint-parent nosym-offset nosym-addr noverbose\n"
-        "# echo print-parent > /debug/tracing/iter_ctrl\n"
+        "# echo print-parent > /debug/tracing/trace_options\n"
         "# echo 1 > /debug/tracing/tracing_enabled\n"
         "# cat /debug/tracing/trace > /tmp/trace.txt\n"
         "echo 0 > /debug/tracing/tracing_enabled\n"
@@ -2310,11 +2889,10 @@ static ssize_t
 tracing_ctrl_read(struct file *filp, char __user *ubuf,
                   size_t cnt, loff_t *ppos)
 {
-        struct trace_array *tr = filp->private_data;
         char buf[64];
         int r;
 
-        r = sprintf(buf, "%ld\n", tr->ctrl);
+        r = sprintf(buf, "%u\n", tracer_enabled);
         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
 
@@ -2342,16 +2920,18 @@ tracing_ctrl_write(struct file *filp, const char __user *ubuf,
         val = !!val;
 
         mutex_lock(&trace_types_lock);
-        if (tr->ctrl ^ val) {
-                if (val)
+        if (tracer_enabled ^ val) {
+                if (val) {
                         tracer_enabled = 1;
-                else
+                        if (current_trace->start)
+                                current_trace->start(tr);
+                        tracing_start();
+                } else {
                         tracer_enabled = 0;
-
-                tr->ctrl = val;
-
-                if (current_trace && current_trace->ctrl_update)
-                        current_trace->ctrl_update(tr);
+                        tracing_stop();
+                        if (current_trace->stop)
+                                current_trace->stop(tr);
+                }
         }
         mutex_unlock(&trace_types_lock);
 
@@ -2377,29 +2957,11 @@ tracing_set_trace_read(struct file *filp, char __user *ubuf,
         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
 
-static ssize_t
-tracing_set_trace_write(struct file *filp, const char __user *ubuf,
-                        size_t cnt, loff_t *ppos)
+static int tracing_set_tracer(char *buf)
 {
         struct trace_array *tr = &global_trace;
         struct tracer *t;
-        char buf[max_tracer_type_len+1];
-        int i;
-        size_t ret;
-
-        ret = cnt;
-
-        if (cnt > max_tracer_type_len)
-                cnt = max_tracer_type_len;
-
-        if (copy_from_user(&buf, ubuf, cnt))
-                return -EFAULT;
-
-        buf[cnt] = 0;
-
-        /* strip ending whitespace. */
-        for (i = cnt - 1; i > 0 && isspace(buf[i]); i--)
-                buf[i] = 0;
+        int ret = 0;
 
         mutex_lock(&trace_types_lock);
         for (t = trace_types; t; t = t->next) {
@@ -2413,18 +2975,52 @@ tracing_set_trace_write(struct file *filp, const char __user *ubuf,
         if (t == current_trace)
                 goto out;
 
+        trace_branch_disable();
         if (current_trace && current_trace->reset)
                 current_trace->reset(tr);
 
         current_trace = t;
-        if (t->init)
-                t->init(tr);
+        if (t->init) {
+                ret = t->init(tr);
+                if (ret)
+                        goto out;
+        }
 
+        trace_branch_enable(tr);
  out:
         mutex_unlock(&trace_types_lock);
 
-        if (ret > 0)
-                filp->f_pos += ret;
+        return ret;
+}
+
+static ssize_t
+tracing_set_trace_write(struct file *filp, const char __user *ubuf,
+                        size_t cnt, loff_t *ppos)
+{
+        char buf[max_tracer_type_len+1];
+        int i;
+        size_t ret;
+        int err;
+
+        ret = cnt;
+
+        if (cnt > max_tracer_type_len)
+                cnt = max_tracer_type_len;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        /* strip ending whitespace. */
+        for (i = cnt - 1; i > 0 && isspace(buf[i]); i--)
+                buf[i] = 0;
+
+        err = tracing_set_tracer(buf);
+        if (err)
+                return err;
+
+        filp->f_pos += ret;
 
         return ret;
 }
@@ -2491,6 +3087,10 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
                 return -ENOMEM;
 
         mutex_lock(&trace_types_lock);
+
+        /* trace pipe does not show start of buffer */
+        cpus_setall(iter->started);
+
         iter->tr = &global_trace;
         iter->trace = current_trace;
         filp->private_data = iter;
@@ -2666,7 +3266,7 @@ tracing_entries_read(struct file *filp, char __user *ubuf,
         char buf[64];
         int r;
 
-        r = sprintf(buf, "%lu\n", tr->entries);
+        r = sprintf(buf, "%lu\n", tr->entries >> 10);
         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
 
@@ -2677,7 +3277,6 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
         unsigned long val;
         char buf[64];
         int ret, cpu;
-        struct trace_array *tr = filp->private_data;
 
         if (cnt >= sizeof(buf))
                 return -EINVAL;
@@ -2697,12 +3296,7 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
 
         mutex_lock(&trace_types_lock);
 
-        if (tr->ctrl) {
-                cnt = -EBUSY;
-                pr_info("ftrace: please disable tracing"
-                        " before modifying buffer size\n");
-                goto out;
-        }
+        tracing_stop();
 
         /* disable all cpu buffers */
         for_each_tracing_cpu(cpu) {
@@ -2712,6 +3306,9 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
                         atomic_inc(&max_tr.data[cpu]->disabled);
         }
 
+        /* value is in KB */
+        val <<= 10;
+
         if (val != global_trace.entries) {
                 ret = ring_buffer_resize(global_trace.buffer, val);
                 if (ret < 0) {
@@ -2750,6 +3347,7 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
                         atomic_dec(&max_tr.data[cpu]->disabled);
         }
 
+        tracing_start();
         max_tr.entries = global_trace.entries;
         mutex_unlock(&trace_types_lock);
 
@@ -2761,7 +3359,7 @@ static int mark_printk(const char *fmt, ...)
         int ret;
         va_list args;
         va_start(args, fmt);
-        ret = trace_vprintk(0, fmt, args);
+        ret = trace_vprintk(0, -1, fmt, args);
         va_end(args);
         return ret;
 }
@@ -2772,9 +3370,8 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
 {
         char *buf;
         char *end;
-        struct trace_array *tr = &global_trace;
 
-        if (!tr->ctrl || tracing_disabled)
+        if (tracing_disabled)
                 return -EINVAL;
 
         if (cnt > TRACE_BUF_SIZE)
@@ -2840,22 +3437,38 @@ static struct file_operations tracing_mark_fops = {
 
 #ifdef CONFIG_DYNAMIC_FTRACE
 
+int __weak ftrace_arch_read_dyn_info(char *buf, int size)
+{
+        return 0;
+}
+
 static ssize_t
-tracing_read_long(struct file *filp, char __user *ubuf,
+tracing_read_dyn_info(struct file *filp, char __user *ubuf,
                   size_t cnt, loff_t *ppos)
 {
+        static char ftrace_dyn_info_buffer[1024];
+        static DEFINE_MUTEX(dyn_info_mutex);
         unsigned long *p = filp->private_data;
-        char buf[64];
+        char *buf = ftrace_dyn_info_buffer;
+        int size = ARRAY_SIZE(ftrace_dyn_info_buffer);
         int r;
 
-        r = sprintf(buf, "%ld\n", *p);
+        mutex_lock(&dyn_info_mutex);
+        r = sprintf(buf, "%ld ", *p);
 
-        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+        r += ftrace_arch_read_dyn_info(buf+r, (size-1)-r);
+        buf[r++] = '\n';
+
+        r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+
+        mutex_unlock(&dyn_info_mutex);
+
+        return r;
 }
 
-static struct file_operations tracing_read_long_fops = {
+static struct file_operations tracing_dyn_info_fops = {
         .open           = tracing_open_generic,
-        .read           = tracing_read_long,
+        .read           = tracing_read_dyn_info,
 };
 #endif
 
@@ -2896,10 +3509,10 @@ static __init int tracer_init_debugfs(void)
         if (!entry)
                 pr_warning("Could not create debugfs 'tracing_enabled' entry\n");
 
-        entry = debugfs_create_file("iter_ctrl", 0644, d_tracer,
+        entry = debugfs_create_file("trace_options", 0644, d_tracer,
                                     NULL, &tracing_iter_fops);
         if (!entry)
-                pr_warning("Could not create debugfs 'iter_ctrl' entry\n");
+                pr_warning("Could not create debugfs 'trace_options' entry\n");
 
         entry = debugfs_create_file("tracing_cpumask", 0644, d_tracer,
                                     NULL, &tracing_cpumask_fops);
@@ -2949,11 +3562,11 @@ static __init int tracer_init_debugfs(void)
                 pr_warning("Could not create debugfs "
                            "'trace_pipe' entry\n");
 
-        entry = debugfs_create_file("trace_entries", 0644, d_tracer,
+        entry = debugfs_create_file("buffer_size_kb", 0644, d_tracer,
                                     &global_trace, &tracing_entries_fops);
         if (!entry)
                 pr_warning("Could not create debugfs "
-                           "'trace_entries' entry\n");
+                           "'buffer_size_kb' entry\n");
 
         entry = debugfs_create_file("trace_marker", 0220, d_tracer,
                                     NULL, &tracing_mark_fops);
@@ -2964,7 +3577,7 @@ static __init int tracer_init_debugfs(void)
 #ifdef CONFIG_DYNAMIC_FTRACE
         entry = debugfs_create_file("dyn_ftrace_total_info", 0444, d_tracer,
                                     &ftrace_update_tot_cnt,
-                                    &tracing_read_long_fops);
+                                    &tracing_dyn_info_fops);
         if (!entry)
                 pr_warning("Could not create debugfs "
                            "'dyn_ftrace_total_info' entry\n");
@@ -2975,7 +3588,7 @@ static __init int tracer_init_debugfs(void)
         return 0;
 }
 
-int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
+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];
@@ -2983,11 +3596,11 @@ int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
         struct ring_buffer_event *event;
         struct trace_array *tr = &global_trace;
         struct trace_array_cpu *data;
-        struct print_entry *entry;
-        unsigned long flags, irq_flags;
         int cpu, len = 0, size, pc;
+        struct print_entry *entry;
+        unsigned long irq_flags;
 
-        if (!tr->ctrl || tracing_disabled)
+        if (tracing_disabled || tracing_selftest_running)
                 return 0;
 
         pc = preempt_count();
@@ -2998,7 +3611,8 @@ int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
         if (unlikely(atomic_read(&data->disabled)))
                 goto out;
 
-        spin_lock_irqsave(&trace_buf_lock, flags);
+        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);
@@ -3009,17 +3623,18 @@ int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
         if (!event)
                 goto out_unlock;
         entry = ring_buffer_event_data(event);
-        tracing_generic_entry_update(&entry->ent, flags, pc);
+        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, flags);
-
+        spin_unlock_irqrestore(&trace_buf_lock, irq_flags);
+        unpause_graph_tracing();
  out:
         preempt_enable_notrace();
 
@@ -3036,7 +3651,7 @@ int __ftrace_printk(unsigned long ip, const char *fmt, ...)
                 return 0;
 
         va_start(ap, fmt);
-        ret = trace_vprintk(ip, fmt, ap);
+        ret = trace_vprintk(ip, task_curr_ret_stack(current), fmt, ap);
         va_end(ap);
         return ret;
 }
@@ -3045,7 +3660,8 @@ EXPORT_SYMBOL_GPL(__ftrace_printk);
 static int trace_panic_handler(struct notifier_block *this,
                                unsigned long event, void *unused)
 {
-        ftrace_dump();
+        if (ftrace_dump_on_oops)
+                ftrace_dump();
         return NOTIFY_OK;
 }
 
@@ -3061,7 +3677,8 @@ static int trace_die_handler(struct notifier_block *self,
 {
         switch (val) {
         case DIE_OOPS:
-                ftrace_dump();
+                if (ftrace_dump_on_oops)
+                        ftrace_dump();
                 break;
         default:
                 break;
@@ -3102,7 +3719,6 @@ trace_printk_seq(struct trace_seq *s)
         trace_seq_reset(s);
 }
 
-
 void ftrace_dump(void)
 {
         static DEFINE_SPINLOCK(ftrace_dump_lock);
@@ -3127,6 +3743,9 @@ void ftrace_dump(void)
                 atomic_inc(&global_trace.data[cpu]->disabled);
         }
 
+        /* don't look at user memory in panic mode */
+        trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
+
         printk(KERN_TRACE "Dumping ftrace buffer:\n");
 
         iter.tr = &global_trace;
@@ -3220,7 +3839,6 @@ __init static int tracer_alloc_buffers(void)
 #endif
 
         /* All seems OK, enable tracing */
-        global_trace.ctrl = tracer_enabled;
         tracing_disabled = 0;
 
         atomic_notifier_chain_register(&panic_notifier_list,