trace: fix the errors caused by incompatible type of RCU variables
authorChunyan Zhang <zhang.chunyan@linaro.org>
Wed, 7 Jun 2017 08:12:51 +0000 (16:12 +0800)
committerSteven Rostedt (VMware) <rostedt@goodmis.org>
Thu, 20 Jul 2017 13:27:29 +0000 (09:27 -0400)
The variables which are processed by RCU functions should be annotated
as RCU, otherwise sparse will report the errors like below:

"error: incompatible types in comparison expression (different
address spaces)"

Link: http://lkml.kernel.org/r/1496823171-7758-1-git-send-email-zhang.chunyan@linaro.org
Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org>
[ Updated to not be 100% 80 column strict ]
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
include/linux/ftrace.h
include/linux/trace_events.h
kernel/trace/ftrace.c
kernel/trace/trace.h

index 5857390ac35aa37d4d2431504adc98c3a3075026..6383115e9d2c5c6459973a1d2d74609aeb438b9f 100644 (file)
@@ -145,8 +145,8 @@ enum {
 #ifdef CONFIG_DYNAMIC_FTRACE
 /* The hash used to know what functions callbacks trace */
 struct ftrace_ops_hash {
-       struct ftrace_hash              *notrace_hash;
-       struct ftrace_hash              *filter_hash;
+       struct ftrace_hash __rcu        *notrace_hash;
+       struct ftrace_hash __rcu        *filter_hash;
        struct mutex                    regex_lock;
 };
 
@@ -168,7 +168,7 @@ static inline void ftrace_free_init_mem(void) { }
  */
 struct ftrace_ops {
        ftrace_func_t                   func;
-       struct ftrace_ops               *next;
+       struct ftrace_ops __rcu         *next;
        unsigned long                   flags;
        void                            *private;
        ftrace_func_t                   saved_func;
index f73cedfa2e0b97cde1c3bcd1c07d650cf616afdb..536c80ff7ad96680ddcca0a7880cd7df81c57f17 100644 (file)
@@ -338,7 +338,7 @@ enum {
 struct trace_event_file {
        struct list_head                list;
        struct trace_event_call         *event_call;
-       struct event_filter             *filter;
+       struct event_filter __rcu       *filter;
        struct dentry                   *dir;
        struct trace_array              *tr;
        struct trace_subsystem_dir      *system;
index 53f6b6401cf05fe9d63be0b67d646d25eed929e7..02004ae918608f915b28341b6ed1b3b7f551c5a5 100644 (file)
@@ -113,7 +113,7 @@ static int ftrace_disabled __read_mostly;
 
 static DEFINE_MUTEX(ftrace_lock);
 
-static struct ftrace_ops *ftrace_ops_list __read_mostly = &ftrace_list_end;
+static struct ftrace_ops __rcu *ftrace_ops_list __read_mostly = &ftrace_list_end;
 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
 static struct ftrace_ops global_ops;
 
@@ -169,8 +169,11 @@ int ftrace_nr_registered_ops(void)
 
        mutex_lock(&ftrace_lock);
 
-       for (ops = ftrace_ops_list;
-            ops != &ftrace_list_end; ops = ops->next)
+       for (ops = rcu_dereference_protected(ftrace_ops_list,
+                                            lockdep_is_held(&ftrace_lock));
+            ops != &ftrace_list_end;
+            ops = rcu_dereference_protected(ops->next,
+                                            lockdep_is_held(&ftrace_lock)))
                cnt++;
 
        mutex_unlock(&ftrace_lock);
@@ -275,10 +278,11 @@ static void update_ftrace_function(void)
         * If there's only one ftrace_ops registered, the ftrace_ops_list
         * will point to the ops we want.
         */
-       set_function_trace_op = ftrace_ops_list;
+       set_function_trace_op = rcu_dereference_protected(ftrace_ops_list,
+                                               lockdep_is_held(&ftrace_lock));
 
        /* If there's no ftrace_ops registered, just call the stub function */
-       if (ftrace_ops_list == &ftrace_list_end) {
+       if (set_function_trace_op == &ftrace_list_end) {
                func = ftrace_stub;
 
        /*
@@ -286,7 +290,8 @@ static void update_ftrace_function(void)
         * recursion safe and not dynamic and the arch supports passing ops,
         * then have the mcount trampoline call the function directly.
         */
-       } else if (ftrace_ops_list->next == &ftrace_list_end) {
+       } else if (rcu_dereference_protected(ftrace_ops_list->next,
+                       lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
                func = ftrace_ops_get_list_func(ftrace_ops_list);
 
        } else {
@@ -348,9 +353,11 @@ int using_ftrace_ops_list_func(void)
        return ftrace_trace_function == ftrace_ops_list_func;
 }
 
-static void add_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
+static void add_ftrace_ops(struct ftrace_ops __rcu **list,
+                          struct ftrace_ops *ops)
 {
-       ops->next = *list;
+       rcu_assign_pointer(ops->next, *list);
+
        /*
         * We are entering ops into the list but another
         * CPU might be walking that list. We need to make sure
@@ -360,7 +367,8 @@ static void add_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
        rcu_assign_pointer(*list, ops);
 }
 
-static int remove_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
+static int remove_ftrace_ops(struct ftrace_ops __rcu **list,
+                            struct ftrace_ops *ops)
 {
        struct ftrace_ops **p;
 
@@ -368,7 +376,10 @@ static int remove_ftrace_ops(struct ftrace_ops **list, struct ftrace_ops *ops)
         * If we are removing the last function, then simply point
         * to the ftrace_stub.
         */
-       if (*list == ops && ops->next == &ftrace_list_end) {
+       if (rcu_dereference_protected(*list,
+                       lockdep_is_held(&ftrace_lock)) == ops &&
+           rcu_dereference_protected(ops->next,
+                       lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
                *list = &ftrace_list_end;
                return 0;
        }
@@ -1569,8 +1580,8 @@ ftrace_ops_test(struct ftrace_ops *ops, unsigned long ip, void *regs)
                return 0;
 #endif
 
-       hash.filter_hash = rcu_dereference_raw_notrace(ops->func_hash->filter_hash);
-       hash.notrace_hash = rcu_dereference_raw_notrace(ops->func_hash->notrace_hash);
+       rcu_assign_pointer(hash.filter_hash, ops->func_hash->filter_hash);
+       rcu_assign_pointer(hash.notrace_hash, ops->func_hash->notrace_hash);
 
        if (hash_contains_ip(ip, &hash))
                ret = 1;
@@ -2840,7 +2851,8 @@ static int ftrace_shutdown(struct ftrace_ops *ops, int command)
         * If there's no more ops registered with ftrace, run a
         * sanity check to make sure all rec flags are cleared.
         */
-       if (ftrace_ops_list == &ftrace_list_end) {
+       if (rcu_dereference_protected(ftrace_ops_list,
+                       lockdep_is_held(&ftrace_lock)) == &ftrace_list_end) {
                struct ftrace_page *pg;
                struct dyn_ftrace *rec;
 
@@ -6453,7 +6465,8 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
        if (ftrace_enabled) {
 
                /* we are starting ftrace again */
-               if (ftrace_ops_list != &ftrace_list_end)
+               if (rcu_dereference_protected(ftrace_ops_list,
+                       lockdep_is_held(&ftrace_lock)) != &ftrace_list_end)
                        update_ftrace_function();
 
                ftrace_startup_sysctl();
index 6ade1c55cc3acaccaad5f50896708c1774072854..490ba229931d7d00243a1be009dec6ab2b3a5864 100644 (file)
@@ -1210,9 +1210,9 @@ struct ftrace_event_field {
 struct event_filter {
        int                     n_preds;        /* Number assigned */
        int                     a_preds;        /* allocated */
-       struct filter_pred      *preds;
-       struct filter_pred      *root;
-       char                    *filter_string;
+       struct filter_pred __rcu        *preds;
+       struct filter_pred __rcu        *root;
+       char                            *filter_string;
 };
 
 struct event_subsystem {