Merge branch 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (121 commits)
  perf symbols: Increase symbol KSYM_NAME_LEN size
  perf hists browser: Refuse 'a' hotkey on non symbolic views
  perf ui browser: Use libslang to read keys
  perf tools: Fix tracing info recording
  perf hists browser: Elide DSO column when it is set to just one DSO, ditto for threads
  perf hists: Don't consider filtered entries when calculating column widths
  perf hists: Don't decay total_period for filtered entries
  perf hists browser: Honour symbol_conf.show_{nr_samples,total_period}
  perf hists browser: Do not exit on tab key with single event
  perf annotate browser: Don't change selection line when returning from callq
  perf tools: handle endianness of feature bitmap
  perf tools: Add prelink suggestion to dso update message
  perf script: Fix unknown feature comment
  perf hists browser: Apply the dso and thread filters when merging new batches
  perf hists: Move the dso and thread filters from hist_browser
  perf ui browser: Honour the xterm colors
  perf top tui: Give color hints just on the percentage, like on --stdio
  perf ui browser: Make the colors configurable and change the defaults
  perf tui: Remove unneeded call to newtCls on startup
  perf hists: Don't format the percentage on hist_entry__snprintf
  ...

Fix up conflicts in arch/x86/kernel/kprobes.c manually.

Ingo's tree did the insane "add volatile to const array", which just
doesn't make sense ("volatile const"?).  But we could remove the const
*and* make the array volatile to make doubly sure that gcc doesn't
optimize it away..

Also fix up kernel/trace/ring_buffer.c non-data-conflicts manually: the
reader_lock has been turned into a raw lock by the core locking merge,
and there was a new user of it introduced in this perf core merge.  Make
sure that new use also uses the raw accessor functions.

11 files changed, 819 insertions, 396 deletions

diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
index f49405f842f4..5f39a07fe5ea 100644
--- a/kernel/trace/Makefile
+++ b/kernel/trace/Makefile
@@ -15,6 +15,8 @@ ifdef CONFIG_TRACING_BRANCHES
 KBUILD_CFLAGS += -DDISABLE_BRANCH_PROFILING
 endif
 
+CFLAGS_trace_events_filter.o := -I$(src)
+
 #
 # Make the trace clocks available generally: it's infrastructure
 # relied on by ptrace for example:
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index c3e4575e7829..077d85387908 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -3863,6 +3863,14 @@ void ftrace_kill(void)
 }
 
 /**
+ * Test if ftrace is dead or not.
+ */
+int ftrace_is_dead(void)
+{
+        return ftrace_disabled;
+}
+
+/**
  * register_ftrace_function - register a function for profiling
  * @ops - ops structure that holds the function for profiling.
  *
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index f2f821acc597..f5b7b5c1195b 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -488,12 +488,14 @@ struct ring_buffer_per_cpu {
         struct buffer_page              *reader_page;
         unsigned long                   lost_events;
         unsigned long                   last_overrun;
+        local_t                         entries_bytes;
         local_t                         commit_overrun;
         local_t                         overrun;
         local_t                         entries;
         local_t                         committing;
         local_t                         commits;
         unsigned long                   read;
+        unsigned long                   read_bytes;
         u64                             write_stamp;
         u64                             read_stamp;
 };
@@ -1708,6 +1710,7 @@ rb_handle_head_page(struct ring_buffer_per_cpu *cpu_buffer,
                  * the counters.
                  */
                 local_add(entries, &cpu_buffer->overrun);
+                local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
 
                 /*
                  * The entries will be zeroed out when we move the
@@ -1863,6 +1866,9 @@ rb_reset_tail(struct ring_buffer_per_cpu *cpu_buffer,
         event = __rb_page_index(tail_page, tail);
         kmemcheck_annotate_bitfield(event, bitfield);
 
+        /* account for padding bytes */
+        local_add(BUF_PAGE_SIZE - tail, &cpu_buffer->entries_bytes);
+
         /*
          * Save the original length to the meta data.
          * This will be used by the reader to add lost event
@@ -2054,6 +2060,9 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
         if (!tail)
                 tail_page->page->time_stamp = ts;
 
+        /* account for these added bytes */
+        local_add(length, &cpu_buffer->entries_bytes);
+
         return event;
 }
 
@@ -2076,6 +2085,7 @@ rb_try_to_discard(struct ring_buffer_per_cpu *cpu_buffer,
         if (bpage->page == (void *)addr && rb_page_write(bpage) == old_index) {
                 unsigned long write_mask =
                         local_read(&bpage->write) & ~RB_WRITE_MASK;
+                unsigned long event_length = rb_event_length(event);
                 /*
                  * This is on the tail page. It is possible that
                  * a write could come in and move the tail page
@@ -2085,8 +2095,11 @@ rb_try_to_discard(struct ring_buffer_per_cpu *cpu_buffer,
                 old_index += write_mask;
                 new_index += write_mask;
                 index = local_cmpxchg(&bpage->write, old_index, new_index);
-                if (index == old_index)
+                if (index == old_index) {
+                        /* update counters */
+                        local_sub(event_length, &cpu_buffer->entries_bytes);
                         return 1;
+                }
         }
 
         /* could not discard */
@@ -2661,6 +2674,58 @@ rb_num_of_entries(struct ring_buffer_per_cpu *cpu_buffer)
 }
 
 /**
+ * ring_buffer_oldest_event_ts - get the oldest event timestamp from the buffer
+ * @buffer: The ring buffer
+ * @cpu: The per CPU buffer to read from.
+ */
+unsigned long ring_buffer_oldest_event_ts(struct ring_buffer *buffer, int cpu)
+{
+        unsigned long flags;
+        struct ring_buffer_per_cpu *cpu_buffer;
+        struct buffer_page *bpage;
+        unsigned long ret;
+
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
+                return 0;
+
+        cpu_buffer = buffer->buffers[cpu];
+        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        /*
+         * if the tail is on reader_page, oldest time stamp is on the reader
+         * page
+         */
+        if (cpu_buffer->tail_page == cpu_buffer->reader_page)
+                bpage = cpu_buffer->reader_page;
+        else
+                bpage = rb_set_head_page(cpu_buffer);
+        ret = bpage->page->time_stamp;
+        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(ring_buffer_oldest_event_ts);
+
+/**
+ * ring_buffer_bytes_cpu - get the number of bytes consumed in a cpu buffer
+ * @buffer: The ring buffer
+ * @cpu: The per CPU buffer to read from.
+ */
+unsigned long ring_buffer_bytes_cpu(struct ring_buffer *buffer, int cpu)
+{
+        struct ring_buffer_per_cpu *cpu_buffer;
+        unsigned long ret;
+
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
+                return 0;
+
+        cpu_buffer = buffer->buffers[cpu];
+        ret = local_read(&cpu_buffer->entries_bytes) - cpu_buffer->read_bytes;
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(ring_buffer_bytes_cpu);
+
+/**
  * ring_buffer_entries_cpu - get the number of entries in a cpu buffer
  * @buffer: The ring buffer
  * @cpu: The per CPU buffer to get the entries from.
@@ -3527,11 +3592,13 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
         cpu_buffer->reader_page->read = 0;
 
         local_set(&cpu_buffer->commit_overrun, 0);
+        local_set(&cpu_buffer->entries_bytes, 0);
         local_set(&cpu_buffer->overrun, 0);
         local_set(&cpu_buffer->entries, 0);
         local_set(&cpu_buffer->committing, 0);
         local_set(&cpu_buffer->commits, 0);
         cpu_buffer->read = 0;
+        cpu_buffer->read_bytes = 0;
 
         cpu_buffer->write_stamp = 0;
         cpu_buffer->read_stamp = 0;
@@ -3918,6 +3985,7 @@ int ring_buffer_read_page(struct ring_buffer *buffer,
         } else {
                 /* update the entry counter */
                 cpu_buffer->read += rb_page_entries(reader);
+                cpu_buffer->read_bytes += BUF_PAGE_SIZE;
 
                 /* swap the pages */
                 rb_init_page(bpage);
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 0c8bdeeb358b..f2bd275bb60f 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -435,6 +435,7 @@ static struct {
 } trace_clocks[] = {
         { trace_clock_local,    "local" },
         { trace_clock_global,   "global" },
+        { trace_clock_counter,  "counter" },
 };
 
 int trace_clock_id;
@@ -2159,6 +2160,14 @@ void trace_default_header(struct seq_file *m)
         }
 }
 
+static void test_ftrace_alive(struct seq_file *m)
+{
+        if (!ftrace_is_dead())
+                return;
+        seq_printf(m, "# WARNING: FUNCTION TRACING IS CORRUPTED\n");
+        seq_printf(m, "#          MAY BE MISSING FUNCTION EVENTS\n");
+}
+
 static int s_show(struct seq_file *m, void *v)
 {
         struct trace_iterator *iter = v;
@@ -2168,6 +2177,7 @@ static int s_show(struct seq_file *m, void *v)
                 if (iter->tr) {
                         seq_printf(m, "# tracer: %s\n", iter->trace->name);
                         seq_puts(m, "#\n");
+                        test_ftrace_alive(m);
                 }
                 if (iter->trace && iter->trace->print_header)
                         iter->trace->print_header(m);
@@ -2710,9 +2720,9 @@ static const char readme_msg[] =
         "# cat /sys/kernel/debug/tracing/trace_options\n"
         "noprint-parent nosym-offset nosym-addr noverbose\n"
         "# echo print-parent > /sys/kernel/debug/tracing/trace_options\n"
-        "# echo 1 > /sys/kernel/debug/tracing/tracing_enabled\n"
+        "# echo 1 > /sys/kernel/debug/tracing/tracing_on\n"
         "# cat /sys/kernel/debug/tracing/trace > /tmp/trace.txt\n"
-        "# echo 0 > /sys/kernel/debug/tracing/tracing_enabled\n"
+        "# echo 0 > /sys/kernel/debug/tracing/tracing_on\n"
 ;
 
 static ssize_t
@@ -3569,6 +3579,30 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
 }
 
 static ssize_t
+tracing_total_entries_read(struct file *filp, char __user *ubuf,
+                                size_t cnt, loff_t *ppos)
+{
+        struct trace_array *tr = filp->private_data;
+        char buf[64];
+        int r, cpu;
+        unsigned long size = 0, expanded_size = 0;
+
+        mutex_lock(&trace_types_lock);
+        for_each_tracing_cpu(cpu) {
+                size += tr->entries >> 10;
+                if (!ring_buffer_expanded)
+                        expanded_size += trace_buf_size >> 10;
+        }
+        if (ring_buffer_expanded)
+                r = sprintf(buf, "%lu\n", size);
+        else
+                r = sprintf(buf, "%lu (expanded: %lu)\n", size, expanded_size);
+        mutex_unlock(&trace_types_lock);
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+}
+
+static ssize_t
 tracing_free_buffer_write(struct file *filp, const char __user *ubuf,
                           size_t cnt, loff_t *ppos)
 {
@@ -3594,22 +3628,24 @@ tracing_free_buffer_release(struct inode *inode, struct file *filp)
         return 0;
 }
 
-static int mark_printk(const char *fmt, ...)
-{
-        int ret;
-        va_list args;
-        va_start(args, fmt);
-        ret = trace_vprintk(0, fmt, args);
-        va_end(args);
-        return ret;
-}
-
 static ssize_t
 tracing_mark_write(struct file *filp, const char __user *ubuf,
                                         size_t cnt, loff_t *fpos)
 {
-        char *buf;
-        size_t written;
+        unsigned long addr = (unsigned long)ubuf;
+        struct ring_buffer_event *event;
+        struct ring_buffer *buffer;
+        struct print_entry *entry;
+        unsigned long irq_flags;
+        struct page *pages[2];
+        int nr_pages = 1;
+        ssize_t written;
+        void *page1;
+        void *page2;
+        int offset;
+        int size;
+        int len;
+        int ret;
 
         if (tracing_disabled)
                 return -EINVAL;
@@ -3617,28 +3653,81 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
         if (cnt > TRACE_BUF_SIZE)
                 cnt = TRACE_BUF_SIZE;
 
-        buf = kmalloc(cnt + 2, GFP_KERNEL);
-        if (buf == NULL)
-                return -ENOMEM;
+        /*
+         * Userspace is injecting traces into the kernel trace buffer.
+         * We want to be as non intrusive as possible.
+         * To do so, we do not want to allocate any special buffers
+         * or take any locks, but instead write the userspace data
+         * straight into the ring buffer.
+         *
+         * First we need to pin the userspace buffer into memory,
+         * which, most likely it is, because it just referenced it.
+         * But there's no guarantee that it is. By using get_user_pages_fast()
+         * and kmap_atomic/kunmap_atomic() we can get access to the
+         * pages directly. We then write the data directly into the
+         * ring buffer.
+         */
+        BUILD_BUG_ON(TRACE_BUF_SIZE >= PAGE_SIZE);
 
-        if (copy_from_user(buf, ubuf, cnt)) {
-                kfree(buf);
-                return -EFAULT;
+        /* check if we cross pages */
+        if ((addr & PAGE_MASK) != ((addr + cnt) & PAGE_MASK))
+                nr_pages = 2;
+
+        offset = addr & (PAGE_SIZE - 1);
+        addr &= PAGE_MASK;
+
+        ret = get_user_pages_fast(addr, nr_pages, 0, pages);
+        if (ret < nr_pages) {
+                while (--ret >= 0)
+                        put_page(pages[ret]);
+                written = -EFAULT;
+                goto out;
+        }
+
+        page1 = kmap_atomic(pages[0]);
+        if (nr_pages == 2)
+                page2 = kmap_atomic(pages[1]);
+
+        local_save_flags(irq_flags);
+        size = sizeof(*entry) + cnt + 2; /* possible \n added */
+        buffer = global_trace.buffer;
+        event = trace_buffer_lock_reserve(buffer, TRACE_PRINT, size,
+                                          irq_flags, preempt_count());
+        if (!event) {
+                /* Ring buffer disabled, return as if not open for write */
+                written = -EBADF;
+                goto out_unlock;
         }
-        if (buf[cnt-1] != '\n') {
-                buf[cnt] = '\n';
-                buf[cnt+1] = '\0';
+
+        entry = ring_buffer_event_data(event);
+        entry->ip = _THIS_IP_;
+
+        if (nr_pages == 2) {
+                len = PAGE_SIZE - offset;
+                memcpy(&entry->buf, page1 + offset, len);
+                memcpy(&entry->buf[len], page2, cnt - len);
         } else
-                buf[cnt] = '\0';
+                memcpy(&entry->buf, page1 + offset, cnt);
 
-        written = mark_printk("%s", buf);
-        kfree(buf);
-        *fpos += written;
+        if (entry->buf[cnt - 1] != '\n') {
+                entry->buf[cnt] = '\n';
+                entry->buf[cnt + 1] = '\0';
+        } else
+                entry->buf[cnt] = '\0';
+
+        ring_buffer_unlock_commit(buffer, event);
 
-        /* don't tell userspace we wrote more - it might confuse them */
-        if (written > cnt)
-                written = cnt;
+        written = cnt;
 
+        *fpos += written;
+
+ out_unlock:
+        if (nr_pages == 2)
+                kunmap_atomic(page2);
+        kunmap_atomic(page1);
+        while (nr_pages > 0)
+                put_page(pages[--nr_pages]);
+ out:
         return written;
 }
 
@@ -3739,6 +3828,12 @@ static const struct file_operations tracing_entries_fops = {
         .llseek         = generic_file_llseek,
 };
 
+static const struct file_operations tracing_total_entries_fops = {
+        .open           = tracing_open_generic,
+        .read           = tracing_total_entries_read,
+        .llseek         = generic_file_llseek,
+};
+
 static const struct file_operations tracing_free_buffer_fops = {
         .write          = tracing_free_buffer_write,
         .release        = tracing_free_buffer_release,
@@ -3808,8 +3903,6 @@ tracing_buffers_read(struct file *filp, char __user *ubuf,
         if (info->read < PAGE_SIZE)
                 goto read;
 
-        info->read = 0;
-
         trace_access_lock(info->cpu);
         ret = ring_buffer_read_page(info->tr->buffer,
                                     &info->spare,
@@ -3819,6 +3912,8 @@ tracing_buffers_read(struct file *filp, char __user *ubuf,
         if (ret < 0)
                 return 0;
 
+        info->read = 0;
+
 read:
         size = PAGE_SIZE - info->read;
         if (size > count)
@@ -4026,6 +4121,8 @@ tracing_stats_read(struct file *filp, char __user *ubuf,
         struct trace_array *tr = &global_trace;
         struct trace_seq *s;
         unsigned long cnt;
+        unsigned long long t;
+        unsigned long usec_rem;
 
         s = kmalloc(sizeof(*s), GFP_KERNEL);
         if (!s)
@@ -4042,6 +4139,17 @@ tracing_stats_read(struct file *filp, char __user *ubuf,
         cnt = ring_buffer_commit_overrun_cpu(tr->buffer, cpu);
         trace_seq_printf(s, "commit overrun: %ld\n", cnt);
 
+        cnt = ring_buffer_bytes_cpu(tr->buffer, cpu);
+        trace_seq_printf(s, "bytes: %ld\n", cnt);
+
+        t = ns2usecs(ring_buffer_oldest_event_ts(tr->buffer, cpu));
+        usec_rem = do_div(t, USEC_PER_SEC);
+        trace_seq_printf(s, "oldest event ts: %5llu.%06lu\n", t, usec_rem);
+
+        t = ns2usecs(ring_buffer_time_stamp(tr->buffer, cpu));
+        usec_rem = do_div(t, USEC_PER_SEC);
+        trace_seq_printf(s, "now ts: %5llu.%06lu\n", t, usec_rem);
+
         count = simple_read_from_buffer(ubuf, count, ppos, s->buffer, s->len);
 
         kfree(s);
@@ -4450,6 +4558,9 @@ static __init int tracer_init_debugfs(void)
         trace_create_file("buffer_size_kb", 0644, d_tracer,
                         &global_trace, &tracing_entries_fops);
 
+        trace_create_file("buffer_total_size_kb", 0444, d_tracer,
+                        &global_trace, &tracing_total_entries_fops);
+
         trace_create_file("free_buffer", 0644, d_tracer,
                         &global_trace, &tracing_free_buffer_fops);
 
@@ -4566,6 +4677,12 @@ __ftrace_dump(bool disable_tracing, enum ftrace_dump_mode oops_dump_mode)
 
         tracing_off();
 
+        /* Did function tracer already get disabled? */
+        if (ftrace_is_dead()) {
+                printk("# WARNING: FUNCTION TRACING IS CORRUPTED\n");
+                printk("#          MAY BE MISSING FUNCTION EVENTS\n");
+        }
+
         if (disable_tracing)
                 ftrace_kill();
 
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 616846bcfee5..092e1f8d18dc 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -579,11 +579,13 @@ static inline int ftrace_trace_task(struct task_struct *task)
 
         return test_tsk_trace_trace(task);
 }
+extern int ftrace_is_dead(void);
 #else
 static inline int ftrace_trace_task(struct task_struct *task)
 {
         return 1;
 }
+static inline int ftrace_is_dead(void) { return 0; }
 #endif
 
 /*
@@ -761,16 +763,10 @@ struct filter_pred {
         filter_pred_fn_t        fn;
         u64                     val;
         struct regex            regex;
-        /*
-         * Leaf nodes use field_name, ops is used by AND and OR
-         * nodes. The field_name is always freed when freeing a pred.
-         * We can overload field_name for ops and have it freed
-         * as well.
-         */
-        union {
-                char            *field_name;
-                unsigned short  *ops;
-        };
+        unsigned short          *ops;
+#ifdef CONFIG_FTRACE_STARTUP_TEST
+        struct ftrace_event_field *field;
+#endif
         int                     offset;
         int                     not;
         int                     op;
diff --git a/kernel/trace/trace_clock.c b/kernel/trace/trace_clock.c
index 6302747a1398..394783531cbb 100644
--- a/kernel/trace/trace_clock.c
+++ b/kernel/trace/trace_clock.c
@@ -113,3 +113,15 @@ u64 notrace trace_clock_global(void)
 
         return now;
 }
+
+static atomic64_t trace_counter;
+
+/*
+ * trace_clock_counter(): simply an atomic counter.
+ * Use the trace_counter "counter" for cases where you do not care
+ * about timings, but are interested in strict ordering.
+ */
+u64 notrace trace_clock_counter(void)
+{
+        return atomic64_add_return(1, &trace_counter);
+}
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index 256764ecccd6..816d3d074979 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -381,6 +381,63 @@ get_pred_parent(struct filter_pred *pred, struct filter_pred *preds,
         return pred;
 }
 
+enum walk_return {
+        WALK_PRED_ABORT,
+        WALK_PRED_PARENT,
+        WALK_PRED_DEFAULT,
+};
+
+typedef int (*filter_pred_walkcb_t) (enum move_type move,
+                                     struct filter_pred *pred,
+                                     int *err, void *data);
+
+static int walk_pred_tree(struct filter_pred *preds,
+                          struct filter_pred *root,
+                          filter_pred_walkcb_t cb, void *data)
+{
+        struct filter_pred *pred = root;
+        enum move_type move = MOVE_DOWN;
+        int done = 0;
+
+        if  (!preds)
+                return -EINVAL;
+
+        do {
+                int err = 0, ret;
+
+                ret = cb(move, pred, &err, data);
+                if (ret == WALK_PRED_ABORT)
+                        return err;
+                if (ret == WALK_PRED_PARENT)
+                        goto get_parent;
+
+                switch (move) {
+                case MOVE_DOWN:
+                        if (pred->left != FILTER_PRED_INVALID) {
+                                pred = &preds[pred->left];
+                                continue;
+                        }
+                        goto get_parent;
+                case MOVE_UP_FROM_LEFT:
+                        pred = &preds[pred->right];
+                        move = MOVE_DOWN;
+                        continue;
+                case MOVE_UP_FROM_RIGHT:
+ get_parent:
+                        if (pred == root)
+                                break;
+                        pred = get_pred_parent(pred, preds,
+                                               pred->parent,
+                                               &move);
+                        continue;
+                }
+                done = 1;
+        } while (!done);
+
+        /* We are fine. */
+        return 0;
+}
+
 /*
  * A series of AND or ORs where found together. Instead of
  * climbing up and down the tree branches, an array of the
@@ -410,99 +467,91 @@ static int process_ops(struct filter_pred *preds,
 
         for (i = 0; i < op->val; i++) {
                 pred = &preds[op->ops[i]];
-                match = pred->fn(pred, rec);
+                if (!WARN_ON_ONCE(!pred->fn))
+                        match = pred->fn(pred, rec);
                 if (!!match == type)
                         return match;
         }
         return match;
 }
 
+struct filter_match_preds_data {
+        struct filter_pred *preds;
+        int match;
+        void *rec;
+};
+
+static int filter_match_preds_cb(enum move_type move, struct filter_pred *pred,
+                                 int *err, void *data)
+{
+        struct filter_match_preds_data *d = data;
+
+        *err = 0;
+        switch (move) {
+        case MOVE_DOWN:
+                /* only AND and OR have children */
+                if (pred->left != FILTER_PRED_INVALID) {
+                        /* If ops is set, then it was folded. */
+                        if (!pred->ops)
+                                return WALK_PRED_DEFAULT;
+                        /* We can treat folded ops as a leaf node */
+                        d->match = process_ops(d->preds, pred, d->rec);
+                } else {
+                        if (!WARN_ON_ONCE(!pred->fn))
+                                d->match = pred->fn(pred, d->rec);
+                }
+
+                return WALK_PRED_PARENT;
+        case MOVE_UP_FROM_LEFT:
+                /*
+                 * Check for short circuits.
+                 *
+                 * Optimization: !!match == (pred->op == OP_OR)
+                 *   is the same as:
+                 * if ((match && pred->op == OP_OR) ||
+                 *     (!match && pred->op == OP_AND))
+                 */
+                if (!!d->match == (pred->op == OP_OR))
+                        return WALK_PRED_PARENT;
+                break;
+        case MOVE_UP_FROM_RIGHT:
+                break;
+        }
+
+        return WALK_PRED_DEFAULT;
+}
+
 /* return 1 if event matches, 0 otherwise (discard) */
 int filter_match_preds(struct event_filter *filter, void *rec)
 {
-        int match = -1;
-        enum move_type move = MOVE_DOWN;
         struct filter_pred *preds;
-        struct filter_pred *pred;
         struct filter_pred *root;
-        int n_preds;
-        int done = 0;
+        struct filter_match_preds_data data = {
+                /* match is currently meaningless */
+                .match = -1,
+                .rec   = rec,
+        };
+        int n_preds, ret;
 
         /* no filter is considered a match */
         if (!filter)
                 return 1;
 
         n_preds = filter->n_preds;
-
         if (!n_preds)
                 return 1;
 
         /*
          * n_preds, root and filter->preds are protect with preemption disabled.
          */
-        preds = rcu_dereference_sched(filter->preds);
         root = rcu_dereference_sched(filter->root);
         if (!root)
                 return 1;
 
-        pred = root;
-
-        /* match is currently meaningless */
-        match = -1;
-
-        do {
-                switch (move) {
-                case MOVE_DOWN:
-                        /* only AND and OR have children */
-                        if (pred->left != FILTER_PRED_INVALID) {
-                                /* If ops is set, then it was folded. */
-                                if (!pred->ops) {
-                                        /* keep going to down the left side */
-                                        pred = &preds[pred->left];
-                                        continue;
-                                }
-                                /* We can treat folded ops as a leaf node */
-                                match = process_ops(preds, pred, rec);
-                        } else
-                                match = pred->fn(pred, rec);
-                        /* If this pred is the only pred */
-                        if (pred == root)
-                                break;
-                        pred = get_pred_parent(pred, preds,
-                                               pred->parent, &move);
-                        continue;
-                case MOVE_UP_FROM_LEFT:
-                        /*
-                         * Check for short circuits.
-                         *
-                         * Optimization: !!match == (pred->op == OP_OR)
-                         *   is the same as:
-                         * if ((match && pred->op == OP_OR) ||
-                         *     (!match && pred->op == OP_AND))
-                         */
-                        if (!!match == (pred->op == OP_OR)) {
-                                if (pred == root)
-                                        break;
-                                pred = get_pred_parent(pred, preds,
-                                                       pred->parent, &move);
-                                continue;
-                        }
-                        /* now go down the right side of the tree. */
-                        pred = &preds[pred->right];
-                        move = MOVE_DOWN;
-                        continue;
-                case MOVE_UP_FROM_RIGHT:
-                        /* We finished this equation. */
-                        if (pred == root)
-                                break;
-                        pred = get_pred_parent(pred, preds,
-                                               pred->parent, &move);
-                        continue;
-                }
-                done = 1;
-        } while (!done);
-
-        return match;
+        data.preds = preds = rcu_dereference_sched(filter->preds);
+        ret = walk_pred_tree(preds, root, filter_match_preds_cb, &data);
+        WARN_ON(ret);
+        return data.match;
 }
 EXPORT_SYMBOL_GPL(filter_match_preds);
 
@@ -628,22 +677,6 @@ find_event_field(struct ftrace_event_call *call, char *name)
         return __find_event_field(head, name);
 }
 
-static void filter_free_pred(struct filter_pred *pred)
-{
-        if (!pred)
-                return;
-
-        kfree(pred->field_name);
-        kfree(pred);
-}
-
-static void filter_clear_pred(struct filter_pred *pred)
-{
-        kfree(pred->field_name);
-        pred->field_name = NULL;
-        pred->regex.len = 0;
-}
-
 static int __alloc_pred_stack(struct pred_stack *stack, int n_preds)
 {
         stack->preds = kzalloc(sizeof(*stack->preds)*(n_preds + 1), GFP_KERNEL);
@@ -689,20 +722,13 @@ __pop_pred_stack(struct pred_stack *stack)
 static int filter_set_pred(struct event_filter *filter,
                            int idx,
                            struct pred_stack *stack,
-                           struct filter_pred *src,
-                           filter_pred_fn_t fn)
+                           struct filter_pred *src)
 {
         struct filter_pred *dest = &filter->preds[idx];
         struct filter_pred *left;
         struct filter_pred *right;
 
         *dest = *src;
-        if (src->field_name) {
-                dest->field_name = kstrdup(src->field_name, GFP_KERNEL);
-                if (!dest->field_name)
-                        return -ENOMEM;
-        }
-        dest->fn = fn;
         dest->index = idx;
 
         if (dest->op == OP_OR || dest->op == OP_AND) {
@@ -743,11 +769,7 @@ static int filter_set_pred(struct event_filter *filter,
 
 static void __free_preds(struct event_filter *filter)
 {
-        int i;
-
         if (filter->preds) {
-                for (i = 0; i < filter->a_preds; i++)
-                        kfree(filter->preds[i].field_name);
                 kfree(filter->preds);
                 filter->preds = NULL;
         }
@@ -840,23 +862,19 @@ static void filter_free_subsystem_filters(struct event_subsystem *system)
         }
 }
 
-static int filter_add_pred_fn(struct filter_parse_state *ps,
-                              struct ftrace_event_call *call,
-                              struct event_filter *filter,
-                              struct filter_pred *pred,
-                              struct pred_stack *stack,
-                              filter_pred_fn_t fn)
+static int filter_add_pred(struct filter_parse_state *ps,
+                           struct event_filter *filter,
+                           struct filter_pred *pred,
+                           struct pred_stack *stack)
 {
-        int idx, err;
+        int err;
 
         if (WARN_ON(filter->n_preds == filter->a_preds)) {
                 parse_error(ps, FILT_ERR_TOO_MANY_PREDS, 0);
                 return -ENOSPC;
         }
 
-        idx = filter->n_preds;
-        filter_clear_pred(&filter->preds[idx]);
-        err = filter_set_pred(filter, idx, stack, pred, fn);
+        err = filter_set_pred(filter, filter->n_preds, stack, pred);
         if (err)
                 return err;
 
@@ -937,31 +955,15 @@ static filter_pred_fn_t select_comparison_fn(int op, int field_size,
         return fn;
 }
 
-static int filter_add_pred(struct filter_parse_state *ps,
-                           struct ftrace_event_call *call,
-                           struct event_filter *filter,
-                           struct filter_pred *pred,
-                           struct pred_stack *stack,
-                           bool dry_run)
+static int init_pred(struct filter_parse_state *ps,
+                     struct ftrace_event_field *field,
+                     struct filter_pred *pred)
+
 {
-        struct ftrace_event_field *field;
-        filter_pred_fn_t fn;
+        filter_pred_fn_t fn = filter_pred_none;
         unsigned long long val;
         int ret;
 
-        fn = pred->fn = filter_pred_none;
-
-        if (pred->op == OP_AND)
-                goto add_pred_fn;
-        else if (pred->op == OP_OR)
-                goto add_pred_fn;
-
-        field = find_event_field(call, pred->field_name);
-        if (!field) {
-                parse_error(ps, FILT_ERR_FIELD_NOT_FOUND, 0);
-                return -EINVAL;
-        }
-
         pred->offset = field->offset;
 
         if (!is_legal_op(field, pred->op)) {
@@ -1001,9 +1003,7 @@ static int filter_add_pred(struct filter_parse_state *ps,
         if (pred->op == OP_NE)
                 pred->not = 1;
 
-add_pred_fn:
-        if (!dry_run)
-                return filter_add_pred_fn(ps, call, filter, pred, stack, fn);
+        pred->fn = fn;
         return 0;
 }
 
@@ -1302,39 +1302,37 @@ parse_operand:
         return 0;
 }
 
-static struct filter_pred *create_pred(int op, char *operand1, char *operand2)
+static struct filter_pred *create_pred(struct filter_parse_state *ps,
+                                       struct ftrace_event_call *call,
+                                       int op, char *operand1, char *operand2)
 {
-        struct filter_pred *pred;
+        struct ftrace_event_field *field;
+        static struct filter_pred pred;
 
-        pred = kzalloc(sizeof(*pred), GFP_KERNEL);
-        if (!pred)
-                return NULL;
+        memset(&pred, 0, sizeof(pred));
+        pred.op = op;
 
-        pred->field_name = kstrdup(operand1, GFP_KERNEL);
-        if (!pred->field_name) {
-                kfree(pred);
+        if (op == OP_AND || op == OP_OR)
+                return &pred;
+
+        if (!operand1 || !operand2) {
+                parse_error(ps, FILT_ERR_MISSING_FIELD, 0);
                 return NULL;
         }
 
-        strcpy(pred->regex.pattern, operand2);
-        pred->regex.len = strlen(pred->regex.pattern);
-
-        pred->op = op;
-
-        return pred;
-}
-
-static struct filter_pred *create_logical_pred(int op)
-{
-        struct filter_pred *pred;
-
-        pred = kzalloc(sizeof(*pred), GFP_KERNEL);
-        if (!pred)
+        field = find_event_field(call, operand1);
+        if (!field) {
+                parse_error(ps, FILT_ERR_FIELD_NOT_FOUND, 0);
                 return NULL;
+        }
 
-        pred->op = op;
+        strcpy(pred.regex.pattern, operand2);
+        pred.regex.len = strlen(pred.regex.pattern);
 
-        return pred;
+#ifdef CONFIG_FTRACE_STARTUP_TEST
+        pred.field = field;
+#endif
+        return init_pred(ps, field, &pred) ? NULL : &pred;
 }
 
 static int check_preds(struct filter_parse_state *ps)
@@ -1375,6 +1373,23 @@ static int count_preds(struct filter_parse_state *ps)
         return n_preds;
 }
 
+struct check_pred_data {
+        int count;
+        int max;
+};
+
+static int check_pred_tree_cb(enum move_type move, struct filter_pred *pred,
+                              int *err, void *data)
+{
+        struct check_pred_data *d = data;
+
+        if (WARN_ON(d->count++ > d->max)) {
+                *err = -EINVAL;
+                return WALK_PRED_ABORT;
+        }
+        return WALK_PRED_DEFAULT;
+}
+
 /*
  * The tree is walked at filtering of an event. If the tree is not correctly
  * built, it may cause an infinite loop. Check here that the tree does
@@ -1383,107 +1398,76 @@ static int count_preds(struct filter_parse_state *ps)
 static int check_pred_tree(struct event_filter *filter,
                            struct filter_pred *root)
 {
-        struct filter_pred *preds;
-        struct filter_pred *pred;
-        enum move_type move = MOVE_DOWN;
-        int count = 0;
-        int done = 0;
-        int max;
-
-        /*
-         * The max that we can hit a node is three times.
-         * Once going down, once coming up from left, and
-         * once coming up from right. This is more than enough
-         * since leafs are only hit a single time.
-         */
-        max = 3 * filter->n_preds;
+        struct check_pred_data data = {
+                /*
+                 * The max that we can hit a node is three times.
+                 * Once going down, once coming up from left, and
+                 * once coming up from right. This is more than enough
+                 * since leafs are only hit a single time.
+                 */
+                .max   = 3 * filter->n_preds,
+                .count = 0,
+        };
 
-        preds = filter->preds;
-        if  (!preds)
-                return -EINVAL;
-        pred = root;
+        return walk_pred_tree(filter->preds, root,
+                              check_pred_tree_cb, &data);
+}
 
-        do {
-                if (WARN_ON(count++ > max))
-                        return -EINVAL;
+static int count_leafs_cb(enum move_type move, struct filter_pred *pred,
+                          int *err, void *data)
+{
+        int *count = data;
 
-                switch (move) {
-                case MOVE_DOWN:
-                        if (pred->left != FILTER_PRED_INVALID) {
-                                pred = &preds[pred->left];
-                                continue;
-                        }
-                        /* A leaf at the root is just a leaf in the tree */
-                        if (pred == root)
-                                break;
-                        pred = get_pred_parent(pred, preds,
-                                               pred->parent, &move);
-                        continue;
-                case MOVE_UP_FROM_LEFT:
-                        pred = &preds[pred->right];
-                        move = MOVE_DOWN;
-                        continue;
-                case MOVE_UP_FROM_RIGHT:
-                        if (pred == root)
-                                break;
-                        pred = get_pred_parent(pred, preds,
-                                               pred->parent, &move);
-                        continue;
-                }
-                done = 1;
-        } while (!done);
+        if ((move == MOVE_DOWN) &&
+            (pred->left == FILTER_PRED_INVALID))
+                (*count)++;
 
-        /* We are fine. */
-        return 0;
+        return WALK_PRED_DEFAULT;
 }
 
 static int count_leafs(struct filter_pred *preds, struct filter_pred *root)
 {
-        struct filter_pred *pred;
-        enum move_type move = MOVE_DOWN;
-        int count = 0;
-        int done = 0;
+        int count = 0, ret;
 
-        pred = root;
+        ret = walk_pred_tree(preds, root, count_leafs_cb, &count);
+        WARN_ON(ret);
+        return count;
+}
 
-        do {
-                switch (move) {
-                case MOVE_DOWN:
-                        if (pred->left != FILTER_PRED_INVALID) {
-                                pred = &preds[pred->left];
-                                continue;
-                        }
-                        /* A leaf at the root is just a leaf in the tree */
-                        if (pred == root)
-                                return 1;
-                        count++;
-                        pred = get_pred_parent(pred, preds,
-                                               pred->parent, &move);
-                        continue;
-                case MOVE_UP_FROM_LEFT:
-                        pred = &preds[pred->right];
-                        move = MOVE_DOWN;
-                        continue;
-                case MOVE_UP_FROM_RIGHT:
-                        if (pred == root)
-                                break;
-                        pred = get_pred_parent(pred, preds,
-                                               pred->parent, &move);
-                        continue;
-                }
-                done = 1;
-        } while (!done);
+struct fold_pred_data {
+        struct filter_pred *root;
+        int count;
+        int children;
+};
 
-        return count;
+static int fold_pred_cb(enum move_type move, struct filter_pred *pred,
+                        int *err, void *data)
+{
+        struct fold_pred_data *d = data;
+        struct filter_pred *root = d->root;
+
+        if (move != MOVE_DOWN)
+                return WALK_PRED_DEFAULT;
+        if (pred->left != FILTER_PRED_INVALID)
+                return WALK_PRED_DEFAULT;
+
+        if (WARN_ON(d->count == d->children)) {
+                *err = -EINVAL;
+                return WALK_PRED_ABORT;
+        }
+
+        pred->index &= ~FILTER_PRED_FOLD;
+        root->ops[d->count++] = pred->index;
+        return WALK_PRED_DEFAULT;
 }
 
 static int fold_pred(struct filter_pred *preds, struct filter_pred *root)
 {
-        struct filter_pred *pred;
-        enum move_type move = MOVE_DOWN;
-        int count = 0;
+        struct fold_pred_data data = {
+                .root  = root,
+                .count = 0,
+        };
         int children;
-        int done = 0;
 
         /* No need to keep the fold flag */
         root->index &= ~FILTER_PRED_FOLD;
@@ -1501,37 +1485,26 @@ static int fold_pred(struct filter_pred *preds, struct filter_pred *root)
                 return -ENOMEM;
 
         root->val = children;
+        data.children = children;
+        return walk_pred_tree(preds, root, fold_pred_cb, &data);
+}
 
-        pred = root;
-        do {
-                switch (move) {
-                case MOVE_DOWN:
-                        if (pred->left != FILTER_PRED_INVALID) {
-                                pred = &preds[pred->left];
-                                continue;
-                        }
-                        if (WARN_ON(count == children))
-                                return -EINVAL;
-                        pred->index &= ~FILTER_PRED_FOLD;
-                        root->ops[count++] = pred->index;
-                        pred = get_pred_parent(pred, preds,
-                                               pred->parent, &move);
-                        continue;
-                case MOVE_UP_FROM_LEFT:
-                        pred = &preds[pred->right];
-                        move = MOVE_DOWN;
-                        continue;
-                case MOVE_UP_FROM_RIGHT:
-                        if (pred == root)
-                                break;
-                        pred = get_pred_parent(pred, preds,
-                                               pred->parent, &move);
-                        continue;
-                }
-                done = 1;
-        } while (!done);
+static int fold_pred_tree_cb(enum move_type move, struct filter_pred *pred,
+                             int *err, void *data)
+{
+        struct filter_pred *preds = data;
 
-        return 0;
+        if (move != MOVE_DOWN)
+                return WALK_PRED_DEFAULT;
+        if (!(pred->index & FILTER_PRED_FOLD))
+                return WALK_PRED_DEFAULT;
+
+        *err = fold_pred(preds, pred);
+        if (*err)
+                return WALK_PRED_ABORT;
+
+        /* eveyrhing below is folded, continue with parent */
+        return WALK_PRED_PARENT;
 }
 
 /*
@@ -1542,51 +1515,8 @@ static int fold_pred(struct filter_pred *preds, struct filter_pred *root)
 static int fold_pred_tree(struct event_filter *filter,
                            struct filter_pred *root)
 {
-        struct filter_pred *preds;
-        struct filter_pred *pred;
-        enum move_type move = MOVE_DOWN;
-        int done = 0;
-        int err;
-
-        preds = filter->preds;
-        if  (!preds)
-                return -EINVAL;
-        pred = root;
-
-        do {
-                switch (move) {
-                case MOVE_DOWN:
-                        if (pred->index & FILTER_PRED_FOLD) {
-                                err = fold_pred(preds, pred);
-                                if (err)
-                                        return err;
-                                /* Folded nodes are like leafs */
-                        } else if (pred->left != FILTER_PRED_INVALID) {
-                                pred = &preds[pred->left];
-                                continue;
-                        }
-
-                        /* A leaf at the root is just a leaf in the tree */
-                        if (pred == root)
-                                break;
-                        pred = get_pred_parent(pred, preds,
-                                               pred->parent, &move);
-                        continue;
-                case MOVE_UP_FROM_LEFT:
-                        pred = &preds[pred->right];
-                        move = MOVE_DOWN;
-                        continue;
-                case MOVE_UP_FROM_RIGHT:
-                        if (pred == root)
-                                break;
-                        pred = get_pred_parent(pred, preds,
-                                               pred->parent, &move);
-                        continue;
-                }
-                done = 1;
-        } while (!done);
-
-        return 0;
+        return walk_pred_tree(filter->preds, root, fold_pred_tree_cb,
+                              filter->preds);
 }
 
 static int replace_preds(struct ftrace_event_call *call,
@@ -1643,27 +1573,17 @@ static int replace_preds(struct ftrace_event_call *call,
                         goto fail;
                 }
 
-                if (elt->op == OP_AND || elt->op == OP_OR) {
-                        pred = create_logical_pred(elt->op);
-                        goto add_pred;
-                }
-
-                if (!operand1 || !operand2) {
-                        parse_error(ps, FILT_ERR_MISSING_FIELD, 0);
+                pred = create_pred(ps, call, elt->op, operand1, operand2);
+                if (!pred) {
                         err = -EINVAL;
                         goto fail;
                 }
 
-                pred = create_pred(elt->op, operand1, operand2);
-add_pred:
-                if (!pred) {
-                        err = -ENOMEM;
-                        goto fail;
+                if (!dry_run) {
+                        err = filter_add_pred(ps, filter, pred, &stack);
+                        if (err)
+                                goto fail;
                 }
-                err = filter_add_pred(ps, call, filter, pred, &stack, dry_run);
-                filter_free_pred(pred);
-                if (err)
-                        goto fail;
 
                 operand1 = operand2 = NULL;
         }
@@ -1958,17 +1878,14 @@ int ftrace_profile_set_filter(struct perf_event *event, int event_id,
         int err;
         struct event_filter *filter;
         struct filter_parse_state *ps;
-        struct ftrace_event_call *call = NULL;
+        struct ftrace_event_call *call;
 
         mutex_lock(&event_mutex);
 
-        list_for_each_entry(call, &ftrace_events, list) {
-                if (call->event.type == event_id)
-                        break;
-        }
+        call = event->tp_event;
 
         err = -EINVAL;
-        if (&call->list == &ftrace_events)
+        if (!call)
                 goto out_unlock;
 
         err = -EEXIST;
@@ -2012,3 +1929,215 @@ out_unlock:
 
 #endif /* CONFIG_PERF_EVENTS */
 
+#ifdef CONFIG_FTRACE_STARTUP_TEST
+
+#include <linux/types.h>
+#include <linux/tracepoint.h>
+
+#define CREATE_TRACE_POINTS
+#include "trace_events_filter_test.h"
+
+static int test_get_filter(char *filter_str, struct ftrace_event_call *call,
+                           struct event_filter **pfilter)
+{
+        struct event_filter *filter;
+        struct filter_parse_state *ps;
+        int err = -ENOMEM;
+
+        filter = __alloc_filter();
+        if (!filter)
+                goto out;
+
+        ps = kzalloc(sizeof(*ps), GFP_KERNEL);
+        if (!ps)
+                goto free_filter;
+
+        parse_init(ps, filter_ops, filter_str);
+        err = filter_parse(ps);
+        if (err)
+                goto free_ps;
+
+        err = replace_preds(call, filter, ps, filter_str, false);
+        if (!err)
+                *pfilter = filter;
+
+ free_ps:
+        filter_opstack_clear(ps);
+        postfix_clear(ps);
+        kfree(ps);
+
+ free_filter:
+        if (err)
+                __free_filter(filter);
+
+ out:
+        return err;
+}
+
+#define DATA_REC(m, va, vb, vc, vd, ve, vf, vg, vh, nvisit) \
+{ \
+        .filter = FILTER, \
+        .rec    = { .a = va, .b = vb, .c = vc, .d = vd, \
+                    .e = ve, .f = vf, .g = vg, .h = vh }, \
+        .match  = m, \
+        .not_visited = nvisit, \
+}
+#define YES 1
+#define NO  0
+
+static struct test_filter_data_t {
+        char *filter;
+        struct ftrace_raw_ftrace_test_filter rec;
+        int match;
+        char *not_visited;
+} test_filter_data[] = {
+#define FILTER "a == 1 && b == 1 && c == 1 && d == 1 && " \
+               "e == 1 && f == 1 && g == 1 && h == 1"
+        DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, ""),
+        DATA_REC(NO,  0, 1, 1, 1, 1, 1, 1, 1, "bcdefgh"),
+        DATA_REC(NO,  1, 1, 1, 1, 1, 1, 1, 0, ""),
+#undef FILTER
+#define FILTER "a == 1 || b == 1 || c == 1 || d == 1 || " \
+               "e == 1 || f == 1 || g == 1 || h == 1"
+        DATA_REC(NO,  0, 0, 0, 0, 0, 0, 0, 0, ""),
+        DATA_REC(YES, 0, 0, 0, 0, 0, 0, 0, 1, ""),
+        DATA_REC(YES, 1, 0, 0, 0, 0, 0, 0, 0, "bcdefgh"),
+#undef FILTER
+#define FILTER "(a == 1 || b == 1) && (c == 1 || d == 1) && " \
+               "(e == 1 || f == 1) && (g == 1 || h == 1)"
+        DATA_REC(NO,  0, 0, 1, 1, 1, 1, 1, 1, "dfh"),
+        DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
+        DATA_REC(YES, 1, 0, 1, 0, 0, 1, 0, 1, "bd"),
+        DATA_REC(NO,  1, 0, 1, 0, 0, 1, 0, 0, "bd"),
+#undef FILTER
+#define FILTER "(a == 1 && b == 1) || (c == 1 && d == 1) || " \
+               "(e == 1 && f == 1) || (g == 1 && h == 1)"
+        DATA_REC(YES, 1, 0, 1, 1, 1, 1, 1, 1, "efgh"),
+        DATA_REC(YES, 0, 0, 0, 0, 0, 0, 1, 1, ""),
+        DATA_REC(NO,  0, 0, 0, 0, 0, 0, 0, 1, ""),
+#undef FILTER
+#define FILTER "(a == 1 && b == 1) && (c == 1 && d == 1) && " \
+               "(e == 1 && f == 1) || (g == 1 && h == 1)"
+        DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 0, "gh"),
+        DATA_REC(NO,  0, 0, 0, 0, 0, 0, 0, 1, ""),
+        DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, ""),
+#undef FILTER
+#define FILTER "((a == 1 || b == 1) || (c == 1 || d == 1) || " \
+               "(e == 1 || f == 1)) && (g == 1 || h == 1)"
+        DATA_REC(YES, 1, 1, 1, 1, 1, 1, 0, 1, "bcdef"),
+        DATA_REC(NO,  0, 0, 0, 0, 0, 0, 0, 0, ""),
+        DATA_REC(YES, 1, 1, 1, 1, 1, 0, 1, 1, "h"),
+#undef FILTER
+#define FILTER "((((((((a == 1) && (b == 1)) || (c == 1)) && (d == 1)) || " \
+               "(e == 1)) && (f == 1)) || (g == 1)) && (h == 1))"
+        DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "ceg"),
+        DATA_REC(NO,  0, 1, 0, 1, 0, 1, 0, 1, ""),
+        DATA_REC(NO,  1, 0, 1, 0, 1, 0, 1, 0, ""),
+#undef FILTER
+#define FILTER "((((((((a == 1) || (b == 1)) && (c == 1)) || (d == 1)) && " \
+               "(e == 1)) || (f == 1)) && (g == 1)) || (h == 1))"
+        DATA_REC(YES, 1, 1, 1, 1, 1, 1, 1, 1, "bdfh"),
+        DATA_REC(YES, 0, 1, 0, 1, 0, 1, 0, 1, ""),
+        DATA_REC(YES, 1, 0, 1, 0, 1, 0, 1, 0, "bdfh"),
+};
+
+#undef DATA_REC
+#undef FILTER
+#undef YES
+#undef NO
+
+#define DATA_CNT (sizeof(test_filter_data)/sizeof(struct test_filter_data_t))
+
+static int test_pred_visited;
+
+static int test_pred_visited_fn(struct filter_pred *pred, void *event)
+{
+        struct ftrace_event_field *field = pred->field;
+
+        test_pred_visited = 1;
+        printk(KERN_INFO "\npred visited %s\n", field->name);
+        return 1;
+}
+
+static int test_walk_pred_cb(enum move_type move, struct filter_pred *pred,
+                             int *err, void *data)
+{
+        char *fields = data;
+
+        if ((move == MOVE_DOWN) &&
+            (pred->left == FILTER_PRED_INVALID)) {
+                struct ftrace_event_field *field = pred->field;
+
+                if (!field) {
+                        WARN(1, "all leafs should have field defined");
+                        return WALK_PRED_DEFAULT;
+                }
+                if (!strchr(fields, *field->name))
+                        return WALK_PRED_DEFAULT;
+
+                WARN_ON(!pred->fn);
+                pred->fn = test_pred_visited_fn;
+        }
+        return WALK_PRED_DEFAULT;
+}
+
+static __init int ftrace_test_event_filter(void)
+{
+        int i;
+
+        printk(KERN_INFO "Testing ftrace filter: ");
+
+        for (i = 0; i < DATA_CNT; i++) {
+                struct event_filter *filter = NULL;
+                struct test_filter_data_t *d = &test_filter_data[i];
+                int err;
+
+                err = test_get_filter(d->filter, &event_ftrace_test_filter,
+                                      &filter);
+                if (err) {
+                        printk(KERN_INFO
+                               "Failed to get filter for '%s', err %d\n",
+                               d->filter, err);
+                        break;
+                }
+
+                /*
+                 * The preemption disabling is not really needed for self
+                 * tests, but the rcu dereference will complain without it.
+                 */
+                preempt_disable();
+                if (*d->not_visited)
+                        walk_pred_tree(filter->preds, filter->root,
+                                       test_walk_pred_cb,
+                                       d->not_visited);
+
+                test_pred_visited = 0;
+                err = filter_match_preds(filter, &d->rec);
+                preempt_enable();
+
+                __free_filter(filter);
+
+                if (test_pred_visited) {
+                        printk(KERN_INFO
+                               "Failed, unwanted pred visited for filter %s\n",
+                               d->filter);
+                        break;
+                }
+
+                if (err != d->match) {
+                        printk(KERN_INFO
+                               "Failed to match filter '%s', expected %d\n",
+                               d->filter, d->match);
+                        break;
+                }
+        }
+
+        if (i == DATA_CNT)
+                printk(KERN_CONT "OK\n");
+
+        return 0;
+}
+
+late_initcall(ftrace_test_event_filter);
+
+#endif /* CONFIG_FTRACE_STARTUP_TEST */
diff --git a/kernel/trace/trace_events_filter_test.h b/kernel/trace/trace_events_filter_test.h
new file mode 100644
index 000000000000..bfd4dba0d603
--- /dev/null
+++ b/kernel/trace/trace_events_filter_test.h
@@ -0,0 +1,50 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM test
+
+#if !defined(_TRACE_TEST_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_TEST_H
+
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(ftrace_test_filter,
+
+        TP_PROTO(int a, int b, int c, int d, int e, int f, int g, int h),
+
+        TP_ARGS(a, b, c, d, e, f, g, h),
+
+        TP_STRUCT__entry(
+                __field(int, a)
+                __field(int, b)
+                __field(int, c)
+                __field(int, d)
+                __field(int, e)
+                __field(int, f)
+                __field(int, g)
+                __field(int, h)
+        ),
+
+        TP_fast_assign(
+                __entry->a = a;
+                __entry->b = b;
+                __entry->c = c;
+                __entry->d = d;
+                __entry->e = e;
+                __entry->f = f;
+                __entry->g = g;
+                __entry->h = h;
+        ),
+
+        TP_printk("a %d, b %d, c %d, d %d, e %d, f %d, g %d, h %d",
+                  __entry->a, __entry->b, __entry->c, __entry->d,
+                  __entry->e, __entry->f, __entry->g, __entry->h)
+);
+
+#endif /* _TRACE_TEST_H || TRACE_HEADER_MULTI_READ */
+
+#undef TRACE_INCLUDE_PATH
+#undef TRACE_INCLUDE_FILE
+#define TRACE_INCLUDE_PATH .
+#define TRACE_INCLUDE_FILE trace_events_filter_test
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index 11186212068c..20dad0d7a163 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -505,13 +505,13 @@ EXPORT_SYMBOL(trace_hardirqs_off_caller);
 #ifdef CONFIG_PREEMPT_TRACER
 void trace_preempt_on(unsigned long a0, unsigned long a1)
 {
-        if (preempt_trace())
+        if (preempt_trace() && !irq_trace())
                 stop_critical_timing(a0, a1);
 }
 
 void trace_preempt_off(unsigned long a0, unsigned long a1)
 {
-        if (preempt_trace())
+        if (preempt_trace() && !irq_trace())
                 start_critical_timing(a0, a1);
 }
 #endif /* CONFIG_PREEMPT_TRACER */
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index 5fb3697bf0e5..00d527c945a4 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -836,11 +836,17 @@ static void __unregister_trace_probe(struct trace_probe *tp)
 }
 
 /* Unregister a trace_probe and probe_event: call with locking probe_lock */
-static void unregister_trace_probe(struct trace_probe *tp)
+static int unregister_trace_probe(struct trace_probe *tp)
 {
+        /* Enabled event can not be unregistered */
+        if (trace_probe_is_enabled(tp))
+                return -EBUSY;
+
         __unregister_trace_probe(tp);
         list_del(&tp->list);
         unregister_probe_event(tp);
+
+        return 0;
 }
 
 /* Register a trace_probe and probe_event */
@@ -854,7 +860,9 @@ static int register_trace_probe(struct trace_probe *tp)
         /* Delete old (same name) event if exist */
         old_tp = find_trace_probe(tp->call.name, tp->call.class->system);
         if (old_tp) {
-                unregister_trace_probe(old_tp);
+                ret = unregister_trace_probe(old_tp);
+                if (ret < 0)
+                        goto end;
                 free_trace_probe(old_tp);
         }
 
@@ -892,6 +900,7 @@ static int trace_probe_module_callback(struct notifier_block *nb,
         mutex_lock(&probe_lock);
         list_for_each_entry(tp, &probe_list, list) {
                 if (trace_probe_within_module(tp, mod)) {
+                        /* Don't need to check busy - this should have gone. */
                         __unregister_trace_probe(tp);
                         ret = __register_trace_probe(tp);
                         if (ret)
@@ -1205,10 +1214,11 @@ static int create_trace_probe(int argc, char **argv)
                         return -ENOENT;
                 }
                 /* delete an event */
-                unregister_trace_probe(tp);
-                free_trace_probe(tp);
+                ret = unregister_trace_probe(tp);
+                if (ret == 0)
+                        free_trace_probe(tp);
                 mutex_unlock(&probe_lock);
-                return 0;
+                return ret;
         }
 
         if (argc < 2) {
@@ -1317,18 +1327,29 @@ error:
         return ret;
 }
 
-static void release_all_trace_probes(void)
+static int release_all_trace_probes(void)
 {
         struct trace_probe *tp;
+        int ret = 0;
 
         mutex_lock(&probe_lock);
+        /* Ensure no probe is in use. */
+        list_for_each_entry(tp, &probe_list, list)
+                if (trace_probe_is_enabled(tp)) {
+                        ret = -EBUSY;
+                        goto end;
+                }
         /* TODO: Use batch unregistration */
         while (!list_empty(&probe_list)) {
                 tp = list_entry(probe_list.next, struct trace_probe, list);
                 unregister_trace_probe(tp);
                 free_trace_probe(tp);
         }
+
+end:
         mutex_unlock(&probe_lock);
+
+        return ret;
 }
 
 /* Probes listing interfaces */
@@ -1380,9 +1401,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))
-                release_all_trace_probes();
+        int ret;
+
+        if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
+                ret = release_all_trace_probes();
+                if (ret < 0)
+                        return ret;
+        }
 
         return seq_open(file, &probes_seq_op);
 }
@@ -2055,6 +2080,21 @@ static __init int kprobe_trace_self_tests_init(void)
 
         ret = target(1, 2, 3, 4, 5, 6);
 
+        /* Disable trace points before removing it */
+        tp = find_trace_probe("testprobe", KPROBE_EVENT_SYSTEM);
+        if (WARN_ON_ONCE(tp == NULL)) {
+                pr_warning("error on getting test probe.\n");
+                warn++;
+        } else
+                disable_trace_probe(tp, TP_FLAG_TRACE);
+
+        tp = find_trace_probe("testprobe2", KPROBE_EVENT_SYSTEM);
+        if (WARN_ON_ONCE(tp == NULL)) {
+                pr_warning("error on getting 2nd test probe.\n");
+                warn++;
+        } else
+                disable_trace_probe(tp, TP_FLAG_TRACE);
+
         ret = command_trace_probe("-:testprobe");
         if (WARN_ON_ONCE(ret)) {
                 pr_warning("error on deleting a probe.\n");
diff --git a/kernel/trace/trace_printk.c b/kernel/trace/trace_printk.c
index 1f06468a10d7..6fd4ffd042f9 100644
--- a/kernel/trace/trace_printk.c
+++ b/kernel/trace/trace_printk.c
@@ -59,18 +59,19 @@ void hold_module_trace_bprintk_format(const char **start, const char **end)
                         continue;
                 }
 
+                fmt = NULL;
                 tb_fmt = kmalloc(sizeof(*tb_fmt), GFP_KERNEL);
-                if (tb_fmt)
+                if (tb_fmt) {
                         fmt = kmalloc(strlen(*iter) + 1, GFP_KERNEL);
-                if (tb_fmt && fmt) {
-                        list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
-                        strcpy(fmt, *iter);
-                        tb_fmt->fmt = fmt;
-                        *iter = tb_fmt->fmt;
-                } else {
-                        kfree(tb_fmt);
-                        *iter = NULL;
+                        if (fmt) {
+                                list_add_tail(&tb_fmt->list, &trace_bprintk_fmt_list);
+                                strcpy(fmt, *iter);
+                                tb_fmt->fmt = fmt;
+                        } else
+                                kfree(tb_fmt);
                 }
+                *iter = fmt;
+
         }
         mutex_unlock(&btrace_mutex);
 }