ftrace: Remove FTRACE_FL_FAILED flag

Since we disable all function tracer processing if we detect
that a modification of a instruction had failed, we do not need
to track that the record has failed. No more ftrace processing
is allowed, and the FTRACE_FL_FAILED flag is pointless.

Removing this flag simplifies some of the code, but some ftrace_disabled
checks needed to be added or move around a little.

Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

1 files changed, 47 insertions, 29 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 97b30f818642..eb19fae2c54a 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -1083,19 +1083,20 @@ static void ftrace_replace_code(int enable)
         struct ftrace_page *pg;
         int failed;
 
+        if (unlikely(ftrace_disabled))
+                return;
+
         do_for_each_ftrace_rec(pg, rec) {
                 /*
                  * Skip over free records, records that have
                  * failed and not converted.
                  */
                 if (rec->flags & FTRACE_FL_FREE ||
-                    rec->flags & FTRACE_FL_FAILED ||
                     !(rec->flags & FTRACE_FL_CONVERTED))
                         continue;
 
                 failed = __ftrace_replace_code(rec, enable);
                 if (failed) {
-                        rec->flags |= FTRACE_FL_FAILED;
                         ftrace_bug(failed, rec->ip);
                         /* Stop processing */
                         return;
@@ -1111,10 +1112,12 @@ ftrace_code_disable(struct module *mod, struct dyn_ftrace *rec)
 
         ip = rec->ip;
 
+        if (unlikely(ftrace_disabled))
+                return 0;
+
         ret = ftrace_make_nop(mod, rec, MCOUNT_ADDR);
         if (ret) {
                 ftrace_bug(ret, ip);
-                rec->flags |= FTRACE_FL_FAILED;
                 return 0;
         }
         return 1;
@@ -1466,6 +1469,9 @@ t_next(struct seq_file *m, void *v, loff_t *pos)
         struct ftrace_iterator *iter = m->private;
         struct dyn_ftrace *rec = NULL;
 
+        if (unlikely(ftrace_disabled))
+                return NULL;
+
         if (iter->flags & FTRACE_ITER_HASH)
                 return t_hash_next(m, pos);
 
@@ -1518,6 +1524,10 @@ static void *t_start(struct seq_file *m, loff_t *pos)
         loff_t l;
 
         mutex_lock(&ftrace_lock);
+
+        if (unlikely(ftrace_disabled))
+                return NULL;
+
         /*
          * If an lseek was done, then reset and start from beginning.
          */
@@ -1636,8 +1646,6 @@ static void ftrace_filter_reset(int enable)
         if (enable)
                 ftrace_filtered = 0;
         do_for_each_ftrace_rec(pg, rec) {
-                if (rec->flags & FTRACE_FL_FAILED)
-                        continue;
                 rec->flags &= ~type;
         } while_for_each_ftrace_rec();
         mutex_unlock(&ftrace_lock);
@@ -1767,9 +1775,6 @@ static int ftrace_match_records(char *buff, int len, int enable)
         mutex_lock(&ftrace_lock);
         do_for_each_ftrace_rec(pg, rec) {
 
-                if (rec->flags & FTRACE_FL_FAILED)
-                        continue;
-
                 if (ftrace_match_record(rec, search, search_len, type)) {
                         if (not)
                                 rec->flags &= ~flag;
@@ -1837,10 +1842,11 @@ static int ftrace_match_module_records(char *buff, char *mod, int enable)
         }
 
         mutex_lock(&ftrace_lock);
-        do_for_each_ftrace_rec(pg, rec) {
 
-                if (rec->flags & FTRACE_FL_FAILED)
-                        continue;
+        if (unlikely(ftrace_disabled))
+                goto out_unlock;
+
+        do_for_each_ftrace_rec(pg, rec) {
 
                 if (ftrace_match_module_record(rec, mod,
                                                search, search_len, type)) {
@@ -1854,6 +1860,7 @@ static int ftrace_match_module_records(char *buff, char *mod, int enable)
                         ftrace_filtered = 1;
 
         } while_for_each_ftrace_rec();
+ out_unlock:
         mutex_unlock(&ftrace_lock);
 
         return found;
@@ -2008,10 +2015,11 @@ register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
                 return -EINVAL;
 
         mutex_lock(&ftrace_lock);
-        do_for_each_ftrace_rec(pg, rec) {
 
-                if (rec->flags & FTRACE_FL_FAILED)
-                        continue;
+        if (unlikely(ftrace_disabled))
+                goto out_unlock;
+
+        do_for_each_ftrace_rec(pg, rec) {
 
                 if (!ftrace_match_record(rec, search, len, type))
                         continue;
@@ -2218,6 +2226,10 @@ ftrace_regex_write(struct file *file, const char __user *ubuf,
 
         mutex_lock(&ftrace_regex_lock);
 
+        ret = -ENODEV;
+        if (unlikely(ftrace_disabled))
+                goto out_unlock;
+
         if (file->f_mode & FMODE_READ) {
                 struct seq_file *m = file->private_data;
                 iter = m->private;
@@ -2545,9 +2557,6 @@ ftrace_set_func(unsigned long *array, int *idx, char *buffer)
         bool exists;
         int i;
 
-        if (ftrace_disabled)
-                return -ENODEV;
-
         /* decode regex */
         type = filter_parse_regex(buffer, strlen(buffer), &search, &not);
         if (!not && *idx >= FTRACE_GRAPH_MAX_FUNCS)
@@ -2556,9 +2565,15 @@ ftrace_set_func(unsigned long *array, int *idx, char *buffer)
         search_len = strlen(search);
 
         mutex_lock(&ftrace_lock);
+
+        if (unlikely(ftrace_disabled)) {
+                mutex_unlock(&ftrace_lock);
+                return -ENODEV;
+        }
+
         do_for_each_ftrace_rec(pg, rec) {
 
-                if (rec->flags & (FTRACE_FL_FAILED | FTRACE_FL_FREE))
+                if (rec->flags & FTRACE_FL_FREE)
                         continue;
 
                 if (ftrace_match_record(rec, search, search_len, type)) {
@@ -2700,10 +2715,11 @@ void ftrace_release_mod(struct module *mod)
         struct dyn_ftrace *rec;
         struct ftrace_page *pg;
 
+        mutex_lock(&ftrace_lock);
+
         if (ftrace_disabled)
-                return;
+                goto out_unlock;
 
-        mutex_lock(&ftrace_lock);
         do_for_each_ftrace_rec(pg, rec) {
                 if (within_module_core(rec->ip, mod)) {
                         /*
@@ -2714,6 +2730,7 @@ void ftrace_release_mod(struct module *mod)
                         ftrace_free_rec(rec);
                 }
         } while_for_each_ftrace_rec();
+ out_unlock:
         mutex_unlock(&ftrace_lock);
 }
 
@@ -3108,16 +3125,17 @@ void ftrace_kill(void)
  */
 int register_ftrace_function(struct ftrace_ops *ops)
 {
-        int ret;
-
-        if (unlikely(ftrace_disabled))
-                return -1;
+        int ret = -1;
 
         mutex_lock(&ftrace_lock);
 
+        if (unlikely(ftrace_disabled))
+                goto out_unlock;
+
         ret = __register_ftrace_function(ops);
         ftrace_startup(0);
 
+ out_unlock:
         mutex_unlock(&ftrace_lock);
         return ret;
 }
@@ -3145,14 +3163,14 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
                      void __user *buffer, size_t *lenp,
                      loff_t *ppos)
 {
-        int ret;
-
-        if (unlikely(ftrace_disabled))
-                return -ENODEV;
+        int ret = -ENODEV;
 
         mutex_lock(&ftrace_lock);
 
-        ret  = proc_dointvec(table, write, buffer, lenp, ppos);
+        if (unlikely(ftrace_disabled))
+                goto out;
+
+        ret = proc_dointvec(table, write, buffer, lenp, ppos);
 
         if (ret || !write || (last_ftrace_enabled == !!ftrace_enabled))
                 goto out;