Merge remote-tracking branch 'linus/master' into testing

16 files changed, 1089 insertions, 591 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 6c508ff33c62..a6d098c6df3f 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -413,6 +413,17 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
         return 0;
 }
 
+static void ftrace_sync(struct work_struct *work)
+{
+        /*
+         * This function is just a stub to implement a hard force
+         * of synchronize_sched(). This requires synchronizing
+         * tasks even in userspace and idle.
+         *
+         * Yes, function tracing is rude.
+         */
+}
+
 static int __unregister_ftrace_function(struct ftrace_ops *ops)
 {
         int ret;
@@ -440,8 +451,12 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
                          * so there'll be no new users. We must ensure
                          * all current users are done before we free
                          * the control data.
+                         * Note synchronize_sched() is not enough, as we
+                         * use preempt_disable() to do RCU, but the function
+                         * tracer can be called where RCU is not active
+                         * (before user_exit()).
                          */
-                        synchronize_sched();
+                        schedule_on_each_cpu(ftrace_sync);
                         control_ops_free(ops);
                 }
         } else
@@ -456,9 +471,13 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
         /*
          * Dynamic ops may be freed, we must make sure that all
          * callers are done before leaving this function.
+         *
+         * Again, normal synchronize_sched() is not good enough.
+         * We need to do a hard force of sched synchronization.
          */
         if (ops->flags & FTRACE_OPS_FL_DYNAMIC)
-                synchronize_sched();
+                schedule_on_each_cpu(ftrace_sync);
+
 
         return 0;
 }
@@ -622,12 +641,18 @@ static int function_stat_show(struct seq_file *m, void *v)
         if (rec->counter <= 1)
                 stddev = 0;
         else {
-                stddev = rec->time_squared - rec->counter * avg * avg;
+                /*
+                 * Apply Welford's method:
+                 * s^2 = 1 / (n * (n-1)) * (n * \Sum (x_i)^2 - (\Sum x_i)^2)
+                 */
+                stddev = rec->counter * rec->time_squared -
+                         rec->time * rec->time;
+
                 /*
                  * Divide only 1000 for ns^2 -> us^2 conversion.
                  * trace_print_graph_duration will divide 1000 again.
                  */
-                do_div(stddev, (rec->counter - 1) * 1000);
+                do_div(stddev, rec->counter * (rec->counter - 1) * 1000);
         }
 
         trace_seq_init(&s);
@@ -1416,12 +1441,22 @@ ftrace_hash_move(struct ftrace_ops *ops, int enable,
  * the hashes are freed with call_rcu_sched().
  */
 static int
-ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip)
+ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
 {
         struct ftrace_hash *filter_hash;
         struct ftrace_hash *notrace_hash;
         int ret;
 
+#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
+        /*
+         * There's a small race when adding ops that the ftrace handler
+         * that wants regs, may be called without them. We can not
+         * allow that handler to be called if regs is NULL.
+         */
+        if (regs == NULL && (ops->flags & FTRACE_OPS_FL_SAVE_REGS))
+                return 0;
+#endif
+
         filter_hash = rcu_dereference_raw_notrace(ops->filter_hash);
         notrace_hash = rcu_dereference_raw_notrace(ops->notrace_hash);
 
@@ -2134,12 +2169,57 @@ static cycle_t		ftrace_update_time;
 static unsigned long    ftrace_update_cnt;
 unsigned long           ftrace_update_tot_cnt;
 
-static int ops_traces_mod(struct ftrace_ops *ops)
+static inline int ops_traces_mod(struct ftrace_ops *ops)
 {
-        struct ftrace_hash *hash;
+        /*
+         * Filter_hash being empty will default to trace module.
+         * But notrace hash requires a test of individual module functions.
+         */
+        return ftrace_hash_empty(ops->filter_hash) &&
+                ftrace_hash_empty(ops->notrace_hash);
+}
+
+/*
+ * Check if the current ops references the record.
+ *
+ * If the ops traces all functions, then it was already accounted for.
+ * If the ops does not trace the current record function, skip it.
+ * If the ops ignores the function via notrace filter, skip it.
+ */
+static inline bool
+ops_references_rec(struct ftrace_ops *ops, struct dyn_ftrace *rec)
+{
+        /* If ops isn't enabled, ignore it */
+        if (!(ops->flags & FTRACE_OPS_FL_ENABLED))
+                return 0;
 
-        hash = ops->filter_hash;
-        return ftrace_hash_empty(hash);
+        /* If ops traces all mods, we already accounted for it */
+        if (ops_traces_mod(ops))
+                return 0;
+
+        /* The function must be in the filter */
+        if (!ftrace_hash_empty(ops->filter_hash) &&
+            !ftrace_lookup_ip(ops->filter_hash, rec->ip))
+                return 0;
+
+        /* If in notrace hash, we ignore it too */
+        if (ftrace_lookup_ip(ops->notrace_hash, rec->ip))
+                return 0;
+
+        return 1;
+}
+
+static int referenced_filters(struct dyn_ftrace *rec)
+{
+        struct ftrace_ops *ops;
+        int cnt = 0;
+
+        for (ops = ftrace_ops_list; ops != &ftrace_list_end; ops = ops->next) {
+                if (ops_references_rec(ops, rec))
+                    cnt++;
+        }
+
+        return cnt;
 }
 
 static int ftrace_update_code(struct module *mod)
@@ -2148,6 +2228,7 @@ static int ftrace_update_code(struct module *mod)
         struct dyn_ftrace *p;
         cycle_t start, stop;
         unsigned long ref = 0;
+        bool test = false;
         int i;
 
         /*
@@ -2161,9 +2242,12 @@ static int ftrace_update_code(struct module *mod)
 
                 for (ops = ftrace_ops_list;
                      ops != &ftrace_list_end; ops = ops->next) {
-                        if (ops->flags & FTRACE_OPS_FL_ENABLED &&
-                            ops_traces_mod(ops))
-                                ref++;
+                        if (ops->flags & FTRACE_OPS_FL_ENABLED) {
+                                if (ops_traces_mod(ops))
+                                        ref++;
+                                else
+                                        test = true;
+                        }
                 }
         }
 
@@ -2173,12 +2257,16 @@ static int ftrace_update_code(struct module *mod)
         for (pg = ftrace_new_pgs; pg; pg = pg->next) {
 
                 for (i = 0; i < pg->index; i++) {
+                        int cnt = ref;
+
                         /* If something went wrong, bail without enabling anything */
                         if (unlikely(ftrace_disabled))
                                 return -1;
 
                         p = &pg->records[i];
-                        p->flags = ref;
+                        if (test)
+                                cnt += referenced_filters(p);
+                        p->flags = cnt;
 
                         /*
                          * Do the initial record conversion from mcount jump
@@ -2198,7 +2286,7 @@ static int ftrace_update_code(struct module *mod)
                          * conversion puts the module to the correct state, thus
                          * passing the ftrace_make_call check.
                          */
-                        if (ftrace_start_up && ref) {
+                        if (ftrace_start_up && cnt) {
                                 int failed = __ftrace_replace_code(p, 1);
                                 if (failed)
                                         ftrace_bug(failed, p->ip);
@@ -3349,6 +3437,12 @@ ftrace_match_addr(struct ftrace_hash *hash, unsigned long ip, int remove)
         return add_hash_entry(hash, ip);
 }
 
+static void ftrace_ops_update_code(struct ftrace_ops *ops)
+{
+        if (ops->flags & FTRACE_OPS_FL_ENABLED && ftrace_enabled)
+                ftrace_run_update_code(FTRACE_UPDATE_CALLS);
+}
+
 static int
 ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len,
                 unsigned long ip, int remove, int reset, int enable)
@@ -3391,9 +3485,8 @@ ftrace_set_hash(struct ftrace_ops *ops, unsigned char *buf, int len,
 
         mutex_lock(&ftrace_lock);
         ret = ftrace_hash_move(ops, enable, orig_hash, hash);
-        if (!ret && ops->flags & FTRACE_OPS_FL_ENABLED
-            && ftrace_enabled)
-                ftrace_run_update_code(FTRACE_UPDATE_CALLS);
+        if (!ret)
+                ftrace_ops_update_code(ops);
 
         mutex_unlock(&ftrace_lock);
 
@@ -3512,8 +3605,12 @@ EXPORT_SYMBOL_GPL(ftrace_set_global_notrace);
 static char ftrace_notrace_buf[FTRACE_FILTER_SIZE] __initdata;
 static char ftrace_filter_buf[FTRACE_FILTER_SIZE] __initdata;
 
+/* Used by function selftest to not test if filter is set */
+bool ftrace_filter_param __initdata;
+
 static int __init set_ftrace_notrace(char *str)
 {
+        ftrace_filter_param = true;
         strlcpy(ftrace_notrace_buf, str, FTRACE_FILTER_SIZE);
         return 1;
 }
@@ -3521,6 +3618,7 @@ __setup("ftrace_notrace=", set_ftrace_notrace);
 
 static int __init set_ftrace_filter(char *str)
 {
+        ftrace_filter_param = true;
         strlcpy(ftrace_filter_buf, str, FTRACE_FILTER_SIZE);
         return 1;
 }
@@ -3615,9 +3713,8 @@ int ftrace_regex_release(struct inode *inode, struct file *file)
                 mutex_lock(&ftrace_lock);
                 ret = ftrace_hash_move(iter->ops, filter_hash,
                                        orig_hash, iter->hash);
-                if (!ret && (iter->ops->flags & FTRACE_OPS_FL_ENABLED)
-                    && ftrace_enabled)
-                        ftrace_run_update_code(FTRACE_UPDATE_CALLS);
+                if (!ret)
+                        ftrace_ops_update_code(iter->ops);
 
                 mutex_unlock(&ftrace_lock);
         }
@@ -4188,7 +4285,7 @@ static inline void ftrace_startup_enable(int command) { }
 # define ftrace_shutdown_sysctl()       do { } while (0)
 
 static inline int
-ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip)
+ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
 {
         return 1;
 }
@@ -4211,7 +4308,7 @@ ftrace_ops_control_func(unsigned long ip, unsigned long parent_ip,
         do_for_each_ftrace_op(op, ftrace_control_list) {
                 if (!(op->flags & FTRACE_OPS_FL_STUB) &&
                     !ftrace_function_local_disabled(op) &&
-                    ftrace_ops_test(op, ip))
+                    ftrace_ops_test(op, ip, regs))
                         op->func(ip, parent_ip, op, regs);
         } while_for_each_ftrace_op(op);
         trace_recursion_clear(TRACE_CONTROL_BIT);
@@ -4244,7 +4341,7 @@ __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
          */
         preempt_disable_notrace();
         do_for_each_ftrace_op(op, ftrace_ops_list) {
-                if (ftrace_ops_test(op, ip))
+                if (ftrace_ops_test(op, ip, regs))
                         op->func(ip, parent_ip, op, regs);
         } while_for_each_ftrace_op(op);
         preempt_enable_notrace();
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index e444ff88f0a4..cc2f66f68dc5 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -36,11 +36,11 @@ int ring_buffer_print_entry_header(struct trace_seq *s)
 {
         int ret;
 
-        ret = trace_seq_printf(s, "# compressed entry header\n");
-        ret = trace_seq_printf(s, "\ttype_len    :    5 bits\n");
-        ret = trace_seq_printf(s, "\ttime_delta  :   27 bits\n");
-        ret = trace_seq_printf(s, "\tarray       :   32 bits\n");
-        ret = trace_seq_printf(s, "\n");
+        ret = trace_seq_puts(s, "# compressed entry header\n");
+        ret = trace_seq_puts(s, "\ttype_len    :    5 bits\n");
+        ret = trace_seq_puts(s, "\ttime_delta  :   27 bits\n");
+        ret = trace_seq_puts(s, "\tarray       :   32 bits\n");
+        ret = trace_seq_putc(s, '\n');
         ret = trace_seq_printf(s, "\tpadding     : type == %d\n",
                                RINGBUF_TYPE_PADDING);
         ret = trace_seq_printf(s, "\ttime_extend : type == %d\n",
@@ -1066,7 +1066,7 @@ static int rb_check_list(struct ring_buffer_per_cpu *cpu_buffer,
 }
 
 /**
- * check_pages - integrity check of buffer pages
+ * rb_check_pages - integrity check of buffer pages
  * @cpu_buffer: CPU buffer with pages to test
  *
  * As a safety measure we check to make sure the data pages have not
@@ -1258,7 +1258,7 @@ static int rb_cpu_notify(struct notifier_block *self,
 #endif
 
 /**
- * ring_buffer_alloc - allocate a new ring_buffer
+ * __ring_buffer_alloc - allocate a new ring_buffer
  * @size: the size in bytes per cpu that is needed.
  * @flags: attributes to set for the ring buffer.
  *
@@ -1607,6 +1607,7 @@ static void update_pages_handler(struct work_struct *work)
  * ring_buffer_resize - resize the ring buffer
  * @buffer: the buffer to resize.
  * @size: the new size.
+ * @cpu_id: the cpu buffer to resize
  *
  * Minimum size is 2 * BUF_PAGE_SIZE.
  *
@@ -3956,11 +3957,11 @@ EXPORT_SYMBOL_GPL(ring_buffer_consume);
  * expected.
  *
  * After a sequence of ring_buffer_read_prepare calls, the user is
- * expected to make at least one call to ring_buffer_prepare_sync.
+ * expected to make at least one call to ring_buffer_read_prepare_sync.
  * Afterwards, ring_buffer_read_start is invoked to get things going
  * for real.
  *
- * This overall must be paired with ring_buffer_finish.
+ * This overall must be paired with ring_buffer_read_finish.
  */
 struct ring_buffer_iter *
 ring_buffer_read_prepare(struct ring_buffer *buffer, int cpu)
@@ -4009,7 +4010,7 @@ EXPORT_SYMBOL_GPL(ring_buffer_read_prepare_sync);
  * an intervening ring_buffer_read_prepare_sync must have been
  * performed.
  *
- * Must be paired with ring_buffer_finish.
+ * Must be paired with ring_buffer_read_finish.
  */
 void
 ring_buffer_read_start(struct ring_buffer_iter *iter)
@@ -4031,7 +4032,7 @@ ring_buffer_read_start(struct ring_buffer_iter *iter)
 EXPORT_SYMBOL_GPL(ring_buffer_read_start);
 
 /**
- * ring_buffer_finish - finish reading the iterator of the buffer
+ * ring_buffer_read_finish - finish reading the iterator of the buffer
  * @iter: The iterator retrieved by ring_buffer_start
  *
  * This re-enables the recording to the buffer, and frees the
@@ -4346,6 +4347,7 @@ EXPORT_SYMBOL_GPL(ring_buffer_swap_cpu);
 /**
  * ring_buffer_alloc_read_page - allocate a page to read from buffer
  * @buffer: the buffer to allocate for.
+ * @cpu: the cpu buffer to allocate.
  *
  * This function is used in conjunction with ring_buffer_read_page.
  * When reading a full page from the ring buffer, these functions
@@ -4403,7 +4405,7 @@ EXPORT_SYMBOL_GPL(ring_buffer_free_read_page);
  * to swap with a page in the ring buffer.
  *
  * for example:
- *      rpage = ring_buffer_alloc_read_page(buffer);
+ *      rpage = ring_buffer_alloc_read_page(buffer, cpu);
  *      if (!rpage)
  *              return error;
  *      ret = ring_buffer_read_page(buffer, &rpage, len, cpu, 0);
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index e71a8be4a6ee..496f94d57698 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -115,6 +115,9 @@ cpumask_var_t __read_mostly	tracing_buffer_mask;
 
 enum ftrace_dump_mode ftrace_dump_on_oops;
 
+/* When set, tracing will stop when a WARN*() is hit */
+int __disable_trace_on_warning;
+
 static int tracing_set_tracer(const char *buf);
 
 #define MAX_TRACER_SIZE         100
@@ -149,6 +152,13 @@ static int __init set_ftrace_dump_on_oops(char *str)
 }
 __setup("ftrace_dump_on_oops", set_ftrace_dump_on_oops);
 
+static int __init stop_trace_on_warning(char *str)
+{
+        __disable_trace_on_warning = 1;
+        return 1;
+}
+__setup("traceoff_on_warning=", stop_trace_on_warning);
+
 static int __init boot_alloc_snapshot(char *str)
 {
         allocate_snapshot = true;
@@ -170,6 +180,7 @@ static int __init set_trace_boot_options(char *str)
 }
 __setup("trace_options=", set_trace_boot_options);
 
+
 unsigned long long ns2usecs(cycle_t nsec)
 {
         nsec += 500;
@@ -193,6 +204,37 @@ static struct trace_array	global_trace;
 
 LIST_HEAD(ftrace_trace_arrays);
 
+int trace_array_get(struct trace_array *this_tr)
+{
+        struct trace_array *tr;
+        int ret = -ENODEV;
+
+        mutex_lock(&trace_types_lock);
+        list_for_each_entry(tr, &ftrace_trace_arrays, list) {
+                if (tr == this_tr) {
+                        tr->ref++;
+                        ret = 0;
+                        break;
+                }
+        }
+        mutex_unlock(&trace_types_lock);
+
+        return ret;
+}
+
+static void __trace_array_put(struct trace_array *this_tr)
+{
+        WARN_ON(!this_tr->ref);
+        this_tr->ref--;
+}
+
+void trace_array_put(struct trace_array *this_tr)
+{
+        mutex_lock(&trace_types_lock);
+        __trace_array_put(this_tr);
+        mutex_unlock(&trace_types_lock);
+}
+
 int filter_current_check_discard(struct ring_buffer *buffer,
                                  struct ftrace_event_call *call, void *rec,
                                  struct ring_buffer_event *event)
@@ -201,23 +243,43 @@ int filter_current_check_discard(struct ring_buffer *buffer,
 }
 EXPORT_SYMBOL_GPL(filter_current_check_discard);
 
-cycle_t ftrace_now(int cpu)
+cycle_t buffer_ftrace_now(struct trace_buffer *buf, int cpu)
 {
         u64 ts;
 
         /* Early boot up does not have a buffer yet */
-        if (!global_trace.trace_buffer.buffer)
+        if (!buf->buffer)
                 return trace_clock_local();
 
-        ts = ring_buffer_time_stamp(global_trace.trace_buffer.buffer, cpu);
-        ring_buffer_normalize_time_stamp(global_trace.trace_buffer.buffer, cpu, &ts);
+        ts = ring_buffer_time_stamp(buf->buffer, cpu);
+        ring_buffer_normalize_time_stamp(buf->buffer, cpu, &ts);
 
         return ts;
 }
 
+cycle_t ftrace_now(int cpu)
+{
+        return buffer_ftrace_now(&global_trace.trace_buffer, cpu);
+}
+
+/**
+ * tracing_is_enabled - Show if global_trace has been disabled
+ *
+ * Shows if the global trace has been enabled or not. It uses the
+ * mirror flag "buffer_disabled" to be used in fast paths such as for
+ * the irqsoff tracer. But it may be inaccurate due to races. If you
+ * need to know the accurate state, use tracing_is_on() which is a little
+ * slower, but accurate.
+ */
 int tracing_is_enabled(void)
 {
-        return tracing_is_on();
+        /*
+         * For quick access (irqsoff uses this in fast path), just
+         * return the mirror variable of the state of the ring buffer.
+         * It's a little racy, but we don't really care.
+         */
+        smp_rmb();
+        return !global_trace.buffer_disabled;
 }
 
 /*
@@ -240,7 +302,7 @@ static struct tracer		*trace_types __read_mostly;
 /*
  * trace_types_lock is used to protect the trace_types list.
  */
-static DEFINE_MUTEX(trace_types_lock);
+DEFINE_MUTEX(trace_types_lock);
 
 /*
  * serialize the access of the ring buffer
@@ -330,6 +392,23 @@ unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
         TRACE_ITER_GRAPH_TIME | TRACE_ITER_RECORD_CMD | TRACE_ITER_OVERWRITE |
         TRACE_ITER_IRQ_INFO | TRACE_ITER_MARKERS | TRACE_ITER_FUNCTION;
 
+static void tracer_tracing_on(struct trace_array *tr)
+{
+        if (tr->trace_buffer.buffer)
+                ring_buffer_record_on(tr->trace_buffer.buffer);
+        /*
+         * This flag is looked at when buffers haven't been allocated
+         * yet, or by some tracers (like irqsoff), that just want to
+         * know if the ring buffer has been disabled, but it can handle
+         * races of where it gets disabled but we still do a record.
+         * As the check is in the fast path of the tracers, it is more
+         * important to be fast than accurate.
+         */
+        tr->buffer_disabled = 0;
+        /* Make the flag seen by readers */
+        smp_wmb();
+}
+
 /**
  * tracing_on - enable tracing buffers
  *
@@ -338,15 +417,7 @@ unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
  */
 void tracing_on(void)
 {
-        if (global_trace.trace_buffer.buffer)
-                ring_buffer_record_on(global_trace.trace_buffer.buffer);
-        /*
-         * This flag is only looked at when buffers haven't been
-         * allocated yet. We don't really care about the race
-         * between setting this flag and actually turning
-         * on the buffer.
-         */
-        global_trace.buffer_disabled = 0;
+        tracer_tracing_on(&global_trace);
 }
 EXPORT_SYMBOL_GPL(tracing_on);
 
@@ -540,6 +611,23 @@ void tracing_snapshot_alloc(void)
 EXPORT_SYMBOL_GPL(tracing_snapshot_alloc);
 #endif /* CONFIG_TRACER_SNAPSHOT */
 
+static void tracer_tracing_off(struct trace_array *tr)
+{
+        if (tr->trace_buffer.buffer)
+                ring_buffer_record_off(tr->trace_buffer.buffer);
+        /*
+         * This flag is looked at when buffers haven't been allocated
+         * yet, or by some tracers (like irqsoff), that just want to
+         * know if the ring buffer has been disabled, but it can handle
+         * races of where it gets disabled but we still do a record.
+         * As the check is in the fast path of the tracers, it is more
+         * important to be fast than accurate.
+         */
+        tr->buffer_disabled = 1;
+        /* Make the flag seen by readers */
+        smp_wmb();
+}
+
 /**
  * tracing_off - turn off tracing buffers
  *
@@ -550,26 +638,35 @@ EXPORT_SYMBOL_GPL(tracing_snapshot_alloc);
  */
 void tracing_off(void)
 {
-        if (global_trace.trace_buffer.buffer)
-                ring_buffer_record_off(global_trace.trace_buffer.buffer);
-        /*
-         * This flag is only looked at when buffers haven't been
-         * allocated yet. We don't really care about the race
-         * between setting this flag and actually turning
-         * on the buffer.
-         */
-        global_trace.buffer_disabled = 1;
+        tracer_tracing_off(&global_trace);
 }
 EXPORT_SYMBOL_GPL(tracing_off);
 
+void disable_trace_on_warning(void)
+{
+        if (__disable_trace_on_warning)
+                tracing_off();
+}
+
+/**
+ * tracer_tracing_is_on - show real state of ring buffer enabled
+ * @tr : the trace array to know if ring buffer is enabled
+ *
+ * Shows real state of the ring buffer if it is enabled or not.
+ */
+static int tracer_tracing_is_on(struct trace_array *tr)
+{
+        if (tr->trace_buffer.buffer)
+                return ring_buffer_record_is_on(tr->trace_buffer.buffer);
+        return !tr->buffer_disabled;
+}
+
 /**
  * tracing_is_on - show state of ring buffers enabled
  */
 int tracing_is_on(void)
 {
-        if (global_trace.trace_buffer.buffer)
-                return ring_buffer_record_is_on(global_trace.trace_buffer.buffer);
-        return !global_trace.buffer_disabled;
+        return tracer_tracing_is_on(&global_trace);
 }
 EXPORT_SYMBOL_GPL(tracing_is_on);
 
@@ -1119,7 +1216,7 @@ void tracing_reset_online_cpus(struct trace_buffer *buf)
         /* Make sure all commits have finished */
         synchronize_sched();
 
-        buf->time_start = ftrace_now(buf->cpu);
+        buf->time_start = buffer_ftrace_now(buf, buf->cpu);
 
         for_each_online_cpu(cpu)
                 ring_buffer_reset_cpu(buffer, cpu);
@@ -1127,23 +1224,17 @@ void tracing_reset_online_cpus(struct trace_buffer *buf)
         ring_buffer_record_enable(buffer);
 }
 
-void tracing_reset_current(int cpu)
-{
-        tracing_reset(&global_trace.trace_buffer, cpu);
-}
-
+/* Must have trace_types_lock held */
 void tracing_reset_all_online_cpus(void)
 {
         struct trace_array *tr;
 
-        mutex_lock(&trace_types_lock);
         list_for_each_entry(tr, &ftrace_trace_arrays, list) {
                 tracing_reset_online_cpus(&tr->trace_buffer);
 #ifdef CONFIG_TRACER_MAX_TRACE
                 tracing_reset_online_cpus(&tr->max_buffer);
 #endif
         }
-        mutex_unlock(&trace_types_lock);
 }
 
 #define SAVED_CMDLINES 128
@@ -1543,15 +1634,6 @@ trace_function(struct trace_array *tr,
                 __buffer_unlock_commit(buffer, event);
 }
 
-void
-ftrace(struct trace_array *tr, struct trace_array_cpu *data,
-       unsigned long ip, unsigned long parent_ip, unsigned long flags,
-       int pc)
-{
-        if (likely(!atomic_read(&data->disabled)))
-                trace_function(tr, ip, parent_ip, flags, pc);
-}
-
 #ifdef CONFIG_STACKTRACE
 
 #define FTRACE_STACK_MAX_ENTRIES (PAGE_SIZE / sizeof(unsigned long))
@@ -2760,6 +2842,17 @@ static int s_show(struct seq_file *m, void *v)
         return 0;
 }
 
+/*
+ * Should be used after trace_array_get(), trace_types_lock
+ * ensures that i_cdev was already initialized.
+ */
+static inline int tracing_get_cpu(struct inode *inode)
+{
+        if (inode->i_cdev) /* See trace_create_cpu_file() */
+                return (long)inode->i_cdev - 1;
+        return RING_BUFFER_ALL_CPUS;
+}
+
 static const struct seq_operations tracer_seq_ops = {
         .start          = s_start,
         .next           = s_next,
@@ -2770,8 +2863,7 @@ static const struct seq_operations tracer_seq_ops = {
 static struct trace_iterator *
 __tracing_open(struct inode *inode, struct file *file, bool snapshot)
 {
-        struct trace_cpu *tc = inode->i_private;
-        struct trace_array *tr = tc->tr;
+        struct trace_array *tr = inode->i_private;
         struct trace_iterator *iter;
         int cpu;
 
@@ -2812,8 +2904,8 @@ __tracing_open(struct inode *inode, struct file *file, bool snapshot)
                 iter->trace_buffer = &tr->trace_buffer;
         iter->snapshot = snapshot;
         iter->pos = -1;
+        iter->cpu_file = tracing_get_cpu(inode);
         mutex_init(&iter->mutex);
-        iter->cpu_file = tc->cpu;
 
         /* Notify the tracer early; before we stop tracing. */
         if (iter->trace && iter->trace->open)
@@ -2850,8 +2942,6 @@ __tracing_open(struct inode *inode, struct file *file, bool snapshot)
                 tracing_iter_reset(iter, cpu);
         }
 
-        tr->ref++;
-
         mutex_unlock(&trace_types_lock);
 
         return iter;
@@ -2874,24 +2964,41 @@ int tracing_open_generic(struct inode *inode, struct file *filp)
         return 0;
 }
 
+/*
+ * Open and update trace_array ref count.
+ * Must have the current trace_array passed to it.
+ */
+static int tracing_open_generic_tr(struct inode *inode, struct file *filp)
+{
+        struct trace_array *tr = inode->i_private;
+
+        if (tracing_disabled)
+                return -ENODEV;
+
+        if (trace_array_get(tr) < 0)
+                return -ENODEV;
+
+        filp->private_data = inode->i_private;
+
+        return 0;
+}
+
 static int tracing_release(struct inode *inode, struct file *file)
 {
+        struct trace_array *tr = inode->i_private;
         struct seq_file *m = file->private_data;
         struct trace_iterator *iter;
-        struct trace_array *tr;
         int cpu;
 
-        if (!(file->f_mode & FMODE_READ))
+        if (!(file->f_mode & FMODE_READ)) {
+                trace_array_put(tr);
                 return 0;
+        }
 
+        /* Writes do not use seq_file */
         iter = m->private;
-        tr = iter->tr;
-
         mutex_lock(&trace_types_lock);
 
-        WARN_ON(!tr->ref);
-        tr->ref--;
-
         for_each_tracing_cpu(cpu) {
                 if (iter->buffer_iter[cpu])
                         ring_buffer_read_finish(iter->buffer_iter[cpu]);
@@ -2903,6 +3010,9 @@ static int tracing_release(struct inode *inode, struct file *file)
         if (!iter->snapshot)
                 /* reenable tracing if it was previously enabled */
                 tracing_start_tr(tr);
+
+        __trace_array_put(tr);
+
         mutex_unlock(&trace_types_lock);
 
         mutex_destroy(&iter->mutex);
@@ -2910,24 +3020,44 @@ static int tracing_release(struct inode *inode, struct file *file)
         kfree(iter->trace);
         kfree(iter->buffer_iter);
         seq_release_private(inode, file);
+
+        return 0;
+}
+
+static int tracing_release_generic_tr(struct inode *inode, struct file *file)
+{
+        struct trace_array *tr = inode->i_private;
+
+        trace_array_put(tr);
         return 0;
 }
 
+static int tracing_single_release_tr(struct inode *inode, struct file *file)
+{
+        struct trace_array *tr = inode->i_private;
+
+        trace_array_put(tr);
+
+        return single_release(inode, file);
+}
+
 static int tracing_open(struct inode *inode, struct file *file)
 {
+        struct trace_array *tr = inode->i_private;
         struct trace_iterator *iter;
         int ret = 0;
 
+        if (trace_array_get(tr) < 0)
+                return -ENODEV;
+
         /* If this file was open for write, then erase contents */
-        if ((file->f_mode & FMODE_WRITE) &&
-            (file->f_flags & O_TRUNC)) {
-                struct trace_cpu *tc = inode->i_private;
-                struct trace_array *tr = tc->tr;
+        if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
+                int cpu = tracing_get_cpu(inode);
 
-                if (tc->cpu == RING_BUFFER_ALL_CPUS)
+                if (cpu == RING_BUFFER_ALL_CPUS)
                         tracing_reset_online_cpus(&tr->trace_buffer);
                 else
-                        tracing_reset(&tr->trace_buffer, tc->cpu);
+                        tracing_reset(&tr->trace_buffer, cpu);
         }
 
         if (file->f_mode & FMODE_READ) {
@@ -2937,6 +3067,10 @@ static int tracing_open(struct inode *inode, struct file *file)
                 else if (trace_flags & TRACE_ITER_LATENCY_FMT)
                         iter->iter_flags |= TRACE_FILE_LAT_FMT;
         }
+
+        if (ret < 0)
+                trace_array_put(tr);
+
         return ret;
 }
 
@@ -3293,17 +3427,27 @@ tracing_trace_options_write(struct file *filp, const char __user *ubuf,
 
 static int tracing_trace_options_open(struct inode *inode, struct file *file)
 {
+        struct trace_array *tr = inode->i_private;
+        int ret;
+
         if (tracing_disabled)
                 return -ENODEV;
 
-        return single_open(file, tracing_trace_options_show, inode->i_private);
+        if (trace_array_get(tr) < 0)
+                return -ENODEV;
+
+        ret = single_open(file, tracing_trace_options_show, inode->i_private);
+        if (ret < 0)
+                trace_array_put(tr);
+
+        return ret;
 }
 
 static const struct file_operations tracing_iter_fops = {
         .open           = tracing_trace_options_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
-        .release        = single_release,
+        .release        = tracing_single_release_tr,
         .write          = tracing_trace_options_write,
 };
 
@@ -3379,14 +3523,14 @@ static const char readme_msg[] =
         "\n  snapshot\t\t- Like 'trace' but shows the content of the static snapshot buffer\n"
         "\t\t\t  Read the contents for more information\n"
 #endif
-#ifdef CONFIG_STACKTRACE
+#ifdef CONFIG_STACK_TRACER
         "  stack_trace\t\t- Shows the max stack trace when active\n"
         "  stack_max_size\t- Shows current max stack size that was traced\n"
         "\t\t\t  Write into this file to reset the max size (trigger a new trace)\n"
 #ifdef CONFIG_DYNAMIC_FTRACE
         "  stack_trace_filter\t- Like set_ftrace_filter but limits what stack_trace traces\n"
 #endif
-#endif /* CONFIG_STACKTRACE */
+#endif /* CONFIG_STACK_TRACER */
 ;
 
 static ssize_t
@@ -3783,20 +3927,23 @@ tracing_max_lat_write(struct file *filp, const char __user *ubuf,
 
 static int tracing_open_pipe(struct inode *inode, struct file *filp)
 {
-        struct trace_cpu *tc = inode->i_private;
-        struct trace_array *tr = tc->tr;
+        struct trace_array *tr = inode->i_private;
         struct trace_iterator *iter;
         int ret = 0;
 
         if (tracing_disabled)
                 return -ENODEV;
 
+        if (trace_array_get(tr) < 0)
+                return -ENODEV;
+
         mutex_lock(&trace_types_lock);
 
         /* create a buffer to store the information to pass to userspace */
         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
         if (!iter) {
                 ret = -ENOMEM;
+                __trace_array_put(tr);
                 goto out;
         }
 
@@ -3826,9 +3973,9 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
         if (trace_clocks[tr->clock_id].in_ns)
                 iter->iter_flags |= TRACE_FILE_TIME_IN_NS;
 
-        iter->cpu_file = tc->cpu;
-        iter->tr = tc->tr;
-        iter->trace_buffer = &tc->tr->trace_buffer;
+        iter->tr = tr;
+        iter->trace_buffer = &tr->trace_buffer;
+        iter->cpu_file = tracing_get_cpu(inode);
         mutex_init(&iter->mutex);
         filp->private_data = iter;
 
@@ -3843,6 +3990,7 @@ out:
 fail:
         kfree(iter->trace);
         kfree(iter);
+        __trace_array_put(tr);
         mutex_unlock(&trace_types_lock);
         return ret;
 }
@@ -3850,6 +3998,7 @@ fail:
 static int tracing_release_pipe(struct inode *inode, struct file *file)
 {
         struct trace_iterator *iter = file->private_data;
+        struct trace_array *tr = inode->i_private;
 
         mutex_lock(&trace_types_lock);
 
@@ -3863,6 +4012,8 @@ static int tracing_release_pipe(struct inode *inode, struct file *file)
         kfree(iter->trace);
         kfree(iter);
 
+        trace_array_put(tr);
+
         return 0;
 }
 
@@ -3939,7 +4090,7 @@ static int tracing_wait_pipe(struct file *filp)
                  *
                  * iter->pos will be 0 if we haven't read anything.
                  */
-                if (!tracing_is_enabled() && iter->pos)
+                if (!tracing_is_on() && iter->pos)
                         break;
         }
 
@@ -4000,6 +4151,7 @@ waitagain:
         memset(&iter->seq, 0,
                sizeof(struct trace_iterator) -
                offsetof(struct trace_iterator, seq));
+        cpumask_clear(iter->started);
         iter->pos = -1;
 
         trace_event_read_lock();
@@ -4200,15 +4352,16 @@ static ssize_t
 tracing_entries_read(struct file *filp, char __user *ubuf,
                      size_t cnt, loff_t *ppos)
 {
-        struct trace_cpu *tc = filp->private_data;
-        struct trace_array *tr = tc->tr;
+        struct inode *inode = file_inode(filp);
+        struct trace_array *tr = inode->i_private;
+        int cpu = tracing_get_cpu(inode);
         char buf[64];
         int r = 0;
         ssize_t ret;
 
         mutex_lock(&trace_types_lock);
 
-        if (tc->cpu == RING_BUFFER_ALL_CPUS) {
+        if (cpu == RING_BUFFER_ALL_CPUS) {
                 int cpu, buf_size_same;
                 unsigned long size;
 
@@ -4235,7 +4388,7 @@ tracing_entries_read(struct file *filp, char __user *ubuf,
                 } else
                         r = sprintf(buf, "X\n");
         } else
-                r = sprintf(buf, "%lu\n", per_cpu_ptr(tr->trace_buffer.data, tc->cpu)->entries >> 10);
+                r = sprintf(buf, "%lu\n", per_cpu_ptr(tr->trace_buffer.data, cpu)->entries >> 10);
 
         mutex_unlock(&trace_types_lock);
 
@@ -4247,7 +4400,8 @@ static ssize_t
 tracing_entries_write(struct file *filp, const char __user *ubuf,
                       size_t cnt, loff_t *ppos)
 {
-        struct trace_cpu *tc = filp->private_data;
+        struct inode *inode = file_inode(filp);
+        struct trace_array *tr = inode->i_private;
         unsigned long val;
         int ret;
 
@@ -4261,8 +4415,7 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
 
         /* value is in KB */
         val <<= 10;
-
-        ret = tracing_resize_ring_buffer(tc->tr, val, tc->cpu);
+        ret = tracing_resize_ring_buffer(tr, val, tracing_get_cpu(inode));
         if (ret < 0)
                 return ret;
 
@@ -4316,10 +4469,12 @@ tracing_free_buffer_release(struct inode *inode, struct file *filp)
 
         /* disable tracing ? */
         if (trace_flags & TRACE_ITER_STOP_ON_FREE)
-                tracing_off();
+                tracer_tracing_off(tr);
         /* resize the ring buffer to 0 */
         tracing_resize_ring_buffer(tr, 0, RING_BUFFER_ALL_CPUS);
 
+        trace_array_put(tr);
+
         return 0;
 }
 
@@ -4328,6 +4483,7 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
                                         size_t cnt, loff_t *fpos)
 {
         unsigned long addr = (unsigned long)ubuf;
+        struct trace_array *tr = filp->private_data;
         struct ring_buffer_event *event;
         struct ring_buffer *buffer;
         struct print_entry *entry;
@@ -4387,7 +4543,7 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
 
         local_save_flags(irq_flags);
         size = sizeof(*entry) + cnt + 2; /* possible \n added */
-        buffer = global_trace.trace_buffer.buffer;
+        buffer = tr->trace_buffer.buffer;
         event = trace_buffer_lock_reserve(buffer, TRACE_PRINT, size,
                                           irq_flags, preempt_count());
         if (!event) {
@@ -4478,12 +4634,12 @@ static ssize_t tracing_clock_write(struct file *filp, const char __user *ubuf,
          * New clock may not be consistent with the previous clock.
          * Reset the buffer so that it doesn't have incomparable timestamps.
          */
-        tracing_reset_online_cpus(&global_trace.trace_buffer);
+        tracing_reset_online_cpus(&tr->trace_buffer);
 
 #ifdef CONFIG_TRACER_MAX_TRACE
         if (tr->flags & TRACE_ARRAY_FL_GLOBAL && tr->max_buffer.buffer)
                 ring_buffer_set_clock(tr->max_buffer.buffer, trace_clocks[i].func);
-        tracing_reset_online_cpus(&global_trace.max_buffer);
+        tracing_reset_online_cpus(&tr->max_buffer);
 #endif
 
         mutex_unlock(&trace_types_lock);
@@ -4495,10 +4651,20 @@ static ssize_t tracing_clock_write(struct file *filp, const char __user *ubuf,
 
 static int tracing_clock_open(struct inode *inode, struct file *file)
 {
+        struct trace_array *tr = inode->i_private;
+        int ret;
+
         if (tracing_disabled)
                 return -ENODEV;
 
-        return single_open(file, tracing_clock_show, inode->i_private);
+        if (trace_array_get(tr))
+                return -ENODEV;
+
+        ret = single_open(file, tracing_clock_show, inode->i_private);
+        if (ret < 0)
+                trace_array_put(tr);
+
+        return ret;
 }
 
 struct ftrace_buffer_info {
@@ -4510,31 +4676,40 @@ struct ftrace_buffer_info {
 #ifdef CONFIG_TRACER_SNAPSHOT
 static int tracing_snapshot_open(struct inode *inode, struct file *file)
 {
-        struct trace_cpu *tc = inode->i_private;
+        struct trace_array *tr = inode->i_private;
         struct trace_iterator *iter;
         struct seq_file *m;
         int ret = 0;
 
+        if (trace_array_get(tr) < 0)
+                return -ENODEV;
+
         if (file->f_mode & FMODE_READ) {
                 iter = __tracing_open(inode, file, true);
                 if (IS_ERR(iter))
                         ret = PTR_ERR(iter);
         } else {
                 /* Writes still need the seq_file to hold the private data */
+                ret = -ENOMEM;
                 m = kzalloc(sizeof(*m), GFP_KERNEL);
                 if (!m)
-                        return -ENOMEM;
+                        goto out;
                 iter = kzalloc(sizeof(*iter), GFP_KERNEL);
                 if (!iter) {
                         kfree(m);
-                        return -ENOMEM;
+                        goto out;
                 }
-                iter->tr = tc->tr;
-                iter->trace_buffer = &tc->tr->max_buffer;
-                iter->cpu_file = tc->cpu;
+                ret = 0;
+
+                iter->tr = tr;
+                iter->trace_buffer = &tr->max_buffer;
+                iter->cpu_file = tracing_get_cpu(inode);
                 m->private = iter;
                 file->private_data = m;
         }
+out:
+        if (ret < 0)
+                trace_array_put(tr);
 
         return ret;
 }
@@ -4616,9 +4791,12 @@ out:
 static int tracing_snapshot_release(struct inode *inode, struct file *file)
 {
         struct seq_file *m = file->private_data;
+        int ret;
+
+        ret = tracing_release(inode, file);
 
         if (file->f_mode & FMODE_READ)
-                return tracing_release(inode, file);
+                return ret;
 
         /* If write only, the seq_file is just a stub */
         if (m)
@@ -4684,34 +4862,38 @@ static const struct file_operations tracing_pipe_fops = {
 };
 
 static const struct file_operations tracing_entries_fops = {
-        .open           = tracing_open_generic,
+        .open           = tracing_open_generic_tr,
         .read           = tracing_entries_read,
         .write          = tracing_entries_write,
         .llseek         = generic_file_llseek,
+        .release        = tracing_release_generic_tr,
 };
 
 static const struct file_operations tracing_total_entries_fops = {
-        .open           = tracing_open_generic,
+        .open           = tracing_open_generic_tr,
         .read           = tracing_total_entries_read,
         .llseek         = generic_file_llseek,
+        .release        = tracing_release_generic_tr,
 };
 
 static const struct file_operations tracing_free_buffer_fops = {
+        .open           = tracing_open_generic_tr,
         .write          = tracing_free_buffer_write,
         .release        = tracing_free_buffer_release,
 };
 
 static const struct file_operations tracing_mark_fops = {
-        .open           = tracing_open_generic,
+        .open           = tracing_open_generic_tr,
         .write          = tracing_mark_write,
         .llseek         = generic_file_llseek,
+        .release        = tracing_release_generic_tr,
 };
 
 static const struct file_operations trace_clock_fops = {
         .open           = tracing_clock_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
-        .release        = single_release,
+        .release        = tracing_single_release_tr,
         .write          = tracing_clock_write,
 };
 
@@ -4736,23 +4918,26 @@ static const struct file_operations snapshot_raw_fops = {
 
 static int tracing_buffers_open(struct inode *inode, struct file *filp)
 {
-        struct trace_cpu *tc = inode->i_private;
-        struct trace_array *tr = tc->tr;
+        struct trace_array *tr = inode->i_private;
         struct ftrace_buffer_info *info;
+        int ret;
 
         if (tracing_disabled)
                 return -ENODEV;
 
+        if (trace_array_get(tr) < 0)
+                return -ENODEV;
+
         info = kzalloc(sizeof(*info), GFP_KERNEL);
-        if (!info)
+        if (!info) {
+                trace_array_put(tr);
                 return -ENOMEM;
+        }
 
         mutex_lock(&trace_types_lock);
 
-        tr->ref++;
-
         info->iter.tr           = tr;
-        info->iter.cpu_file     = tc->cpu;
+        info->iter.cpu_file     = tracing_get_cpu(inode);
         info->iter.trace        = tr->current_trace;
         info->iter.trace_buffer = &tr->trace_buffer;
         info->spare             = NULL;
@@ -4763,7 +4948,11 @@ static int tracing_buffers_open(struct inode *inode, struct file *filp)
 
         mutex_unlock(&trace_types_lock);
 
-        return nonseekable_open(inode, filp);
+        ret = nonseekable_open(inode, filp);
+        if (ret < 0)
+                trace_array_put(tr);
+
+        return ret;
 }
 
 static unsigned int
@@ -4863,8 +5052,7 @@ static int tracing_buffers_release(struct inode *inode, struct file *file)
 
         mutex_lock(&trace_types_lock);
 
-        WARN_ON(!iter->tr->ref);
-        iter->tr->ref--;
+        __trace_array_put(iter->tr);
 
         if (info->spare)
                 ring_buffer_free_read_page(iter->trace_buffer->buffer, info->spare);
@@ -5066,14 +5254,14 @@ static ssize_t
 tracing_stats_read(struct file *filp, char __user *ubuf,
                    size_t count, loff_t *ppos)
 {
-        struct trace_cpu *tc = filp->private_data;
-        struct trace_array *tr = tc->tr;
+        struct inode *inode = file_inode(filp);
+        struct trace_array *tr = inode->i_private;
         struct trace_buffer *trace_buf = &tr->trace_buffer;
+        int cpu = tracing_get_cpu(inode);
         struct trace_seq *s;
         unsigned long cnt;
         unsigned long long t;
         unsigned long usec_rem;
-        int cpu = tc->cpu;
 
         s = kmalloc(sizeof(*s), GFP_KERNEL);
         if (!s)
@@ -5126,9 +5314,10 @@ tracing_stats_read(struct file *filp, char __user *ubuf,
 }
 
 static const struct file_operations tracing_stats_fops = {
-        .open           = tracing_open_generic,
+        .open           = tracing_open_generic_tr,
         .read           = tracing_stats_read,
         .llseek         = generic_file_llseek,
+        .release        = tracing_release_generic_tr,
 };
 
 #ifdef CONFIG_DYNAMIC_FTRACE
@@ -5317,10 +5506,20 @@ static struct dentry *tracing_dentry_percpu(struct trace_array *tr, int cpu)
         return tr->percpu_dir;
 }
 
+static struct dentry *
+trace_create_cpu_file(const char *name, umode_t mode, struct dentry *parent,
+                      void *data, long cpu, const struct file_operations *fops)
+{
+        struct dentry *ret = trace_create_file(name, mode, parent, data, fops);
+
+        if (ret) /* See tracing_get_cpu() */
+                ret->d_inode->i_cdev = (void *)(cpu + 1);
+        return ret;
+}
+
 static void
 tracing_init_debugfs_percpu(struct trace_array *tr, long cpu)
 {
-        struct trace_array_cpu *data = per_cpu_ptr(tr->trace_buffer.data, cpu);
         struct dentry *d_percpu = tracing_dentry_percpu(tr, cpu);
         struct dentry *d_cpu;
         char cpu_dir[30]; /* 30 characters should be more than enough */
@@ -5336,28 +5535,28 @@ tracing_init_debugfs_percpu(struct trace_array *tr, long cpu)
         }
 
         /* per cpu trace_pipe */
-        trace_create_file("trace_pipe", 0444, d_cpu,
-                        (void *)&data->trace_cpu, &tracing_pipe_fops);
+        trace_create_cpu_file("trace_pipe", 0444, d_cpu,
+                                tr, cpu, &tracing_pipe_fops);
 
         /* per cpu trace */
-        trace_create_file("trace", 0644, d_cpu,
-                        (void *)&data->trace_cpu, &tracing_fops);
+        trace_create_cpu_file("trace", 0644, d_cpu,
+                                tr, cpu, &tracing_fops);
 
-        trace_create_file("trace_pipe_raw", 0444, d_cpu,
-                        (void *)&data->trace_cpu, &tracing_buffers_fops);
+        trace_create_cpu_file("trace_pipe_raw", 0444, d_cpu,
+                                tr, cpu, &tracing_buffers_fops);
 
-        trace_create_file("stats", 0444, d_cpu,
-                        (void *)&data->trace_cpu, &tracing_stats_fops);
+        trace_create_cpu_file("stats", 0444, d_cpu,
+                                tr, cpu, &tracing_stats_fops);
 
-        trace_create_file("buffer_size_kb", 0444, d_cpu,
-                        (void *)&data->trace_cpu, &tracing_entries_fops);
+        trace_create_cpu_file("buffer_size_kb", 0444, d_cpu,
+                                tr, cpu, &tracing_entries_fops);
 
 #ifdef CONFIG_TRACER_SNAPSHOT
-        trace_create_file("snapshot", 0644, d_cpu,
-                          (void *)&data->trace_cpu, &snapshot_fops);
+        trace_create_cpu_file("snapshot", 0644, d_cpu,
+                                tr, cpu, &snapshot_fops);
 
-        trace_create_file("snapshot_raw", 0444, d_cpu,
-                        (void *)&data->trace_cpu, &snapshot_raw_fops);
+        trace_create_cpu_file("snapshot_raw", 0444, d_cpu,
+                                tr, cpu, &snapshot_raw_fops);
 #endif
 }
 
@@ -5612,15 +5811,10 @@ rb_simple_read(struct file *filp, char __user *ubuf,
                size_t cnt, loff_t *ppos)
 {
         struct trace_array *tr = filp->private_data;
-        struct ring_buffer *buffer = tr->trace_buffer.buffer;
         char buf[64];
         int r;
 
-        if (buffer)
-                r = ring_buffer_record_is_on(buffer);
-        else
-                r = 0;
-
+        r = tracer_tracing_is_on(tr);
         r = sprintf(buf, "%d\n", r);
 
         return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
@@ -5642,11 +5836,11 @@ rb_simple_write(struct file *filp, const char __user *ubuf,
         if (buffer) {
                 mutex_lock(&trace_types_lock);
                 if (val) {
-                        ring_buffer_record_on(buffer);
+                        tracer_tracing_on(tr);
                         if (tr->current_trace->start)
                                 tr->current_trace->start(tr);
                 } else {
-                        ring_buffer_record_off(buffer);
+                        tracer_tracing_off(tr);
                         if (tr->current_trace->stop)
                                 tr->current_trace->stop(tr);
                 }
@@ -5659,9 +5853,10 @@ rb_simple_write(struct file *filp, const char __user *ubuf,
 }
 
 static const struct file_operations rb_simple_fops = {
-        .open           = tracing_open_generic,
+        .open           = tracing_open_generic_tr,
         .read           = rb_simple_read,
         .write          = rb_simple_write,
+        .release        = tracing_release_generic_tr,
         .llseek         = default_llseek,
 };
 
@@ -5670,17 +5865,6 @@ struct dentry *trace_instance_dir;
 static void
 init_tracer_debugfs(struct trace_array *tr, struct dentry *d_tracer);
 
-static void init_trace_buffers(struct trace_array *tr, struct trace_buffer *buf)
-{
-        int cpu;
-
-        for_each_tracing_cpu(cpu) {
-                memset(per_cpu_ptr(buf->data, cpu), 0, sizeof(struct trace_array_cpu));
-                per_cpu_ptr(buf->data, cpu)->trace_cpu.cpu = cpu;
-                per_cpu_ptr(buf->data, cpu)->trace_cpu.tr = tr;
-        }
-}
-
 static int
 allocate_trace_buffer(struct trace_array *tr, struct trace_buffer *buf, int size)
 {
@@ -5698,8 +5882,6 @@ allocate_trace_buffer(struct trace_array *tr, struct trace_buffer *buf, int size
                 return -ENOMEM;
         }
 
-        init_trace_buffers(tr, buf);
-
         /* Allocate the first page for all buffers */
         set_buffer_entries(&tr->trace_buffer,
                            ring_buffer_size(tr->trace_buffer.buffer, 0));
@@ -5766,17 +5948,15 @@ static int new_instance_create(const char *name)
         if (allocate_trace_buffers(tr, trace_buf_size) < 0)
                 goto out_free_tr;
 
-        /* Holder for file callbacks */
-        tr->trace_cpu.cpu = RING_BUFFER_ALL_CPUS;
-        tr->trace_cpu.tr = tr;
-
         tr->dir = debugfs_create_dir(name, trace_instance_dir);
         if (!tr->dir)
                 goto out_free_tr;
 
         ret = event_trace_add_tracer(tr->dir, tr);
-        if (ret)
+        if (ret) {
+                debugfs_remove_recursive(tr->dir);
                 goto out_free_tr;
+        }
 
         init_tracer_debugfs(tr, tr->dir);
 
@@ -5922,18 +6102,18 @@ init_tracer_debugfs(struct trace_array *tr, struct dentry *d_tracer)
                           tr, &tracing_iter_fops);
 
         trace_create_file("trace", 0644, d_tracer,
-                        (void *)&tr->trace_cpu, &tracing_fops);
+                          tr, &tracing_fops);
 
         trace_create_file("trace_pipe", 0444, d_tracer,
-                        (void *)&tr->trace_cpu, &tracing_pipe_fops);
+                          tr, &tracing_pipe_fops);
 
         trace_create_file("buffer_size_kb", 0644, d_tracer,
-                        (void *)&tr->trace_cpu, &tracing_entries_fops);
+                          tr, &tracing_entries_fops);
 
         trace_create_file("buffer_total_size_kb", 0444, d_tracer,
                           tr, &tracing_total_entries_fops);
 
-        trace_create_file("free_buffer", 0644, d_tracer,
+        trace_create_file("free_buffer", 0200, d_tracer,
                           tr, &tracing_free_buffer_fops);
 
         trace_create_file("trace_marker", 0220, d_tracer,
@@ -5943,11 +6123,11 @@ init_tracer_debugfs(struct trace_array *tr, struct dentry *d_tracer)
                           &trace_clock_fops);
 
         trace_create_file("tracing_on", 0644, d_tracer,
-                            tr, &rb_simple_fops);
+                          tr, &rb_simple_fops);
 
 #ifdef CONFIG_TRACER_SNAPSHOT
         trace_create_file("snapshot", 0644, d_tracer,
-                          (void *)&tr->trace_cpu, &snapshot_fops);
+                          tr, &snapshot_fops);
 #endif
 
         for_each_tracing_cpu(cpu)
@@ -6241,10 +6421,6 @@ __init static int tracer_alloc_buffers(void)
 
         global_trace.flags = TRACE_ARRAY_FL_GLOBAL;
 
-        /* Holder for file callbacks */
-        global_trace.trace_cpu.cpu = RING_BUFFER_ALL_CPUS;
-        global_trace.trace_cpu.tr = &global_trace;
-
         INIT_LIST_HEAD(&global_trace.systems);
         INIT_LIST_HEAD(&global_trace.events);
         list_add(&global_trace.list, &ftrace_trace_arrays);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 20572ed88c5c..afaae41b0a02 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -130,19 +130,12 @@ enum trace_flag_type {
 
 struct trace_array;
 
-struct trace_cpu {
-        struct trace_array      *tr;
-        struct dentry           *dir;
-        int                     cpu;
-};
-
 /*
  * The CPU trace array - it consists of thousands of trace entries
  * plus some other descriptor data: (for example which task started
  * the trace, etc.)
  */
 struct trace_array_cpu {
-        struct trace_cpu        trace_cpu;
         atomic_t                disabled;
         void                    *buffer_page;   /* ring buffer spare */
 
@@ -196,7 +189,6 @@ struct trace_array {
         bool                    allocated_snapshot;
 #endif
         int                     buffer_disabled;
-        struct trace_cpu        trace_cpu;      /* place holder */
 #ifdef CONFIG_FTRACE_SYSCALLS
         int                     sys_refcount_enter;
         int                     sys_refcount_exit;
@@ -214,7 +206,6 @@ struct trace_array {
         struct dentry           *event_dir;
         struct list_head        systems;
         struct list_head        events;
-        struct task_struct      *waiter;
         int                     ref;
 };
 
@@ -224,6 +215,11 @@ enum {
 
 extern struct list_head ftrace_trace_arrays;
 
+extern struct mutex trace_types_lock;
+
+extern int trace_array_get(struct trace_array *tr);
+extern void trace_array_put(struct trace_array *tr);
+
 /*
  * The global tracer (top) should be the first trace array added,
  * but we check the flag anyway.
@@ -554,11 +550,6 @@ void tracing_iter_reset(struct trace_iterator *iter, int cpu);
 
 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 task_struct *prev,
                                 struct task_struct *next,
@@ -680,6 +671,15 @@ extern int trace_selftest_startup_sched_switch(struct tracer *trace,
                                                struct trace_array *tr);
 extern int trace_selftest_startup_branch(struct tracer *trace,
                                          struct trace_array *tr);
+/*
+ * Tracer data references selftest functions that only occur
+ * on boot up. These can be __init functions. Thus, when selftests
+ * are enabled, then the tracers need to reference __init functions.
+ */
+#define __tracer_data           __refdata
+#else
+/* Tracers are seldom changed. Optimize when selftests are disabled. */
+#define __tracer_data           __read_mostly
 #endif /* CONFIG_FTRACE_STARTUP_TEST */
 
 extern void *head_page(struct trace_array_cpu *data);
@@ -774,6 +774,7 @@ print_graph_function_flags(struct trace_iterator *iter, u32 flags)
 extern struct list_head ftrace_pids;
 
 #ifdef CONFIG_FUNCTION_TRACER
+extern bool ftrace_filter_param __initdata;
 static inline int ftrace_trace_task(struct task_struct *task)
 {
         if (list_empty(&ftrace_pids))
@@ -899,12 +900,6 @@ static inline void trace_branch_disable(void)
 /* 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_field {
         struct list_head        link;
         const char              *name;
diff --git a/kernel/trace/trace_event_perf.c b/kernel/trace/trace_event_perf.c
index 84b1e045faba..80c36bcf66e8 100644
--- a/kernel/trace/trace_event_perf.c
+++ b/kernel/trace/trace_event_perf.c
@@ -236,6 +236,10 @@ __kprobes void *perf_trace_buf_prepare(int size, unsigned short type,
 
         BUILD_BUG_ON(PERF_MAX_TRACE_SIZE % sizeof(unsigned long));
 
+        if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
+                        "perf buffer not large enough"))
+                return NULL;
+
         pc = preempt_count();
 
         *rctxp = perf_swevent_get_recursion_context();
@@ -266,6 +270,10 @@ perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip,
         struct pt_regs regs;
         int rctx;
 
+        head = this_cpu_ptr(event_function.perf_events);
+        if (hlist_empty(head))
+                return;
+
 #define ENTRY_SIZE (ALIGN(sizeof(struct ftrace_entry) + sizeof(u32), \
                     sizeof(u64)) - sizeof(u32))
 
@@ -279,8 +287,6 @@ perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip,
 
         entry->ip = ip;
         entry->parent_ip = parent_ip;
-
-        head = this_cpu_ptr(event_function.perf_events);
         perf_trace_buf_submit(entry, ENTRY_SIZE, rctx, 0,
                               1, &regs, head, NULL);
 
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index 27963e2bf4bf..29a7ebcfb426 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -41,6 +41,23 @@ static LIST_HEAD(ftrace_common_fields);
 static struct kmem_cache *field_cachep;
 static struct kmem_cache *file_cachep;
 
+#define SYSTEM_FL_FREE_NAME             (1 << 31)
+
+static inline int system_refcount(struct event_subsystem *system)
+{
+        return system->ref_count & ~SYSTEM_FL_FREE_NAME;
+}
+
+static int system_refcount_inc(struct event_subsystem *system)
+{
+        return (system->ref_count++) & ~SYSTEM_FL_FREE_NAME;
+}
+
+static int system_refcount_dec(struct event_subsystem *system)
+{
+        return (--system->ref_count) & ~SYSTEM_FL_FREE_NAME;
+}
+
 /* Double loops, do not use break, only goto's work */
 #define do_for_each_event_file(tr, file)                        \
         list_for_each_entry(tr, &ftrace_trace_arrays, list) {   \
@@ -97,7 +114,7 @@ static int __trace_define_field(struct list_head *head, const char *type,
 
         field = kmem_cache_alloc(field_cachep, GFP_TRACE);
         if (!field)
-                goto err;
+                return -ENOMEM;
 
         field->name = name;
         field->type = type;
@@ -114,11 +131,6 @@ static int __trace_define_field(struct list_head *head, const char *type,
         list_add(&field->link, head);
 
         return 0;
-
-err:
-        kmem_cache_free(field_cachep, field);
-
-        return -ENOMEM;
 }
 
 int trace_define_field(struct ftrace_event_call *call, const char *type,
@@ -279,9 +291,11 @@ static int __ftrace_event_enable_disable(struct ftrace_event_file *file,
                         }
                         call->class->reg(call, TRACE_REG_UNREGISTER, file);
                 }
-                /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT */
+                /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */
                 if (file->flags & FTRACE_EVENT_FL_SOFT_MODE)
                         set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);
+                else
+                        clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);
                 break;
         case 1:
                 /*
@@ -349,8 +363,8 @@ static void __put_system(struct event_subsystem *system)
 {
         struct event_filter *filter = system->filter;
 
-        WARN_ON_ONCE(system->ref_count == 0);
-        if (--system->ref_count)
+        WARN_ON_ONCE(system_refcount(system) == 0);
+        if (system_refcount_dec(system))
                 return;
 
         list_del(&system->list);
@@ -359,13 +373,15 @@ static void __put_system(struct event_subsystem *system)
                 kfree(filter->filter_string);
                 kfree(filter);
         }
+        if (system->ref_count & SYSTEM_FL_FREE_NAME)
+                kfree(system->name);
         kfree(system);
 }
 
 static void __get_system(struct event_subsystem *system)
 {
-        WARN_ON_ONCE(system->ref_count == 0);
-        system->ref_count++;
+        WARN_ON_ONCE(system_refcount(system) == 0);
+        system_refcount_inc(system);
 }
 
 static void __get_system_dir(struct ftrace_subsystem_dir *dir)
@@ -379,7 +395,7 @@ static void __put_system_dir(struct ftrace_subsystem_dir *dir)
 {
         WARN_ON_ONCE(dir->ref_count == 0);
         /* If the subsystem is about to be freed, the dir must be too */
-        WARN_ON_ONCE(dir->subsystem->ref_count == 1 && dir->ref_count != 1);
+        WARN_ON_ONCE(system_refcount(dir->subsystem) == 1 && dir->ref_count != 1);
 
         __put_system(dir->subsystem);
         if (!--dir->ref_count)
@@ -393,17 +409,55 @@ static void put_system(struct ftrace_subsystem_dir *dir)
         mutex_unlock(&event_mutex);
 }
 
+static void remove_subsystem(struct ftrace_subsystem_dir *dir)
+{
+        if (!dir)
+                return;
+
+        if (!--dir->nr_events) {
+                debugfs_remove_recursive(dir->entry);
+                list_del(&dir->list);
+                __put_system_dir(dir);
+        }
+}
+
+static void *event_file_data(struct file *filp)
+{
+        return ACCESS_ONCE(file_inode(filp)->i_private);
+}
+
+static void remove_event_file_dir(struct ftrace_event_file *file)
+{
+        struct dentry *dir = file->dir;
+        struct dentry *child;
+
+        if (dir) {
+                spin_lock(&dir->d_lock);        /* probably unneeded */
+                list_for_each_entry(child, &dir->d_subdirs, d_u.d_child) {
+                        if (child->d_inode)     /* probably unneeded */
+                                child->d_inode->i_private = NULL;
+                }
+                spin_unlock(&dir->d_lock);
+
+                debugfs_remove_recursive(dir);
+        }
+
+        list_del(&file->list);
+        remove_subsystem(file->system);
+        kmem_cache_free(file_cachep, file);
+}
+
 /*
  * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
  */
-static int __ftrace_set_clr_event(struct trace_array *tr, const char *match,
-                                  const char *sub, const char *event, int set)
+static int
+__ftrace_set_clr_event_nolock(struct trace_array *tr, const char *match,
+                              const char *sub, const char *event, int set)
 {
         struct ftrace_event_file *file;
         struct ftrace_event_call *call;
         int ret = -EINVAL;
 
-        mutex_lock(&event_mutex);
         list_for_each_entry(file, &tr->events, list) {
 
                 call = file->event_call;
@@ -429,6 +483,17 @@ static int __ftrace_set_clr_event(struct trace_array *tr, const char *match,
 
                 ret = 0;
         }
+
+        return ret;
+}
+
+static int __ftrace_set_clr_event(struct trace_array *tr, const char *match,
+                                  const char *sub, const char *event, int set)
+{
+        int ret;
+
+        mutex_lock(&event_mutex);
+        ret = __ftrace_set_clr_event_nolock(tr, match, sub, event, set);
         mutex_unlock(&event_mutex);
 
         return ret;
@@ -623,18 +688,28 @@ static ssize_t
 event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
                   loff_t *ppos)
 {
-        struct ftrace_event_file *file = filp->private_data;
-        char *buf;
+        struct ftrace_event_file *file;
+        unsigned long flags;
+        char buf[4] = "0";
 
-        if (file->flags & FTRACE_EVENT_FL_ENABLED) {
-                if (file->flags & FTRACE_EVENT_FL_SOFT_DISABLED)
-                        buf = "0*\n";
-                else if (file->flags & FTRACE_EVENT_FL_SOFT_MODE)
-                        buf = "1*\n";
-                else
-                        buf = "1\n";
-        } else
-                buf = "0\n";
+        mutex_lock(&event_mutex);
+        file = event_file_data(filp);
+        if (likely(file))
+                flags = file->flags;
+        mutex_unlock(&event_mutex);
+
+        if (!file)
+                return -ENODEV;
+
+        if (flags & FTRACE_EVENT_FL_ENABLED &&
+            !(flags & FTRACE_EVENT_FL_SOFT_DISABLED))
+                strcpy(buf, "1");
+
+        if (flags & FTRACE_EVENT_FL_SOFT_DISABLED ||
+            flags & FTRACE_EVENT_FL_SOFT_MODE)
+                strcat(buf, "*");
+
+        strcat(buf, "\n");
 
         return simple_read_from_buffer(ubuf, cnt, ppos, buf, strlen(buf));
 }
@@ -643,13 +718,10 @@ static ssize_t
 event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
                    loff_t *ppos)
 {
-        struct ftrace_event_file *file = filp->private_data;
+        struct ftrace_event_file *file;
         unsigned long val;
         int ret;
 
-        if (!file)
-                return -EINVAL;
-
         ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
         if (ret)
                 return ret;
@@ -661,8 +733,11 @@ event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
         switch (val) {
         case 0:
         case 1:
+                ret = -ENODEV;
                 mutex_lock(&event_mutex);
-                ret = ftrace_event_enable_disable(file, val);
+                file = event_file_data(filp);
+                if (likely(file))
+                        ret = ftrace_event_enable_disable(file, val);
                 mutex_unlock(&event_mutex);
                 break;
 
@@ -769,65 +844,39 @@ enum {
 
 static void *f_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        struct ftrace_event_call *call = m->private;
-        struct ftrace_event_field *field;
+        struct ftrace_event_call *call = event_file_data(m->private);
         struct list_head *common_head = &ftrace_common_fields;
         struct list_head *head = trace_get_fields(call);
+        struct list_head *node = v;
 
         (*pos)++;
 
         switch ((unsigned long)v) {
         case FORMAT_HEADER:
-                if (unlikely(list_empty(common_head)))
-                        return NULL;
-
-                field = list_entry(common_head->prev,
-                                   struct ftrace_event_field, link);
-                return field;
+                node = common_head;
+                break;
 
         case FORMAT_FIELD_SEPERATOR:
-                if (unlikely(list_empty(head)))
-                        return NULL;
-
-                field = list_entry(head->prev, struct ftrace_event_field, link);
-                return field;
+                node = head;
+                break;
 
         case FORMAT_PRINTFMT:
                 /* all done */
                 return NULL;
         }
 
-        field = v;
-        if (field->link.prev == common_head)
+        node = node->prev;
+        if (node == common_head)
                 return (void *)FORMAT_FIELD_SEPERATOR;
-        else if (field->link.prev == head)
+        else if (node == head)
                 return (void *)FORMAT_PRINTFMT;
-
-        field = list_entry(field->link.prev, struct ftrace_event_field, link);
-
-        return field;
-}
-
-static void *f_start(struct seq_file *m, loff_t *pos)
-{
-        loff_t l = 0;
-        void *p;
-
-        /* Start by showing the header */
-        if (!*pos)
-                return (void *)FORMAT_HEADER;
-
-        p = (void *)FORMAT_HEADER;
-        do {
-                p = f_next(m, p, &l);
-        } while (p && l < *pos);
-
-        return p;
+        else
+                return node;
 }
 
 static int f_show(struct seq_file *m, void *v)
 {
-        struct ftrace_event_call *call = m->private;
+        struct ftrace_event_call *call = event_file_data(m->private);
         struct ftrace_event_field *field;
         const char *array_descriptor;
 
@@ -848,8 +897,7 @@ static int f_show(struct seq_file *m, void *v)
                 return 0;
         }
 
-        field = v;
-
+        field = list_entry(v, struct ftrace_event_field, link);
         /*
          * Smartly shows the array type(except dynamic array).
          * Normal:
@@ -876,8 +924,25 @@ static int f_show(struct seq_file *m, void *v)
         return 0;
 }
 
+static void *f_start(struct seq_file *m, loff_t *pos)
+{
+        void *p = (void *)FORMAT_HEADER;
+        loff_t l = 0;
+
+        /* ->stop() is called even if ->start() fails */
+        mutex_lock(&event_mutex);
+        if (!event_file_data(m->private))
+                return ERR_PTR(-ENODEV);
+
+        while (l < *pos && p)
+                p = f_next(m, p, &l);
+
+        return p;
+}
+
 static void f_stop(struct seq_file *m, void *p)
 {
+        mutex_unlock(&event_mutex);
 }
 
 static const struct seq_operations trace_format_seq_ops = {
@@ -889,7 +954,6 @@ static const struct seq_operations trace_format_seq_ops = {
 
 static int trace_format_open(struct inode *inode, struct file *file)
 {
-        struct ftrace_event_call *call = inode->i_private;
         struct seq_file *m;
         int ret;
 
@@ -898,7 +962,7 @@ static int trace_format_open(struct inode *inode, struct file *file)
                 return ret;
 
         m = file->private_data;
-        m->private = call;
+        m->private = file;
 
         return 0;
 }
@@ -906,45 +970,47 @@ static int trace_format_open(struct inode *inode, struct file *file)
 static ssize_t
 event_id_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;
-        int r;
+        int id = (long)event_file_data(filp);
+        char buf[32];
+        int len;
 
         if (*ppos)
                 return 0;
 
-        s = kmalloc(sizeof(*s), GFP_KERNEL);
-        if (!s)
-                return -ENOMEM;
+        if (unlikely(!id))
+                return -ENODEV;
 
-        trace_seq_init(s);
-        trace_seq_printf(s, "%d\n", call->event.type);
+        len = sprintf(buf, "%d\n", id);
 
-        r = simple_read_from_buffer(ubuf, cnt, ppos,
-                                    s->buffer, s->len);
-        kfree(s);
-        return r;
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
 }
 
 static ssize_t
 event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
                   loff_t *ppos)
 {
-        struct ftrace_event_call *call = filp->private_data;
+        struct ftrace_event_call *call;
         struct trace_seq *s;
-        int r;
+        int r = -ENODEV;
 
         if (*ppos)
                 return 0;
 
         s = kmalloc(sizeof(*s), GFP_KERNEL);
+
         if (!s)
                 return -ENOMEM;
 
         trace_seq_init(s);
 
-        print_event_filter(call, s);
-        r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
+        mutex_lock(&event_mutex);
+        call = event_file_data(filp);
+        if (call)
+                print_event_filter(call, s);
+        mutex_unlock(&event_mutex);
+
+        if (call)
+                r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
 
         kfree(s);
 
@@ -955,9 +1021,9 @@ static ssize_t
 event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
                    loff_t *ppos)
 {
-        struct ftrace_event_call *call = filp->private_data;
+        struct ftrace_event_call *call;
         char *buf;
-        int err;
+        int err = -ENODEV;
 
         if (cnt >= PAGE_SIZE)
                 return -EINVAL;
@@ -972,7 +1038,12 @@ event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
         }
         buf[cnt] = '\0';
 
-        err = apply_event_filter(call, buf);
+        mutex_lock(&event_mutex);
+        call = event_file_data(filp);
+        if (call)
+                err = apply_event_filter(call, buf);
+        mutex_unlock(&event_mutex);
+
         free_page((unsigned long) buf);
         if (err < 0)
                 return err;
@@ -992,6 +1063,7 @@ static int subsystem_open(struct inode *inode, struct file *filp)
         int ret;
 
         /* Make sure the system still exists */
+        mutex_lock(&trace_types_lock);
         mutex_lock(&event_mutex);
         list_for_each_entry(tr, &ftrace_trace_arrays, list) {
                 list_for_each_entry(dir, &tr->systems, list) {
@@ -1007,6 +1079,7 @@ static int subsystem_open(struct inode *inode, struct file *filp)
         }
  exit_loop:
         mutex_unlock(&event_mutex);
+        mutex_unlock(&trace_types_lock);
 
         if (!system)
                 return -ENODEV;
@@ -1014,9 +1087,17 @@ static int subsystem_open(struct inode *inode, struct file *filp)
         /* Some versions of gcc think dir can be uninitialized here */
         WARN_ON(!dir);
 
+        /* Still need to increment the ref count of the system */
+        if (trace_array_get(tr) < 0) {
+                put_system(dir);
+                return -ENODEV;
+        }
+
         ret = tracing_open_generic(inode, filp);
-        if (ret < 0)
+        if (ret < 0) {
+                trace_array_put(tr);
                 put_system(dir);
+        }
 
         return ret;
 }
@@ -1027,16 +1108,23 @@ static int system_tr_open(struct inode *inode, struct file *filp)
         struct trace_array *tr = inode->i_private;
         int ret;
 
+        if (trace_array_get(tr) < 0)
+                return -ENODEV;
+
         /* Make a temporary dir that has no system but points to tr */
         dir = kzalloc(sizeof(*dir), GFP_KERNEL);
-        if (!dir)
+        if (!dir) {
+                trace_array_put(tr);
                 return -ENOMEM;
+        }
 
         dir->tr = tr;
 
         ret = tracing_open_generic(inode, filp);
-        if (ret < 0)
+        if (ret < 0) {
+                trace_array_put(tr);
                 kfree(dir);
+        }
 
         filp->private_data = dir;
 
@@ -1047,6 +1135,8 @@ static int subsystem_release(struct inode *inode, struct file *file)
 {
         struct ftrace_subsystem_dir *dir = file->private_data;
 
+        trace_array_put(dir->tr);
+
         /*
          * If dir->subsystem is NULL, then this is a temporary
          * descriptor that was made for a trace_array to enable
@@ -1143,6 +1233,7 @@ show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
 
 static int ftrace_event_avail_open(struct inode *inode, struct file *file);
 static int ftrace_event_set_open(struct inode *inode, struct file *file);
+static int ftrace_event_release(struct inode *inode, struct file *file);
 
 static const struct seq_operations show_event_seq_ops = {
         .start = t_start,
@@ -1170,7 +1261,7 @@ static const struct file_operations ftrace_set_event_fops = {
         .read = seq_read,
         .write = ftrace_event_write,
         .llseek = seq_lseek,
-        .release = seq_release,
+        .release = ftrace_event_release,
 };
 
 static const struct file_operations ftrace_enable_fops = {
@@ -1188,7 +1279,6 @@ static const struct file_operations ftrace_event_format_fops = {
 };
 
 static const struct file_operations ftrace_event_id_fops = {
-        .open = tracing_open_generic,
         .read = event_id_read,
         .llseek = default_llseek,
 };
@@ -1247,6 +1337,15 @@ ftrace_event_open(struct inode *inode, struct file *file,
         return ret;
 }
 
+static int ftrace_event_release(struct inode *inode, struct file *file)
+{
+        struct trace_array *tr = inode->i_private;
+
+        trace_array_put(tr);
+
+        return seq_release(inode, file);
+}
+
 static int
 ftrace_event_avail_open(struct inode *inode, struct file *file)
 {
@@ -1260,12 +1359,19 @@ ftrace_event_set_open(struct inode *inode, struct file *file)
 {
         const struct seq_operations *seq_ops = &show_set_event_seq_ops;
         struct trace_array *tr = inode->i_private;
+        int ret;
+
+        if (trace_array_get(tr) < 0)
+                return -ENODEV;
 
         if ((file->f_mode & FMODE_WRITE) &&
             (file->f_flags & O_TRUNC))
                 ftrace_clear_events(tr);
 
-        return ftrace_event_open(inode, file, seq_ops);
+        ret = ftrace_event_open(inode, file, seq_ops);
+        if (ret < 0)
+                trace_array_put(tr);
+        return ret;
 }
 
 static struct event_subsystem *
@@ -1279,7 +1385,15 @@ create_new_subsystem(const char *name)
                 return NULL;
 
         system->ref_count = 1;
-        system->name = name;
+
+        /* Only allocate if dynamic (kprobes and modules) */
+        if (!core_kernel_data((unsigned long)name)) {
+                system->ref_count |= SYSTEM_FL_FREE_NAME;
+                system->name = kstrdup(name, GFP_KERNEL);
+                if (!system->name)
+                        goto out_free;
+        } else
+                system->name = name;
 
         system->filter = NULL;
 
@@ -1292,6 +1406,8 @@ create_new_subsystem(const char *name)
         return system;
 
  out_free:
+        if (system->ref_count & SYSTEM_FL_FREE_NAME)
+                kfree(system->name);
         kfree(system);
         return NULL;
 }
@@ -1410,8 +1526,8 @@ event_create_dir(struct dentry *parent,
 
 #ifdef CONFIG_PERF_EVENTS
         if (call->event.type && call->class->reg)
-                trace_create_file("id", 0444, file->dir, call,
-                                  id);
+                trace_create_file("id", 0444, file->dir,
+                                  (void *)(long)call->event.type, id);
 #endif
 
         /*
@@ -1436,33 +1552,16 @@ event_create_dir(struct dentry *parent,
         return 0;
 }
 
-static void remove_subsystem(struct ftrace_subsystem_dir *dir)
-{
-        if (!dir)
-                return;
-
-        if (!--dir->nr_events) {
-                debugfs_remove_recursive(dir->entry);
-                list_del(&dir->list);
-                __put_system_dir(dir);
-        }
-}
-
 static void remove_event_from_tracers(struct ftrace_event_call *call)
 {
         struct ftrace_event_file *file;
         struct trace_array *tr;
 
         do_for_each_event_file_safe(tr, file) {
-
                 if (file->event_call != call)
                         continue;
 
-                list_del(&file->list);
-                debugfs_remove_recursive(file->dir);
-                remove_subsystem(file->system);
-                kmem_cache_free(file_cachep, file);
-
+                remove_event_file_dir(file);
                 /*
                  * The do_for_each_event_file_safe() is
                  * a double loop. After finding the call for this
@@ -1591,6 +1690,7 @@ static void __add_event_to_tracers(struct ftrace_event_call *call,
 int trace_add_event_call(struct ftrace_event_call *call)
 {
         int ret;
+        mutex_lock(&trace_types_lock);
         mutex_lock(&event_mutex);
 
         ret = __register_event(call, NULL);
@@ -1598,11 +1698,13 @@ int trace_add_event_call(struct ftrace_event_call *call)
                 __add_event_to_tracers(call, NULL);
 
         mutex_unlock(&event_mutex);
+        mutex_unlock(&trace_types_lock);
         return ret;
 }
 
 /*
- * Must be called under locking both of event_mutex and trace_event_sem.
+ * Must be called under locking of trace_types_lock, event_mutex and
+ * trace_event_sem.
  */
 static void __trace_remove_event_call(struct ftrace_event_call *call)
 {
@@ -1611,14 +1713,53 @@ static void __trace_remove_event_call(struct ftrace_event_call *call)
         destroy_preds(call);
 }
 
+static int probe_remove_event_call(struct ftrace_event_call *call)
+{
+        struct trace_array *tr;
+        struct ftrace_event_file *file;
+
+#ifdef CONFIG_PERF_EVENTS
+        if (call->perf_refcount)
+                return -EBUSY;
+#endif
+        do_for_each_event_file(tr, file) {
+                if (file->event_call != call)
+                        continue;
+                /*
+                 * We can't rely on ftrace_event_enable_disable(enable => 0)
+                 * we are going to do, FTRACE_EVENT_FL_SOFT_MODE can suppress
+                 * TRACE_REG_UNREGISTER.
+                 */
+                if (file->flags & FTRACE_EVENT_FL_ENABLED)
+                        return -EBUSY;
+                /*
+                 * The do_for_each_event_file_safe() is
+                 * a double loop. After finding the call for this
+                 * trace_array, we use break to jump to the next
+                 * trace_array.
+                 */
+                break;
+        } while_for_each_event_file();
+
+        __trace_remove_event_call(call);
+
+        return 0;
+}
+
 /* Remove an event_call */
-void trace_remove_event_call(struct ftrace_event_call *call)
+int trace_remove_event_call(struct ftrace_event_call *call)
 {
+        int ret;
+
+        mutex_lock(&trace_types_lock);
         mutex_lock(&event_mutex);
         down_write(&trace_event_sem);
-        __trace_remove_event_call(call);
+        ret = probe_remove_event_call(call);
         up_write(&trace_event_sem);
         mutex_unlock(&event_mutex);
+        mutex_unlock(&trace_types_lock);
+
+        return ret;
 }
 
 #define for_each_event(event, start, end)                       \
@@ -1762,6 +1903,7 @@ static int trace_module_notify(struct notifier_block *self,
 {
         struct module *mod = data;
 
+        mutex_lock(&trace_types_lock);
         mutex_lock(&event_mutex);
         switch (val) {
         case MODULE_STATE_COMING:
@@ -1772,6 +1914,7 @@ static int trace_module_notify(struct notifier_block *self,
                 break;
         }
         mutex_unlock(&event_mutex);
+        mutex_unlock(&trace_types_lock);
 
         return 0;
 }
@@ -2011,10 +2154,7 @@ event_enable_func(struct ftrace_hash *hash,
         int ret;
 
         /* hash funcs only work with set_ftrace_filter */
-        if (!enabled)
-                return -EINVAL;
-
-        if (!param)
+        if (!enabled || !param)
                 return -EINVAL;
 
         system = strsep(&param, ":");
@@ -2188,12 +2328,8 @@ __trace_remove_event_dirs(struct trace_array *tr)
 {
         struct ftrace_event_file *file, *next;
 
-        list_for_each_entry_safe(file, next, &tr->events, list) {
-                list_del(&file->list);
-                debugfs_remove_recursive(file->dir);
-                remove_subsystem(file->system);
-                kmem_cache_free(file_cachep, file);
-        }
+        list_for_each_entry_safe(file, next, &tr->events, list)
+                remove_event_file_dir(file);
 }
 
 static void
@@ -2329,11 +2465,11 @@ early_event_add_tracer(struct dentry *parent, struct trace_array *tr)
 
 int event_trace_del_tracer(struct trace_array *tr)
 {
-        /* Disable any running events */
-        __ftrace_set_clr_event(tr, NULL, NULL, NULL, 0);
-
         mutex_lock(&event_mutex);
 
+        /* Disable any running events */
+        __ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, 0);
+
         down_write(&trace_event_sem);
         __trace_remove_event_dirs(tr);
         debugfs_remove_recursive(tr->event_dir);
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index e1b653f7e1ca..97daa8cf958d 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -44,6 +44,7 @@ enum filter_op_ids
         OP_LE,
         OP_GT,
         OP_GE,
+        OP_BAND,
         OP_NONE,
         OP_OPEN_PAREN,
 };
@@ -54,6 +55,7 @@ struct filter_op {
         int precedence;
 };
 
+/* Order must be the same as enum filter_op_ids above */
 static struct filter_op filter_ops[] = {
         { OP_OR,        "||",           1 },
         { OP_AND,       "&&",           2 },
@@ -64,6 +66,7 @@ static struct filter_op filter_ops[] = {
         { OP_LE,        "<=",           5 },
         { OP_GT,        ">",            5 },
         { OP_GE,        ">=",           5 },
+        { OP_BAND,      "&",            6 },
         { OP_NONE,      "OP_NONE",      0 },
         { OP_OPEN_PAREN, "(",           0 },
 };
@@ -156,6 +159,9 @@ static int filter_pred_##type(struct filter_pred *pred, void *event)	\
         case OP_GE:                                                     \
                 match = (*addr >= val);                                 \
                 break;                                                  \
+        case OP_BAND:                                                   \
+                match = (*addr & val);                                  \
+                break;                                                  \
         default:                                                        \
                 break;                                                  \
         }                                                               \
@@ -631,17 +637,15 @@ static void append_filter_err(struct filter_parse_state *ps,
         free_page((unsigned long) buf);
 }
 
+/* caller must hold event_mutex */
 void print_event_filter(struct ftrace_event_call *call, struct trace_seq *s)
 {
-        struct event_filter *filter;
+        struct event_filter *filter = call->filter;
 
-        mutex_lock(&event_mutex);
-        filter = call->filter;
         if (filter && filter->filter_string)
                 trace_seq_printf(s, "%s\n", filter->filter_string);
         else
-                trace_seq_printf(s, "none\n");
-        mutex_unlock(&event_mutex);
+                trace_seq_puts(s, "none\n");
 }
 
 void print_subsystem_event_filter(struct event_subsystem *system,
@@ -654,7 +658,7 @@ void print_subsystem_event_filter(struct event_subsystem *system,
         if (filter && filter->filter_string)
                 trace_seq_printf(s, "%s\n", filter->filter_string);
         else
-                trace_seq_printf(s, DEFAULT_SYS_FILTER_MESSAGE "\n");
+                trace_seq_puts(s, DEFAULT_SYS_FILTER_MESSAGE "\n");
         mutex_unlock(&event_mutex);
 }
 
@@ -1835,23 +1839,22 @@ static int create_system_filter(struct event_subsystem *system,
         return err;
 }
 
+/* caller must hold event_mutex */
 int apply_event_filter(struct ftrace_event_call *call, char *filter_string)
 {
         struct event_filter *filter;
-        int err = 0;
-
-        mutex_lock(&event_mutex);
+        int err;
 
         if (!strcmp(strstrip(filter_string), "0")) {
                 filter_disable(call);
                 filter = call->filter;
                 if (!filter)
-                        goto out_unlock;
+                        return 0;
                 RCU_INIT_POINTER(call->filter, NULL);
                 /* Make sure the filter is not being used */
                 synchronize_sched();
                 __free_filter(filter);
-                goto out_unlock;
+                return 0;
         }
 
         err = create_filter(call, filter_string, true, &filter);
@@ -1878,8 +1881,6 @@ int apply_event_filter(struct ftrace_event_call *call, char *filter_string)
                         __free_filter(tmp);
                 }
         }
-out_unlock:
-        mutex_unlock(&event_mutex);
 
         return err;
 }
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index c4d6d7191988..38fe1483c508 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -199,7 +199,7 @@ static int func_set_flag(u32 old_flags, u32 bit, int set)
         return 0;
 }
 
-static struct tracer function_trace __read_mostly =
+static struct tracer function_trace __tracer_data =
 {
         .name           = "function",
         .init           = function_trace_init,
@@ -290,6 +290,21 @@ ftrace_stacktrace_count(unsigned long ip, unsigned long parent_ip, void **data)
                 trace_dump_stack(STACK_SKIP);
 }
 
+static void
+ftrace_dump_probe(unsigned long ip, unsigned long parent_ip, void **data)
+{
+        if (update_count(data))
+                ftrace_dump(DUMP_ALL);
+}
+
+/* Only dump the current CPU buffer. */
+static void
+ftrace_cpudump_probe(unsigned long ip, unsigned long parent_ip, void **data)
+{
+        if (update_count(data))
+                ftrace_dump(DUMP_ORIG);
+}
+
 static int
 ftrace_probe_print(const char *name, struct seq_file *m,
                    unsigned long ip, void *data)
@@ -327,6 +342,20 @@ ftrace_stacktrace_print(struct seq_file *m, unsigned long ip,
         return ftrace_probe_print("stacktrace", m, ip, data);
 }
 
+static int
+ftrace_dump_print(struct seq_file *m, unsigned long ip,
+                        struct ftrace_probe_ops *ops, void *data)
+{
+        return ftrace_probe_print("dump", m, ip, data);
+}
+
+static int
+ftrace_cpudump_print(struct seq_file *m, unsigned long ip,
+                        struct ftrace_probe_ops *ops, void *data)
+{
+        return ftrace_probe_print("cpudump", m, ip, data);
+}
+
 static struct ftrace_probe_ops traceon_count_probe_ops = {
         .func                   = ftrace_traceon_count,
         .print                  = ftrace_traceon_print,
@@ -342,6 +371,16 @@ static struct ftrace_probe_ops stacktrace_count_probe_ops = {
         .print                  = ftrace_stacktrace_print,
 };
 
+static struct ftrace_probe_ops dump_probe_ops = {
+        .func                   = ftrace_dump_probe,
+        .print                  = ftrace_dump_print,
+};
+
+static struct ftrace_probe_ops cpudump_probe_ops = {
+        .func                   = ftrace_cpudump_probe,
+        .print                  = ftrace_cpudump_print,
+};
+
 static struct ftrace_probe_ops traceon_probe_ops = {
         .func                   = ftrace_traceon,
         .print                  = ftrace_traceon_print,
@@ -425,6 +464,32 @@ ftrace_stacktrace_callback(struct ftrace_hash *hash,
                                            param, enable);
 }
 
+static int
+ftrace_dump_callback(struct ftrace_hash *hash,
+                           char *glob, char *cmd, char *param, int enable)
+{
+        struct ftrace_probe_ops *ops;
+
+        ops = &dump_probe_ops;
+
+        /* Only dump once. */
+        return ftrace_trace_probe_callback(ops, hash, glob, cmd,
+                                           "1", enable);
+}
+
+static int
+ftrace_cpudump_callback(struct ftrace_hash *hash,
+                           char *glob, char *cmd, char *param, int enable)
+{
+        struct ftrace_probe_ops *ops;
+
+        ops = &cpudump_probe_ops;
+
+        /* Only dump once. */
+        return ftrace_trace_probe_callback(ops, hash, glob, cmd,
+                                           "1", enable);
+}
+
 static struct ftrace_func_command ftrace_traceon_cmd = {
         .name                   = "traceon",
         .func                   = ftrace_trace_onoff_callback,
@@ -440,6 +505,16 @@ static struct ftrace_func_command ftrace_stacktrace_cmd = {
         .func                   = ftrace_stacktrace_callback,
 };
 
+static struct ftrace_func_command ftrace_dump_cmd = {
+        .name                   = "dump",
+        .func                   = ftrace_dump_callback,
+};
+
+static struct ftrace_func_command ftrace_cpudump_cmd = {
+        .name                   = "cpudump",
+        .func                   = ftrace_cpudump_callback,
+};
+
 static int __init init_func_cmd_traceon(void)
 {
         int ret;
@@ -450,13 +525,31 @@ static int __init init_func_cmd_traceon(void)
 
         ret = register_ftrace_command(&ftrace_traceon_cmd);
         if (ret)
-                unregister_ftrace_command(&ftrace_traceoff_cmd);
+                goto out_free_traceoff;
 
         ret = register_ftrace_command(&ftrace_stacktrace_cmd);
-        if (ret) {
-                unregister_ftrace_command(&ftrace_traceoff_cmd);
-                unregister_ftrace_command(&ftrace_traceon_cmd);
-        }
+        if (ret)
+                goto out_free_traceon;
+
+        ret = register_ftrace_command(&ftrace_dump_cmd);
+        if (ret)
+                goto out_free_stacktrace;
+
+        ret = register_ftrace_command(&ftrace_cpudump_cmd);
+        if (ret)
+                goto out_free_dump;
+
+        return 0;
+
+ out_free_dump:
+        unregister_ftrace_command(&ftrace_dump_cmd);
+ out_free_stacktrace:
+        unregister_ftrace_command(&ftrace_stacktrace_cmd);
+ out_free_traceon:
+        unregister_ftrace_command(&ftrace_traceon_cmd);
+ out_free_traceoff:
+        unregister_ftrace_command(&ftrace_traceoff_cmd);
+
         return ret;
 }
 #else
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index 8388bc99f2ee..b5c09242683d 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -446,7 +446,7 @@ print_graph_proc(struct trace_seq *s, pid_t pid)
 
         /* First spaces to align center */
         for (i = 0; i < spaces / 2; i++) {
-                ret = trace_seq_printf(s, " ");
+                ret = trace_seq_putc(s, ' ');
                 if (!ret)
                         return TRACE_TYPE_PARTIAL_LINE;
         }
@@ -457,7 +457,7 @@ print_graph_proc(struct trace_seq *s, pid_t pid)
 
         /* Last spaces to align center */
         for (i = 0; i < spaces - (spaces / 2); i++) {
-                ret = trace_seq_printf(s, " ");
+                ret = trace_seq_putc(s, ' ');
                 if (!ret)
                         return TRACE_TYPE_PARTIAL_LINE;
         }
@@ -503,7 +503,7 @@ verif_pid(struct trace_seq *s, pid_t pid, int cpu, struct fgraph_data *data)
  ------------------------------------------
 
  */
-        ret = trace_seq_printf(s,
+        ret = trace_seq_puts(s,
                 " ------------------------------------------\n");
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
@@ -516,7 +516,7 @@ verif_pid(struct trace_seq *s, pid_t pid, int cpu, struct fgraph_data *data)
         if (ret == TRACE_TYPE_PARTIAL_LINE)
                 return TRACE_TYPE_PARTIAL_LINE;
 
-        ret = trace_seq_printf(s, " => ");
+        ret = trace_seq_puts(s, " => ");
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
@@ -524,7 +524,7 @@ verif_pid(struct trace_seq *s, pid_t pid, int cpu, struct fgraph_data *data)
         if (ret == TRACE_TYPE_PARTIAL_LINE)
                 return TRACE_TYPE_PARTIAL_LINE;
 
-        ret = trace_seq_printf(s,
+        ret = trace_seq_puts(s,
                 "\n ------------------------------------------\n\n");
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
@@ -645,7 +645,7 @@ print_graph_irq(struct trace_iterator *iter, unsigned long addr,
                         ret = print_graph_proc(s, pid);
                         if (ret == TRACE_TYPE_PARTIAL_LINE)
                                 return TRACE_TYPE_PARTIAL_LINE;
-                        ret = trace_seq_printf(s, " | ");
+                        ret = trace_seq_puts(s, " | ");
                         if (!ret)
                                 return TRACE_TYPE_PARTIAL_LINE;
                 }
@@ -657,9 +657,9 @@ print_graph_irq(struct trace_iterator *iter, unsigned long addr,
                 return ret;
 
         if (type == TRACE_GRAPH_ENT)
-                ret = trace_seq_printf(s, "==========>");
+                ret = trace_seq_puts(s, "==========>");
         else
-                ret = trace_seq_printf(s, "<==========");
+                ret = trace_seq_puts(s, "<==========");
 
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
@@ -668,7 +668,7 @@ print_graph_irq(struct trace_iterator *iter, unsigned long addr,
         if (ret != TRACE_TYPE_HANDLED)
                 return ret;
 
-        ret = trace_seq_printf(s, "\n");
+        ret = trace_seq_putc(s, '\n');
 
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
@@ -705,13 +705,13 @@ trace_print_graph_duration(unsigned long long duration, struct trace_seq *s)
                 len += strlen(nsecs_str);
         }
 
-        ret = trace_seq_printf(s, " us ");
+        ret = trace_seq_puts(s, " us ");
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
         /* Print remaining spaces to fit the row's width */
         for (i = len; i < 7; i++) {
-                ret = trace_seq_printf(s, " ");
+                ret = trace_seq_putc(s, ' ');
                 if (!ret)
                         return TRACE_TYPE_PARTIAL_LINE;
         }
@@ -731,13 +731,13 @@ print_graph_duration(unsigned long long duration, struct trace_seq *s,
         /* No real adata, just filling the column with spaces */
         switch (duration) {
         case DURATION_FILL_FULL:
-                ret = trace_seq_printf(s, "              |  ");
+                ret = trace_seq_puts(s, "              |  ");
                 return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
         case DURATION_FILL_START:
-                ret = trace_seq_printf(s, "  ");
+                ret = trace_seq_puts(s, "  ");
                 return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
         case DURATION_FILL_END:
-                ret = trace_seq_printf(s, " |");
+                ret = trace_seq_puts(s, " |");
                 return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
         }
 
@@ -745,10 +745,10 @@ print_graph_duration(unsigned long long duration, struct trace_seq *s,
         if (flags & TRACE_GRAPH_PRINT_OVERHEAD) {
                 /* Duration exceeded 100 msecs */
                 if (duration > 100000ULL)
-                        ret = trace_seq_printf(s, "! ");
+                        ret = trace_seq_puts(s, "! ");
                 /* Duration exceeded 10 msecs */
                 else if (duration > 10000ULL)
-                        ret = trace_seq_printf(s, "+ ");
+                        ret = trace_seq_puts(s, "+ ");
         }
 
         /*
@@ -757,7 +757,7 @@ print_graph_duration(unsigned long long duration, struct trace_seq *s,
          * to fill out the space.
          */
         if (ret == -1)
-                ret = trace_seq_printf(s, "  ");
+                ret = trace_seq_puts(s, "  ");
 
         /* Catching here any failure happenned above */
         if (!ret)
@@ -767,7 +767,7 @@ print_graph_duration(unsigned long long duration, struct trace_seq *s,
         if (ret != TRACE_TYPE_HANDLED)
                 return ret;
 
-        ret = trace_seq_printf(s, "|  ");
+        ret = trace_seq_puts(s, "|  ");
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
@@ -817,7 +817,7 @@ print_graph_entry_leaf(struct trace_iterator *iter,
 
         /* Function */
         for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
-                ret = trace_seq_printf(s, " ");
+                ret = trace_seq_putc(s, ' ');
                 if (!ret)
                         return TRACE_TYPE_PARTIAL_LINE;
         }
@@ -858,7 +858,7 @@ print_graph_entry_nested(struct trace_iterator *iter,
 
         /* Function */
         for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
-                ret = trace_seq_printf(s, " ");
+                ret = trace_seq_putc(s, ' ');
                 if (!ret)
                         return TRACE_TYPE_PARTIAL_LINE;
         }
@@ -917,7 +917,7 @@ print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s,
                 if (ret == TRACE_TYPE_PARTIAL_LINE)
                         return TRACE_TYPE_PARTIAL_LINE;
 
-                ret = trace_seq_printf(s, " | ");
+                ret = trace_seq_puts(s, " | ");
                 if (!ret)
                         return TRACE_TYPE_PARTIAL_LINE;
         }
@@ -1117,7 +1117,7 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
 
         /* Closing brace */
         for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++) {
-                ret = trace_seq_printf(s, " ");
+                ret = trace_seq_putc(s, ' ');
                 if (!ret)
                         return TRACE_TYPE_PARTIAL_LINE;
         }
@@ -1129,7 +1129,7 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
          * belongs to, write out the function name.
          */
         if (func_match) {
-                ret = trace_seq_printf(s, "}\n");
+                ret = trace_seq_puts(s, "}\n");
                 if (!ret)
                         return TRACE_TYPE_PARTIAL_LINE;
         } else {
@@ -1179,13 +1179,13 @@ print_graph_comment(struct trace_seq *s, struct trace_entry *ent,
         /* Indentation */
         if (depth > 0)
                 for (i = 0; i < (depth + 1) * TRACE_GRAPH_INDENT; i++) {
-                        ret = trace_seq_printf(s, " ");
+                        ret = trace_seq_putc(s, ' ');
                         if (!ret)
                                 return TRACE_TYPE_PARTIAL_LINE;
                 }
 
         /* The comment */
-        ret = trace_seq_printf(s, "/* ");
+        ret = trace_seq_puts(s, "/* ");
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
@@ -1216,7 +1216,7 @@ print_graph_comment(struct trace_seq *s, struct trace_entry *ent,
                 s->len--;
         }
 
-        ret = trace_seq_printf(s, " */\n");
+        ret = trace_seq_puts(s, " */\n");
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
@@ -1448,7 +1448,7 @@ static struct trace_event graph_trace_ret_event = {
         .funcs          = &graph_functions
 };
 
-static struct tracer graph_trace __read_mostly = {
+static struct tracer graph_trace __tracer_data = {
         .name           = "function_graph",
         .open           = graph_trace_open,
         .pipe_open      = graph_trace_open,
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index b19d065a28cb..2aefbee93a6d 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -373,7 +373,7 @@ start_critical_timing(unsigned long ip, unsigned long parent_ip)
         struct trace_array_cpu *data;
         unsigned long flags;
 
-        if (likely(!tracer_enabled))
+        if (!tracer_enabled || !tracing_is_enabled())
                 return;
 
         cpu = raw_smp_processor_id();
@@ -416,7 +416,7 @@ stop_critical_timing(unsigned long ip, unsigned long parent_ip)
         else
                 return;
 
-        if (!tracer_enabled)
+        if (!tracer_enabled || !tracing_is_enabled())
                 return;
 
         data = per_cpu_ptr(tr->trace_buffer.data, cpu);
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index 9f46e98ba8f2..243f6834d026 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -35,12 +35,17 @@ struct trace_probe {
         const char              *symbol;        /* symbol name */
         struct ftrace_event_class       class;
         struct ftrace_event_call        call;
-        struct ftrace_event_file * __rcu *files;
+        struct list_head        files;
         ssize_t                 size;           /* trace entry size */
         unsigned int            nr_args;
         struct probe_arg        args[];
 };
 
+struct event_file_link {
+        struct ftrace_event_file        *file;
+        struct list_head                list;
+};
+
 #define SIZEOF_TRACE_PROBE(n)                   \
         (offsetof(struct trace_probe, args) +   \
         (sizeof(struct probe_arg) * (n)))
@@ -90,7 +95,7 @@ static __kprobes bool trace_probe_is_on_module(struct trace_probe *tp)
 }
 
 static int register_probe_event(struct trace_probe *tp);
-static void unregister_probe_event(struct trace_probe *tp);
+static int unregister_probe_event(struct trace_probe *tp);
 
 static DEFINE_MUTEX(probe_lock);
 static LIST_HEAD(probe_list);
@@ -150,6 +155,7 @@ static struct trace_probe *alloc_trace_probe(const char *group,
                 goto error;
 
         INIT_LIST_HEAD(&tp->list);
+        INIT_LIST_HEAD(&tp->files);
         return tp;
 error:
         kfree(tp->call.name);
@@ -183,25 +189,6 @@ static struct trace_probe *find_trace_probe(const char *event,
         return NULL;
 }
 
-static int trace_probe_nr_files(struct trace_probe *tp)
-{
-        struct ftrace_event_file **file;
-        int ret = 0;
-
-        /*
-         * Since all tp->files updater is protected by probe_enable_lock,
-         * we don't need to lock an rcu_read_lock.
-         */
-        file = rcu_dereference_raw(tp->files);
-        if (file)
-                while (*(file++))
-                        ret++;
-
-        return ret;
-}
-
-static DEFINE_MUTEX(probe_enable_lock);
-
 /*
  * Enable trace_probe
  * if the file is NULL, enable "perf" handler, or enable "trace" handler.
@@ -211,67 +198,42 @@ enable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)
 {
         int ret = 0;
 
-        mutex_lock(&probe_enable_lock);
-
         if (file) {
-                struct ftrace_event_file **new, **old;
-                int n = trace_probe_nr_files(tp);
-
-                old = rcu_dereference_raw(tp->files);
-                /* 1 is for new one and 1 is for stopper */
-                new = kzalloc((n + 2) * sizeof(struct ftrace_event_file *),
-                              GFP_KERNEL);
-                if (!new) {
+                struct event_file_link *link;
+
+                link = kmalloc(sizeof(*link), GFP_KERNEL);
+                if (!link) {
                         ret = -ENOMEM;
-                        goto out_unlock;
+                        goto out;
                 }
-                memcpy(new, old, n * sizeof(struct ftrace_event_file *));
-                new[n] = file;
-                /* The last one keeps a NULL */
 
-                rcu_assign_pointer(tp->files, new);
-                tp->flags |= TP_FLAG_TRACE;
+                link->file = file;
+                list_add_tail_rcu(&link->list, &tp->files);
 
-                if (old) {
-                        /* Make sure the probe is done with old files */
-                        synchronize_sched();
-                        kfree(old);
-                }
+                tp->flags |= TP_FLAG_TRACE;
         } else
                 tp->flags |= TP_FLAG_PROFILE;
 
-        if (trace_probe_is_enabled(tp) && trace_probe_is_registered(tp) &&
-            !trace_probe_has_gone(tp)) {
+        if (trace_probe_is_registered(tp) && !trace_probe_has_gone(tp)) {
                 if (trace_probe_is_return(tp))
                         ret = enable_kretprobe(&tp->rp);
                 else
                         ret = enable_kprobe(&tp->rp.kp);
         }
-
- out_unlock:
-        mutex_unlock(&probe_enable_lock);
-
+ out:
         return ret;
 }
 
-static int
-trace_probe_file_index(struct trace_probe *tp, struct ftrace_event_file *file)
+static struct event_file_link *
+find_event_file_link(struct trace_probe *tp, struct ftrace_event_file *file)
 {
-        struct ftrace_event_file **files;
-        int i;
+        struct event_file_link *link;
 
-        /*
-         * Since all tp->files updater is protected by probe_enable_lock,
-         * we don't need to lock an rcu_read_lock.
-         */
-        files = rcu_dereference_raw(tp->files);
-        if (files) {
-                for (i = 0; files[i]; i++)
-                        if (files[i] == file)
-                                return i;
-        }
+        list_for_each_entry(link, &tp->files, list)
+                if (link->file == file)
+                        return link;
 
-        return -1;
+        return NULL;
 }
 
 /*
@@ -281,43 +243,23 @@ trace_probe_file_index(struct trace_probe *tp, struct ftrace_event_file *file)
 static int
 disable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)
 {
+        struct event_file_link *link = NULL;
+        int wait = 0;
         int ret = 0;
 
-        mutex_lock(&probe_enable_lock);
-
         if (file) {
-                struct ftrace_event_file **new, **old;
-                int n = trace_probe_nr_files(tp);
-                int i, j;
-
-                old = rcu_dereference_raw(tp->files);
-                if (n == 0 || trace_probe_file_index(tp, file) < 0) {
+                link = find_event_file_link(tp, file);
+                if (!link) {
                         ret = -EINVAL;
-                        goto out_unlock;
+                        goto out;
                 }
 
-                if (n == 1) {   /* Remove the last file */
-                        tp->flags &= ~TP_FLAG_TRACE;
-                        new = NULL;
-                } else {
-                        new = kzalloc(n * sizeof(struct ftrace_event_file *),
-                                      GFP_KERNEL);
-                        if (!new) {
-                                ret = -ENOMEM;
-                                goto out_unlock;
-                        }
-
-                        /* This copy & check loop copies the NULL stopper too */
-                        for (i = 0, j = 0; j < n && i < n + 1; i++)
-                                if (old[i] != file)
-                                        new[j++] = old[i];
-                }
-
-                rcu_assign_pointer(tp->files, new);
+                list_del_rcu(&link->list);
+                wait = 1;
+                if (!list_empty(&tp->files))
+                        goto out;
 
-                /* Make sure the probe is done with old files */
-                synchronize_sched();
-                kfree(old);
+                tp->flags &= ~TP_FLAG_TRACE;
         } else
                 tp->flags &= ~TP_FLAG_PROFILE;
 
@@ -326,10 +268,21 @@ disable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)
                         disable_kretprobe(&tp->rp);
                 else
                         disable_kprobe(&tp->rp.kp);
+                wait = 1;
+        }
+ out:
+        if (wait) {
+                /*
+                 * Synchronize with kprobe_trace_func/kretprobe_trace_func
+                 * to ensure disabled (all running handlers are finished).
+                 * This is not only for kfree(), but also the caller,
+                 * trace_remove_event_call() supposes it for releasing
+                 * event_call related objects, which will be accessed in
+                 * the kprobe_trace_func/kretprobe_trace_func.
+                 */
+                synchronize_sched();
+                kfree(link);    /* Ignored if link == NULL */
         }
-
- out_unlock:
-        mutex_unlock(&probe_enable_lock);
 
         return ret;
 }
@@ -398,9 +351,12 @@ static int unregister_trace_probe(struct trace_probe *tp)
         if (trace_probe_is_enabled(tp))
                 return -EBUSY;
 
+        /* Will fail if probe is being used by ftrace or perf */
+        if (unregister_probe_event(tp))
+                return -EBUSY;
+
         __unregister_trace_probe(tp);
         list_del(&tp->list);
-        unregister_probe_event(tp);
 
         return 0;
 }
@@ -679,7 +635,9 @@ static int release_all_trace_probes(void)
         /* TODO: Use batch unregistration */
         while (!list_empty(&probe_list)) {
                 tp = list_entry(probe_list.next, struct trace_probe, list);
-                unregister_trace_probe(tp);
+                ret = unregister_trace_probe(tp);
+                if (ret)
+                        goto end;
                 free_trace_probe(tp);
         }
 
@@ -885,20 +843,10 @@ __kprobe_trace_func(struct trace_probe *tp, struct pt_regs *regs,
 static __kprobes void
 kprobe_trace_func(struct trace_probe *tp, struct pt_regs *regs)
 {
-        /*
-         * Note: preempt is already disabled around the kprobe handler.
-         * However, we still need an smp_read_barrier_depends() corresponding
-         * to smp_wmb() in rcu_assign_pointer() to access the pointer.
-         */
-        struct ftrace_event_file **file = rcu_dereference_raw(tp->files);
-
-        if (unlikely(!file))
-                return;
+        struct event_file_link *link;
 
-        while (*file) {
-                __kprobe_trace_func(tp, regs, *file);
-                file++;
-        }
+        list_for_each_entry_rcu(link, &tp->files, list)
+                __kprobe_trace_func(tp, regs, link->file);
 }
 
 /* Kretprobe handler */
@@ -945,20 +893,10 @@ static __kprobes void
 kretprobe_trace_func(struct trace_probe *tp, struct kretprobe_instance *ri,
                      struct pt_regs *regs)
 {
-        /*
-         * Note: preempt is already disabled around the kprobe handler.
-         * However, we still need an smp_read_barrier_depends() corresponding
-         * to smp_wmb() in rcu_assign_pointer() to access the pointer.
-         */
-        struct ftrace_event_file **file = rcu_dereference_raw(tp->files);
-
-        if (unlikely(!file))
-                return;
+        struct event_file_link *link;
 
-        while (*file) {
-                __kretprobe_trace_func(tp, ri, regs, *file);
-                file++;
-        }
+        list_for_each_entry_rcu(link, &tp->files, list)
+                __kretprobe_trace_func(tp, ri, regs, link->file);
 }
 
 /* Event entry printers */
@@ -1157,13 +1095,14 @@ kprobe_perf_func(struct trace_probe *tp, struct pt_regs *regs)
         int size, __size, dsize;
         int rctx;
 
+        head = this_cpu_ptr(call->perf_events);
+        if (hlist_empty(head))
+                return;
+
         dsize = __get_data_size(tp, regs);
         __size = sizeof(*entry) + tp->size + dsize;
         size = ALIGN(__size + sizeof(u32), sizeof(u64));
         size -= sizeof(u32);
-        if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
-                     "profile buffer not large enough"))
-                return;
 
         entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
         if (!entry)
@@ -1172,10 +1111,7 @@ kprobe_perf_func(struct trace_probe *tp, struct pt_regs *regs)
         entry->ip = (unsigned long)tp->rp.kp.addr;
         memset(&entry[1], 0, dsize);
         store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
-
-        head = this_cpu_ptr(call->perf_events);
-        perf_trace_buf_submit(entry, size, rctx,
-                                        entry->ip, 1, regs, head, NULL);
+        perf_trace_buf_submit(entry, size, rctx, 0, 1, regs, head, NULL);
 }
 
 /* Kretprobe profile handler */
@@ -1189,13 +1125,14 @@ kretprobe_perf_func(struct trace_probe *tp, struct kretprobe_instance *ri,
         int size, __size, dsize;
         int rctx;
 
+        head = this_cpu_ptr(call->perf_events);
+        if (hlist_empty(head))
+                return;
+
         dsize = __get_data_size(tp, regs);
         __size = sizeof(*entry) + tp->size + dsize;
         size = ALIGN(__size + sizeof(u32), sizeof(u64));
         size -= sizeof(u32);
-        if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
-                     "profile buffer not large enough"))
-                return;
 
         entry = perf_trace_buf_prepare(size, call->event.type, regs, &rctx);
         if (!entry)
@@ -1204,13 +1141,16 @@ kretprobe_perf_func(struct trace_probe *tp, struct kretprobe_instance *ri,
         entry->func = (unsigned long)tp->rp.kp.addr;
         entry->ret_ip = (unsigned long)ri->ret_addr;
         store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
-
-        head = this_cpu_ptr(call->perf_events);
-        perf_trace_buf_submit(entry, size, rctx,
-                                        entry->ret_ip, 1, regs, head, NULL);
+        perf_trace_buf_submit(entry, size, rctx, 0, 1, regs, head, NULL);
 }
 #endif  /* CONFIG_PERF_EVENTS */
 
+/*
+ * called by perf_trace_init() or __ftrace_set_clr_event() under event_mutex.
+ *
+ * kprobe_trace_self_tests_init() does enable_trace_probe/disable_trace_probe
+ * lockless, but we can't race with this __init function.
+ */
 static __kprobes
 int kprobe_register(struct ftrace_event_call *event,
                     enum trace_reg type, void *data)
@@ -1312,11 +1252,15 @@ static int register_probe_event(struct trace_probe *tp)
         return ret;
 }
 
-static void unregister_probe_event(struct trace_probe *tp)
+static int unregister_probe_event(struct trace_probe *tp)
 {
+        int ret;
+
         /* tp->event is unregistered in trace_remove_event_call() */
-        trace_remove_event_call(&tp->call);
-        kfree(tp->call.print_fmt);
+        ret = trace_remove_event_call(&tp->call);
+        if (!ret)
+                kfree(tp->call.print_fmt);
+        return ret;
 }
 
 /* Make a debugfs interface for controlling probe points */
@@ -1376,6 +1320,10 @@ find_trace_probe_file(struct trace_probe *tp, struct trace_array *tr)
         return NULL;
 }
 
+/*
+ * Nobody but us can call enable_trace_probe/disable_trace_probe at this
+ * stage, we can do this lockless.
+ */
 static __init int kprobe_trace_self_tests_init(void)
 {
         int ret, warn = 0;
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index a5e8f4878bfa..b3dcfb2f0fef 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -90,7 +90,7 @@ static int mmio_print_pcidev(struct trace_seq *s, const struct pci_dev *dev)
         if (drv)
                 ret += trace_seq_printf(s, " %s\n", drv->name);
         else
-                ret += trace_seq_printf(s, " \n");
+                ret += trace_seq_puts(s, " \n");
         return ret;
 }
 
@@ -107,7 +107,7 @@ static void mmio_pipe_open(struct trace_iterator *iter)
         struct header_iter *hiter;
         struct trace_seq *s = &iter->seq;
 
-        trace_seq_printf(s, "VERSION 20070824\n");
+        trace_seq_puts(s, "VERSION 20070824\n");
 
         hiter = kzalloc(sizeof(*hiter), GFP_KERNEL);
         if (!hiter)
@@ -209,7 +209,7 @@ static enum print_line_t mmio_print_rw(struct trace_iterator *iter)
                         (rw->value >> 0) & 0xff, rw->pc, 0);
                 break;
         default:
-                ret = trace_seq_printf(s, "rw what?\n");
+                ret = trace_seq_puts(s, "rw what?\n");
                 break;
         }
         if (ret)
@@ -245,7 +245,7 @@ static enum print_line_t mmio_print_map(struct trace_iterator *iter)
                         secs, usec_rem, m->map_id, 0UL, 0);
                 break;
         default:
-                ret = trace_seq_printf(s, "map what?\n");
+                ret = trace_seq_puts(s, "map what?\n");
                 break;
         }
         if (ret)
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
index bb922d9ee51b..34e7cbac0c9c 100644
--- a/kernel/trace/trace_output.c
+++ b/kernel/trace/trace_output.c
@@ -78,7 +78,7 @@ enum print_line_t trace_print_printk_msg_only(struct trace_iterator *iter)
 
         trace_assign_type(field, entry);
 
-        ret = trace_seq_printf(s, "%s", field->buf);
+        ret = trace_seq_puts(s, field->buf);
         if (!ret)
                 return TRACE_TYPE_PARTIAL_LINE;
 
@@ -558,14 +558,14 @@ seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,
                         if (ret)
                                 ret = trace_seq_puts(s, "??");
                         if (ret)
-                                ret = trace_seq_puts(s, "\n");
+                                ret = trace_seq_putc(s, '\n');
                         continue;
                 }
                 if (!ret)
                         break;
                 if (ret)
                         ret = seq_print_user_ip(s, mm, ip, sym_flags);
-                ret = trace_seq_puts(s, "\n");
+                ret = trace_seq_putc(s, '\n');
         }
 
         if (mm)
@@ -579,7 +579,7 @@ 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");
+                return trace_seq_putc(s, '0');
 
         if (sym_flags & TRACE_ITER_SYM_OFFSET)
                 ret = seq_print_sym_offset(s, "%s", ip);
@@ -964,14 +964,14 @@ static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags,
                 goto partial;
 
         if ((flags & TRACE_ITER_PRINT_PARENT) && field->parent_ip) {
-                if (!trace_seq_printf(s, " <-"))
+                if (!trace_seq_puts(s, " <-"))
                         goto partial;
                 if (!seq_print_ip_sym(s,
                                       field->parent_ip,
                                       flags))
                         goto partial;
         }
-        if (!trace_seq_printf(s, "\n"))
+        if (!trace_seq_putc(s, '\n'))
                 goto partial;
 
         return TRACE_TYPE_HANDLED;
@@ -1210,7 +1210,7 @@ static enum print_line_t trace_stack_print(struct trace_iterator *iter,
 
                 if (!seq_print_ip_sym(s, *p, flags))
                         goto partial;
-                if (!trace_seq_puts(s, "\n"))
+                if (!trace_seq_putc(s, '\n'))
                         goto partial;
         }
 
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 2901e3b88590..a7329b7902f8 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -640,13 +640,20 @@ out:
  * Enable ftrace, sleep 1/10 second, and then read the trace
  * buffer to see if all is in order.
  */
-int
+__init int
 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
 {
         int save_ftrace_enabled = ftrace_enabled;
         unsigned long count;
         int ret;
 
+#ifdef CONFIG_DYNAMIC_FTRACE
+        if (ftrace_filter_param) {
+                printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
+                return 0;
+        }
+#endif
+
         /* make sure msleep has been recorded */
         msleep(1);
 
@@ -727,13 +734,20 @@ static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace)
  * Pretty much the same than for the function tracer from which the selftest
  * has been borrowed.
  */
-int
+__init int
 trace_selftest_startup_function_graph(struct tracer *trace,
                                         struct trace_array *tr)
 {
         int ret;
         unsigned long count;
 
+#ifdef CONFIG_DYNAMIC_FTRACE
+        if (ftrace_filter_param) {
+                printk(KERN_CONT " ... kernel command line filter set: force PASS ... ");
+                return 0;
+        }
+#endif
+
         /*
          * Simulate the init() callback but we attach a watchdog callback
          * to detect and recover from possible hangs
diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
index 8f2ac73c7a5f..8fd03657bc7d 100644
--- a/kernel/trace/trace_syscalls.c
+++ b/kernel/trace/trace_syscalls.c
@@ -175,7 +175,7 @@ print_syscall_exit(struct trace_iterator *iter, int flags,
         entry = syscall_nr_to_meta(syscall);
 
         if (!entry) {
-                trace_seq_printf(s, "\n");
+                trace_seq_putc(s, '\n');
                 return TRACE_TYPE_HANDLED;
         }
 
@@ -306,6 +306,8 @@ static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id)
         struct syscall_metadata *sys_data;
         struct ring_buffer_event *event;
         struct ring_buffer *buffer;
+        unsigned long irq_flags;
+        int pc;
         int syscall_nr;
         int size;
 
@@ -321,9 +323,12 @@ static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id)
 
         size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
 
+        local_save_flags(irq_flags);
+        pc = preempt_count();
+
         buffer = tr->trace_buffer.buffer;
         event = trace_buffer_lock_reserve(buffer,
-                        sys_data->enter_event->event.type, size, 0, 0);
+                        sys_data->enter_event->event.type, size, irq_flags, pc);
         if (!event)
                 return;
 
@@ -333,7 +338,8 @@ static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id)
 
         if (!filter_current_check_discard(buffer, sys_data->enter_event,
                                           entry, event))
-                trace_current_buffer_unlock_commit(buffer, event, 0, 0);
+                trace_current_buffer_unlock_commit(buffer, event,
+                                                   irq_flags, pc);
 }
 
 static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret)
@@ -343,6 +349,8 @@ static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret)
         struct syscall_metadata *sys_data;
         struct ring_buffer_event *event;
         struct ring_buffer *buffer;
+        unsigned long irq_flags;
+        int pc;
         int syscall_nr;
 
         syscall_nr = trace_get_syscall_nr(current, regs);
@@ -355,9 +363,13 @@ static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret)
         if (!sys_data)
                 return;
 
+        local_save_flags(irq_flags);
+        pc = preempt_count();
+
         buffer = tr->trace_buffer.buffer;
         event = trace_buffer_lock_reserve(buffer,
-                        sys_data->exit_event->event.type, sizeof(*entry), 0, 0);
+                        sys_data->exit_event->event.type, sizeof(*entry),
+                        irq_flags, pc);
         if (!event)
                 return;
 
@@ -367,7 +379,8 @@ static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret)
 
         if (!filter_current_check_discard(buffer, sys_data->exit_event,
                                           entry, event))
-                trace_current_buffer_unlock_commit(buffer, event, 0, 0);
+                trace_current_buffer_unlock_commit(buffer, event,
+                                                   irq_flags, pc);
 }
 
 static int reg_event_syscall_enter(struct ftrace_event_file *file,
@@ -553,15 +566,15 @@ static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id)
         if (!sys_data)
                 return;
 
+        head = this_cpu_ptr(sys_data->enter_event->perf_events);
+        if (hlist_empty(head))
+                return;
+
         /* get the size after alignment with the u32 buffer size field */
         size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
         size = ALIGN(size + sizeof(u32), sizeof(u64));
         size -= sizeof(u32);
 
-        if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
-                      "perf buffer not large enough"))
-                return;
-
         rec = (struct syscall_trace_enter *)perf_trace_buf_prepare(size,
                                 sys_data->enter_event->event.type, regs, &rctx);
         if (!rec)
@@ -570,8 +583,6 @@ static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id)
         rec->nr = syscall_nr;
         syscall_get_arguments(current, regs, 0, sys_data->nb_args,
                                (unsigned long *)&rec->args);
-
-        head = this_cpu_ptr(sys_data->enter_event->perf_events);
         perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
 }
 
@@ -629,18 +640,14 @@ static void perf_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
         if (!sys_data)
                 return;
 
+        head = this_cpu_ptr(sys_data->exit_event->perf_events);
+        if (hlist_empty(head))
+                return;
+
         /* We can probably do that at build time */
         size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64));
         size -= sizeof(u32);
 
-        /*
-         * Impossible, but be paranoid with the future
-         * How to put this check outside runtime?
-         */
-        if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
-                "exit event has grown above perf buffer size"))
-                return;
-
         rec = (struct syscall_trace_exit *)perf_trace_buf_prepare(size,
                                 sys_data->exit_event->event.type, regs, &rctx);
         if (!rec)
@@ -648,8 +655,6 @@ static void perf_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
 
         rec->nr = syscall_nr;
         rec->ret = syscall_get_return_value(current, regs);
-
-        head = this_cpu_ptr(sys_data->exit_event->perf_events);
         perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
 }
 
diff --git a/kernel/trace/trace_uprobe.c b/kernel/trace/trace_uprobe.c
index 32494fb0ee64..272261b5f94f 100644
--- a/kernel/trace/trace_uprobe.c
+++ b/kernel/trace/trace_uprobe.c
@@ -70,7 +70,7 @@ struct trace_uprobe {
         (sizeof(struct probe_arg) * (n)))
 
 static int register_uprobe_event(struct trace_uprobe *tu);
-static void unregister_uprobe_event(struct trace_uprobe *tu);
+static int unregister_uprobe_event(struct trace_uprobe *tu);
 
 static DEFINE_MUTEX(uprobe_lock);
 static LIST_HEAD(uprobe_list);
@@ -164,11 +164,17 @@ static struct trace_uprobe *find_probe_event(const char *event, const char *grou
 }
 
 /* Unregister a trace_uprobe and probe_event: call with locking uprobe_lock */
-static void unregister_trace_uprobe(struct trace_uprobe *tu)
+static int unregister_trace_uprobe(struct trace_uprobe *tu)
 {
+        int ret;
+
+        ret = unregister_uprobe_event(tu);
+        if (ret)
+                return ret;
+
         list_del(&tu->list);
-        unregister_uprobe_event(tu);
         free_trace_uprobe(tu);
+        return 0;
 }
 
 /* Register a trace_uprobe and probe_event */
@@ -181,9 +187,12 @@ static int register_trace_uprobe(struct trace_uprobe *tu)
 
         /* register as an event */
         old_tp = find_probe_event(tu->call.name, tu->call.class->system);
-        if (old_tp)
+        if (old_tp) {
                 /* delete old event */
-                unregister_trace_uprobe(old_tp);
+                ret = unregister_trace_uprobe(old_tp);
+                if (ret)
+                        goto end;
+        }
 
         ret = register_uprobe_event(tu);
         if (ret) {
@@ -256,6 +265,8 @@ static int create_trace_uprobe(int argc, char **argv)
                 group = UPROBE_EVENT_SYSTEM;
 
         if (is_delete) {
+                int ret;
+
                 if (!event) {
                         pr_info("Delete command needs an event name.\n");
                         return -EINVAL;
@@ -269,9 +280,9 @@ static int create_trace_uprobe(int argc, char **argv)
                         return -ENOENT;
                 }
                 /* delete an event */
-                unregister_trace_uprobe(tu);
+                ret = unregister_trace_uprobe(tu);
                 mutex_unlock(&uprobe_lock);
-                return 0;
+                return ret;
         }
 
         if (argc < 2) {
@@ -283,8 +294,10 @@ static int create_trace_uprobe(int argc, char **argv)
                 return -EINVAL;
         }
         arg = strchr(argv[1], ':');
-        if (!arg)
+        if (!arg) {
+                ret = -EINVAL;
                 goto fail_address_parse;
+        }
 
         *arg++ = '\0';
         filename = argv[1];
@@ -406,16 +419,20 @@ fail_address_parse:
         return ret;
 }
 
-static void cleanup_all_probes(void)
+static int cleanup_all_probes(void)
 {
         struct trace_uprobe *tu;
+        int ret = 0;
 
         mutex_lock(&uprobe_lock);
         while (!list_empty(&uprobe_list)) {
                 tu = list_entry(uprobe_list.next, struct trace_uprobe, list);
-                unregister_trace_uprobe(tu);
+                ret = unregister_trace_uprobe(tu);
+                if (ret)
+                        break;
         }
         mutex_unlock(&uprobe_lock);
+        return ret;
 }
 
 /* Probes listing interfaces */
@@ -460,8 +477,13 @@ static const struct seq_operations probes_seq_op = {
 
 static int probes_open(struct inode *inode, struct file *file)
 {
-        if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC))
-                cleanup_all_probes();
+        int ret;
+
+        if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
+                ret = cleanup_all_probes();
+                if (ret)
+                        return ret;
+        }
 
         return seq_open(file, &probes_seq_op);
 }
@@ -816,8 +838,6 @@ static void uprobe_perf_print(struct trace_uprobe *tu,
 
         size = SIZEOF_TRACE_ENTRY(is_ret_probe(tu));
         size = ALIGN(size + tu->size + sizeof(u32), sizeof(u64)) - sizeof(u32);
-        if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE, "profile buffer not large enough"))
-                return;
 
         preempt_disable();
         head = this_cpu_ptr(call->perf_events);
@@ -968,12 +988,17 @@ static int register_uprobe_event(struct trace_uprobe *tu)
         return ret;
 }
 
-static void unregister_uprobe_event(struct trace_uprobe *tu)
+static int unregister_uprobe_event(struct trace_uprobe *tu)
 {
+        int ret;
+
         /* tu->event is unregistered in trace_remove_event_call() */
-        trace_remove_event_call(&tu->call);
+        ret = trace_remove_event_call(&tu->call);
+        if (ret)
+                return ret;
         kfree(tu->call.print_fmt);
         tu->call.print_fmt = NULL;
+        return 0;
 }
 
 /* Make a trace interface for controling probe points */