ftrace: disable tracing on failure

Since ftrace touches practically every function. If we detect any
anomaly, we want to fully disable ftrace. This patch adds code
to try shutdown ftrace as much as possible without doing any more
harm is something is detected not quite correct.

This only kills ftrace, this patch does have checks for other parts of
the tracer (irqsoff, wakeup, etc.).

Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

2 files changed, 107 insertions, 9 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 8e02aa690b2b..ff42345dd78e 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -29,9 +29,16 @@
 
 #include "trace.h"
 
-int ftrace_enabled;
+/* ftrace_enabled is a method to turn ftrace on or off */
+int ftrace_enabled __read_mostly;
 static int last_ftrace_enabled;
 
+/*
+ * ftrace_disabled is set when an anomaly is discovered.
+ * ftrace_disabled is much stronger than ftrace_enabled.
+ */
+static int ftrace_disabled __read_mostly;
+
 static DEFINE_SPINLOCK(ftrace_lock);
 static DEFINE_MUTEX(ftrace_sysctl_lock);
 
@@ -230,10 +237,11 @@ static notrace struct dyn_ftrace *ftrace_alloc_dyn_node(unsigned long ip)
         if (ftrace_free_records) {
                 rec = ftrace_free_records;
 
-                /* todo, disable tracing altogether on this warning */
                 if (unlikely(!(rec->flags & FTRACE_FL_FREE))) {
                         WARN_ON_ONCE(1);
                         ftrace_free_records = NULL;
+                        ftrace_disabled = 1;
+                        ftrace_enabled = 0;
                         return NULL;
                 }
 
@@ -260,7 +268,7 @@ ftrace_record_ip(unsigned long ip)
         int resched;
         int atomic;
 
-        if (!ftrace_enabled)
+        if (!ftrace_enabled || ftrace_disabled)
                 return;
 
         resched = need_resched();
@@ -485,6 +493,9 @@ static void notrace ftrace_startup(void)
 {
         int command = 0;
 
+        if (unlikely(ftrace_disabled))
+                return;
+
         mutex_lock(&ftraced_lock);
         ftraced_suspend++;
         if (ftraced_suspend == 1)
@@ -507,6 +518,9 @@ static void notrace ftrace_shutdown(void)
 {
         int command = 0;
 
+        if (unlikely(ftrace_disabled))
+                return;
+
         mutex_lock(&ftraced_lock);
         ftraced_suspend--;
         if (!ftraced_suspend)
@@ -529,6 +543,9 @@ static void notrace ftrace_startup_sysctl(void)
 {
         int command = FTRACE_ENABLE_MCOUNT;
 
+        if (unlikely(ftrace_disabled))
+                return;
+
         mutex_lock(&ftraced_lock);
         /* Force update next time */
         saved_ftrace_func = NULL;
@@ -544,6 +561,9 @@ static void notrace ftrace_shutdown_sysctl(void)
 {
         int command = FTRACE_DISABLE_MCOUNT;
 
+        if (unlikely(ftrace_disabled))
+                return;
+
         mutex_lock(&ftraced_lock);
         /* ftraced_suspend is true if ftrace is running */
         if (ftraced_suspend)
@@ -600,6 +620,9 @@ static int notrace __ftrace_update_code(void *ignore)
 
 static void notrace ftrace_update_code(void)
 {
+        if (unlikely(ftrace_disabled))
+                return;
+
         stop_machine_run(__ftrace_update_code, NULL, NR_CPUS);
 }
 
@@ -614,6 +637,9 @@ static int notrace ftraced(void *ignore)
                 /* check once a second */
                 schedule_timeout(HZ);
 
+                if (unlikely(ftrace_disabled))
+                        continue;
+
                 mutex_lock(&ftrace_sysctl_lock);
                 mutex_lock(&ftraced_lock);
                 if (ftrace_enabled && ftraced_trigger && !ftraced_suspend) {
@@ -628,6 +654,7 @@ static int notrace ftraced(void *ignore)
                                         ftrace_update_cnt != 1 ? "s" : "",
                                         ftrace_update_tot_cnt,
                                         usecs, usecs != 1 ? "s" : "");
+                                ftrace_disabled = 1;
                                 WARN_ON_ONCE(1);
                         }
                         ftraced_trigger = 0;
@@ -785,6 +812,9 @@ ftrace_avail_open(struct inode *inode, struct file *file)
         struct ftrace_iterator *iter;
         int ret;
 
+        if (unlikely(ftrace_disabled))
+                return -ENODEV;
+
         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
         if (!iter)
                 return -ENOMEM;
@@ -843,6 +873,9 @@ ftrace_filter_open(struct inode *inode, struct file *file)
         struct ftrace_iterator *iter;
         int ret = 0;
 
+        if (unlikely(ftrace_disabled))
+                return -ENODEV;
+
         iter = kzalloc(sizeof(*iter), GFP_KERNEL);
         if (!iter)
                 return -ENOMEM;
@@ -1063,6 +1096,9 @@ ftrace_filter_write(struct file *file, const char __user *ubuf,
  */
 notrace void ftrace_set_filter(unsigned char *buf, int len, int reset)
 {
+        if (unlikely(ftrace_disabled))
+                return;
+
         mutex_lock(&ftrace_filter_lock);
         if (reset)
                 ftrace_filter_reset();
@@ -1133,7 +1169,7 @@ int ftrace_force_update(void)
         DECLARE_WAITQUEUE(wait, current);
         int ret = 0;
 
-        if (!ftraced_task)
+        if (unlikely(ftrace_disabled))
                 return -ENODEV;
 
         mutex_lock(&ftraced_lock);
@@ -1142,6 +1178,11 @@ int ftrace_force_update(void)
         set_current_state(TASK_INTERRUPTIBLE);
         add_wait_queue(&ftraced_waiters, &wait);
 
+        if (unlikely(!ftraced_task)) {
+                ret = -ENODEV;
+                goto out;
+        }
+
         do {