Merge branch 'linus' into core/rcu

6 files changed, 308 insertions, 118 deletions

diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index b58f43bec36..33dbefd471e 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -25,7 +25,7 @@ config TRACING
         bool
         select DEBUG_FS
         select RING_BUFFER
-        select STACKTRACE
+        select STACKTRACE if STACKTRACE_SUPPORT
         select TRACEPOINTS
         select NOP_TRACER
 
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 4a39d24568c..78db083390f 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -185,7 +185,6 @@ enum {
 };
 
 static int ftrace_filtered;
-static int tracing_on;
 
 static LIST_HEAD(ftrace_new_addrs);
 
@@ -327,96 +326,89 @@ ftrace_record_ip(unsigned long ip)
 
 static int
 __ftrace_replace_code(struct dyn_ftrace *rec,
-                      unsigned char *old, unsigned char *new, int enable)
+                      unsigned char *nop, int enable)
 {
         unsigned long ip, fl;
+        unsigned char *call, *old, *new;
 
         ip = rec->ip;
 
-        if (ftrace_filtered && enable) {
+        /*
+         * If this record is not to be traced and
+         * it is not enabled then do nothing.
+         *
+         * If this record is not to be traced and
+         * it is enabled then disabled it.
+         *
+         */
+        if (rec->flags & FTRACE_FL_NOTRACE) {
+                if (rec->flags & FTRACE_FL_ENABLED)
+                        rec->flags &= ~FTRACE_FL_ENABLED;
+                else
+                        return 0;
+
+        } else if (ftrace_filtered && enable) {
                 /*
-                 * If filtering is on:
-                 *
-                 * If this record is set to be filtered and
-                 * is enabled then do nothing.
-                 *
-                 * If this record is set to be filtered and
-                 * it is not enabled, enable it.
-                 *
-                 * If this record is not set to be filtered
-                 * and it is not enabled do nothing.
-                 *
-                 * If this record is set not to trace then
-                 * do nothing.
-                 *
-                 * If this record is set not to trace and
-                 * it is enabled then disable it.
-                 *
-                 * If this record is not set to be filtered and
-                 * it is enabled, disable it.
+                 * Filtering is on:
                  */
 
-                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE |
-                                   FTRACE_FL_ENABLED);
+                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_ENABLED);
 
-                if ((fl ==  (FTRACE_FL_FILTER | FTRACE_FL_ENABLED)) ||
-                    (fl ==  (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE)) ||
-                    !fl || (fl == FTRACE_FL_NOTRACE))
+                /* Record is filtered and enabled, do nothing */
+                if (fl == (FTRACE_FL_FILTER | FTRACE_FL_ENABLED))
                         return 0;
 
-                /*
-                 * If it is enabled disable it,
-                 * otherwise enable it!
-                 */
-                if (fl & FTRACE_FL_ENABLED) {
-                        /* swap new and old */
-                        new = old;
-                        old = ftrace_call_replace(ip, FTRACE_ADDR);
+                /* Record is not filtered and is not enabled do nothing */
+                if (!fl)
+                        return 0;
+
+                /* Record is not filtered but enabled, disable it */
+                if (fl == FTRACE_FL_ENABLED)
                         rec->flags &= ~FTRACE_FL_ENABLED;
-                } else {
-                        new = ftrace_call_replace(ip, FTRACE_ADDR);
+                else
+                /* Otherwise record is filtered but not enabled, enable it */
                         rec->flags |= FTRACE_FL_ENABLED;
-                }
         } else {
+                /* Disable or not filtered */
 
                 if (enable) {
-                        /*
-                         * If this record is set not to trace and is
-                         * not enabled, do nothing.
-                         */
-                        fl = rec->flags & (FTRACE_FL_NOTRACE | FTRACE_FL_ENABLED);
-                        if (fl == FTRACE_FL_NOTRACE)
-                                return 0;
-
-                        new = ftrace_call_replace(ip, FTRACE_ADDR);
-                } else
-                        old = ftrace_call_replace(ip, FTRACE_ADDR);
-
-                if (enable) {
+                        /* if record is enabled, do nothing */
                         if (rec->flags & FTRACE_FL_ENABLED)
                                 return 0;
+
                         rec->flags |= FTRACE_FL_ENABLED;
+
                 } else {
+
+                        /* if record is not enabled do nothing */
                         if (!(rec->flags & FTRACE_FL_ENABLED))
                                 return 0;
+
                         rec->flags &= ~FTRACE_FL_ENABLED;
                 }
         }
 
+        call = ftrace_call_replace(ip, FTRACE_ADDR);
+
+        if (rec->flags & FTRACE_FL_ENABLED) {
+                old = nop;
+                new = call;
+        } else {
+                old = call;
+                new = nop;
+        }
+
         return ftrace_modify_code(ip, old, new);
 }
 
 static void ftrace_replace_code(int enable)
 {
         int i, failed;
-        unsigned char *new = NULL, *old = NULL;
+        unsigned char *nop = NULL;
         struct dyn_ftrace *rec;
         struct ftrace_page *pg;
 
-        if (enable)
-                old = ftrace_nop_replace();
-        else
-                new = ftrace_nop_replace();
+        nop = ftrace_nop_replace();
 
         for (pg = ftrace_pages_start; pg; pg = pg->next) {
                 for (i = 0; i < pg->index; i++) {
@@ -434,7 +426,7 @@ static void ftrace_replace_code(int enable)
                                 unfreeze_record(rec);
                         }
 
-                        failed = __ftrace_replace_code(rec, old, new, enable);
+                        failed = __ftrace_replace_code(rec, nop, enable);
                         if (failed && (rec->flags & FTRACE_FL_CONVERTED)) {
                                 rec->flags |= FTRACE_FL_FAILED;
                                 if ((system_state == SYSTEM_BOOTING) ||
@@ -506,13 +498,10 @@ static int __ftrace_modify_code(void *data)
 {
         int *command = data;
 
-        if (*command & FTRACE_ENABLE_CALLS) {
+        if (*command & FTRACE_ENABLE_CALLS)
                 ftrace_replace_code(1);
-                tracing_on = 1;
-        } else if (*command & FTRACE_DISABLE_CALLS) {
+        else if (*command & FTRACE_DISABLE_CALLS)
                 ftrace_replace_code(0);
-                tracing_on = 0;
-        }
 
         if (*command & FTRACE_UPDATE_TRACE_FUNC)
                 ftrace_update_ftrace_func(ftrace_trace_function);
@@ -538,8 +527,7 @@ static void ftrace_startup(void)
 
         mutex_lock(&ftrace_start_lock);
         ftrace_start++;
-        if (ftrace_start == 1)
-                command |= FTRACE_ENABLE_CALLS;
+        command |= FTRACE_ENABLE_CALLS;
 
         if (saved_ftrace_func != ftrace_trace_function) {
                 saved_ftrace_func = ftrace_trace_function;
@@ -677,7 +665,7 @@ static int __init ftrace_dyn_table_alloc(unsigned long num_to_init)
 
         cnt = num_to_init / ENTRIES_PER_PAGE;
         pr_info("ftrace: allocating %ld entries in %d pages\n",
-                num_to_init, cnt);
+                num_to_init, cnt + 1);
 
         for (i = 0; i < cnt; i++) {
                 pg->next = (void *)get_zeroed_page(GFP_KERNEL);
@@ -738,6 +726,9 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                     ((iter->flags & FTRACE_ITER_FAILURES) &&
                      !(rec->flags & FTRACE_FL_FAILED)) ||
 
+                    ((iter->flags & FTRACE_ITER_FILTER) &&
+                     !(rec->flags & FTRACE_FL_FILTER)) ||
+
                     ((iter->flags & FTRACE_ITER_NOTRACE) &&
                      !(rec->flags & FTRACE_FL_NOTRACE))) {
                         rec = NULL;
@@ -757,13 +748,11 @@ static void *t_start(struct seq_file *m, loff_t *pos)
         void *p = NULL;
         loff_t l = -1;
 
-        if (*pos != iter->pos) {
-                for (p = t_next(m, p, &l); p && l < *pos; p = t_next(m, p, &l))
-                        ;
-        } else {
-                l = *pos;
-                p = t_next(m, p, &l);
-        }
+        if (*pos > iter->pos)
+                *pos = iter->pos;
+
+        l = *pos;
+        p = t_next(m, p, &l);
 
         return p;
 }
@@ -774,15 +763,21 @@ static void t_stop(struct seq_file *m, void *p)
 
 static int t_show(struct seq_file *m, void *v)
 {
+        struct ftrace_iterator *iter = m->private;
         struct dyn_ftrace *rec = v;
         char str[KSYM_SYMBOL_LEN];
+        int ret = 0;
 
         if (!rec)
                 return 0;
 
         kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
 
-        seq_printf(m, "%s\n", str);
+        ret = seq_printf(m, "%s\n", str);
+        if (ret < 0) {
+                iter->pos--;
+                iter->idx--;
+        }
 
         return 0;
 }
@@ -808,7 +803,7 @@ ftrace_avail_open(struct inode *inode, struct file *file)
                 return -ENOMEM;
 
         iter->pg = ftrace_pages_start;
-        iter->pos = -1;
+        iter->pos = 0;
 
         ret = seq_open(file, &show_ftrace_seq_ops);
         if (!ret) {
@@ -895,7 +890,7 @@ ftrace_regex_open(struct inode *inode, struct file *file, int enable)
 
         if (file->f_mode & FMODE_READ) {
                 iter->pg = ftrace_pages_start;
-                iter->pos = -1;
+                iter->pos = 0;
                 iter->flags = enable ? FTRACE_ITER_FILTER :
                         FTRACE_ITER_NOTRACE;
 
@@ -1186,7 +1181,7 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
 
         mutex_lock(&ftrace_sysctl_lock);
         mutex_lock(&ftrace_start_lock);
-        if (iter->filtered && ftrace_start && ftrace_enabled)
+        if (ftrace_start && ftrace_enabled)
                 ftrace_run_update_code(FTRACE_ENABLE_CALLS);
         mutex_unlock(&ftrace_start_lock);
         mutex_unlock(&ftrace_sysctl_lock);
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index cedf4e26828..668bbb5ef2b 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -16,14 +16,49 @@
 #include <linux/list.h>
 #include <linux/fs.h>
 
+#include "trace.h"
+
+/* Global flag to disable all recording to ring buffers */
+static int ring_buffers_off __read_mostly;
+
+/**
+ * tracing_on - enable all tracing buffers
+ *
+ * This function enables all tracing buffers that may have been
+ * disabled with tracing_off.
+ */
+void tracing_on(void)
+{
+        ring_buffers_off = 0;
+}
+
+/**
+ * tracing_off - turn off all tracing buffers
+ *
+ * This function stops all tracing buffers from recording data.
+ * It does not disable any overhead the tracers themselves may
+ * be causing. This function simply causes all recording to
+ * the ring buffers to fail.
+ */
+void tracing_off(void)
+{
+        ring_buffers_off = 1;
+}
+
 /* Up this if you want to test the TIME_EXTENTS and normalization */
 #define DEBUG_SHIFT 0
 
 /* FIXME!!! */
 u64 ring_buffer_time_stamp(int cpu)
 {
+        u64 time;
+
+        preempt_disable_notrace();
         /* shift to debug/test normalization and TIME_EXTENTS */
-        return sched_clock() << DEBUG_SHIFT;
+        time = sched_clock() << DEBUG_SHIFT;
+        preempt_enable_notrace();
+
+        return time;
 }
 
 void ring_buffer_normalize_time_stamp(int cpu, u64 *ts)
@@ -503,6 +538,12 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
         LIST_HEAD(pages);
         int i, cpu;
 
+        /*
+         * Always succeed at resizing a non-existent buffer:
+         */
+        if (!buffer)
+                return size;
+
         size = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
         size *= BUF_PAGE_SIZE;
         buffer_size = buffer->pages * BUF_PAGE_SIZE;
@@ -576,6 +617,7 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
                 list_del_init(&page->list);
                 free_buffer_page(page);
         }
+        mutex_unlock(&buffer->mutex);
         return -ENOMEM;
 }
 
@@ -1022,8 +1064,23 @@ rb_reserve_next_event(struct ring_buffer_per_cpu *cpu_buffer,
         struct ring_buffer_event *event;
         u64 ts, delta;
         int commit = 0;
+        int nr_loops = 0;
 
  again:
+        /*
+         * We allow for interrupts to reenter here and do a trace.
+         * If one does, it will cause this original code to loop
+         * back here. Even with heavy interrupts happening, this
+         * should only happen a few times in a row. If this happens
+         * 1000 times in a row, there must be either an interrupt
+         * storm or we have something buggy.
+         * Bail!
+         */
+        if (unlikely(++nr_loops > 1000)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
+
         ts = ring_buffer_time_stamp(cpu_buffer->cpu);
 
         /*
@@ -1045,7 +1102,7 @@ rb_reserve_next_event(struct ring_buffer_per_cpu *cpu_buffer,
 
                 /* Did the write stamp get updated already? */
                 if (unlikely(ts < cpu_buffer->write_stamp))
-                        goto again;
+                        delta = 0;
 
                 if (test_time_stamp(delta)) {
 
@@ -1118,6 +1175,9 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
         struct ring_buffer_event *event;
         int cpu, resched;
 
+        if (ring_buffers_off)
+                return NULL;
+
         if (atomic_read(&buffer->record_disabled))
                 return NULL;
 
@@ -1155,7 +1215,7 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
 
  out:
         if (resched)
-                preempt_enable_notrace();
+                preempt_enable_no_resched_notrace();
         else
                 preempt_enable_notrace();
         return NULL;
@@ -1234,6 +1294,9 @@ int ring_buffer_write(struct ring_buffer *buffer,
         int ret = -EBUSY;
         int cpu, resched;
 
+        if (ring_buffers_off)
+                return -EBUSY;
+
         if (atomic_read(&buffer->record_disabled))
                 return -EBUSY;
 
@@ -1532,10 +1595,23 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
 {
         struct buffer_page *reader = NULL;
         unsigned long flags;
+        int nr_loops = 0;
 
         spin_lock_irqsave(&cpu_buffer->lock, flags);
 
  again:
+        /*
+         * This should normally only loop twice. But because the
+         * start of the reader inserts an empty page, it causes
+         * a case where we will loop three times. There should be no
+         * reason to loop four times (that I know of).
+         */
+        if (unlikely(++nr_loops > 3)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                reader = NULL;
+                goto out;
+        }
+
         reader = cpu_buffer->reader_page;
 
         /* If there's more to read, return this page */
@@ -1665,6 +1741,7 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
         struct ring_buffer_per_cpu *cpu_buffer;
         struct ring_buffer_event *event;
         struct buffer_page *reader;
+        int nr_loops = 0;
 
         if (!cpu_isset(cpu, buffer->cpumask))
                 return NULL;
@@ -1672,6 +1749,19 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
         cpu_buffer = buffer->buffers[cpu];
 
  again:
+        /*
+         * We repeat when a timestamp is encountered. It is possible
+         * to get multiple timestamps from an interrupt entering just
+         * as one timestamp is about to be written. The max times
+         * that this can happen is the number of nested interrupts we
+         * can have.  Nesting 10 deep of interrupts is clearly
+         * an anomaly.
+         */
+        if (unlikely(++nr_loops > 10)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
+
         reader = rb_get_reader_page(cpu_buffer);
         if (!reader)
                 return NULL;
@@ -1722,6 +1812,7 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
         struct ring_buffer *buffer;
         struct ring_buffer_per_cpu *cpu_buffer;
         struct ring_buffer_event *event;
+        int nr_loops = 0;
 
         if (ring_buffer_iter_empty(iter))
                 return NULL;
@@ -1730,6 +1821,19 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
         buffer = cpu_buffer->buffer;
 
  again:
+        /*
+         * We repeat when a timestamp is encountered. It is possible
+         * to get multiple timestamps from an interrupt entering just
+         * as one timestamp is about to be written. The max times
+         * that this can happen is the number of nested interrupts we
+         * can have. Nesting 10 deep of interrupts is clearly
+         * an anomaly.
+         */
+        if (unlikely(++nr_loops > 10)) {
+                RB_WARN_ON(cpu_buffer, 1);
+                return NULL;
+        }
+
         if (rb_per_cpu_empty(cpu_buffer))
                 return NULL;
 
@@ -2014,3 +2118,69 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
         return 0;
 }
 
+static ssize_t
+rb_simple_read(struct file *filp, char __user *ubuf,
+               size_t cnt, loff_t *ppos)
+{
+        int *p = filp->private_data;
+        char buf[64];
+        int r;
+
+        /* !ring_buffers_off == tracing_on */
+        r = sprintf(buf, "%d\n", !*p);
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+}
+
+static ssize_t
+rb_simple_write(struct file *filp, const char __user *ubuf,
+                size_t cnt, loff_t *ppos)
+{
+        int *p = filp->private_data;
+        char buf[64];
+        long val;
+        int ret;
+
+        if (cnt >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret < 0)
+                return ret;
+
+        /* !ring_buffers_off == tracing_on */
+        *p = !val;
+
+        (*ppos)++;
+
+        return cnt;
+}
+
+static struct file_operations rb_simple_fops = {
+        .open           = tracing_open_generic,
+        .read           = rb_simple_read,
+        .write          = rb_simple_write,
+};
+
+
+static __init int rb_init_debugfs(void)
+{
+        struct dentry *d_tracer;
+        struct dentry *entry;
+
+        d_tracer = tracing_init_dentry();
+
+        entry = debugfs_create_file("tracing_on", 0644, d_tracer,
+                                    &ring_buffers_off, &rb_simple_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs 'tracing_on' entry\n");
+
+        return 0;
+}
+
+fs_initcall(rb_init_debugfs);
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 8a499e2adae..d86e3252f30 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -705,6 +705,7 @@ static void ftrace_trace_stack(struct trace_array *tr,
                                unsigned long flags,
                                int skip, int pc)
 {
+#ifdef CONFIG_STACKTRACE
         struct ring_buffer_event *event;
         struct stack_entry *entry;
         struct stack_trace trace;
@@ -730,6 +731,7 @@ static void ftrace_trace_stack(struct trace_array *tr,
 
         save_stack_trace(&trace);
         ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
+#endif
 }
 
 void __trace_stack(struct trace_array *tr,
@@ -1086,17 +1088,20 @@ static void s_stop(struct seq_file *m, void *p)
         mutex_unlock(&trace_types_lock);
 }
 
-#define KRETPROBE_MSG "[unknown/kretprobe'd]"
-
 #ifdef CONFIG_KRETPROBES
-static inline int kretprobed(unsigned long addr)
+static inline const char *kretprobed(const char *name)
 {
-        return addr == (unsigned long)kretprobe_trampoline;
+        static const char tramp_name[] = "kretprobe_trampoline";
+        int size = sizeof(tramp_name);
+
+        if (strncmp(tramp_name, name, size) == 0)
+                return "[unknown/kretprobe'd]";
+        return name;
 }
 #else
-static inline int kretprobed(unsigned long addr)
+static inline const char *kretprobed(const char *name)
 {
-        return 0;
+        return name;
 }
 #endif /* CONFIG_KRETPROBES */
 
@@ -1105,10 +1110,13 @@ seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
 {
 #ifdef CONFIG_KALLSYMS
         char str[KSYM_SYMBOL_LEN];
+        const char *name;
 
         kallsyms_lookup(address, NULL, NULL, NULL, str);
 
-        return trace_seq_printf(s, fmt, str);
+        name = kretprobed(str);
+
+        return trace_seq_printf(s, fmt, name);
 #endif
         return 1;
 }
@@ -1119,9 +1127,12 @@ seq_print_sym_offset(struct trace_seq *s, const char *fmt,
 {
 #ifdef CONFIG_KALLSYMS
         char str[KSYM_SYMBOL_LEN];
+        const char *name;
 
         sprint_symbol(str, address);
-        return trace_seq_printf(s, fmt, str);
+        name = kretprobed(str);
+
+        return trace_seq_printf(s, fmt, name);
 #endif
         return 1;
 }
@@ -1375,10 +1386,7 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
 
                 seq_print_ip_sym(s, field->ip, sym_flags);
                 trace_seq_puts(s, " (");
-                if (kretprobed(field->parent_ip))
-                        trace_seq_puts(s, KRETPROBE_MSG);
-                else
-                        seq_print_ip_sym(s, field->parent_ip, sym_flags);
+                seq_print_ip_sym(s, field->parent_ip, sym_flags);
                 trace_seq_puts(s, ")\n");
                 break;
         }
@@ -1494,12 +1502,9 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
                         ret = trace_seq_printf(s, " <-");
                         if (!ret)
                                 return TRACE_TYPE_PARTIAL_LINE;
-                        if (kretprobed(field->parent_ip))
-                                ret = trace_seq_puts(s, KRETPROBE_MSG);
-                        else
-                                ret = seq_print_ip_sym(s,
-                                                       field->parent_ip,
-                                                       sym_flags);
+                        ret = seq_print_ip_sym(s,
+                                               field->parent_ip,
+                                               sym_flags);
                         if (!ret)
                                 return TRACE_TYPE_PARTIAL_LINE;
                 }
@@ -1750,7 +1755,7 @@ static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
                 return TRACE_TYPE_HANDLED;
 
         SEQ_PUT_FIELD_RET(s, entry->pid);
-        SEQ_PUT_FIELD_RET(s, iter->cpu);
+        SEQ_PUT_FIELD_RET(s, entry->cpu);
         SEQ_PUT_FIELD_RET(s, iter->ts);
 
         switch (entry->type) {
@@ -1931,6 +1936,7 @@ __tracing_open(struct inode *inode, struct file *file, int *ret)
                         ring_buffer_read_finish(iter->buffer_iter[cpu]);
         }
         mutex_unlock(&trace_types_lock);
+        kfree(iter);
 
         return ERR_PTR(-ENOMEM);
 }
@@ -2671,7 +2677,7 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
 {
         unsigned long val;
         char buf[64];
-        int ret;
+        int ret, cpu;
         struct trace_array *tr = filp->private_data;
 
         if (cnt >= sizeof(buf))
@@ -2699,6 +2705,14 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
                 goto out;
         }
 
+        /* disable all cpu buffers */
+        for_each_tracing_cpu(cpu) {
+                if (global_trace.data[cpu])
+                        atomic_inc(&global_trace.data[cpu]->disabled);
+                if (max_tr.data[cpu])
+                        atomic_inc(&max_tr.data[cpu]->disabled);
+        }
+
         if (val != global_trace.entries) {
                 ret = ring_buffer_resize(global_trace.buffer, val);
                 if (ret < 0) {
@@ -2730,6 +2744,13 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
         if (tracing_disabled)
                 cnt = -ENOMEM;
  out:
+        for_each_tracing_cpu(cpu) {
+                if (global_trace.data[cpu])
+                        atomic_dec(&global_trace.data[cpu]->disabled);
+                if (max_tr.data[cpu])
+                        atomic_dec(&max_tr.data[cpu]->disabled);
+        }
+
         max_tr.entries = global_trace.entries;
         mutex_unlock(&trace_types_lock);
 
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index f28484618ff..e62cbf78eab 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -18,12 +18,14 @@ struct header_iter {
 
 static struct trace_array *mmio_trace_array;
 static bool overrun_detected;
+static unsigned long prev_overruns;
 
 static void mmio_reset_data(struct trace_array *tr)
 {
         int cpu;
 
         overrun_detected = false;
+        prev_overruns = 0;
         tr->time_start = ftrace_now(tr->cpu);
 
         for_each_online_cpu(cpu)
@@ -128,16 +130,12 @@ static void mmio_close(struct trace_iterator *iter)
 
 static unsigned long count_overruns(struct trace_iterator *iter)
 {
-        int cpu;
         unsigned long cnt = 0;
-/* FIXME: */
-#if 0
-        for_each_online_cpu(cpu) {
-                cnt += iter->overrun[cpu];
-                iter->overrun[cpu] = 0;
-        }
-#endif
-        (void)cpu;
+        unsigned long over = ring_buffer_overruns(iter->tr->buffer);
+
+        if (over > prev_overruns)
+                cnt = over - prev_overruns;
+        prev_overruns = over;
         return cnt;
 }
 
diff --git a/kernel/trace/trace_stack.c b/kernel/trace/trace_stack.c
index be682b62fe5..3bdb44bde4b 100644
--- a/kernel/trace/trace_stack.c
+++ b/kernel/trace/trace_stack.c
@@ -184,11 +184,16 @@ static struct file_operations stack_max_size_fops = {
 static void *
 t_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        long i = (long)m->private;
+        long i;
 
         (*pos)++;
 
-        i++;
+        if (v == SEQ_START_TOKEN)
+                i = 0;
+        else {
+                i = *(long *)v;
+                i++;
+        }
 
         if (i >= max_stack_trace.nr_entries ||
             stack_dump_trace[i] == ULONG_MAX)
@@ -201,12 +206,15 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
 
 static void *t_start(struct seq_file *m, loff_t *pos)
 {
-        void *t = &m->private;
+        void *t = SEQ_START_TOKEN;
         loff_t l = 0;
 
         local_irq_disable();
         __raw_spin_lock(&max_stack_lock);
 
+        if (*pos == 0)
+                return SEQ_START_TOKEN;
+
         for (; t && l < *pos; t = t_next(m, t, &l))
                 ;
 
@@ -235,10 +243,10 @@ static int trace_lookup_stack(struct seq_file *m, long i)
 
 static int t_show(struct seq_file *m, void *v)
 {
-        long i = *(long *)v;
+        long i;
         int size;
 
-        if (i < 0) {
+        if (v == SEQ_START_TOKEN) {
                 seq_printf(m, "        Depth   Size      Location"
                            "    (%d entries)\n"
                            "        -----   ----      --------\n",
@@ -246,6 +254,8 @@ static int t_show(struct seq_file *m, void *v)
                 return 0;
         }
 
+        i = *(long *)v;
+
         if (i >= max_stack_trace.nr_entries ||
             stack_dump_trace[i] == ULONG_MAX)
                 return 0;
@@ -275,10 +285,6 @@ static int stack_trace_open(struct inode *inode, struct file *file)
         int ret;
 
         ret = seq_open(file, &stack_trace_seq_ops);
-        if (!ret) {
-                struct seq_file *m = file->private_data;
-                m->private = (void *)-1;
-        }
 
         return ret;
 }