tracing: Rename FTRACE_EVENT_FL_* flags to EVENT_FILE_FL_*

The name "ftrace" really refers to the function hook infrastructure. It
is not about the trace_events. The FTRACE_EVENT_FL_* flags are flags to
do with the trace_event files in the tracefs directory. They are not related
to function tracing. Rename them to a more descriptive name.

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

4 files changed, 45 insertions, 45 deletions

diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 07ff08661167..abcbf7ff8743 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -301,7 +301,7 @@ int filter_check_discard(struct trace_event_file *file, void *rec,
                          struct ring_buffer *buffer,
                          struct ring_buffer_event *event)
 {
-        if (unlikely(file->flags & FTRACE_EVENT_FL_FILTERED) &&
+        if (unlikely(file->flags & EVENT_FILE_FL_FILTERED) &&
             !filter_match_preds(file->filter, rec)) {
                 ring_buffer_discard_commit(buffer, event);
                 return 1;
@@ -1709,7 +1709,7 @@ trace_event_buffer_lock_reserve(struct ring_buffer **current_rb,
          * to store the trace event for the tigger to use. It's recusive
          * safe and will not be recorded anywhere.
          */
-        if (!entry && trace_file->flags & FTRACE_EVENT_FL_TRIGGER_COND) {
+        if (!entry && trace_file->flags & EVENT_FILE_FL_TRIGGER_COND) {
                 *current_rb = temp_buffer;
                 entry = trace_buffer_lock_reserve(*current_rb,
                                                   type, len, flags, pc);
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index 58984c252aac..404a372ad85a 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -298,15 +298,15 @@ void trace_event_enable_cmd_record(bool enable)
         mutex_lock(&event_mutex);
         do_for_each_event_file(tr, file) {
 
-                if (!(file->flags & FTRACE_EVENT_FL_ENABLED))
+                if (!(file->flags & EVENT_FILE_FL_ENABLED))
                         continue;
 
                 if (enable) {
                         tracing_start_cmdline_record();
-                        set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);
+                        set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
                 } else {
                         tracing_stop_cmdline_record();
-                        clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);
+                        clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
                 }
         } while_for_each_event_file();
         mutex_unlock(&event_mutex);
@@ -337,24 +337,24 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
                 if (soft_disable) {
                         if (atomic_dec_return(&file->sm_ref) > 0)
                                 break;
-                        disable = file->flags & FTRACE_EVENT_FL_SOFT_DISABLED;
-                        clear_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags);
+                        disable = file->flags & EVENT_FILE_FL_SOFT_DISABLED;
+                        clear_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);
                 } else
-                        disable = !(file->flags & FTRACE_EVENT_FL_SOFT_MODE);
+                        disable = !(file->flags & EVENT_FILE_FL_SOFT_MODE);
 
-                if (disable && (file->flags & FTRACE_EVENT_FL_ENABLED)) {
-                        clear_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags);
-                        if (file->flags & FTRACE_EVENT_FL_RECORDED_CMD) {
+                if (disable && (file->flags & EVENT_FILE_FL_ENABLED)) {
+                        clear_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);
+                        if (file->flags & EVENT_FILE_FL_RECORDED_CMD) {
                                 tracing_stop_cmdline_record();
-                                clear_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);
+                                clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
                         }
                         call->class->reg(call, TRACE_REG_UNREGISTER, file);
                 }
                 /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */
-                if (file->flags & FTRACE_EVENT_FL_SOFT_MODE)
-                        set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);
+                if (file->flags & EVENT_FILE_FL_SOFT_MODE)
+                        set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
                 else
-                        clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);
+                        clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
                 break;
         case 1:
                 /*
@@ -366,22 +366,22 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
                  * it still seems to be disabled.
                  */
                 if (!soft_disable)
-                        clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);
+                        clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
                 else {
                         if (atomic_inc_return(&file->sm_ref) > 1)
                                 break;
-                        set_bit(FTRACE_EVENT_FL_SOFT_MODE_BIT, &file->flags);
+                        set_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);
                 }
 
-                if (!(file->flags & FTRACE_EVENT_FL_ENABLED)) {
+                if (!(file->flags & EVENT_FILE_FL_ENABLED)) {
 
                         /* Keep the event disabled, when going to SOFT_MODE. */
                         if (soft_disable)
-                                set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);
+                                set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
 
                         if (trace_flags & TRACE_ITER_RECORD_CMD) {
                                 tracing_start_cmdline_record();
-                                set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);
+                                set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
                         }
                         ret = call->class->reg(call, TRACE_REG_REGISTER, file);
                         if (ret) {
@@ -390,7 +390,7 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
                                         "%s\n", trace_event_name(call));
                                 break;
                         }
-                        set_bit(FTRACE_EVENT_FL_ENABLED_BIT, &file->flags);
+                        set_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);
 
                         /* WAS_ENABLED gets set but never cleared. */
                         call->flags |= TRACE_EVENT_FL_WAS_ENABLED;
@@ -716,7 +716,7 @@ s_next(struct seq_file *m, void *v, loff_t *pos)
         (*pos)++;
 
         list_for_each_entry_continue(file, &tr->events, list) {
-                if (file->flags & FTRACE_EVENT_FL_ENABLED)
+                if (file->flags & EVENT_FILE_FL_ENABLED)
                         return file;
         }
 
@@ -774,12 +774,12 @@ event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
         if (!file)
                 return -ENODEV;
 
-        if (flags & FTRACE_EVENT_FL_ENABLED &&
-            !(flags & FTRACE_EVENT_FL_SOFT_DISABLED))
+        if (flags & EVENT_FILE_FL_ENABLED &&
+            !(flags & EVENT_FILE_FL_SOFT_DISABLED))
                 strcpy(buf, "1");
 
-        if (flags & FTRACE_EVENT_FL_SOFT_DISABLED ||
-            flags & FTRACE_EVENT_FL_SOFT_MODE)
+        if (flags & EVENT_FILE_FL_SOFT_DISABLED ||
+            flags & EVENT_FILE_FL_SOFT_MODE)
                 strcat(buf, "*");
 
         strcat(buf, "\n");
@@ -851,7 +851,7 @@ system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
                  * or if all events or cleared, or if we have
                  * a mixture.
                  */
-                set |= (1 << !!(file->flags & FTRACE_EVENT_FL_ENABLED));
+                set |= (1 << !!(file->flags & EVENT_FILE_FL_ENABLED));
 
                 /*
                  * If we have a mixture, no need to look further.
@@ -1932,10 +1932,10 @@ static int probe_remove_event_call(struct trace_event_call *call)
                         continue;
                 /*
                  * We can't rely on ftrace_event_enable_disable(enable => 0)
-                 * we are going to do, FTRACE_EVENT_FL_SOFT_MODE can suppress
+                 * we are going to do, EVENT_FILE_FL_SOFT_MODE can suppress
                  * TRACE_REG_UNREGISTER.
                  */
-                if (file->flags & FTRACE_EVENT_FL_ENABLED)
+                if (file->flags & EVENT_FILE_FL_ENABLED)
                         return -EBUSY;
                 /*
                  * The do_for_each_event_file_safe() is
@@ -2114,9 +2114,9 @@ event_enable_probe(unsigned long ip, unsigned long parent_ip, void **_data)
                 return;
 
         if (data->enable)
-                clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &data->file->flags);
+                clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);
         else
-                set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &data->file->flags);
+                set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);
 }
 
 static void
@@ -2132,7 +2132,7 @@ event_enable_count_probe(unsigned long ip, unsigned long parent_ip, void **_data
                 return;
 
         /* Skip if the event is in a state we want to switch to */
-        if (data->enable == !(data->file->flags & FTRACE_EVENT_FL_SOFT_DISABLED))
+        if (data->enable == !(data->file->flags & EVENT_FILE_FL_SOFT_DISABLED))
                 return;
 
         if (data->count != -1)
@@ -2793,7 +2793,7 @@ static __init void event_trace_self_tests(void)
                  * If an event is already enabled, someone is using
                  * it and the self test should not be on.
                  */
-                if (file->flags & FTRACE_EVENT_FL_ENABLED) {
+                if (file->flags & EVENT_FILE_FL_ENABLED) {
                         pr_warn("Enabled event during self test!\n");
                         WARN_ON_ONCE(1);
                         continue;
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index 203dd3750e91..319560a1af4b 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -787,7 +787,7 @@ static void filter_disable(struct trace_event_file *file)
         if (call->flags & TRACE_EVENT_FL_USE_CALL_FILTER)
                 call->flags &= ~TRACE_EVENT_FL_FILTERED;
         else
-                file->flags &= ~FTRACE_EVENT_FL_FILTERED;
+                file->flags &= ~EVENT_FILE_FL_FILTERED;
 }
 
 static void __free_filter(struct event_filter *filter)
@@ -1669,7 +1669,7 @@ static inline void event_set_filtered_flag(struct trace_event_file *file)
         if (call->flags & TRACE_EVENT_FL_USE_CALL_FILTER)
                 call->flags |= TRACE_EVENT_FL_FILTERED;
         else
-                file->flags |= FTRACE_EVENT_FL_FILTERED;
+                file->flags |= EVENT_FILE_FL_FILTERED;
 }
 
 static inline void event_set_filter(struct trace_event_file *file,
@@ -1701,7 +1701,7 @@ event_set_no_set_filter_flag(struct trace_event_file *file)
         if (call->flags & TRACE_EVENT_FL_USE_CALL_FILTER)
                 call->flags |= TRACE_EVENT_FL_NO_SET_FILTER;
         else
-                file->flags |= FTRACE_EVENT_FL_NO_SET_FILTER;
+                file->flags |= EVENT_FILE_FL_NO_SET_FILTER;
 }
 
 static inline void
@@ -1712,7 +1712,7 @@ event_clear_no_set_filter_flag(struct trace_event_file *file)
         if (call->flags & TRACE_EVENT_FL_USE_CALL_FILTER)
                 call->flags &= ~TRACE_EVENT_FL_NO_SET_FILTER;
         else
-                file->flags &= ~FTRACE_EVENT_FL_NO_SET_FILTER;
+                file->flags &= ~EVENT_FILE_FL_NO_SET_FILTER;
 }
 
 static inline bool
@@ -1720,7 +1720,7 @@ event_no_set_filter_flag(struct trace_event_file *file)
 {
         struct trace_event_call *call = file->event_call;
 
-        if (file->flags & FTRACE_EVENT_FL_NO_SET_FILTER)
+        if (file->flags & EVENT_FILE_FL_NO_SET_FILTER)
                 return true;
 
         if ((call->flags & TRACE_EVENT_FL_USE_CALL_FILTER) &&
diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_events_trigger.c
index ccd6a2adc7ad..bb2cff8abe71 100644
--- a/kernel/trace/trace_events_trigger.c
+++ b/kernel/trace/trace_events_trigger.c
@@ -438,12 +438,12 @@ static int trace_event_trigger_enable_disable(struct trace_event_file *file,
         if (trigger_enable) {
                 if (atomic_inc_return(&file->tm_ref) > 1)
                         return ret;
-                set_bit(FTRACE_EVENT_FL_TRIGGER_MODE_BIT, &file->flags);
+                set_bit(EVENT_FILE_FL_TRIGGER_MODE_BIT, &file->flags);
                 ret = trace_event_enable_disable(file, 1, 1);
         } else {
                 if (atomic_dec_return(&file->tm_ref) > 0)
                         return ret;
-                clear_bit(FTRACE_EVENT_FL_TRIGGER_MODE_BIT, &file->flags);
+                clear_bit(EVENT_FILE_FL_TRIGGER_MODE_BIT, &file->flags);
                 ret = trace_event_enable_disable(file, 0, 1);
         }
 
@@ -501,9 +501,9 @@ static void update_cond_flag(struct trace_event_file *file)
         }
 
         if (set_cond)
-                set_bit(FTRACE_EVENT_FL_TRIGGER_COND_BIT, &file->flags);
+                set_bit(EVENT_FILE_FL_TRIGGER_COND_BIT, &file->flags);
         else
-                clear_bit(FTRACE_EVENT_FL_TRIGGER_COND_BIT, &file->flags);
+                clear_bit(EVENT_FILE_FL_TRIGGER_COND_BIT, &file->flags);
 }
 
 /**
@@ -1063,9 +1063,9 @@ event_enable_trigger(struct event_trigger_data *data)
         struct enable_trigger_data *enable_data = data->private_data;
 
         if (enable_data->enable)
-                clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &enable_data->file->flags);
+                clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &enable_data->file->flags);
         else
-                set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &enable_data->file->flags);
+                set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &enable_data->file->flags);
 }
 
 static void
@@ -1077,7 +1077,7 @@ event_enable_count_trigger(struct event_trigger_data *data)
                 return;
 
         /* Skip if the event is in a state we want to switch to */
-        if (enable_data->enable == !(enable_data->file->flags & FTRACE_EVENT_FL_SOFT_DISABLED))
+        if (enable_data->enable == !(enable_data->file->flags & EVENT_FILE_FL_SOFT_DISABLED))
                 return;
 
         if (data->count != -1)