/* Do not #define _LGPL_SOURCE to ensure we can emit the wrapper symbols */
#include "urcu.h"
-#ifndef CONFIG_URCU_AVOID_SIGNALS
+#ifndef URCU_MB
+static int init_done;
+
void __attribute__((constructor)) urcu_init(void);
void __attribute__((destructor)) urcu_exit(void);
#else
}
#endif
-int init_done;
+static pthread_mutex_t urcu_mutex = PTHREAD_MUTEX_INITIALIZER;
-pthread_mutex_t urcu_mutex = PTHREAD_MUTEX_INITIALIZER;
+int gp_futex;
/*
* Global grace period counter.
* Contains the current RCU_GP_CTR_BIT.
- * Also has a RCU_GP_CTR_BIT of 1, to accelerate the reader fast path.
+ * Also has a RCU_GP_COUNT of 1, to accelerate the reader fast path.
* Written to only by writer with mutex taken. Read by both writer and readers.
*/
long urcu_gp_ctr = RCU_GP_COUNT;
static char __thread need_mb;
static int num_readers, alloc_readers;
-void internal_urcu_lock(void)
+static void internal_urcu_lock(void)
{
int ret;
#endif /* #else #ifndef DISTRUST_SIGNALS_EXTREME */
}
-void internal_urcu_unlock(void)
+static void internal_urcu_unlock(void)
{
int ret;
STORE_SHARED(urcu_gp_ctr, urcu_gp_ctr ^ RCU_GP_CTR_BIT);
}
-#ifdef CONFIG_URCU_AVOID_SIGNALS
-#ifdef HAS_INCOHERENT_CACHES
+#ifdef URCU_MB
static void force_mb_single_thread(struct reader_registry *index)
{
smp_mb();
}
-#endif /* #ifdef HAS_INCOHERENT_CACHES */
static void force_mb_all_threads(void)
{
smp_mb();
}
-#else /* #ifdef CONFIG_URCU_AVOID_SIGNALS */
-#ifdef HAS_INCOHERENT_CACHES
+#else /* #ifdef URCU_MB */
static void force_mb_single_thread(struct reader_registry *index)
{
assert(registry);
}
smp_mb(); /* read ->need_mb before ending the barrier */
}
-#endif /* #ifdef HAS_INCOHERENT_CACHES */
static void force_mb_all_threads(void)
{
}
smp_mb(); /* read ->need_mb before ending the barrier */
}
-#endif /* #else #ifdef CONFIG_URCU_AVOID_SIGNALS */
+#endif /* #else #ifdef URCU_MB */
+
+/*
+ * synchronize_rcu() waiting. Single thread.
+ */
+static void wait_gp(struct reader_registry *index)
+{
+ atomic_dec(&gp_futex);
+ force_mb_single_thread(index); /* Write futex before read reader_gp */
+ if (!rcu_old_gp_ongoing(index->urcu_active_readers)) {
+ /* Read reader_gp before write futex */
+ force_mb_single_thread(index);
+ /* Callbacks are queued, don't wait. */
+ atomic_set(&gp_futex, 0);
+ } else {
+ /* Read reader_gp before read futex */
+ force_mb_single_thread(index);
+ if (atomic_read(&gp_futex) == -1)
+ futex(&gp_futex, FUTEX_WAIT, -1,
+ NULL, NULL, 0);
+ }
+}
void wait_for_quiescent_state(void)
{
* Wait for each thread urcu_active_readers count to become 0.
*/
for (index = registry; index < registry + num_readers; index++) {
+ int wait_loops = 0;
#ifndef HAS_INCOHERENT_CACHES
- while (rcu_old_gp_ongoing(index->urcu_active_readers))
- cpu_relax();
+ while (rcu_old_gp_ongoing(index->urcu_active_readers)) {
+ if (wait_loops++ == RCU_QS_ACTIVE_ATTEMPTS) {
+ wait_gp(index);
+ } else {
+ cpu_relax();
+ }
+ }
#else /* #ifndef HAS_INCOHERENT_CACHES */
- int wait_loops = 0;
/*
* BUSY-LOOP. Force the reader thread to commit its
* urcu_active_readers update to memory if we wait for too long.
*/
while (rcu_old_gp_ongoing(index->urcu_active_readers)) {
- if (wait_loops++ == KICK_READER_LOOPS) {
+ switch (wait_loops++) {
+ case RCU_QS_ACTIVE_ATTEMPTS:
+ wait_gp(index);
+ break;
+ case KICK_READER_LOOPS:
force_mb_single_thread(index);
wait_loops = 0;
- } else {
+ break;
+ default:
cpu_relax();
}
}
return xchg(p, v);
}
+void *rcu_cmpxchg_pointer_sym(void **p, void *old, void *_new)
+{
+ wmb();
+ return cmpxchg(p, old, _new);
+}
+
void *rcu_publish_content_sym(void **p, void *v)
{
void *oldptr;
internal_urcu_unlock();
}
-#ifndef CONFIG_URCU_AVOID_SIGNALS
+#ifndef URCU_MB
static void sigurcu_handler(int signo, siginfo_t *siginfo, void *context)
{
/*
assert(act.sa_sigaction == sigurcu_handler);
free(registry);
}
-#endif /* #ifndef CONFIG_URCU_AVOID_SIGNALS */
+#endif /* #ifndef URCU_MB */