[PATCH v4 5/6] tracing: Unify the logic for function tracing options

[Yordan Karadzhov (VMware)]

Currently the logic for dealing with the options for function tracing
has two different implementations. One is used when we set the flags
(in "static int func_set_flag()") and another used when we initialize
the tracer (in "static int function_trace_init()"). Those two
implementations are meant to do essentially the same thing and they
are both not very convenient for adding new options. In this patch
we add a helper function that provides a single implementation of
the logic for dealing with the options and we make it such that new
options can be easily added.

Signed-off-by: Yordan Karadzhov (VMware) <y.kar...@gmail.com>
---
 kernel/trace/trace_functions.c | 65 ++++++++++++++++++++--------------
 1 file changed, 38 insertions(+), 27 deletions(-)

diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index f93723ca66bc..f37f73a9b1b8 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -31,9 +31,12 @@ static struct tracer_flags func_flags;
 
 /* Our option */
 enum {
+       TRACE_FUNC_NO_OPTS      = 0x0, /* No flags set. */
        TRACE_FUNC_OPT_STACK    = 0x1,
 };
 
+#define TRACE_FUNC_OPT_MASK    (TRACE_FUNC_OPT_STACK)
+
 int ftrace_allocate_ftrace_ops(struct trace_array *tr)
 {
        struct ftrace_ops *ops;
@@ -86,6 +89,18 @@ void ftrace_destroy_function_files(struct trace_array *tr)
        ftrace_free_ftrace_ops(tr);
 }
 
+static ftrace_func_t select_trace_function(u32 flags_val)
+{
+       switch (flags_val & TRACE_FUNC_OPT_MASK) {
+       case TRACE_FUNC_NO_OPTS:
+               return function_trace_call;
+       case TRACE_FUNC_OPT_STACK:
+               return function_stack_trace_call;
+       default:
+               return NULL;
+       }
+}
+
 static int function_trace_init(struct trace_array *tr)
 {
        ftrace_func_t func;
@@ -97,12 +112,9 @@ static int function_trace_init(struct trace_array *tr)
        if (!tr->ops)
                return -ENOMEM;
 
-       /* Currently only the global instance can do stack tracing */
-       if (tr->flags & TRACE_ARRAY_FL_GLOBAL &&
-           func_flags.val & TRACE_FUNC_OPT_STACK)
-               func = function_stack_trace_call;
-       else
-               func = function_trace_call;
+       func = select_trace_function(func_flags.val);
+       if (!func)
+               return -EINVAL;
 
        ftrace_init_array_ops(tr, func);
 
@@ -213,7 +225,7 @@ static struct tracer_opt func_opts[] = {
 };
 
 static struct tracer_flags func_flags = {
-       .val = 0, /* By default: all flags disabled */
+       .val = TRACE_FUNC_NO_OPTS, /* By default: all flags disabled */
        .opts = func_opts
 };
 
@@ -235,30 +247,29 @@ static struct tracer function_trace;
 static int
 func_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set)
 {
-       switch (bit) {
-       case TRACE_FUNC_OPT_STACK:
-               /* do nothing if already set */
-               if (!!set == !!(func_flags.val & TRACE_FUNC_OPT_STACK))
-                       break;
-
-               /* We can change this flag when not running. */
-               if (tr->current_trace != &function_trace)
-                       break;
+       ftrace_func_t func;
+       u32 new_flags;
 
-               unregister_ftrace_function(tr->ops);
+       /* Do nothing if already set. */
+       if (!!set == !!(func_flags.val & bit))
+               return 0;
 
-               if (set) {
-                       tr->ops->func = function_stack_trace_call;
-                       register_ftrace_function(tr->ops);
-               } else {
-                       tr->ops->func = function_trace_call;
-                       register_ftrace_function(tr->ops);
-               }
+       /* We can change this flag only when not running. */
+       if (tr->current_trace != &function_trace)
+               return 0;
 
-               break;
-       default:
+       new_flags = (func_flags.val & ~bit) | (set ? bit : 0);
+       func = select_trace_function(new_flags);
+       if (!func)
                return -EINVAL;
-       }
+
+       /* Check if there's anything to change. */
+       if (tr->ops->func == func)
+               return 0;
+
+       unregister_ftrace_function(tr->ops);
+       tr->ops->func = func;
+       register_ftrace_function(tr->ops);
 
        return 0;
 }
-- 
2.25.1