cleanup: explicitly mark unused parameters (-Wunused-parameter)

[urcu.git] / src / urcu-call-rcu-impl.h

diff --git a/src/urcu-call-rcu-impl.h b/src/urcu-call-rcu-impl.h
index f7844cc17f6dc49f774650cba20bbdc8ecf825b0..c49084fcf49126f6eebd97a3da7fb4209d43c913 100644 (file)
--- a/src/urcu-call-rcu-impl.h
+++ b/src/urcu-call-rcu-impl.h
@@ -215,11 +215,8 @@ int set_thread_cpu_affinity(struct call_rcu_data *crdp)
 
        CPU_ZERO(&mask);
        CPU_SET(crdp->cpu_affinity, &mask);
-#if SCHED_SETAFFINITY_ARGS == 2
-       ret = sched_setaffinity(0, &mask);
-#else
        ret = sched_setaffinity(0, sizeof(mask), &mask);
-#endif
+
        /*
         * EINVAL is fine: can be caused by hotunplugged CPUs, or by
         * cpuset(7). This is why we should always retry if we detect
@@ -465,7 +462,7 @@ struct call_rcu_data *get_cpu_call_rcu_data(int cpu)
                return NULL;
        return rcu_dereference(pcpu_crdp[cpu]);
 }
-__attribute__((alias(urcu_stringify(get_cpu_call_rcu_data))))
+URCU_ATTR_ALIAS(urcu_stringify(get_cpu_call_rcu_data))
 struct call_rcu_data *alias_get_cpu_call_rcu_data();
 
 /*
@@ -477,7 +474,7 @@ pthread_t get_call_rcu_thread(struct call_rcu_data *crdp)
 {
        return crdp->tid;
 }
-__attribute__((alias(urcu_stringify(get_call_rcu_thread))))
+URCU_ATTR_ALIAS(urcu_stringify(get_call_rcu_thread))
 pthread_t alias_get_call_rcu_thread();
 
 /*
@@ -493,7 +490,7 @@ static struct call_rcu_data *__create_call_rcu_data(unsigned long flags,
        return crdp;
 }
 
-__attribute__((alias(urcu_stringify(create_call_rcu_data))))
+URCU_ATTR_ALIAS(urcu_stringify(create_call_rcu_data))
 struct call_rcu_data *alias_create_call_rcu_data();
 struct call_rcu_data *create_call_rcu_data(unsigned long flags,
                                           int cpu_affinity)
@@ -551,7 +548,7 @@ int set_cpu_call_rcu_data(int cpu, struct call_rcu_data *crdp)
        call_rcu_unlock(&call_rcu_mutex);
        return 0;
 }
-__attribute__((alias(urcu_stringify(set_cpu_call_rcu_data))))
+URCU_ATTR_ALIAS(urcu_stringify(set_cpu_call_rcu_data))
 int alias_set_cpu_call_rcu_data();
 
 /*
@@ -573,7 +570,7 @@ struct call_rcu_data *get_default_call_rcu_data(void)
        call_rcu_unlock(&call_rcu_mutex);
        return default_call_rcu_data;
 }
-__attribute__((alias(urcu_stringify(get_default_call_rcu_data))))
+URCU_ATTR_ALIAS(urcu_stringify(get_default_call_rcu_data))
 struct call_rcu_data *alias_get_default_call_rcu_data();
 
 /*
@@ -602,7 +599,7 @@ struct call_rcu_data *get_call_rcu_data(void)
 
        return get_default_call_rcu_data();
 }
-__attribute__((alias(urcu_stringify(get_call_rcu_data))))
+URCU_ATTR_ALIAS(urcu_stringify(get_call_rcu_data))
 struct call_rcu_data *alias_get_call_rcu_data();
 
 /*
@@ -613,7 +610,7 @@ struct call_rcu_data *get_thread_call_rcu_data(void)
 {
        return URCU_TLS(thread_call_rcu_data);
 }
-__attribute__((alias(urcu_stringify(get_thread_call_rcu_data))))
+URCU_ATTR_ALIAS(urcu_stringify(get_thread_call_rcu_data))
 struct call_rcu_data *alias_get_thread_call_rcu_data();
 
 /*
@@ -631,7 +628,7 @@ void set_thread_call_rcu_data(struct call_rcu_data *crdp)
 {
        URCU_TLS(thread_call_rcu_data) = crdp;
 }
-__attribute__((alias(urcu_stringify(set_thread_call_rcu_data))))
+URCU_ATTR_ALIAS(urcu_stringify(set_thread_call_rcu_data))
 void alias_set_thread_call_rcu_data();
 
 /*
@@ -684,7 +681,7 @@ int create_all_cpu_call_rcu_data(unsigned long flags)
        }
        return 0;
 }
-__attribute__((alias(urcu_stringify(create_all_cpu_call_rcu_data))))
+URCU_ATTR_ALIAS(urcu_stringify(create_all_cpu_call_rcu_data))
 int alias_create_all_cpu_call_rcu_data();
 
 /*
@@ -733,7 +730,7 @@ void call_rcu(struct rcu_head *head,
        _call_rcu(head, func, crdp);
        _rcu_read_unlock();
 }
-__attribute__((alias(urcu_stringify(call_rcu)))) void alias_call_rcu();
+URCU_ATTR_ALIAS(urcu_stringify(call_rcu)) void alias_call_rcu();
 
 /*
  * Free up the specified call_rcu_data structure, terminating the
@@ -772,9 +769,13 @@ void call_rcu_data_free(struct call_rcu_data *crdp)
                while ((uatomic_read(&crdp->flags) & URCU_CALL_RCU_STOPPED) == 0)
                        (void) poll(NULL, 0, 1);
        }
+       call_rcu_lock(&call_rcu_mutex);
        if (!cds_wfcq_empty(&crdp->cbs_head, &crdp->cbs_tail)) {
-               /* Create default call rcu data if need be */
+               call_rcu_unlock(&call_rcu_mutex);
+               /* Create default call rcu data if need be. */
+               /* CBs queued here will be handed to the default list. */
                (void) get_default_call_rcu_data();
+               call_rcu_lock(&call_rcu_mutex);
                __cds_wfcq_splice_blocking(&default_call_rcu_data->cbs_head,
                        &default_call_rcu_data->cbs_tail,
                        &crdp->cbs_head, &crdp->cbs_tail);
@@ -783,13 +784,12 @@ void call_rcu_data_free(struct call_rcu_data *crdp)
                wake_call_rcu_thread(default_call_rcu_data);
        }
 
-       call_rcu_lock(&call_rcu_mutex);
        cds_list_del(&crdp->list);
        call_rcu_unlock(&call_rcu_mutex);
 
        free(crdp);
 }
-__attribute__((alias(urcu_stringify(call_rcu_data_free))))
+URCU_ATTR_ALIAS(urcu_stringify(call_rcu_data_free))
 void alias_call_rcu_data_free();
 
 /*
@@ -834,11 +834,11 @@ void free_all_cpu_call_rcu_data(void)
 #ifdef RCU_QSBR
 /* ABI6 has a non-namespaced free_all_cpu_call_rcu_data for qsbr */
 #undef free_all_cpu_call_rcu_data
-__attribute__((alias("urcu_qsbr_free_all_cpu_call_rcu_data")))
+URCU_ATTR_ALIAS("urcu_qsbr_free_all_cpu_call_rcu_data")
 void free_all_cpu_call_rcu_data();
 #define free_all_cpu_call_rcu_data urcu_qsbr_free_all_cpu_call_rcu_data
 #else
-__attribute__((alias(urcu_stringify(free_all_cpu_call_rcu_data))))
+URCU_ATTR_ALIAS(urcu_stringify(free_all_cpu_call_rcu_data))
 void alias_free_all_cpu_call_rcu_data();
 #endif
 
@@ -932,7 +932,7 @@ online:
        if (was_online)
                rcu_thread_online();
 }
-__attribute__((alias(urcu_stringify(rcu_barrier))))
+URCU_ATTR_ALIAS(urcu_stringify(rcu_barrier))
 void alias_rcu_barrier();
 
 /*
@@ -962,7 +962,7 @@ void call_rcu_before_fork(void)
                        (void) poll(NULL, 0, 1);
        }
 }
-__attribute__((alias(urcu_stringify(call_rcu_before_fork))))
+URCU_ATTR_ALIAS(urcu_stringify(call_rcu_before_fork))
 void alias_call_rcu_before_fork();
 
 /*
@@ -986,7 +986,7 @@ void call_rcu_after_fork_parent(void)
                atfork->after_fork_parent(atfork->priv);
        call_rcu_unlock(&call_rcu_mutex);
 }
-__attribute__((alias(urcu_stringify(call_rcu_after_fork_parent))))
+URCU_ATTR_ALIAS(urcu_stringify(call_rcu_after_fork_parent))
 void alias_call_rcu_after_fork_parent();
 
 /*
@@ -1035,7 +1035,7 @@ void call_rcu_after_fork_child(void)
                call_rcu_data_free(crdp);
        }
 }
-__attribute__((alias(urcu_stringify(call_rcu_after_fork_child))))
+URCU_ATTR_ALIAS(urcu_stringify(call_rcu_after_fork_child))
 void alias_call_rcu_after_fork_child();
 
 void urcu_register_rculfhash_atfork(struct urcu_atfork *atfork)
@@ -1047,10 +1047,10 @@ void urcu_register_rculfhash_atfork(struct urcu_atfork *atfork)
 end:
        call_rcu_unlock(&call_rcu_mutex);
 }
-__attribute__((alias(urcu_stringify(urcu_register_rculfhash_atfork))))
+URCU_ATTR_ALIAS(urcu_stringify(urcu_register_rculfhash_atfork))
 void alias_urcu_register_rculfhash_atfork();
 
-void urcu_unregister_rculfhash_atfork(struct urcu_atfork *atfork)
+void urcu_unregister_rculfhash_atfork(struct urcu_atfork *atfork __attribute__((unused)))
 {
        call_rcu_lock(&call_rcu_mutex);
        if (--registered_rculfhash_atfork_refcount)
@@ -1059,5 +1059,5 @@ void urcu_unregister_rculfhash_atfork(struct urcu_atfork *atfork)
 end:
        call_rcu_unlock(&call_rcu_mutex);
 }
-__attribute__((alias(urcu_stringify(urcu_unregister_rculfhash_atfork))))
+URCU_ATTR_ALIAS(urcu_stringify(urcu_unregister_rculfhash_atfork))
 void alias_urcu_unregister_rculfhash_atfork();