zygo: GPL symbol whack-a-mole: kernel/rcu/update.c

diff --git a/kernel/rcu/update.c b/kernel/rcu/update.c
index f0d8322bc3ec179f7a3cfa2f9bef7a0d8f8cb950..67412e792ea5e7085a39f7b6ac7923f32d34a274 100644 (file)
--- a/kernel/rcu/update.c
+++ b/kernel/rcu/update.c
@@ -128,7 +128,7 @@ bool rcu_gp_is_normal(void)
 {
        return READ_ONCE(rcu_normal);
 }
-EXPORT_SYMBOL_GPL(rcu_gp_is_normal);
+EXPORT_SYMBOL(rcu_gp_is_normal);
 
 static atomic_t rcu_expedited_nesting =
        ATOMIC_INIT(IS_ENABLED(CONFIG_RCU_EXPEDITE_BOOT) ? 1 : 0);
@@ -144,7 +144,7 @@ bool rcu_gp_is_expedited(void)
 {
        return rcu_expedited || atomic_read(&rcu_expedited_nesting);
 }
-EXPORT_SYMBOL_GPL(rcu_gp_is_expedited);
+EXPORT_SYMBOL(rcu_gp_is_expedited);
 
 /**
  * rcu_expedite_gp - Expedite future RCU grace periods
@@ -157,7 +157,7 @@ void rcu_expedite_gp(void)
 {
        atomic_inc(&rcu_expedited_nesting);
 }
-EXPORT_SYMBOL_GPL(rcu_expedite_gp);
+EXPORT_SYMBOL(rcu_expedite_gp);
 
 /**
  * rcu_unexpedite_gp - Cancel prior rcu_expedite_gp() invocation
@@ -172,7 +172,7 @@ void rcu_unexpedite_gp(void)
 {
        atomic_dec(&rcu_expedited_nesting);
 }
-EXPORT_SYMBOL_GPL(rcu_unexpedite_gp);
+EXPORT_SYMBOL(rcu_unexpedite_gp);
 
 /*
  * Inform RCU of the end of the in-kernel boot sequence.
@@ -199,7 +199,7 @@ void __rcu_read_lock(void)
        current->rcu_read_lock_nesting++;
        barrier();  /* critical section after entry code. */
 }
-EXPORT_SYMBOL_GPL(__rcu_read_lock);
+EXPORT_SYMBOL(__rcu_read_lock);
 
 /*
  * Preemptible RCU implementation for rcu_read_unlock().
@@ -231,7 +231,7 @@ void __rcu_read_unlock(void)
        }
 #endif /* #ifdef CONFIG_PROVE_LOCKING */
 }
-EXPORT_SYMBOL_GPL(__rcu_read_unlock);
+EXPORT_SYMBOL(__rcu_read_unlock);
 
 #endif /* #ifdef CONFIG_PREEMPT_RCU */
 
@@ -239,29 +239,29 @@ EXPORT_SYMBOL_GPL(__rcu_read_unlock);
 static struct lock_class_key rcu_lock_key;
 struct lockdep_map rcu_lock_map =
        STATIC_LOCKDEP_MAP_INIT("rcu_read_lock", &rcu_lock_key);
-EXPORT_SYMBOL_GPL(rcu_lock_map);
+EXPORT_SYMBOL(rcu_lock_map);
 
 static struct lock_class_key rcu_bh_lock_key;
 struct lockdep_map rcu_bh_lock_map =
        STATIC_LOCKDEP_MAP_INIT("rcu_read_lock_bh", &rcu_bh_lock_key);
-EXPORT_SYMBOL_GPL(rcu_bh_lock_map);
+EXPORT_SYMBOL(rcu_bh_lock_map);
 
 static struct lock_class_key rcu_sched_lock_key;
 struct lockdep_map rcu_sched_lock_map =
        STATIC_LOCKDEP_MAP_INIT("rcu_read_lock_sched", &rcu_sched_lock_key);
-EXPORT_SYMBOL_GPL(rcu_sched_lock_map);
+EXPORT_SYMBOL(rcu_sched_lock_map);
 
 static struct lock_class_key rcu_callback_key;
 struct lockdep_map rcu_callback_map =
        STATIC_LOCKDEP_MAP_INIT("rcu_callback", &rcu_callback_key);
-EXPORT_SYMBOL_GPL(rcu_callback_map);
+EXPORT_SYMBOL(rcu_callback_map);
 
 int notrace debug_lockdep_rcu_enabled(void)
 {
        return rcu_scheduler_active && debug_locks &&
               current->lockdep_recursion == 0;
 }
-EXPORT_SYMBOL_GPL(debug_lockdep_rcu_enabled);
+EXPORT_SYMBOL(debug_lockdep_rcu_enabled);
 
 /**
  * rcu_read_lock_held() - might we be in RCU read-side critical section?
@@ -293,7 +293,7 @@ int rcu_read_lock_held(void)
                return 0;
        return lock_is_held(&rcu_lock_map);
 }
-EXPORT_SYMBOL_GPL(rcu_read_lock_held);
+EXPORT_SYMBOL(rcu_read_lock_held);
 
 /**
  * rcu_read_lock_bh_held() - might we be in RCU-bh read-side critical section?
@@ -320,7 +320,7 @@ int rcu_read_lock_bh_held(void)
                return 0;
        return in_softirq() || irqs_disabled();
 }
-EXPORT_SYMBOL_GPL(rcu_read_lock_bh_held);
+EXPORT_SYMBOL(rcu_read_lock_bh_held);
 
 #endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
 
@@ -337,7 +337,7 @@ void wakeme_after_rcu(struct rcu_head *head)
        rcu = container_of(head, struct rcu_synchronize, head);
        complete(&rcu->completion);
 }
-EXPORT_SYMBOL_GPL(wakeme_after_rcu);
+EXPORT_SYMBOL(wakeme_after_rcu);
 
 void __wait_rcu_gp(bool checktiny, int n, call_rcu_func_t *crcu_array,
                   struct rcu_synchronize *rs_array)
@@ -367,7 +367,7 @@ void __wait_rcu_gp(bool checktiny, int n, call_rcu_func_t *crcu_array,
                destroy_rcu_head_on_stack(&rs_array[i].head);
        }
 }
-EXPORT_SYMBOL_GPL(__wait_rcu_gp);
+EXPORT_SYMBOL(__wait_rcu_gp);
 
 #ifdef CONFIG_DEBUG_OBJECTS_RCU_HEAD
 void init_rcu_head(struct rcu_head *head)
@@ -399,7 +399,7 @@ void init_rcu_head_on_stack(struct rcu_head *head)
 {
        debug_object_init_on_stack(head, &rcuhead_debug_descr);
 }
-EXPORT_SYMBOL_GPL(init_rcu_head_on_stack);
+EXPORT_SYMBOL(init_rcu_head_on_stack);
 
 /**
  * destroy_rcu_head_on_stack() - destroy on-stack rcu_head for debugobjects
@@ -416,13 +416,13 @@ void destroy_rcu_head_on_stack(struct rcu_head *head)
 {
        debug_object_free(head, &rcuhead_debug_descr);
 }
-EXPORT_SYMBOL_GPL(destroy_rcu_head_on_stack);
+EXPORT_SYMBOL(destroy_rcu_head_on_stack);
 
 struct debug_obj_descr rcuhead_debug_descr = {
        .name = "rcu_head",
        .is_static_object = rcuhead_is_static_object,
 };
-EXPORT_SYMBOL_GPL(rcuhead_debug_descr);
+EXPORT_SYMBOL(rcuhead_debug_descr);
 #endif /* #ifdef CONFIG_DEBUG_OBJECTS_RCU_HEAD */
 
 #if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU) || defined(CONFIG_RCU_TRACE)
@@ -432,7 +432,7 @@ void do_trace_rcu_torture_read(const char *rcutorturename, struct rcu_head *rhp,
 {
        trace_rcu_torture_read(rcutorturename, rhp, secs, c_old, c);
 }
-EXPORT_SYMBOL_GPL(do_trace_rcu_torture_read);
+EXPORT_SYMBOL(do_trace_rcu_torture_read);
 #else
 #define do_trace_rcu_torture_read(rcutorturename, rhp, secs, c_old, c) \
        do { } while (0)
@@ -554,7 +554,7 @@ void call_rcu_tasks(struct rcu_head *rhp, rcu_callback_t func)
                wake_up(&rcu_tasks_cbs_wq);
        }
 }
-EXPORT_SYMBOL_GPL(call_rcu_tasks);
+EXPORT_SYMBOL(call_rcu_tasks);
 
 /**
  * synchronize_rcu_tasks - wait until an rcu-tasks grace period has elapsed.
@@ -598,7 +598,7 @@ void synchronize_rcu_tasks(void)
        /* Wait for the grace period. */
        wait_rcu_gp(call_rcu_tasks);
 }
-EXPORT_SYMBOL_GPL(synchronize_rcu_tasks);
+EXPORT_SYMBOL(synchronize_rcu_tasks);
 
 /**
  * rcu_barrier_tasks - Wait for in-flight call_rcu_tasks() callbacks.
@@ -611,7 +611,7 @@ void rcu_barrier_tasks(void)
        /* There is only one callback queue, so this is easy.  ;-) */
        synchronize_rcu_tasks();
 }
-EXPORT_SYMBOL_GPL(rcu_barrier_tasks);
+EXPORT_SYMBOL(rcu_barrier_tasks);
 
 /* See if tasks are still holding out, complain if so. */
 static void check_holdout_task(struct task_struct *t,