Merge branches 'idle-fix' and 'misc' into release

13 files changed, 794 insertions, 233 deletions

diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index cd3134510f3d..a1d2849f2473 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -141,7 +141,7 @@ if FTRACE
 config FUNCTION_TRACER
         bool "Kernel Function Tracer"
         depends on HAVE_FUNCTION_TRACER
-        select FRAME_POINTER if !ARM_UNWIND && !S390 && !MICROBLAZE
+        select FRAME_POINTER if !ARM_UNWIND && !PPC && !S390 && !MICROBLAZE
         select KALLSYMS
         select GENERIC_TRACER
         select CONTEXT_SWITCH_TRACER
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 683d559a0eef..0fa92f677c92 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -62,6 +62,8 @@
 #define FTRACE_HASH_DEFAULT_BITS 10
 #define FTRACE_HASH_MAX_BITS 12
 
+#define FL_GLOBAL_CONTROL_MASK (FTRACE_OPS_FL_GLOBAL | FTRACE_OPS_FL_CONTROL)
+
 /* ftrace_enabled is a method to turn ftrace on or off */
 int ftrace_enabled __read_mostly;
 static int last_ftrace_enabled;
@@ -89,12 +91,14 @@ static struct ftrace_ops ftrace_list_end __read_mostly = {
 };
 
 static struct ftrace_ops *ftrace_global_list __read_mostly = &ftrace_list_end;
+static struct ftrace_ops *ftrace_control_list __read_mostly = &ftrace_list_end;
 static struct ftrace_ops *ftrace_ops_list __read_mostly = &ftrace_list_end;
 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
 static ftrace_func_t __ftrace_trace_function_delay __read_mostly = ftrace_stub;
 ftrace_func_t __ftrace_trace_function __read_mostly = ftrace_stub;
 ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub;
 static struct ftrace_ops global_ops;
+static struct ftrace_ops control_ops;
 
 static void
 ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip);
@@ -168,6 +172,32 @@ static void ftrace_test_stop_func(unsigned long ip, unsigned long parent_ip)
 }
 #endif
 
+static void control_ops_disable_all(struct ftrace_ops *ops)
+{
+        int cpu;
+
+        for_each_possible_cpu(cpu)
+                *per_cpu_ptr(ops->disabled, cpu) = 1;
+}
+
+static int control_ops_alloc(struct ftrace_ops *ops)
+{
+        int __percpu *disabled;
+
+        disabled = alloc_percpu(int);
+        if (!disabled)
+                return -ENOMEM;
+
+        ops->disabled = disabled;
+        control_ops_disable_all(ops);
+        return 0;
+}
+
+static void control_ops_free(struct ftrace_ops *ops)
+{
+        free_percpu(ops->disabled);
+}
+
 static void update_global_ops(void)
 {
         ftrace_func_t func;
@@ -219,7 +249,8 @@ static void update_ftrace_function(void)
 #else
         __ftrace_trace_function = func;
 #endif
-        ftrace_trace_function = ftrace_test_stop_func;
+        ftrace_trace_function =
+                (func == ftrace_stub) ? func : ftrace_test_stop_func;
 #endif
 }
 
@@ -259,6 +290,26 @@ static int remove_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
         return 0;
 }
 
+static void add_ftrace_list_ops(struct ftrace_ops **list,
+                                struct ftrace_ops *main_ops,
+                                struct ftrace_ops *ops)
+{
+        int first = *list == &ftrace_list_end;
+        add_ftrace_ops(list, ops);
+        if (first)
+                add_ftrace_ops(&ftrace_ops_list, main_ops);
+}
+
+static int remove_ftrace_list_ops(struct ftrace_ops **list,
+                                  struct ftrace_ops *main_ops,
+                                  struct ftrace_ops *ops)
+{
+        int ret = remove_ftrace_ops(list, ops);
+        if (!ret && *list == &ftrace_list_end)
+                ret = remove_ftrace_ops(&ftrace_ops_list, main_ops);
+        return ret;
+}
+
 static int __register_ftrace_function(struct ftrace_ops *ops)
 {
         if (ftrace_disabled)
@@ -270,15 +321,20 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
         if (WARN_ON(ops->flags & FTRACE_OPS_FL_ENABLED))
                 return -EBUSY;
 
+        /* We don't support both control and global flags set. */
+        if ((ops->flags & FL_GLOBAL_CONTROL_MASK) == FL_GLOBAL_CONTROL_MASK)
+                return -EINVAL;
+
         if (!core_kernel_data((unsigned long)ops))
                 ops->flags |= FTRACE_OPS_FL_DYNAMIC;
 
         if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
-                int first = ftrace_global_list == &ftrace_list_end;
-                add_ftrace_ops(&ftrace_global_list, ops);
+                add_ftrace_list_ops(&ftrace_global_list, &global_ops, ops);
                 ops->flags |= FTRACE_OPS_FL_ENABLED;
-                if (first)
-                        add_ftrace_ops(&ftrace_ops_list, &global_ops);
+        } else if (ops->flags & FTRACE_OPS_FL_CONTROL) {
+                if (control_ops_alloc(ops))
+                        return -ENOMEM;
+                add_ftrace_list_ops(&ftrace_control_list, &control_ops, ops);
         } else
                 add_ftrace_ops(&ftrace_ops_list, ops);
 
@@ -302,11 +358,23 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
                 return -EINVAL;
 
         if (ops->flags & FTRACE_OPS_FL_GLOBAL) {
-                ret = remove_ftrace_ops(&ftrace_global_list, ops);
-                if (!ret && ftrace_global_list == &ftrace_list_end)
-                        ret = remove_ftrace_ops(&ftrace_ops_list, &global_ops);
+                ret = remove_ftrace_list_ops(&ftrace_global_list,
+                                             &global_ops, ops);
                 if (!ret)
                         ops->flags &= ~FTRACE_OPS_FL_ENABLED;
+        } else if (ops->flags & FTRACE_OPS_FL_CONTROL) {
+                ret = remove_ftrace_list_ops(&ftrace_control_list,
+                                             &control_ops, ops);
+                if (!ret) {
+                        /*
+                         * The ftrace_ops is now removed from the list,
+                         * so there'll be no new users. We must ensure
+                         * all current users are done before we free
+                         * the control data.
+                         */
+                        synchronize_sched();
+                        control_ops_free(ops);
+                }
         } else
                 ret = remove_ftrace_ops(&ftrace_ops_list, ops);
 
@@ -1119,6 +1187,12 @@ static void free_ftrace_hash_rcu(struct ftrace_hash *hash)
         call_rcu_sched(&hash->rcu, __free_ftrace_hash_rcu);
 }
 
+void ftrace_free_filter(struct ftrace_ops *ops)
+{
+        free_ftrace_hash(ops->filter_hash);
+        free_ftrace_hash(ops->notrace_hash);
+}
+
 static struct ftrace_hash *alloc_ftrace_hash(int size_bits)
 {
         struct ftrace_hash *hash;
@@ -1129,7 +1203,7 @@ static struct ftrace_hash *alloc_ftrace_hash(int size_bits)
                 return NULL;
 
         size = 1 << size_bits;
-        hash->buckets = kzalloc(sizeof(*hash->buckets) * size, GFP_KERNEL);
+        hash->buckets = kcalloc(size, sizeof(*hash->buckets), GFP_KERNEL);
 
         if (!hash->buckets) {
                 kfree(hash);
@@ -3146,8 +3220,10 @@ ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len,
         mutex_lock(&ftrace_regex_lock);
         if (reset)
                 ftrace_filter_reset(hash);
-        if (buf)
-                ftrace_match_records(hash, buf, len);
+        if (buf && !ftrace_match_records(hash, buf, len)) {
+                ret = -EINVAL;
+                goto out_regex_unlock;
+        }
 
         mutex_lock(&ftrace_lock);
         ret = ftrace_hash_move(ops, enable, orig_hash, hash);
@@ -3157,6 +3233,7 @@ ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len,
 
         mutex_unlock(&ftrace_lock);
 
+ out_regex_unlock:
         mutex_unlock(&ftrace_regex_lock);
 
         free_ftrace_hash(hash);
@@ -3173,10 +3250,10 @@ ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len,
  * Filters denote which functions should be enabled when tracing is enabled.
  * If @buf is NULL and reset is set, all functions will be enabled for tracing.
  */
-void ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
+int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
                        int len, int reset)
 {
-        ftrace_set_regex(ops, buf, len, reset, 1);
+        return ftrace_set_regex(ops, buf, len, reset, 1);
 }
 EXPORT_SYMBOL_GPL(ftrace_set_filter);
 
@@ -3191,10 +3268,10 @@ EXPORT_SYMBOL_GPL(ftrace_set_filter);
  * is enabled. If @buf is NULL and reset is set, all functions will be enabled
  * for tracing.
  */
-void ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
+int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
                         int len, int reset)
 {
-        ftrace_set_regex(ops, buf, len, reset, 0);
+        return ftrace_set_regex(ops, buf, len, reset, 0);
 }
 EXPORT_SYMBOL_GPL(ftrace_set_notrace);
 /**
@@ -3871,6 +3948,36 @@ ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip)
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
 static void
+ftrace_ops_control_func(unsigned long ip, unsigned long parent_ip)
+{
+        struct ftrace_ops *op;
+
+        if (unlikely(trace_recursion_test(TRACE_CONTROL_BIT)))
+                return;
+
+        /*
+         * Some of the ops may be dynamically allocated,
+         * they must be freed after a synchronize_sched().
+         */
+        preempt_disable_notrace();
+        trace_recursion_set(TRACE_CONTROL_BIT);
+        op = rcu_dereference_raw(ftrace_control_list);
+        while (op != &ftrace_list_end) {
+                if (!ftrace_function_local_disabled(op) &&
+                    ftrace_ops_test(op, ip))
+                        op->func(ip, parent_ip);
+
+                op = rcu_dereference_raw(op->next);
+        };
+        trace_recursion_clear(TRACE_CONTROL_BIT);
+        preempt_enable_notrace();
+}
+
+static struct ftrace_ops control_ops = {
+        .func = ftrace_ops_control_func,
+};
+
+static void
 ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip)
 {
         struct ftrace_ops *op;
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index f5b7b5c1195b..cf8d11e91efd 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -154,33 +154,10 @@ enum {
 
 static unsigned long ring_buffer_flags __read_mostly = RB_BUFFERS_ON;
 
-#define BUF_PAGE_HDR_SIZE offsetof(struct buffer_data_page, data)
-
-/**
- * tracing_on - enable all tracing buffers
- *
- * This function enables all tracing buffers that may have been
- * disabled with tracing_off.
- */
-void tracing_on(void)
-{
-        set_bit(RB_BUFFERS_ON_BIT, &ring_buffer_flags);
-}
-EXPORT_SYMBOL_GPL(tracing_on);
+/* Used for individual buffers (after the counter) */
+#define RB_BUFFER_OFF           (1 << 20)
 
-/**
- * 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)
-{
-        clear_bit(RB_BUFFERS_ON_BIT, &ring_buffer_flags);
-}
-EXPORT_SYMBOL_GPL(tracing_off);
+#define BUF_PAGE_HDR_SIZE offsetof(struct buffer_data_page, data)
 
 /**
  * tracing_off_permanent - permanently disable ring buffers
@@ -193,15 +170,6 @@ void tracing_off_permanent(void)
         set_bit(RB_BUFFERS_DISABLED_BIT, &ring_buffer_flags);
 }
 
-/**
- * tracing_is_on - show state of ring buffers enabled
- */
-int tracing_is_on(void)
-{
-        return ring_buffer_flags == RB_BUFFERS_ON;
-}
-EXPORT_SYMBOL_GPL(tracing_is_on);
-
 #define RB_EVNT_HDR_SIZE (offsetof(struct ring_buffer_event, array))
 #define RB_ALIGNMENT            4U
 #define RB_MAX_SMALL_DATA       (RB_ALIGNMENT * RINGBUF_TYPE_DATA_TYPE_LEN_MAX)
@@ -2619,6 +2587,63 @@ void ring_buffer_record_enable(struct ring_buffer *buffer)
 EXPORT_SYMBOL_GPL(ring_buffer_record_enable);
 
 /**
+ * ring_buffer_record_off - stop all writes into the buffer
+ * @buffer: The ring buffer to stop writes to.
+ *
+ * This prevents all writes to the buffer. Any attempt to write
+ * to the buffer after this will fail and return NULL.
+ *
+ * This is different than ring_buffer_record_disable() as
+ * it works like an on/off switch, where as the disable() verison
+ * must be paired with a enable().
+ */
+void ring_buffer_record_off(struct ring_buffer *buffer)
+{
+        unsigned int rd;
+        unsigned int new_rd;
+
+        do {
+                rd = atomic_read(&buffer->record_disabled);
+                new_rd = rd | RB_BUFFER_OFF;
+        } while (atomic_cmpxchg(&buffer->record_disabled, rd, new_rd) != rd);
+}
+EXPORT_SYMBOL_GPL(ring_buffer_record_off);
+
+/**
+ * ring_buffer_record_on - restart writes into the buffer
+ * @buffer: The ring buffer to start writes to.
+ *
+ * This enables all writes to the buffer that was disabled by
+ * ring_buffer_record_off().
+ *
+ * This is different than ring_buffer_record_enable() as
+ * it works like an on/off switch, where as the enable() verison
+ * must be paired with a disable().
+ */
+void ring_buffer_record_on(struct ring_buffer *buffer)
+{
+        unsigned int rd;
+        unsigned int new_rd;
+
+        do {
+                rd = atomic_read(&buffer->record_disabled);
+                new_rd = rd & ~RB_BUFFER_OFF;
+        } while (atomic_cmpxchg(&buffer->record_disabled, rd, new_rd) != rd);
+}
+EXPORT_SYMBOL_GPL(ring_buffer_record_on);
+
+/**
+ * ring_buffer_record_is_on - return true if the ring buffer can write
+ * @buffer: The ring buffer to see if write is enabled
+ *
+ * Returns true if the ring buffer is in a state that it accepts writes.
+ */
+int ring_buffer_record_is_on(struct ring_buffer *buffer)
+{
+        return !atomic_read(&buffer->record_disabled);
+}
+
+/**
  * ring_buffer_record_disable_cpu - stop all writes into the cpu_buffer
  * @buffer: The ring buffer to stop writes to.
  * @cpu: The CPU buffer to stop
@@ -4039,68 +4064,6 @@ int ring_buffer_read_page(struct ring_buffer *buffer,
 }
 EXPORT_SYMBOL_GPL(ring_buffer_read_page);
 
-#ifdef CONFIG_TRACING
-static ssize_t
-rb_simple_read(struct file *filp, char __user *ubuf,
-               size_t cnt, loff_t *ppos)
-{
-        unsigned long *p = filp->private_data;
-        char buf[64];
-        int r;
-
-        if (test_bit(RB_BUFFERS_DISABLED_BIT, p))
-                r = sprintf(buf, "permanently disabled\n");
-        else
-                r = sprintf(buf, "%d\n", test_bit(RB_BUFFERS_ON_BIT, 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)
-{
-        unsigned long *p = filp->private_data;
-        unsigned long val;
-        int ret;
-
-        ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
-        if (ret)
-                return ret;
-
-        if (val)
-                set_bit(RB_BUFFERS_ON_BIT, p);
-        else
-                clear_bit(RB_BUFFERS_ON_BIT, p);
-
-        (*ppos)++;
-
-        return cnt;
-}
-
-static const struct file_operations rb_simple_fops = {
-        .open           = tracing_open_generic,
-        .read           = rb_simple_read,
-        .write          = rb_simple_write,
-        .llseek         = default_llseek,
-};
-
-
-static __init int rb_init_debugfs(void)
-{
-        struct dentry *d_tracer;
-
-        d_tracer = tracing_init_dentry();
-
-        trace_create_file("tracing_on", 0644, d_tracer,
-                            &ring_buffer_flags, &rb_simple_fops);
-
-        return 0;
-}
-
-fs_initcall(rb_init_debugfs);
-#endif
-
 #ifdef CONFIG_HOTPLUG_CPU
 static int rb_cpu_notify(struct notifier_block *self,
                          unsigned long action, void *hcpu)
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index a3f1bc5d2a00..ed7b5d1e12f4 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -36,6 +36,7 @@
 #include <linux/ctype.h>
 #include <linux/init.h>
 #include <linux/poll.h>
+#include <linux/nmi.h>
 #include <linux/fs.h>
 
 #include "trace.h"
@@ -352,6 +353,59 @@ static void wakeup_work_handler(struct work_struct *work)
 static DECLARE_DELAYED_WORK(wakeup_work, wakeup_work_handler);
 
 /**
+ * tracing_on - enable tracing buffers
+ *
+ * This function enables tracing buffers that may have been
+ * disabled with tracing_off.
+ */
+void tracing_on(void)
+{
+        if (global_trace.buffer)
+                ring_buffer_record_on(global_trace.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;
+}
+EXPORT_SYMBOL_GPL(tracing_on);
+
+/**
+ * tracing_off - turn off tracing buffers
+ *
+ * This function stops the 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)
+{
+        if (global_trace.buffer)
+                ring_buffer_record_on(global_trace.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;
+}
+EXPORT_SYMBOL_GPL(tracing_off);
+
+/**
+ * tracing_is_on - show state of ring buffers enabled
+ */
+int tracing_is_on(void)
+{
+        if (global_trace.buffer)
+                return ring_buffer_record_is_on(global_trace.buffer);
+        return !global_trace.buffer_disabled;
+}
+EXPORT_SYMBOL_GPL(tracing_is_on);
+
+/**
  * trace_wake_up - wake up tasks waiting for trace input
  *
  * Schedules a delayed work to wake up any task that is blocked on the
@@ -1644,6 +1698,7 @@ __find_next_entry(struct trace_iterator *iter, int *ent_cpu,
         int cpu_file = iter->cpu_file;
         u64 next_ts = 0, ts;
         int next_cpu = -1;
+        int next_size = 0;
         int cpu;
 
         /*
@@ -1675,9 +1730,12 @@ __find_next_entry(struct trace_iterator *iter, int *ent_cpu,
                         next_cpu = cpu;
                         next_ts = ts;
                         next_lost = lost_events;
+                        next_size = iter->ent_size;
                 }
         }
 
+        iter->ent_size = next_size;
+
         if (ent_cpu)
                 *ent_cpu = next_cpu;
 
@@ -2764,12 +2822,12 @@ static const char readme_msg[] =
         "tracing mini-HOWTO:\n\n"
         "# mount -t debugfs nodev /sys/kernel/debug\n\n"
         "# cat /sys/kernel/debug/tracing/available_tracers\n"
-        "wakeup preemptirqsoff preemptoff irqsoff function sched_switch nop\n\n"
+        "wakeup wakeup_rt preemptirqsoff preemptoff irqsoff function nop\n\n"
         "# cat /sys/kernel/debug/tracing/current_tracer\n"
         "nop\n"
-        "# echo sched_switch > /sys/kernel/debug/tracing/current_tracer\n"
+        "# echo wakeup > /sys/kernel/debug/tracing/current_tracer\n"
         "# cat /sys/kernel/debug/tracing/current_tracer\n"
-        "sched_switch\n"
+        "wakeup\n"
         "# 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"
@@ -4567,6 +4625,55 @@ static __init void create_trace_options_dir(void)
                 create_trace_option_core_file(trace_options[i], i);
 }
 
+static ssize_t
+rb_simple_read(struct file *filp, char __user *ubuf,
+               size_t cnt, loff_t *ppos)
+{
+        struct ring_buffer *buffer = filp->private_data;
+        char buf[64];
+        int r;
+
+        if (buffer)
+                r = ring_buffer_record_is_on(buffer);
+        else
+                r = 0;
+
+        r = sprintf(buf, "%d\n", r);
+
+        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)
+{
+        struct ring_buffer *buffer = filp->private_data;
+        unsigned long val;
+        int ret;
+
+        ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
+        if (ret)
+                return ret;
+
+        if (buffer) {
+                if (val)
+                        ring_buffer_record_on(buffer);
+                else
+                        ring_buffer_record_off(buffer);
+        }
+
+        (*ppos)++;
+
+        return cnt;
+}
+
+static const struct file_operations rb_simple_fops = {
+        .open           = tracing_open_generic,
+        .read           = rb_simple_read,
+        .write          = rb_simple_write,
+        .llseek         = default_llseek,
+};
+
 static __init int tracer_init_debugfs(void)
 {
         struct dentry *d_tracer;
@@ -4626,6 +4733,9 @@ static __init int tracer_init_debugfs(void)
         trace_create_file("trace_clock", 0644, d_tracer, NULL,
                           &trace_clock_fops);
 
+        trace_create_file("tracing_on", 0644, d_tracer,
+                            global_trace.buffer, &rb_simple_fops);
+
 #ifdef CONFIG_DYNAMIC_FTRACE
         trace_create_file("dyn_ftrace_total_info", 0444, d_tracer,
                         &ftrace_update_tot_cnt, &tracing_dyn_info_fops);
@@ -4798,6 +4908,7 @@ __ftrace_dump(bool disable_tracing, enum ftrace_dump_mode oops_dump_mode)
                         if (ret != TRACE_TYPE_NO_CONSUME)
                                 trace_consume(&iter);
                 }
+                touch_nmi_watchdog();
 
                 trace_printk_seq(&iter.seq);
         }
@@ -4863,6 +4974,8 @@ __init static int tracer_alloc_buffers(void)
                 goto out_free_cpumask;
         }
         global_trace.entries = ring_buffer_size(global_trace.buffer);
+        if (global_trace.buffer_disabled)
+                tracing_off();
 
 
 #ifdef CONFIG_TRACER_MAX_TRACE
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index b93ecbadad6d..95059f091a24 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -56,17 +56,23 @@ enum trace_type {
 #define F_STRUCT(args...)               args
 
 #undef FTRACE_ENTRY
-#define FTRACE_ENTRY(name, struct_name, id, tstruct, print)     \
-        struct struct_name {                                    \
-                struct trace_entry      ent;                    \
-                tstruct                                         \
+#define FTRACE_ENTRY(name, struct_name, id, tstruct, print, filter)     \
+        struct struct_name {                                            \
+                struct trace_entry      ent;                            \
+                tstruct                                                 \
         }
 
 #undef TP_ARGS
 #define TP_ARGS(args...)        args
 
 #undef FTRACE_ENTRY_DUP
-#define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk)
+#define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk, filter)
+
+#undef FTRACE_ENTRY_REG
+#define FTRACE_ENTRY_REG(name, struct_name, id, tstruct, print, \
+                         filter, regfn) \
+        FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
+                     filter)
 
 #include "trace_entries.h"
 
@@ -148,6 +154,7 @@ struct trace_array {
         struct ring_buffer      *buffer;
         unsigned long           entries;
         int                     cpu;
+        int                     buffer_disabled;
         cycle_t                 time_start;
         struct task_struct      *waiter;
         struct trace_array_cpu  *data[NR_CPUS];
@@ -288,6 +295,8 @@ struct tracer {
 /* for function tracing recursion */
 #define TRACE_INTERNAL_BIT              (1<<11)
 #define TRACE_GLOBAL_BIT                (1<<12)
+#define TRACE_CONTROL_BIT               (1<<13)
+
 /*
  * Abuse of the trace_recursion.
  * As we need a way to maintain state if we are tracing the function
@@ -589,6 +598,8 @@ static inline int ftrace_trace_task(struct task_struct *task)
 static inline int ftrace_is_dead(void) { return 0; }
 #endif
 
+int ftrace_event_is_function(struct ftrace_event_call *call);
+
 /*
  * struct trace_parser - servers for reading the user input separated by spaces
  * @cont: set if the input is not complete - no final space char was found
@@ -766,9 +777,7 @@ struct filter_pred {
         u64                     val;
         struct regex            regex;
         unsigned short          *ops;
-#ifdef CONFIG_FTRACE_STARTUP_TEST
         struct ftrace_event_field *field;
-#endif
         int                     offset;
         int                     not;
         int                     op;
@@ -818,12 +827,20 @@ extern const char *__start___trace_bprintk_fmt[];
 extern const char *__stop___trace_bprintk_fmt[];
 
 #undef FTRACE_ENTRY
-#define FTRACE_ENTRY(call, struct_name, id, tstruct, print)             \
+#define FTRACE_ENTRY(call, struct_name, id, tstruct, print, filter)     \
         extern struct ftrace_event_call                                 \
         __attribute__((__aligned__(4))) event_##call;
 #undef FTRACE_ENTRY_DUP
-#define FTRACE_ENTRY_DUP(call, struct_name, id, tstruct, print)         \
-        FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print))
+#define FTRACE_ENTRY_DUP(call, struct_name, id, tstruct, print, filter) \
+        FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print), \
+                     filter)
 #include "trace_entries.h"
 
+#ifdef CONFIG_FUNCTION_TRACER
+int perf_ftrace_event_register(struct ftrace_event_call *call,
+                               enum trace_reg type, void *data);
+#else
+#define perf_ftrace_event_register NULL
+#endif /* CONFIG_FUNCTION_TRACER */
+
 #endif /* _LINUX_KERNEL_TRACE_H */
diff --git a/kernel/trace/trace_entries.h b/kernel/trace/trace_entries.h
index 93365907f219..4108e1250ca2 100644
--- a/kernel/trace/trace_entries.h
+++ b/kernel/trace/trace_entries.h
@@ -55,7 +55,7 @@
 /*
  * Function trace entry - function address and parent function address:
  */
-FTRACE_ENTRY(function, ftrace_entry,
+FTRACE_ENTRY_REG(function, ftrace_entry,
 
         TRACE_FN,
 
@@ -64,7 +64,11 @@ FTRACE_ENTRY(function, ftrace_entry,
                 __field(        unsigned long,  parent_ip       )
         ),
 
-        F_printk(" %lx <-- %lx", __entry->ip, __entry->parent_ip)
+        F_printk(" %lx <-- %lx", __entry->ip, __entry->parent_ip),
+
+        FILTER_TRACE_FN,
+
+        perf_ftrace_event_register
 );
 
 /* Function call entry */
@@ -78,7 +82,9 @@ FTRACE_ENTRY(funcgraph_entry, ftrace_graph_ent_entry,
                 __field_desc(   int,            graph_ent,      depth           )
         ),
 
-        F_printk("--> %lx (%d)", __entry->func, __entry->depth)
+        F_printk("--> %lx (%d)", __entry->func, __entry->depth),
+
+        FILTER_OTHER
 );
 
 /* Function return entry */
@@ -98,7 +104,9 @@ FTRACE_ENTRY(funcgraph_exit, ftrace_graph_ret_entry,
         F_printk("<-- %lx (%d) (start: %llx  end: %llx) over: %d",
                  __entry->func, __entry->depth,
                  __entry->calltime, __entry->rettime,
-                 __entry->depth)
+                 __entry->depth),
+
+        FILTER_OTHER
 );
 
 /*
@@ -127,8 +135,9 @@ FTRACE_ENTRY(context_switch, ctx_switch_entry,
         F_printk("%u:%u:%u  ==> %u:%u:%u [%03u]",
                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
                  __entry->next_pid, __entry->next_prio, __entry->next_state,
-                 __entry->next_cpu
-                )
+                 __entry->next_cpu),
+
+        FILTER_OTHER
 );
 
 /*
@@ -146,8 +155,9 @@ FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry,
         F_printk("%u:%u:%u  ==+ %u:%u:%u [%03u]",
                  __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
                  __entry->next_pid, __entry->next_prio, __entry->next_state,
-                 __entry->next_cpu
-                )
+                 __entry->next_cpu),
+
+        FILTER_OTHER
 );
 
 /*
@@ -156,6 +166,12 @@ FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry,
 
 #define FTRACE_STACK_ENTRIES    8
 
+#ifndef CONFIG_64BIT
+# define IP_FMT "%08lx"
+#else
+# define IP_FMT "%016lx"
+#endif
+
 FTRACE_ENTRY(kernel_stack, stack_entry,
 
         TRACE_STACK,
@@ -165,11 +181,14 @@ FTRACE_ENTRY(kernel_stack, stack_entry,
                 __dynamic_array(unsigned long,  caller  )
         ),
 
-        F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
-                 "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n",
+        F_printk("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
+                 "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
+                 "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n",
                  __entry->caller[0], __entry->caller[1], __entry->caller[2],
                  __entry->caller[3], __entry->caller[4], __entry->caller[5],
-                 __entry->caller[6], __entry->caller[7])
+                 __entry->caller[6], __entry->caller[7]),
+
+        FILTER_OTHER
 );
 
 FTRACE_ENTRY(user_stack, userstack_entry,
@@ -181,11 +200,14 @@ FTRACE_ENTRY(user_stack, userstack_entry,
                 __array(        unsigned long,  caller, FTRACE_STACK_ENTRIES    )
         ),
 
-        F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
-                 "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n",
+        F_printk("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
+                 "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
+                 "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n",
                  __entry->caller[0], __entry->caller[1], __entry->caller[2],
                  __entry->caller[3], __entry->caller[4], __entry->caller[5],
-                 __entry->caller[6], __entry->caller[7])
+                 __entry->caller[6], __entry->caller[7]),
+
+        FILTER_OTHER
 );
 
 /*
@@ -202,7 +224,9 @@ FTRACE_ENTRY(bprint, bprint_entry,
         ),
 
         F_printk("%08lx fmt:%p",
-                 __entry->ip, __entry->fmt)
+                 __entry->ip, __entry->fmt),
+
+        FILTER_OTHER
 );
 
 FTRACE_ENTRY(print, print_entry,
@@ -215,7 +239,9 @@ FTRACE_ENTRY(print, print_entry,
         ),
 
         F_printk("%08lx %s",
-                 __entry->ip, __entry->buf)
+                 __entry->ip, __entry->buf),
+
+        FILTER_OTHER
 );
 
 FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw,
@@ -234,7 +260,9 @@ FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw,
 
         F_printk("%lx %lx %lx %d %x %x",
                  (unsigned long)__entry->phys, __entry->value, __entry->pc,
-                 __entry->map_id, __entry->opcode, __entry->width)
+                 __entry->map_id, __entry->opcode, __entry->width),
+
+        FILTER_OTHER
 );
 
 FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map,
@@ -252,7 +280,9 @@ FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map,
 
         F_printk("%lx %lx %lx %d %x",
                  (unsigned long)__entry->phys, __entry->virt, __entry->len,
-                 __entry->map_id, __entry->opcode)
+                 __entry->map_id, __entry->opcode),
+
+        FILTER_OTHER
 );
 
 
@@ -272,6 +302,8 @@ FTRACE_ENTRY(branch, trace_branch,
 
         F_printk("%u:%s:%s (%u)",
                  __entry->line,
-                 __entry->func, __entry->file, __entry->correct)
+                 __entry->func, __entry->file, __entry->correct),
+
+        FILTER_OTHER
 );
 
diff --git a/kernel/trace/trace_event_perf.c b/kernel/trace/trace_event_perf.c
index 19a359d5e6d5..fee3752ae8f6 100644
--- a/kernel/trace/trace_event_perf.c
+++ b/kernel/trace/trace_event_perf.c
@@ -24,6 +24,11 @@ static int	total_ref_count;
 static int perf_trace_event_perm(struct ftrace_event_call *tp_event,
                                  struct perf_event *p_event)
 {
+        /* The ftrace function trace is allowed only for root. */
+        if (ftrace_event_is_function(tp_event) &&
+            perf_paranoid_kernel() && !capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
         /* No tracing, just counting, so no obvious leak */
         if (!(p_event->attr.sample_type & PERF_SAMPLE_RAW))
                 return 0;
@@ -44,23 +49,17 @@ static int perf_trace_event_perm(struct ftrace_event_call *tp_event,
         return 0;
 }
 
-static int perf_trace_event_init(struct ftrace_event_call *tp_event,
-                                 struct perf_event *p_event)
+static int perf_trace_event_reg(struct ftrace_event_call *tp_event,
+                                struct perf_event *p_event)
 {
         struct hlist_head __percpu *list;
-        int ret;
+        int ret = -ENOMEM;
         int cpu;
 
-        ret = perf_trace_event_perm(tp_event, p_event);
-        if (ret)
-                return ret;
-
         p_event->tp_event = tp_event;
         if (tp_event->perf_refcount++ > 0)
                 return 0;
 
-        ret = -ENOMEM;
-
         list = alloc_percpu(struct hlist_head);
         if (!list)
                 goto fail;
@@ -83,7 +82,7 @@ static int perf_trace_event_init(struct ftrace_event_call *tp_event,
                 }
         }
 
-        ret = tp_event->class->reg(tp_event, TRACE_REG_PERF_REGISTER);
+        ret = tp_event->class->reg(tp_event, TRACE_REG_PERF_REGISTER, NULL);
         if (ret)
                 goto fail;
 
@@ -108,6 +107,69 @@ fail:
         return ret;
 }
 
+static void perf_trace_event_unreg(struct perf_event *p_event)
+{
+        struct ftrace_event_call *tp_event = p_event->tp_event;
+        int i;
+
+        if (--tp_event->perf_refcount > 0)
+                goto out;
+
+        tp_event->class->reg(tp_event, TRACE_REG_PERF_UNREGISTER, NULL);
+
+        /*
+         * Ensure our callback won't be called anymore. The buffers
+         * will be freed after that.
+         */
+        tracepoint_synchronize_unregister();
+
+        free_percpu(tp_event->perf_events);
+        tp_event->perf_events = NULL;
+
+        if (!--total_ref_count) {
+                for (i = 0; i < PERF_NR_CONTEXTS; i++) {
+                        free_percpu(perf_trace_buf[i]);
+                        perf_trace_buf[i] = NULL;
+                }
+        }
+out:
+        module_put(tp_event->mod);
+}
+
+static int perf_trace_event_open(struct perf_event *p_event)
+{
+        struct ftrace_event_call *tp_event = p_event->tp_event;
+        return tp_event->class->reg(tp_event, TRACE_REG_PERF_OPEN, p_event);
+}
+
+static void perf_trace_event_close(struct perf_event *p_event)
+{
+        struct ftrace_event_call *tp_event = p_event->tp_event;
+        tp_event->class->reg(tp_event, TRACE_REG_PERF_CLOSE, p_event);
+}
+
+static int perf_trace_event_init(struct ftrace_event_call *tp_event,
+                                 struct perf_event *p_event)
+{
+        int ret;
+
+        ret = perf_trace_event_perm(tp_event, p_event);
+        if (ret)
+                return ret;
+
+        ret = perf_trace_event_reg(tp_event, p_event);
+        if (ret)
+                return ret;
+
+        ret = perf_trace_event_open(p_event);
+        if (ret) {
+                perf_trace_event_unreg(p_event);
+                return ret;
+        }
+
+        return 0;
+}
+
 int perf_trace_init(struct perf_event *p_event)
 {
         struct ftrace_event_call *tp_event;
@@ -130,6 +192,14 @@ int perf_trace_init(struct perf_event *p_event)
         return ret;
 }
 
+void perf_trace_destroy(struct perf_event *p_event)
+{
+        mutex_lock(&event_mutex);
+        perf_trace_event_close(p_event);
+        perf_trace_event_unreg(p_event);
+        mutex_unlock(&event_mutex);
+}
+
 int perf_trace_add(struct perf_event *p_event, int flags)
 {
         struct ftrace_event_call *tp_event = p_event->tp_event;
@@ -146,43 +216,14 @@ int perf_trace_add(struct perf_event *p_event, int flags)
         list = this_cpu_ptr(pcpu_list);
         hlist_add_head_rcu(&p_event->hlist_entry, list);
 
-        return 0;
+        return tp_event->class->reg(tp_event, TRACE_REG_PERF_ADD, p_event);
 }
 
 void perf_trace_del(struct perf_event *p_event, int flags)
 {
-        hlist_del_rcu(&p_event->hlist_entry);
-}
-
-void perf_trace_destroy(struct perf_event *p_event)
-{
         struct ftrace_event_call *tp_event = p_event->tp_event;
-        int i;
-
-        mutex_lock(&event_mutex);
-        if (--tp_event->perf_refcount > 0)
-                goto out;
-
-        tp_event->class->reg(tp_event, TRACE_REG_PERF_UNREGISTER);
-
-        /*
-         * Ensure our callback won't be called anymore. The buffers
-         * will be freed after that.
-         */
-        tracepoint_synchronize_unregister();
-
-        free_percpu(tp_event->perf_events);
-        tp_event->perf_events = NULL;
-
-        if (!--total_ref_count) {
-                for (i = 0; i < PERF_NR_CONTEXTS; i++) {
-                        free_percpu(perf_trace_buf[i]);
-                        perf_trace_buf[i] = NULL;
-                }
-        }
-out:
-        module_put(tp_event->mod);
-        mutex_unlock(&event_mutex);
+        hlist_del_rcu(&p_event->hlist_entry);
+        tp_event->class->reg(tp_event, TRACE_REG_PERF_DEL, p_event);
 }
 
 __kprobes void *perf_trace_buf_prepare(int size, unsigned short type,
@@ -214,3 +255,86 @@ __kprobes void *perf_trace_buf_prepare(int size, unsigned short type,
         return raw_data;
 }
 EXPORT_SYMBOL_GPL(perf_trace_buf_prepare);
+
+#ifdef CONFIG_FUNCTION_TRACER
+static void
+perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip)
+{
+        struct ftrace_entry *entry;
+        struct hlist_head *head;
+        struct pt_regs regs;
+        int rctx;
+
+#define ENTRY_SIZE (ALIGN(sizeof(struct ftrace_entry) + sizeof(u32), \
+                    sizeof(u64)) - sizeof(u32))
+
+        BUILD_BUG_ON(ENTRY_SIZE > PERF_MAX_TRACE_SIZE);
+
+        perf_fetch_caller_regs(&regs);
+
+        entry = perf_trace_buf_prepare(ENTRY_SIZE, TRACE_FN, NULL, &rctx);
+        if (!entry)
+                return;
+
+        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);
+
+#undef ENTRY_SIZE
+}
+
+static int perf_ftrace_function_register(struct perf_event *event)
+{
+        struct ftrace_ops *ops = &event->ftrace_ops;
+
+        ops->flags |= FTRACE_OPS_FL_CONTROL;
+        ops->func = perf_ftrace_function_call;
+        return register_ftrace_function(ops);
+}
+
+static int perf_ftrace_function_unregister(struct perf_event *event)
+{
+        struct ftrace_ops *ops = &event->ftrace_ops;
+        int ret = unregister_ftrace_function(ops);
+        ftrace_free_filter(ops);
+        return ret;
+}
+
+static void perf_ftrace_function_enable(struct perf_event *event)
+{
+        ftrace_function_local_enable(&event->ftrace_ops);
+}
+
+static void perf_ftrace_function_disable(struct perf_event *event)
+{
+        ftrace_function_local_disable(&event->ftrace_ops);
+}
+
+int perf_ftrace_event_register(struct ftrace_event_call *call,
+                               enum trace_reg type, void *data)
+{
+        switch (type) {
+        case TRACE_REG_REGISTER:
+        case TRACE_REG_UNREGISTER:
+                break;
+        case TRACE_REG_PERF_REGISTER:
+        case TRACE_REG_PERF_UNREGISTER:
+                return 0;
+        case TRACE_REG_PERF_OPEN:
+                return perf_ftrace_function_register(data);
+        case TRACE_REG_PERF_CLOSE:
+                return perf_ftrace_function_unregister(data);
+        case TRACE_REG_PERF_ADD:
+                perf_ftrace_function_enable(data);
+                return 0;
+        case TRACE_REG_PERF_DEL:
+                perf_ftrace_function_disable(data);
+                return 0;
+        }
+
+        return -EINVAL;
+}
+#endif /* CONFIG_FUNCTION_TRACER */
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index c212a7f934ec..079a93ae8a9d 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -147,7 +147,8 @@ int trace_event_raw_init(struct ftrace_event_call *call)
 }
 EXPORT_SYMBOL_GPL(trace_event_raw_init);
 
-int ftrace_event_reg(struct ftrace_event_call *call, enum trace_reg type)
+int ftrace_event_reg(struct ftrace_event_call *call,
+                     enum trace_reg type, void *data)
 {
         switch (type) {
         case TRACE_REG_REGISTER:
@@ -170,6 +171,11 @@ int ftrace_event_reg(struct ftrace_event_call *call, enum trace_reg type)
                                             call->class->perf_probe,
                                             call);
                 return 0;
+        case TRACE_REG_PERF_OPEN:
+        case TRACE_REG_PERF_CLOSE:
+        case TRACE_REG_PERF_ADD:
+        case TRACE_REG_PERF_DEL:
+                return 0;
 #endif
         }
         return 0;
@@ -209,7 +215,7 @@ static int ftrace_event_enable_disable(struct ftrace_event_call *call,
                                 tracing_stop_cmdline_record();
                                 call->flags &= ~TRACE_EVENT_FL_RECORDED_CMD;
                         }
-                        call->class->reg(call, TRACE_REG_UNREGISTER);
+                        call->class->reg(call, TRACE_REG_UNREGISTER, NULL);
                 }
                 break;
         case 1:
@@ -218,7 +224,7 @@ static int ftrace_event_enable_disable(struct ftrace_event_call *call,
                                 tracing_start_cmdline_record();
                                 call->flags |= TRACE_EVENT_FL_RECORDED_CMD;
                         }
-                        ret = call->class->reg(call, TRACE_REG_REGISTER);
+                        ret = call->class->reg(call, TRACE_REG_REGISTER, NULL);
                         if (ret) {
                                 tracing_stop_cmdline_record();
                                 pr_info("event trace: Could not enable event "
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index 24aee7127451..431dba8b7542 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -81,6 +81,7 @@ enum {
         FILT_ERR_TOO_MANY_PREDS,
         FILT_ERR_MISSING_FIELD,
         FILT_ERR_INVALID_FILTER,
+        FILT_ERR_IP_FIELD_ONLY,
 };
 
 static char *err_text[] = {
@@ -96,6 +97,7 @@ static char *err_text[] = {
         "Too many terms in predicate expression",
         "Missing field name and/or value",
         "Meaningless filter expression",
+        "Only 'ip' field is supported for function trace",
 };
 
 struct opstack_op {
@@ -685,7 +687,7 @@ find_event_field(struct ftrace_event_call *call, char *name)
 
 static int __alloc_pred_stack(struct pred_stack *stack, int n_preds)
 {
-        stack->preds = kzalloc(sizeof(*stack->preds)*(n_preds + 1), GFP_KERNEL);
+        stack->preds = kcalloc(n_preds + 1, sizeof(*stack->preds), GFP_KERNEL);
         if (!stack->preds)
                 return -ENOMEM;
         stack->index = n_preds;
@@ -826,8 +828,7 @@ static int __alloc_preds(struct event_filter *filter, int n_preds)
         if (filter->preds)
                 __free_preds(filter);
 
-        filter->preds =
-                kzalloc(sizeof(*filter->preds) * n_preds, GFP_KERNEL);
+        filter->preds = kcalloc(n_preds, sizeof(*filter->preds), GFP_KERNEL);
 
         if (!filter->preds)
                 return -ENOMEM;
@@ -900,6 +901,11 @@ int filter_assign_type(const char *type)
         return FILTER_OTHER;
 }
 
+static bool is_function_field(struct ftrace_event_field *field)
+{
+        return field->filter_type == FILTER_TRACE_FN;
+}
+
 static bool is_string_field(struct ftrace_event_field *field)
 {
         return field->filter_type == FILTER_DYN_STRING ||
@@ -987,6 +993,11 @@ static int init_pred(struct filter_parse_state *ps,
                         fn = filter_pred_strloc;
                 else
                         fn = filter_pred_pchar;
+        } else if (is_function_field(field)) {
+                if (strcmp(field->name, "ip")) {
+                        parse_error(ps, FILT_ERR_IP_FIELD_ONLY, 0);
+                        return -EINVAL;
+                }
         } else {
                 if (field->is_signed)
                         ret = strict_strtoll(pred->regex.pattern, 0, &val);
@@ -1334,10 +1345,7 @@ static struct filter_pred *create_pred(struct filter_parse_state *ps,
 
         strcpy(pred.regex.pattern, operand2);
         pred.regex.len = strlen(pred.regex.pattern);
-
-#ifdef CONFIG_FTRACE_STARTUP_TEST
         pred.field = field;
-#endif
         return init_pred(ps, field, &pred) ? NULL : &pred;
 }
 
@@ -1486,7 +1494,7 @@ static int fold_pred(struct filter_pred *preds, struct filter_pred *root)
         children = count_leafs(preds, &preds[root->left]);
         children += count_leafs(preds, &preds[root->right]);
 
-        root->ops = kzalloc(sizeof(*root->ops) * children, GFP_KERNEL);
+        root->ops = kcalloc(children, sizeof(*root->ops), GFP_KERNEL);
         if (!root->ops)
                 return -ENOMEM;
 
@@ -1950,6 +1958,148 @@ void ftrace_profile_free_filter(struct perf_event *event)
         __free_filter(filter);
 }
 
+struct function_filter_data {
+        struct ftrace_ops *ops;
+        int first_filter;
+        int first_notrace;
+};
+
+#ifdef CONFIG_FUNCTION_TRACER
+static char **
+ftrace_function_filter_re(char *buf, int len, int *count)
+{
+        char *str, *sep, **re;
+
+        str = kstrndup(buf, len, GFP_KERNEL);
+        if (!str)
+                return NULL;
+
+        /*
+         * The argv_split function takes white space
+         * as a separator, so convert ',' into spaces.
+         */
+        while ((sep = strchr(str, ',')))
+                *sep = ' ';
+
+        re = argv_split(GFP_KERNEL, str, count);
+        kfree(str);
+        return re;
+}
+
+static int ftrace_function_set_regexp(struct ftrace_ops *ops, int filter,
+                                      int reset, char *re, int len)
+{
+        int ret;
+
+        if (filter)
+                ret = ftrace_set_filter(ops, re, len, reset);
+        else
+                ret = ftrace_set_notrace(ops, re, len, reset);
+
+        return ret;
+}
+
+static int __ftrace_function_set_filter(int filter, char *buf, int len,
+                                        struct function_filter_data *data)
+{
+        int i, re_cnt, ret;
+        int *reset;
+        char **re;
+
+        reset = filter ? &data->first_filter : &data->first_notrace;
+
+        /*
+         * The 'ip' field could have multiple filters set, separated
+         * either by space or comma. We first cut the filter and apply
+         * all pieces separatelly.
+         */
+        re = ftrace_function_filter_re(buf, len, &re_cnt);
+        if (!re)
+                return -EINVAL;
+
+        for (i = 0; i < re_cnt; i++) {
+                ret = ftrace_function_set_regexp(data->ops, filter, *reset,
+                                                 re[i], strlen(re[i]));
+                if (ret)
+                        break;
+
+                if (*reset)
+                        *reset = 0;
+        }
+
+        argv_free(re);
+        return ret;
+}
+
+static int ftrace_function_check_pred(struct filter_pred *pred, int leaf)
+{
+        struct ftrace_event_field *field = pred->field;
+
+        if (leaf) {
+                /*
+                 * Check the leaf predicate for function trace, verify:
+                 *  - only '==' and '!=' is used
+                 *  - the 'ip' field is used
+                 */
+                if ((pred->op != OP_EQ) && (pred->op != OP_NE))
+                        return -EINVAL;
+
+                if (strcmp(field->name, "ip"))
+                        return -EINVAL;
+        } else {
+                /*
+                 * Check the non leaf predicate for function trace, verify:
+                 *  - only '||' is used
+                */
+                if (pred->op != OP_OR)
+                        return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int ftrace_function_set_filter_cb(enum move_type move,
+                                         struct filter_pred *pred,
+                                         int *err, void *data)
+{
+        /* Checking the node is valid for function trace. */
+        if ((move != MOVE_DOWN) ||
+            (pred->left != FILTER_PRED_INVALID)) {
+                *err = ftrace_function_check_pred(pred, 0);
+        } else {
+                *err = ftrace_function_check_pred(pred, 1);
+                if (*err)
+                        return WALK_PRED_ABORT;
+
+                *err = __ftrace_function_set_filter(pred->op == OP_EQ,
+                                                    pred->regex.pattern,
+                                                    pred->regex.len,
+                                                    data);
+        }
+
+        return (*err) ? WALK_PRED_ABORT : WALK_PRED_DEFAULT;
+}
+
+static int ftrace_function_set_filter(struct perf_event *event,
+                                      struct event_filter *filter)
+{
+        struct function_filter_data data = {
+                .first_filter  = 1,
+                .first_notrace = 1,
+                .ops           = &event->ftrace_ops,
+        };
+
+        return walk_pred_tree(filter->preds, filter->root,
+                              ftrace_function_set_filter_cb, &data);
+}
+#else
+static int ftrace_function_set_filter(struct perf_event *event,
+                                      struct event_filter *filter)
+{
+        return -ENODEV;
+}
+#endif /* CONFIG_FUNCTION_TRACER */
+
 int ftrace_profile_set_filter(struct perf_event *event, int event_id,
                               char *filter_str)
 {
@@ -1970,9 +2120,16 @@ int ftrace_profile_set_filter(struct perf_event *event, int event_id,
                 goto out_unlock;
 
         err = create_filter(call, filter_str, false, &filter);
-        if (!err)
-                event->filter = filter;
+        if (err)
+                goto free_filter;
+
+        if (ftrace_event_is_function(call))
+                err = ftrace_function_set_filter(event, filter);
         else
+                event->filter = filter;
+
+free_filter:
+        if (err || ftrace_event_is_function(call))
                 __free_filter(filter);
 
 out_unlock:
diff --git a/kernel/trace/trace_export.c b/kernel/trace/trace_export.c
index bbeec31e0ae3..3dd15e8bc856 100644
--- a/kernel/trace/trace_export.c
+++ b/kernel/trace/trace_export.c
@@ -18,6 +18,16 @@
 #undef TRACE_SYSTEM
 #define TRACE_SYSTEM    ftrace
 
+/*
+ * The FTRACE_ENTRY_REG macro allows ftrace entry to define register
+ * function and thus become accesible via perf.
+ */
+#undef FTRACE_ENTRY_REG
+#define FTRACE_ENTRY_REG(name, struct_name, id, tstruct, print, \
+                         filter, regfn) \
+        FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
+                     filter)
+
 /* not needed for this file */
 #undef __field_struct
 #define __field_struct(type, item)
@@ -44,21 +54,22 @@
 #define F_printk(fmt, args...) fmt, args
 
 #undef FTRACE_ENTRY
-#define FTRACE_ENTRY(name, struct_name, id, tstruct, print)     \
-struct ____ftrace_##name {                                      \
-        tstruct                                                 \
-};                                                              \
-static void __always_unused ____ftrace_check_##name(void)       \
-{                                                               \
-        struct ____ftrace_##name *__entry = NULL;               \
-                                                                \
-        /* force compile-time check on F_printk() */            \
-        printk(print);                                          \
+#define FTRACE_ENTRY(name, struct_name, id, tstruct, print, filter)     \
+struct ____ftrace_##name {                                              \
+        tstruct                                                         \
+};                                                                      \
+static void __always_unused ____ftrace_check_##name(void)               \
+{                                                                       \
+        struct ____ftrace_##name *__entry = NULL;                       \
+                                                                        \
+        /* force compile-time check on F_printk() */                    \
+        printk(print);                                                  \
 }
 
 #undef FTRACE_ENTRY_DUP
-#define FTRACE_ENTRY_DUP(name, struct_name, id, tstruct, print) \
-        FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print))
+#define FTRACE_ENTRY_DUP(name, struct_name, id, tstruct, print, filter) \
+        FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
+                     filter)
 
 #include "trace_entries.h"
 
@@ -67,7 +78,7 @@ static void __always_unused ____ftrace_check_##name(void)	\
         ret = trace_define_field(event_call, #type, #item,              \
                                  offsetof(typeof(field), item),         \
                                  sizeof(field.item),                    \
-                                 is_signed_type(type), FILTER_OTHER);   \
+                                 is_signed_type(type), filter_type);    \
         if (ret)                                                        \
                 return ret;
 
@@ -77,7 +88,7 @@ static void __always_unused ____ftrace_check_##name(void)	\
                                  offsetof(typeof(field),                \
                                           container.item),              \
                                  sizeof(field.container.item),          \
-                                 is_signed_type(type), FILTER_OTHER);   \
+                                 is_signed_type(type), filter_type);    \
         if (ret)                                                        \
                 return ret;
 
@@ -91,7 +102,7 @@ static void __always_unused ____ftrace_check_##name(void)	\
                 ret = trace_define_field(event_call, event_storage, #item, \
                                  offsetof(typeof(field), item),         \
                                  sizeof(field.item),                    \
-                                 is_signed_type(type), FILTER_OTHER);   \
+                                 is_signed_type(type), filter_type);    \
                 mutex_unlock(&event_storage_mutex);                     \
                 if (ret)                                                \
                         return ret;                                     \
@@ -104,7 +115,7 @@ static void __always_unused ____ftrace_check_##name(void)	\
                                  offsetof(typeof(field),                \
                                           container.item),              \
                                  sizeof(field.container.item),          \
-                                 is_signed_type(type), FILTER_OTHER);   \
+                                 is_signed_type(type), filter_type);    \
         if (ret)                                                        \
                 return ret;
 
@@ -112,17 +123,18 @@ static void __always_unused ____ftrace_check_##name(void)	\
 #define __dynamic_array(type, item)                                     \
         ret = trace_define_field(event_call, #type, #item,              \
                                  offsetof(typeof(field), item),         \
-                                 0, is_signed_type(type), FILTER_OTHER);\
+                                 0, is_signed_type(type), filter_type);\
         if (ret)                                                        \
                 return ret;
 
 #undef FTRACE_ENTRY
-#define FTRACE_ENTRY(name, struct_name, id, tstruct, print)             \
+#define FTRACE_ENTRY(name, struct_name, id, tstruct, print, filter)     \
 int                                                                     \
 ftrace_define_fields_##name(struct ftrace_event_call *event_call)       \
 {                                                                       \
         struct struct_name field;                                       \
         int ret;                                                        \
+        int filter_type = filter;                                       \
                                                                         \
         tstruct;                                                        \
                                                                         \
@@ -150,15 +162,17 @@ ftrace_define_fields_##name(struct ftrace_event_call *event_call)	\
 #define __dynamic_array(type, item)
 
 #undef F_printk
-#define F_printk(fmt, args...) #fmt ", "  __stringify(args)
+#define F_printk(fmt, args...) __stringify(fmt) ", "  __stringify(args)
 
-#undef FTRACE_ENTRY
-#define FTRACE_ENTRY(call, struct_name, etype, tstruct, print)          \
+#undef FTRACE_ENTRY_REG
+#define FTRACE_ENTRY_REG(call, struct_name, etype, tstruct, print, filter,\
+                         regfn)                                         \
                                                                         \
 struct ftrace_event_class event_class_ftrace_##call = {                 \
         .system                 = __stringify(TRACE_SYSTEM),            \
         .define_fields          = ftrace_define_fields_##call,          \
         .fields                 = LIST_HEAD_INIT(event_class_ftrace_##call.fields),\
+        .reg                    = regfn,                                \
 };                                                                      \
                                                                         \
 struct ftrace_event_call __used event_##call = {                        \
@@ -170,4 +184,14 @@ struct ftrace_event_call __used event_##call = {			\
 struct ftrace_event_call __used                                         \
 __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call;
 
+#undef FTRACE_ENTRY
+#define FTRACE_ENTRY(call, struct_name, etype, tstruct, print, filter)  \
+        FTRACE_ENTRY_REG(call, struct_name, etype,                      \
+                         PARAMS(tstruct), PARAMS(print), filter, NULL)
+
+int ftrace_event_is_function(struct ftrace_event_call *call)
+{
+        return call == &event_function;
+}
+
 #include "trace_entries.h"
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index 00d527c945a4..580a05ec926b 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -1892,7 +1892,8 @@ static __kprobes void kretprobe_perf_func(struct kretprobe_instance *ri,
 #endif  /* CONFIG_PERF_EVENTS */
 
 static __kprobes
-int kprobe_register(struct ftrace_event_call *event, enum trace_reg type)
+int kprobe_register(struct ftrace_event_call *event,
+                    enum trace_reg type, void *data)
 {
         struct trace_probe *tp = (struct trace_probe *)event->data;
 
@@ -1909,6 +1910,11 @@ int kprobe_register(struct ftrace_event_call *event, enum trace_reg type)
         case TRACE_REG_PERF_UNREGISTER:
                 disable_trace_probe(tp, TP_FLAG_PROFILE);
                 return 0;
+        case TRACE_REG_PERF_OPEN:
+        case TRACE_REG_PERF_CLOSE:
+        case TRACE_REG_PERF_ADD:
+        case TRACE_REG_PERF_DEL:
+                return 0;
 #endif
         }
         return 0;
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
index 0d6ff3555942..859fae6b1825 100644
--- a/kernel/trace/trace_output.c
+++ b/kernel/trace/trace_output.c
@@ -264,7 +264,7 @@ void *trace_seq_reserve(struct trace_seq *s, size_t len)
         return ret;
 }
 
-int trace_seq_path(struct trace_seq *s, struct path *path)
+int trace_seq_path(struct trace_seq *s, const struct path *path)
 {
         unsigned char *p;
 
@@ -300,7 +300,7 @@ ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
         unsigned long mask;
         const char *str;
         const char *ret = p->buffer + p->len;
-        int i;
+        int i, first = 1;
 
         for (i = 0;  flag_array[i].name && flags; i++) {
 
@@ -310,14 +310,16 @@ ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
 
                 str = flag_array[i].name;
                 flags &= ~mask;
-                if (p->len && delim)
+                if (!first && delim)
                         trace_seq_puts(p, delim);
+                else
+                        first = 0;
                 trace_seq_puts(p, str);
         }
 
         /* check for left over flags */
         if (flags) {
-                if (p->len && delim)
+                if (!first && delim)
                         trace_seq_puts(p, delim);
                 trace_seq_printf(p, "0x%lx", flags);
         }
@@ -344,7 +346,7 @@ ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
                 break;
         }
 
-        if (!p->len)
+        if (ret == (const char *)(p->buffer + p->len))
                 trace_seq_printf(p, "0x%lx", val);
                 
         trace_seq_putc(p, 0);
@@ -370,7 +372,7 @@ ftrace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val,
                 break;
         }
 
-        if (!p->len)
+        if (ret == (const char *)(p->buffer + p->len))
                 trace_seq_printf(p, "0x%llx", val);
 
         trace_seq_putc(p, 0);
diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
index cb654542c1a1..96fc73369099 100644
--- a/kernel/trace/trace_syscalls.c
+++ b/kernel/trace/trace_syscalls.c
@@ -17,9 +17,9 @@ static DECLARE_BITMAP(enabled_enter_syscalls, NR_syscalls);
 static DECLARE_BITMAP(enabled_exit_syscalls, NR_syscalls);
 
 static int syscall_enter_register(struct ftrace_event_call *event,
-                                 enum trace_reg type);
+                                 enum trace_reg type, void *data);
 static int syscall_exit_register(struct ftrace_event_call *event,
-                                 enum trace_reg type);
+                                 enum trace_reg type, void *data);
 
 static int syscall_enter_define_fields(struct ftrace_event_call *call);
 static int syscall_exit_define_fields(struct ftrace_event_call *call);
@@ -468,8 +468,8 @@ int __init init_ftrace_syscalls(void)
         unsigned long addr;
         int i;
 
-        syscalls_metadata = kzalloc(sizeof(*syscalls_metadata) *
-                                        NR_syscalls, GFP_KERNEL);
+        syscalls_metadata = kcalloc(NR_syscalls, sizeof(*syscalls_metadata),
+                                    GFP_KERNEL);
         if (!syscalls_metadata) {
                 WARN_ON(1);
                 return -ENOMEM;
@@ -649,7 +649,7 @@ void perf_sysexit_disable(struct ftrace_event_call *call)
 #endif /* CONFIG_PERF_EVENTS */
 
 static int syscall_enter_register(struct ftrace_event_call *event,
-                                 enum trace_reg type)
+                                 enum trace_reg type, void *data)
 {
         switch (type) {
         case TRACE_REG_REGISTER:
@@ -664,13 +664,18 @@ static int syscall_enter_register(struct ftrace_event_call *event,
         case TRACE_REG_PERF_UNREGISTER:
                 perf_sysenter_disable(event);
                 return 0;
+        case TRACE_REG_PERF_OPEN:
+        case TRACE_REG_PERF_CLOSE:
+        case TRACE_REG_PERF_ADD:
+        case TRACE_REG_PERF_DEL:
+                return 0;
 #endif
         }
         return 0;
 }
 
 static int syscall_exit_register(struct ftrace_event_call *event,
-                                 enum trace_reg type)
+                                 enum trace_reg type, void *data)
 {
         switch (type) {
         case TRACE_REG_REGISTER:
@@ -685,6 +690,11 @@ static int syscall_exit_register(struct ftrace_event_call *event,
         case TRACE_REG_PERF_UNREGISTER:
                 perf_sysexit_disable(event);
                 return 0;
+        case TRACE_REG_PERF_OPEN:
+        case TRACE_REG_PERF_CLOSE:
+        case TRACE_REG_PERF_ADD:
+        case TRACE_REG_PERF_DEL:
+                return 0;
 #endif
         }
         return 0;