8 files changed, 628 insertions, 212 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 89bd9a6f52ec..0f271c45cd02 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -21,12 +21,15 @@
 #include <linux/hardirq.h>
 #include <linux/kthread.h>
 #include <linux/uaccess.h>
+#include <linux/kprobes.h>
 #include <linux/ftrace.h>
 #include <linux/sysctl.h>
 #include <linux/ctype.h>
 #include <linux/hash.h>
 #include <linux/list.h>
 
+#include <asm/ftrace.h>
+
 #include "trace.h"
 
 /* ftrace_enabled is a method to turn ftrace on or off */
@@ -50,7 +53,7 @@ static struct ftrace_ops ftrace_list_end __read_mostly =
 static struct ftrace_ops *ftrace_list __read_mostly = &ftrace_list_end;
 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
 
-void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
+static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
 {
         struct ftrace_ops *op = ftrace_list;
 
@@ -151,8 +154,6 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
 #ifdef CONFIG_DYNAMIC_FTRACE
 
 static struct task_struct *ftraced_task;
-static DECLARE_WAIT_QUEUE_HEAD(ftraced_waiters);
-static unsigned long ftraced_iteration_counter;
 
 enum {
         FTRACE_ENABLE_CALLS             = (1 << 0),
@@ -163,6 +164,8 @@ enum {
 };
 
 static int ftrace_filtered;
+static int tracing_on;
+static int frozen_record_count;
 
 static struct hlist_head ftrace_hash[FTRACE_HASHSIZE];
 
@@ -170,7 +173,7 @@ static DEFINE_PER_CPU(int, ftrace_shutdown_disable_cpu);
 
 static DEFINE_SPINLOCK(ftrace_shutdown_lock);
 static DEFINE_MUTEX(ftraced_lock);
-static DEFINE_MUTEX(ftrace_filter_lock);
+static DEFINE_MUTEX(ftrace_regex_lock);
 
 struct ftrace_page {
         struct ftrace_page      *next;
@@ -189,11 +192,77 @@ static struct ftrace_page	*ftrace_pages;
 
 static int ftraced_trigger;
 static int ftraced_suspend;
+static int ftraced_stop;
 
 static int ftrace_record_suspend;
 
 static struct dyn_ftrace *ftrace_free_records;
 
+
+#ifdef CONFIG_KPROBES
+static inline void freeze_record(struct dyn_ftrace *rec)
+{
+        if (!(rec->flags & FTRACE_FL_FROZEN)) {
+                rec->flags |= FTRACE_FL_FROZEN;
+                frozen_record_count++;
+        }
+}
+
+static inline void unfreeze_record(struct dyn_ftrace *rec)
+{
+        if (rec->flags & FTRACE_FL_FROZEN) {
+                rec->flags &= ~FTRACE_FL_FROZEN;
+                frozen_record_count--;
+        }
+}
+
+static inline int record_frozen(struct dyn_ftrace *rec)
+{
+        return rec->flags & FTRACE_FL_FROZEN;
+}
+#else
+# define freeze_record(rec)                     ({ 0; })
+# define unfreeze_record(rec)                   ({ 0; })
+# define record_frozen(rec)                     ({ 0; })
+#endif /* CONFIG_KPROBES */
+
+int skip_trace(unsigned long ip)
+{
+        unsigned long fl;
+        struct dyn_ftrace *rec;
+        struct hlist_node *t;
+        struct hlist_head *head;
+
+        if (frozen_record_count == 0)
+                return 0;
+
+        head = &ftrace_hash[hash_long(ip, FTRACE_HASHBITS)];
+        hlist_for_each_entry_rcu(rec, t, head, node) {
+                if (rec->ip == ip) {
+                        if (record_frozen(rec)) {
+                                if (rec->flags & FTRACE_FL_FAILED)
+                                        return 1;
+
+                                if (!(rec->flags & FTRACE_FL_CONVERTED))
+                                        return 1;
+
+                                if (!tracing_on || !ftrace_enabled)
+                                        return 1;
+
+                                if (ftrace_filtered) {
+                                        fl = rec->flags & (FTRACE_FL_FILTER |
+                                                           FTRACE_FL_NOTRACE);
+                                        if (!fl || (fl & FTRACE_FL_NOTRACE))
+                                                return 1;
+                                }
+                        }
+                        break;
+                }
+        }
+
+        return 0;
+}
+
 static inline int
 ftrace_ip_in_hash(unsigned long ip, unsigned long key)
 {
@@ -201,7 +270,7 @@ ftrace_ip_in_hash(unsigned long ip, unsigned long key)
         struct hlist_node *t;
         int found = 0;
 
-        hlist_for_each_entry(p, t, &ftrace_hash[key], node) {
+        hlist_for_each_entry_rcu(p, t, &ftrace_hash[key], node) {
                 if (p->ip == ip) {
                         found = 1;
                         break;
@@ -214,7 +283,13 @@ ftrace_ip_in_hash(unsigned long ip, unsigned long key)
 static inline void
 ftrace_add_hash(struct dyn_ftrace *node, unsigned long key)
 {
-        hlist_add_head(&node->node, &ftrace_hash[key]);
+        hlist_add_head_rcu(&node->node, &ftrace_hash[key]);
+}
+
+/* called from kstop_machine */
+static inline void ftrace_del_hash(struct dyn_ftrace *node)
+{
+        hlist_del(&node->node);
 }
 
 static void ftrace_free_rec(struct dyn_ftrace *rec)
@@ -301,13 +376,6 @@ ftrace_record_ip(unsigned long ip)
         if (ftrace_ip_in_hash(ip, key))
                 goto out_unlock;
 
-        /*
-         * There's a slight race that the ftraced will update the
-         * hash and reset here. If it is already converted, skip it.
-         */
-        if (ftrace_ip_converted(ip))
-                goto out_unlock;
-
         node = ftrace_alloc_dyn_node(ip);
         if (!node)
                 goto out_unlock;
@@ -331,19 +399,16 @@ ftrace_record_ip(unsigned long ip)
 }
 
 #define FTRACE_ADDR ((long)(ftrace_caller))
-#define MCOUNT_ADDR ((long)(mcount))
 
-static void
+static int
 __ftrace_replace_code(struct dyn_ftrace *rec,
                       unsigned char *old, unsigned char *new, int enable)
 {
-        unsigned long ip;
-        int failed;
+        unsigned long ip, fl;
 
         ip = rec->ip;
 
         if (ftrace_filtered && enable) {
-                unsigned long fl;
                 /*
                  * If filtering is on:
                  *
@@ -356,20 +421,29 @@ __ftrace_replace_code(struct dyn_ftrace *rec,
                  * If this record is not set to be filtered
                  * and it is not enabled do nothing.
                  *
+                 * If this record is set not to trace then
+                 * do nothing.
+                 *
+                 * If this record is set not to trace and
+                 * it is enabled then disable it.
+                 *
                  * If this record is not set to be filtered and
                  * it is enabled, disable it.
                  */
-                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_ENABLED);
+
+                fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE |
+                                   FTRACE_FL_ENABLED);
 
                 if ((fl ==  (FTRACE_FL_FILTER | FTRACE_FL_ENABLED)) ||
-                    (fl == 0))
-                        return;
+                    (fl ==  (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE)) ||
+                    !fl || (fl == FTRACE_FL_NOTRACE))
+                        return 0;
 
                 /*
                  * If it is enabled disable it,
                  * otherwise enable it!
                  */
-                if (fl == FTRACE_FL_ENABLED) {
+                if (fl & FTRACE_FL_ENABLED) {
                         /* swap new and old */
                         new = old;
                         old = ftrace_call_replace(ip, FTRACE_ADDR);
@@ -380,41 +454,39 @@ __ftrace_replace_code(struct dyn_ftrace *rec,
                 }
         } else {
 
-                if (enable)
+                if (enable) {
+                        /*
+                         * If this record is set not to trace and is
+                         * not enabled, do nothing.
+                         */
+                        fl = rec->flags & (FTRACE_FL_NOTRACE | FTRACE_FL_ENABLED);
+                        if (fl == FTRACE_FL_NOTRACE)
+                                return 0;
+
                         new = ftrace_call_replace(ip, FTRACE_ADDR);
-                else
+                } else
                         old = ftrace_call_replace(ip, FTRACE_ADDR);
 
                 if (enable) {
                         if (rec->flags & FTRACE_FL_ENABLED)
-                                return;
+                                return 0;
                         rec->flags |= FTRACE_FL_ENABLED;
                 } else {
                         if (!(rec->flags & FTRACE_FL_ENABLED))
-                                return;
+                                return 0;
                         rec->flags &= ~FTRACE_FL_ENABLED;
                 }
         }
 
-        failed = ftrace_modify_code(ip, old, new);
-        if (failed) {
-                unsigned long key;
-                /* It is possible that the function hasn't been converted yet */
-                key = hash_long(ip, FTRACE_HASHBITS);
-                if (!ftrace_ip_in_hash(ip, key)) {
-                        rec->flags |= FTRACE_FL_FAILED;
-                        ftrace_free_rec(rec);
-                }
-
-        }
+        return ftrace_modify_code(ip, old, new);
 }
 
 static void ftrace_replace_code(int enable)
 {
+        int i, failed;
         unsigned char *new = NULL, *old = NULL;
         struct dyn_ftrace *rec;
         struct ftrace_page *pg;
-        int i;
 
         if (enable)
                 old = ftrace_nop_replace();
@@ -429,7 +501,23 @@ static void ftrace_replace_code(int enable)
                         if (rec->flags & FTRACE_FL_FAILED)
                                 continue;
 
-                        __ftrace_replace_code(rec, old, new, enable);
+                        /* ignore updates to this record's mcount site */
+                        if (get_kprobe((void *)rec->ip)) {
+                                freeze_record(rec);
+                                continue;
+                        } else {
+                                unfreeze_record(rec);
+                        }
+
+                        failed = __ftrace_replace_code(rec, old, new, enable);
+                        if (failed && (rec->flags & FTRACE_FL_CONVERTED)) {
+                                rec->flags |= FTRACE_FL_FAILED;
+                                if ((system_state == SYSTEM_BOOTING) ||
+                                    !core_kernel_text(rec->ip)) {
+                                        ftrace_del_hash(rec);
+                                        ftrace_free_rec(rec);
+                                }
+                        }
                 }
         }
 }
@@ -443,7 +531,7 @@ static void ftrace_shutdown_replenish(void)
         ftrace_pages->next = (void *)get_zeroed_page(GFP_KERNEL);
 }
 
-static void
+static int
 ftrace_code_disable(struct dyn_ftrace *rec)
 {
         unsigned long ip;
@@ -458,19 +546,30 @@ ftrace_code_disable(struct dyn_ftrace *rec)
         failed = ftrace_modify_code(ip, call, nop);
         if (failed) {
                 rec->flags |= FTRACE_FL_FAILED;
-                ftrace_free_rec(rec);
+                return 0;
         }
+        return 1;
 }
 
+static int __ftrace_update_code(void *ignore);
+
 static int __ftrace_modify_code(void *data)
 {
         unsigned long addr;
         int *command = data;
 
-        if (*command & FTRACE_ENABLE_CALLS)
+        if (*command & FTRACE_ENABLE_CALLS) {
+                /*
+                 * Update any recorded ips now that we have the
+                 * machine stopped
+                 */
+                __ftrace_update_code(NULL);
                 ftrace_replace_code(1);
-        else if (*command & FTRACE_DISABLE_CALLS)
+                tracing_on = 1;
+        } else if (*command & FTRACE_DISABLE_CALLS) {
                 ftrace_replace_code(0);
+                tracing_on = 0;
+        }
 
         if (*command & FTRACE_UPDATE_TRACE_FUNC)
                 ftrace_update_ftrace_func(ftrace_trace_function);
@@ -491,6 +590,25 @@ static void ftrace_run_update_code(int command)
         stop_machine_run(__ftrace_modify_code, &command, NR_CPUS);
 }
 
+void ftrace_disable_daemon(void)
+{
+        /* Stop the daemon from calling kstop_machine */
+        mutex_lock(&ftraced_lock);
+        ftraced_stop = 1;
+        mutex_unlock(&ftraced_lock);
+
+        ftrace_force_update();
+}
+
+void ftrace_enable_daemon(void)
+{
+        mutex_lock(&ftraced_lock);
+        ftraced_stop = 0;
+        mutex_unlock(&ftraced_lock);
+
+        ftrace_force_update();
+}
+
 static ftrace_func_t saved_ftrace_func;
 
 static void ftrace_startup(void)
@@ -583,14 +701,14 @@ unsigned long		ftrace_update_tot_cnt;
 
 static int __ftrace_update_code(void *ignore)
 {
-        struct dyn_ftrace *p;
-        struct hlist_head head;
-        struct hlist_node *t;
-        int save_ftrace_enabled;
+        int i, save_ftrace_enabled;
         cycle_t start, stop;
-        int i;
+        struct dyn_ftrace *p;
+        struct hlist_node *t, *n;
+        struct hlist_head *head, temp_list;
 
         /* Don't be recording funcs now */
+        ftrace_record_suspend++;
         save_ftrace_enabled = ftrace_enabled;
         ftrace_enabled = 0;
 
@@ -599,35 +717,79 @@ static int __ftrace_update_code(void *ignore)
 
         /* No locks needed, the machine is stopped! */
         for (i = 0; i < FTRACE_HASHSIZE; i++) {
-                if (hlist_empty(&ftrace_hash[i]))
-                        continue;
-
-                head = ftrace_hash[i];
-                INIT_HLIST_HEAD(&ftrace_hash[i]);
+                INIT_HLIST_HEAD(&temp_list);
+                head = &ftrace_hash[i];
 
                 /* all CPUS are stopped, we are safe to modify code */
-                hlist_for_each_entry(p, t, &head, node) {
-                        ftrace_code_disable(p);
-                        ftrace_update_cnt++;
+                hlist_for_each_entry_safe(p, t, n, head, node) {
+                        /* Skip over failed records which have not been
+                         * freed. */
+                        if (p->flags & FTRACE_FL_FAILED)
+                                continue;
+
+                        /* Unconverted records are always at the head of the
+                         * hash bucket. Once we encounter a converted record,
+                         * simply skip over to the next bucket. Saves ftraced
+                         * some processor cycles (ftrace does its bid for
+                         * global warming :-p ). */
+                        if (p->flags & (FTRACE_FL_CONVERTED))
+                                break;
+
+                        /* Ignore updates to this record's mcount site.
+                         * Reintroduce this record at the head of this
+                         * bucket to attempt to "convert" it again if
+                         * the kprobe on it is unregistered before the
+                         * next run. */
+                        if (get_kprobe((void *)p->ip)) {
+                                ftrace_del_hash(p);
+                                INIT_HLIST_NODE(&p->node);
+                                hlist_add_head(&p->node, &temp_list);
+                                freeze_record(p);
+                                continue;
+                        } else {
+                                unfreeze_record(p);
+                        }
+
+                        /* convert record (i.e, patch mcount-call with NOP) */
+                        if (ftrace_code_disable(p)) {
+                                p->flags |= FTRACE_FL_CONVERTED;
+                                ftrace_update_cnt++;
+                        } else {
+                                if ((system_state == SYSTEM_BOOTING) ||
+                                    !core_kernel_text(p->ip)) {
+                                        ftrace_del_hash(p);
+                                        ftrace_free_rec(p);
+                                }
+                        }
                 }
 
+                hlist_for_each_entry_safe(p, t, n, &temp_list, node) {
+                        hlist_del(&p->node);
+                        INIT_HLIST_NODE(&p->node);
+                        hlist_add_head(&p->node, head);
+                }
         }
 
         stop = ftrace_now(raw_smp_processor_id());
         ftrace_update_time = stop - start;
         ftrace_update_tot_cnt += ftrace_update_cnt;
+        ftraced_trigger = 0;
 
         ftrace_enabled = save_ftrace_enabled;
+        ftrace_record_suspend--;
 
         return 0;
 }
 
-static void ftrace_update_code(void)
+static int ftrace_update_code(void)
 {
-        if (unlikely(ftrace_disabled))
-                return;
+        if (unlikely(ftrace_disabled) ||
+            !ftrace_enabled || !ftraced_trigger)
+                return 0;
 
         stop_machine_run(__ftrace_update_code, NULL, NR_CPUS);
+
+        return 1;
 }
 
 static int ftraced(void *ignore)
@@ -646,14 +808,13 @@ static int ftraced(void *ignore)
 
                 mutex_lock(&ftrace_sysctl_lock);
                 mutex_lock(&ftraced_lock);
-                if (ftrace_enabled && ftraced_trigger && !ftraced_suspend) {
-                        ftrace_record_suspend++;
-                        ftrace_update_code();
+                if (!ftraced_suspend && !ftraced_stop &&
+                    ftrace_update_code()) {
                         usecs = nsecs_to_usecs(ftrace_update_time);
                         if (ftrace_update_tot_cnt > 100000) {
                                 ftrace_update_tot_cnt = 0;
                                 pr_info("hm, dftrace overflow: %lu change%s"
-                                         " (%lu total) in %lu usec%s\n",
+                                        " (%lu total) in %lu usec%s\n",
                                         ftrace_update_cnt,
                                         ftrace_update_cnt != 1 ? "s" : "",
                                         ftrace_update_tot_cnt,
@@ -661,15 +822,10 @@ static int ftraced(void *ignore)
                                 ftrace_disabled = 1;
                                 WARN_ON_ONCE(1);
                         }
-                        ftraced_trigger = 0;
-                        ftrace_record_suspend--;
                 }
-                ftraced_iteration_counter++;
                 mutex_unlock(&ftraced_lock);
                 mutex_unlock(&ftrace_sysctl_lock);
 
-                wake_up_interruptible(&ftraced_waiters);
-
                 ftrace_shutdown_replenish();
         }
         __set_current_state(TASK_RUNNING);
@@ -721,6 +877,8 @@ static int __init ftrace_dyn_table_alloc(void)
 enum {
         FTRACE_ITER_FILTER      = (1 << 0),
         FTRACE_ITER_CONT        = (1 << 1),
+        FTRACE_ITER_NOTRACE     = (1 << 2),
+        FTRACE_ITER_FAILURES    = (1 << 3),
 };
 
 #define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
@@ -752,9 +910,18 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
                 }
         } else {
                 rec = &iter->pg->records[iter->idx++];
-                if ((rec->flags & FTRACE_FL_FAILED) ||
+                if ((!(iter->flags & FTRACE_ITER_FAILURES) &&
+                     (rec->flags & FTRACE_FL_FAILED)) ||
+
+                    ((iter->flags & FTRACE_ITER_FAILURES) &&
+                     (!(rec->flags & FTRACE_FL_FAILED) ||
+                      (rec->flags & FTRACE_FL_FREE))) ||
+
                     ((iter->flags & FTRACE_ITER_FILTER) &&
-                     !(rec->flags & FTRACE_FL_FILTER))) {
+                     !(rec->flags & FTRACE_FL_FILTER)) ||
+
+                    ((iter->flags & FTRACE_ITER_NOTRACE) &&
+                     !(rec->flags & FTRACE_FL_NOTRACE))) {
                         rec = NULL;
                         goto retry;
                 }
@@ -847,22 +1014,42 @@ int ftrace_avail_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static void ftrace_filter_reset(void)
+static int
+ftrace_failures_open(struct inode *inode, struct file *file)
+{
+        int ret;
+        struct seq_file *m;
+        struct ftrace_iterator *iter;
+
+        ret = ftrace_avail_open(inode, file);
+        if (!ret) {
+                m = (struct seq_file *)file->private_data;
+                iter = (struct ftrace_iterator *)m->private;
+                iter->flags = FTRACE_ITER_FAILURES;
+        }
+
+        return ret;
+}
+
+
+static void ftrace_filter_reset(int enable)
 {
         struct ftrace_page *pg;
         struct dyn_ftrace *rec;
+        unsigned long type = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
         unsigned i;
 
         /* keep kstop machine from running */
         preempt_disable();
-        ftrace_filtered = 0;
+        if (enable)
+                ftrace_filtered = 0;
         pg = ftrace_pages_start;
         while (pg) {
                 for (i = 0; i < pg->index; i++) {
                         rec = &pg->records[i];
                         if (rec->flags & FTRACE_FL_FAILED)
                                 continue;
-                        rec->flags &= ~FTRACE_FL_FILTER;
+                        rec->flags &= ~type;
                 }
                 pg = pg->next;
         }
@@ -870,7 +1057,7 @@ static void ftrace_filter_reset(void)
 }
 
 static int
-ftrace_filter_open(struct inode *inode, struct file *file)
+ftrace_regex_open(struct inode *inode, struct file *file, int enable)
 {
         struct ftrace_iterator *iter;
         int ret = 0;
@@ -882,15 +1069,16 @@ ftrace_filter_open(struct inode *inode, struct file *file)
         if (!iter)
                 return -ENOMEM;
 
-        mutex_lock(&ftrace_filter_lock);
+        mutex_lock(&ftrace_regex_lock);
         if ((file->f_mode & FMODE_WRITE) &&
             !(file->f_flags & O_APPEND))
-                ftrace_filter_reset();
+                ftrace_filter_reset(enable);
 
         if (file->f_mode & FMODE_READ) {
                 iter->pg = ftrace_pages_start;
                 iter->pos = -1;
-                iter->flags = FTRACE_ITER_FILTER;
+                iter->flags = enable ? FTRACE_ITER_FILTER :
+                        FTRACE_ITER_NOTRACE;
 
                 ret = seq_open(file, &show_ftrace_seq_ops);
                 if (!ret) {
@@ -900,13 +1088,25 @@ ftrace_filter_open(struct inode *inode, struct file *file)
                         kfree(iter);
         } else
                 file->private_data = iter;
-        mutex_unlock(&ftrace_filter_lock);
+        mutex_unlock(&ftrace_regex_lock);
 
         return ret;
 }
 
+static int
+ftrace_filter_open(struct inode *inode, struct file *file)
+{
+        return ftrace_regex_open(inode, file, 1);
+}
+
+static int
+ftrace_notrace_open(struct inode *inode, struct file *file)
+{
+        return ftrace_regex_open(inode, file, 0);
+}
+
 static ssize_t
-ftrace_filter_read(struct file *file, char __user *ubuf,
+ftrace_regex_read(struct file *file, char __user *ubuf,
                        size_t cnt, loff_t *ppos)
 {
         if (file->f_mode & FMODE_READ)
@@ -916,7 +1116,7 @@ ftrace_filter_read(struct file *file, char __user *ubuf,
 }
 
 static loff_t
-ftrace_filter_lseek(struct file *file, loff_t offset, int origin)
+ftrace_regex_lseek(struct file *file, loff_t offset, int origin)
 {
         loff_t ret;
 
@@ -936,13 +1136,14 @@ enum {
 };
 
 static void
-ftrace_match(unsigned char *buff, int len)
+ftrace_match(unsigned char *buff, int len, int enable)
 {
         char str[KSYM_SYMBOL_LEN];
         char *search = NULL;
         struct ftrace_page *pg;
         struct dyn_ftrace *rec;
         int type = MATCH_FULL;
+        unsigned long flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
         unsigned i, match = 0, search_len = 0;
 
         for (i = 0; i < len; i++) {
@@ -966,7 +1167,8 @@ ftrace_match(unsigned char *buff, int len)
 
         /* keep kstop machine from running */
         preempt_disable();
-        ftrace_filtered = 1;
+        if (enable)
+                ftrace_filtered = 1;
         pg = ftrace_pages_start;
         while (pg) {
                 for (i = 0; i < pg->index; i++) {
@@ -997,7 +1199,7 @@ ftrace_match(unsigned char *buff, int len)
                                 break;
                         }
                         if (matched)
-                                rec->flags |= FTRACE_FL_FILTER;
+                                rec->flags |= flag;
                 }
                 pg = pg->next;
         }
@@ -1005,8 +1207,8 @@ ftrace_match(unsigned char *buff, int len)
 }
 
 static ssize_t
-ftrace_filter_write(struct file *file, const char __user *ubuf,
-                    size_t cnt, loff_t *ppos)
+ftrace_regex_write(struct file *file, const char __user *ubuf,
+                   size_t cnt, loff_t *ppos, int enable)
 {
         struct ftrace_iterator *iter;
         char ch;
@@ -1016,7 +1218,7 @@ ftrace_filter_write(struct file *file, const char __user *ubuf,
         if (!cnt || cnt < 0)
                 return 0;
 
-        mutex_lock(&ftrace_filter_lock);
+        mutex_lock(&ftrace_regex_lock);
 
         if (file->f_mode & FMODE_READ) {
                 struct seq_file *m = file->private_data;
@@ -1045,7 +1247,6 @@ ftrace_filter_write(struct file *file, const char __user *ubuf,
                         cnt--;
                 }
 
-
                 if (isspace(ch)) {
                         file->f_pos += read;
                         ret = read;
@@ -1072,7 +1273,7 @@ ftrace_filter_write(struct file *file, const char __user *ubuf,
         if (isspace(ch)) {
                 iter->filtered++;
                 iter->buffer[iter->buffer_idx] = 0;
-                ftrace_match(iter->buffer, iter->buffer_idx);
+                ftrace_match(iter->buffer, iter->buffer_idx, enable);
                 iter->buffer_idx = 0;
         } else
                 iter->flags |= FTRACE_ITER_CONT;
@@ -1082,11 +1283,39 @@ ftrace_filter_write(struct file *file, const char __user *ubuf,
 
         ret = read;
  out:
-        mutex_unlock(&ftrace_filter_lock);
+        mutex_unlock(&ftrace_regex_lock);
 
         return ret;
 }
 
+static ssize_t
+ftrace_filter_write(struct file *file, const char __user *ubuf,
+                    size_t cnt, loff_t *ppos)
+{
+        return ftrace_regex_write(file, ubuf, cnt, ppos, 1);
+}
+
+static ssize_t
+ftrace_notrace_write(struct file *file, const char __user *ubuf,
+                     size_t cnt, loff_t *ppos)
+{
+        return ftrace_regex_write(file, ubuf, cnt, ppos, 0);
+}
+
+static void
+ftrace_set_regex(unsigned char *buf, int len, int reset, int enable)
+{
+        if (unlikely(ftrace_disabled))
+                return;
+
+        mutex_lock(&ftrace_regex_lock);
+        if (reset)
+                ftrace_filter_reset(enable);
+        if (buf)
+                ftrace_match(buf, len, enable);
+        mutex_unlock(&ftrace_regex_lock);
+}
+
 /**
  * ftrace_set_filter - set a function to filter on in ftrace
  * @buf - the string that holds the function filter text.
@@ -1098,24 +1327,31 @@ ftrace_filter_write(struct file *file, const char __user *ubuf,
  */
 void ftrace_set_filter(unsigned char *buf, int len, int reset)
 {
-        if (unlikely(ftrace_disabled))
-                return;
+        ftrace_set_regex(buf, len, reset, 1);
+}
 
-        mutex_lock(&ftrace_filter_lock);
-        if (reset)
-                ftrace_filter_reset();
-        if (buf)
-                ftrace_match(buf, len);
-        mutex_unlock(&ftrace_filter_lock);
+/**
+ * ftrace_set_notrace - set a function to not trace in ftrace
+ * @buf - the string that holds the function notrace text.
+ * @len - the length of the string.
+ * @reset - non zero to reset all filters before applying this filter.
+ *
+ * Notrace Filters denote which functions should not be enabled when tracing
+ * is enabled. If @buf is NULL and reset is set, all functions will be enabled
+ * for tracing.
+ */
+void ftrace_set_notrace(unsigned char *buf, int len, int reset)
+{
+        ftrace_set_regex(buf, len, reset, 0);
 }
 
 static int
-ftrace_filter_release(struct inode *inode, struct file *file)
+ftrace_regex_release(struct inode *inode, struct file *file, int enable)
 {
         struct seq_file *m = (struct seq_file *)file->private_data;
         struct ftrace_iterator *iter;
 
-        mutex_lock(&ftrace_filter_lock);
+        mutex_lock(&ftrace_regex_lock);
         if (file->f_mode & FMODE_READ) {
                 iter = m->private;
 
@@ -1126,7 +1362,7 @@ ftrace_filter_release(struct inode *inode, struct file *file)
         if (iter->buffer_idx) {
                 iter->filtered++;
                 iter->buffer[iter->buffer_idx] = 0;
-                ftrace_match(iter->buffer, iter->buffer_idx);
+                ftrace_match(iter->buffer, iter->buffer_idx, enable);
         }
 
         mutex_lock(&ftrace_sysctl_lock);
@@ -1137,10 +1373,71 @@ ftrace_filter_release(struct inode *inode, struct file *file)
         mutex_unlock(&ftrace_sysctl_lock);
 
         kfree(iter);
-        mutex_unlock(&ftrace_filter_lock);
+        mutex_unlock(&ftrace_regex_lock);
         return 0;
 }
 
+static int
+ftrace_filter_release(struct inode *inode, struct file *file)
+{
+        return ftrace_regex_release(inode, file, 1);
+}
+
+static int
+ftrace_notrace_release(struct inode *inode, struct file *file)
+{
+        return ftrace_regex_release(inode, file, 0);
+}
+
+static ssize_t
+ftraced_read(struct file *filp, char __user *ubuf,
+                     size_t cnt, loff_t *ppos)
+{
+        /* don't worry about races */
+        char *buf = ftraced_stop ? "disabled\n" : "enabled\n";
+        int r = strlen(buf);
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+}
+
+static ssize_t
+ftraced_write(struct file *filp, const char __user *ubuf,
+                      size_t cnt, loff_t *ppos)
+{
+        char buf[64];
+        long val;
+        int ret;
+
+        if (cnt >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        if (strncmp(buf, "enable", 6) == 0)
+                val = 1;
+        else if (strncmp(buf, "disable", 7) == 0)
+                val = 0;
+        else {
+                buf[cnt] = 0;
+
+                ret = strict_strtoul(buf, 10, &val);
+                if (ret < 0)
+                        return ret;
+
+                val = !!val;
+        }
+
+        if (val)
+                ftrace_enable_daemon();
+        else
+                ftrace_disable_daemon();
+
+        filp->f_pos += cnt;
+
+        return cnt;
+}
+
 static struct file_operations ftrace_avail_fops = {
         .open = ftrace_avail_open,
         .read = seq_read,
@@ -1148,59 +1445,57 @@ static struct file_operations ftrace_avail_fops = {
         .release = ftrace_avail_release,
 };
 
+static struct file_operations ftrace_failures_fops = {
+        .open = ftrace_failures_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = ftrace_avail_release,
+};
+
 static struct file_operations ftrace_filter_fops = {
         .open = ftrace_filter_open,
-        .read = ftrace_filter_read,
+        .read = ftrace_regex_read,
         .write = ftrace_filter_write,
-        .llseek = ftrace_filter_lseek,
+        .llseek = ftrace_regex_lseek,
         .release = ftrace_filter_release,
 };
 
+static struct file_operations ftrace_notrace_fops = {
+        .open = ftrace_notrace_open,
+        .read = ftrace_regex_read,
+        .write = ftrace_notrace_write,
+        .llseek = ftrace_regex_lseek,
+        .release = ftrace_notrace_release,
+};
+
+static struct file_operations ftraced_fops = {
+        .open = tracing_open_generic,
+        .read = ftraced_read,
+        .write = ftraced_write,
+};
+
 /**
  * ftrace_force_update - force an update to all recording ftrace functions
- *
- * The ftrace dynamic update daemon only wakes up once a second.
- * There may be cases where an update needs to be done immediately
- * for tests or internal kernel tracing to begin. This function
- * wakes the daemon to do an update and will not return until the
- * update is complete.
  */
 int ftrace_force_update(void)
 {
-        unsigned long last_counter;
-        DECLARE_WAITQUEUE(wait, current);
         int ret = 0;
 
         if (unlikely(ftrace_disabled))
                 return -ENODEV;
 
+        mutex_lock(&ftrace_sysctl_lock);
         mutex_lock(&ftraced_lock);
-        last_counter = ftraced_iteration_counter;
 
-        set_current_state(TASK_INTERRUPTIBLE);
-        add_wait_queue(&ftraced_waiters, &wait);
-
-        if (unlikely(!ftraced_task)) {
-                ret = -ENODEV;
-                goto out;
-        }
-
-        do {
-                mutex_unlock(&ftraced_lock);
-                wake_up_process(ftraced_task);
-                schedule();
-                mutex_lock(&ftraced_lock);
-                if (signal_pending(current)) {
-                        ret = -EINTR;
-                        break;
-                }
-                set_current_state(TASK_INTERRUPTIBLE);
-        } while (last_counter == ftraced_iteration_counter);
+        /*
+         * If ftraced_trigger is not set, then there is nothing
+         * to update.
+         */
+        if (ftraced_trigger && !ftrace_update_code())
+                ret = -EBUSY;
 
- out:
         mutex_unlock(&ftraced_lock);
-        remove_wait_queue(&ftraced_waiters, &wait);
-        set_current_state(TASK_RUNNING);
+        mutex_unlock(&ftrace_sysctl_lock);
 
         return ret;
 }
@@ -1234,11 +1529,28 @@ static __init int ftrace_init_debugfs(void)
                 pr_warning("Could not create debugfs "
                            "'available_filter_functions' entry\n");
 
+        entry = debugfs_create_file("failures", 0444,
+                                    d_tracer, NULL, &ftrace_failures_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs 'failures' entry\n");
+
         entry = debugfs_create_file("set_ftrace_filter", 0644, d_tracer,
                                     NULL, &ftrace_filter_fops);
         if (!entry)
                 pr_warning("Could not create debugfs "
                            "'set_ftrace_filter' entry\n");
+
+        entry = debugfs_create_file("set_ftrace_notrace", 0644, d_tracer,
+                                    NULL, &ftrace_notrace_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs "
+                           "'set_ftrace_notrace' entry\n");
+
+        entry = debugfs_create_file("ftraced_enabled", 0644, d_tracer,
+                                    NULL, &ftraced_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs "
+                           "'ftraced_enabled' entry\n");
         return 0;
 }
 
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 4dcc4e85c5d6..4a875600733b 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -27,6 +27,7 @@
 #include <linux/poll.h>
 #include <linux/gfp.h>
 #include <linux/fs.h>
+#include <linux/kprobes.h>
 #include <linux/writeback.h>
 
 #include <linux/stacktrace.h>
@@ -42,11 +43,6 @@ static cpumask_t __read_mostly		tracing_buffer_mask;
 #define for_each_tracing_cpu(cpu)       \
         for_each_cpu_mask(cpu, tracing_buffer_mask)
 
-/* dummy trace to disable tracing */
-static struct tracer no_tracer __read_mostly = {
-        .name           = "none",
-};
-
 static int trace_alloc_page(void);
 static int trace_free_page(void);
 
@@ -134,6 +130,23 @@ static DECLARE_WAIT_QUEUE_HEAD(trace_wait);
 /* trace_flags holds iter_ctrl options */
 unsigned long trace_flags = TRACE_ITER_PRINT_PARENT;
 
+static notrace void no_trace_init(struct trace_array *tr)
+{
+        int cpu;
+
+        if(tr->ctrl)
+                for_each_online_cpu(cpu)
+                        tracing_reset(tr->data[cpu]);
+        tracer_enabled = 0;
+}
+
+/* dummy trace to disable tracing */
+static struct tracer no_tracer __read_mostly = {
+        .name           = "none",
+        .init           = no_trace_init
+};
+
+
 /**
  * trace_wake_up - wake up tasks waiting for trace input
  *
@@ -249,24 +262,32 @@ __update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
         tracing_record_cmdline(current);
 }
 
+#define CHECK_COND(cond)                        \
+        if (unlikely(cond)) {                   \
+                tracing_disabled = 1;           \
+                WARN_ON(1);                     \
+                return -1;                      \
+        }
+
 /**
  * check_pages - integrity check of trace buffers
  *
  * As a safty measure we check to make sure the data pages have not
- * been corrupted. TODO: configure to disable this because it adds
- * a bit of overhead.
+ * been corrupted.
  */
-void check_pages(struct trace_array_cpu *data)
+int check_pages(struct trace_array_cpu *data)
 {
         struct page *page, *tmp;
 
-        BUG_ON(data->trace_pages.next->prev != &data->trace_pages);
-        BUG_ON(data->trace_pages.prev->next != &data->trace_pages);
+        CHECK_COND(data->trace_pages.next->prev != &data->trace_pages);
+        CHECK_COND(data->trace_pages.prev->next != &data->trace_pages);
 
         list_for_each_entry_safe(page, tmp, &data->trace_pages, lru) {
-                BUG_ON(page->lru.next->prev != &page->lru);
-                BUG_ON(page->lru.prev->next != &page->lru);
+                CHECK_COND(page->lru.next->prev != &page->lru);
+                CHECK_COND(page->lru.prev->next != &page->lru);
         }
+
+        return 0;
 }
 
 /**
@@ -280,7 +301,6 @@ void *head_page(struct trace_array_cpu *data)
 {
         struct page *page;
 
-        check_pages(data);
         if (list_empty(&data->trace_pages))
                 return NULL;
 
@@ -645,9 +665,6 @@ static char saved_cmdlines[SAVED_CMDLINES][TASK_COMM_LEN];
 static int cmdline_idx;
 static DEFINE_SPINLOCK(trace_cmdline_lock);
 
-/* trace in all context switches */
-atomic_t trace_record_cmdline_enabled __read_mostly;
-
 /* temporary disable recording */
 atomic_t trace_record_cmdline_disabled __read_mostly;
 
@@ -976,6 +993,30 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
         trace_wake_up();
 }
 
+void
+ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
+{
+        struct trace_array *tr = &global_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int cpu;
+
+        if (tracing_disabled || current_trace == &no_tracer || !tr->ctrl)
+                return;
+
+        local_irq_save(flags);
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+        disabled = atomic_inc_return(&data->disabled);
+
+        if (likely(disabled == 1))
+                __trace_special(tr, data, arg1, arg2, arg3);
+
+        atomic_dec(&data->disabled);
+        local_irq_restore(flags);
+}
+
 #ifdef CONFIG_FTRACE
 static void
 function_trace_call(unsigned long ip, unsigned long parent_ip)
@@ -989,6 +1030,9 @@ function_trace_call(unsigned long ip, unsigned long parent_ip)
         if (unlikely(!tracer_enabled))
                 return;
 
+        if (skip_trace(ip))
+                return;
+
         local_irq_save(flags);
         cpu = raw_smp_processor_id();
         data = tr->data[cpu];
@@ -1213,6 +1257,20 @@ static void s_stop(struct seq_file *m, void *p)
         mutex_unlock(&trace_types_lock);
 }
 
+#define KRETPROBE_MSG "[unknown/kretprobe'd]"
+
+#ifdef CONFIG_KRETPROBES
+static inline int kretprobed(unsigned long addr)
+{
+        return addr == (unsigned long)kretprobe_trampoline;
+}
+#else
+static inline int kretprobed(unsigned long addr)
+{
+        return 0;
+}
+#endif /* CONFIG_KRETPROBES */
+
 static int
 seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
 {
@@ -1448,7 +1506,10 @@ print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
         case TRACE_FN:
                 seq_print_ip_sym(s, entry->fn.ip, sym_flags);
                 trace_seq_puts(s, " (");
-                seq_print_ip_sym(s, entry->fn.parent_ip, sym_flags);
+                if (kretprobed(entry->fn.parent_ip))
+                        trace_seq_puts(s, KRETPROBE_MSG);
+                else
+                        seq_print_ip_sym(s, entry->fn.parent_ip, sym_flags);
                 trace_seq_puts(s, ")\n");
                 break;
         case TRACE_CTX:
@@ -1528,8 +1589,11 @@ static int print_trace_fmt(struct trace_iterator *iter)
                         ret = trace_seq_printf(s, " <-");
                         if (!ret)
                                 return 0;
-                        ret = seq_print_ip_sym(s, entry->fn.parent_ip,
-                                               sym_flags);
+                        if (kretprobed(entry->fn.parent_ip))
+                                ret = trace_seq_puts(s, KRETPROBE_MSG);
+                        else
+                                ret = seq_print_ip_sym(s, entry->fn.parent_ip,
+                                                       sym_flags);
                         if (!ret)
                                 return 0;
                 }
@@ -2608,7 +2672,7 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
 {
         unsigned long val;
         char buf[64];
-        int ret;
+        int i, ret;
 
         if (cnt >= sizeof(buf))
                 return -EINVAL;
@@ -2677,8 +2741,15 @@ tracing_entries_write(struct file *filp, const char __user *ubuf,
                         trace_free_page();
         }
 
+        /* check integrity */
+        for_each_tracing_cpu(i)
+                check_pages(global_trace.data[i]);
+
         filp->f_pos += cnt;
 
+        /* If check pages failed, return ENOMEM */
+        if (tracing_disabled)
+                cnt = -ENOMEM;
  out:
         max_tr.entries = global_trace.entries;
         mutex_unlock(&trace_types_lock);
@@ -2969,8 +3040,6 @@ __init static int tracer_alloc_buffers(void)
         int ret = -ENOMEM;
         int i;
 
-        global_trace.ctrl = tracer_enabled;
-
         /* TODO: make the number of buffers hot pluggable with CPUS */
         tracing_nr_buffers = num_possible_cpus();
         tracing_buffer_mask = cpu_possible_map;
@@ -3027,9 +3096,8 @@ __init static int tracer_alloc_buffers(void)
         }
         max_tr.entries = global_trace.entries;
 
-        pr_info("tracer: %d pages allocated for %ld",
-                pages, trace_nr_entries);
-        pr_info(" entries of %ld bytes\n", (long)TRACE_ENTRY_SIZE);
+        pr_info("tracer: %d pages allocated for %ld entries of %ld bytes\n",
+                pages, trace_nr_entries, (long)TRACE_ENTRY_SIZE);
         pr_info("   actual entries %ld\n", global_trace.entries);
 
         tracer_init_debugfs();
@@ -3040,6 +3108,7 @@ __init static int tracer_alloc_buffers(void)
         current_trace = &no_tracer;
 
         /* All seems OK, enable tracing */
+        global_trace.ctrl = tracer_enabled;
         tracing_disabled = 0;
 
         return 0;
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 0ef9ef74c806..4966e6a964fe 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -223,6 +223,8 @@ void trace_function(struct trace_array *tr,
 
 void tracing_start_function_trace(void);
 void tracing_stop_function_trace(void);
+void tracing_start_cmdline_record(void);
+void tracing_stop_cmdline_record(void);
 int register_tracer(struct tracer *type);
 void unregister_tracer(struct tracer *type);
 
@@ -231,8 +233,6 @@ extern unsigned long nsecs_to_usecs(unsigned long nsecs);
 extern unsigned long tracing_max_latency;
 extern unsigned long tracing_thresh;
 
-extern atomic_t trace_record_cmdline_enabled;
-
 void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu);
 void update_max_tr_single(struct trace_array *tr,
                           struct task_struct *tsk, int cpu);
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index 0a084656d7cf..7ee7dcd76b7d 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -29,14 +29,14 @@ static void function_reset(struct trace_array *tr)
 static void start_function_trace(struct trace_array *tr)
 {
         function_reset(tr);
-        atomic_inc(&trace_record_cmdline_enabled);
+        tracing_start_cmdline_record();
         tracing_start_function_trace();
 }
 
 static void stop_function_trace(struct trace_array *tr)
 {
         tracing_stop_function_trace();
-        atomic_dec(&trace_record_cmdline_enabled);
+        tracing_stop_cmdline_record();
 }
 
 static void function_trace_init(struct trace_array *tr)
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index 761f3ec66c50..421d6fe3650e 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -165,22 +165,6 @@ check_critical_timing(struct trace_array *tr,
 
         update_max_tr_single(tr, current, cpu);
 
-        if (!runqueue_is_locked()) {
-                if (tracing_thresh) {
-                        printk(KERN_INFO "(%16s-%-5d|#%d): %lu us critical"
-                               " section violates %lu us threshold.\n",
-                               current->comm, current->pid,
-                               raw_smp_processor_id(),
-                               latency, nsecs_to_usecs(tracing_thresh));
-                } else {
-                        printk(KERN_INFO "(%16s-%-5d|#%d): new %lu us"
-                               " maximum-latency critical section.\n",
-                               current->comm, current->pid,
-                               raw_smp_processor_id(),
-                               latency);
-                }
-        }
-
         max_sequence++;
 
 out_unlock:
diff --git a/kernel/trace/trace_sched_switch.c b/kernel/trace/trace_sched_switch.c
index d25ffa5eaf2b..93a662009151 100644
--- a/kernel/trace/trace_sched_switch.c
+++ b/kernel/trace/trace_sched_switch.c
@@ -29,6 +29,9 @@ sched_switch_func(void *private, void *__rq, struct task_struct *prev,
         long disabled;
         int cpu;
 
+        tracing_record_cmdline(prev);
+        tracing_record_cmdline(next);
+
         if (!tracer_enabled)
                 return;
 
@@ -63,8 +66,6 @@ sched_switch_callback(void *probe_data, void *call_data,
         prev = va_arg(*args, typeof(prev));
         next = va_arg(*args, typeof(next));
 
-        tracing_record_cmdline(prev);
-
         /*
          * If tracer_switch_func only points to the local
          * switch func, it still needs the ptr passed to it.
@@ -125,30 +126,6 @@ wake_up_callback(void *probe_data, void *call_data,
         wakeup_func(probe_data, __rq, task, curr);
 }
 
-void
-ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
-{
-        struct trace_array *tr = ctx_trace;
-        struct trace_array_cpu *data;
-        unsigned long flags;
-        long disabled;
-        int cpu;
-
-        if (!tracer_enabled)
-                return;
-
-        local_irq_save(flags);
-        cpu = raw_smp_processor_id();
-        data = tr->data[cpu];
-        disabled = atomic_inc_return(&data->disabled);
-
-        if (likely(disabled == 1))
-                __trace_special(tr, data, arg1, arg2, arg3);
-
-        atomic_dec(&data->disabled);
-        local_irq_restore(flags);
-}
-
 static void sched_switch_reset(struct trace_array *tr)
 {
         int cpu;
@@ -219,7 +196,7 @@ static void tracing_sched_unregister(void)
                                 &ctx_trace);
 }
 
-void tracing_start_sched_switch(void)
+static void tracing_start_sched_switch(void)
 {
         long ref;
 
@@ -228,7 +205,7 @@ void tracing_start_sched_switch(void)
                 tracing_sched_register();
 }
 
-void tracing_stop_sched_switch(void)
+static void tracing_stop_sched_switch(void)
 {
         long ref;
 
@@ -237,18 +214,26 @@ void tracing_stop_sched_switch(void)
                 tracing_sched_unregister();
 }
 
+void tracing_start_cmdline_record(void)
+{
+        tracing_start_sched_switch();
+}
+
+void tracing_stop_cmdline_record(void)
+{
+        tracing_stop_sched_switch();
+}
+
 static void start_sched_trace(struct trace_array *tr)
 {
         sched_switch_reset(tr);
-        atomic_inc(&trace_record_cmdline_enabled);
         tracer_enabled = 1;
-        tracing_start_sched_switch();
+        tracing_start_cmdline_record();
 }
 
 static void stop_sched_trace(struct trace_array *tr)
 {
-        tracing_stop_sched_switch();
-        atomic_dec(&trace_record_cmdline_enabled);
+        tracing_stop_cmdline_record();
         tracer_enabled = 0;
 }
 
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index 5d2fb48e47f8..bf7e91caef57 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -30,6 +30,69 @@ static DEFINE_SPINLOCK(wakeup_lock);
 
 static void __wakeup_reset(struct trace_array *tr);
 
+#ifdef CONFIG_FTRACE
+/*
+ * irqsoff uses its own tracer function to keep the overhead down:
+ */
+static void
+wakeup_tracer_call(unsigned long ip, unsigned long parent_ip)
+{
+        struct trace_array *tr = wakeup_trace;
+        struct trace_array_cpu *data;
+        unsigned long flags;
+        long disabled;
+        int resched;
+        int cpu;
+
+        if (likely(!wakeup_task))
+                return;
+
+        resched = need_resched();
+        preempt_disable_notrace();
+
+        cpu = raw_smp_processor_id();
+        data = tr->data[cpu];
+        disabled = atomic_inc_return(&data->disabled);
+        if (unlikely(disabled != 1))
+                goto out;
+
+        spin_lock_irqsave(&wakeup_lock, flags);
+
+        if (unlikely(!wakeup_task))
+                goto unlock;
+
+        /*
+         * The task can't disappear because it needs to
+         * wake up first, and we have the wakeup_lock.
+         */
+        if (task_cpu(wakeup_task) != cpu)
+                goto unlock;
+
+        trace_function(tr, data, ip, parent_ip, flags);
+
+ unlock:
+        spin_unlock_irqrestore(&wakeup_lock, flags);
+
+ out:
+        atomic_dec(&data->disabled);
+
+        /*
+         * To prevent recursion from the scheduler, if the
+         * resched flag was set before we entered, then
+         * don't reschedule.
+         */
+        if (resched)
+                preempt_enable_no_resched_notrace();
+        else
+                preempt_enable_notrace();
+}
+
+static struct ftrace_ops trace_ops __read_mostly =
+{
+        .func = wakeup_tracer_call,
+};
+#endif /* CONFIG_FTRACE */
+
 /*
  * Should this new latency be reported/recorded?
  */
@@ -73,7 +136,7 @@ wakeup_sched_switch(void *private, void *rq, struct task_struct *prev,
         if (next != wakeup_task)
                 return;
 
-        /* The task we are waitng for is waking up */
+        /* The task we are waiting for is waking up */
         data = tr->data[wakeup_cpu];
 
         /* disable local data, not wakeup_cpu data */
@@ -290,6 +353,7 @@ static void start_wakeup_tracer(struct trace_array *tr)
         smp_wmb();
 
         tracer_enabled = 1;
+        register_ftrace_function(&trace_ops);
 
         return;
 fail_deprobe_wake_new:
@@ -305,6 +369,7 @@ fail_deprobe:
 static void stop_wakeup_tracer(struct trace_array *tr)
 {
         tracer_enabled = 0;
+        unregister_ftrace_function(&trace_ops);
         marker_probe_unregister("kernel_sched_schedule",
                                 sched_switch_callback,
                                 &wakeup_trace);
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 3877dd9102f1..18c5423bc977 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -28,6 +28,7 @@ trace_test_buffer_cpu(struct trace_array *tr, struct trace_array_cpu *data)
         page = list_entry(data->trace_pages.next, struct page, lru);
         entries = page_address(page);
 
+        check_pages(data);
         if (head_page(data) != entries)
                 goto failed;