Fix: i386 compat code duplicated mutex instances

[urcu.git] / urcu-bp.c

diff --git a/urcu-bp.c b/urcu-bp.c
index f99c0e502ee20f197b5f225a2b6a49088d3b138a..93d781fcf44e5f2c9ee89928631a9d0d6cbb3e21 100644 (file)
--- a/urcu-bp.c
+++ b/urcu-bp.c
@@ -109,13 +109,7 @@ unsigned int rcu_yield_active;
 DEFINE_URCU_TLS(unsigned int, rcu_rand_yield);
 #endif
 
-/*
- * Global grace period counter.
- * Contains the current RCU_GP_CTR_PHASE.
- * 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.
- */
-unsigned long rcu_gp_ctr = RCU_GP_COUNT;
+struct rcu_gp rcu_gp = { .ctr = RCU_GP_COUNT };
 
 /*
  * Pointer to registry elements. Written to only by each individual reader. Read
@@ -174,7 +168,7 @@ static void wait_for_readers(struct cds_list_head *input_readers,
        /*
         * Wait for each thread URCU_TLS(rcu_reader).ctr to either
         * indicate quiescence (not nested), or observe the current
-        * rcu_gp_ctr value.
+        * rcu_gp.ctr value.
         */
        for (;;) {
                wait_loops++;
@@ -219,9 +213,9 @@ void synchronize_rcu(void)
        sigset_t newmask, oldmask;
        int ret;
 
-       ret = sigemptyset(&newmask);
+       ret = sigfillset(&newmask);
        assert(!ret);
-       ret = pthread_sigmask(SIG_SETMASK, &newmask, &oldmask);
+       ret = pthread_sigmask(SIG_BLOCK, &newmask, &oldmask);
        assert(!ret);
 
        mutex_lock(&rcu_gp_lock);
@@ -250,7 +244,7 @@ void synchronize_rcu(void)
        cmm_smp_mb();
 
        /* Switch parity: 0 -> 1, 1 -> 0 */
-       CMM_STORE_SHARED(rcu_gp_ctr, rcu_gp_ctr ^ RCU_GP_CTR_PHASE);
+       CMM_STORE_SHARED(rcu_gp.ctr, rcu_gp.ctr ^ RCU_GP_CTR_PHASE);
 
        /*
         * Must commit qparity update to memory before waiting for other parity
@@ -301,31 +295,47 @@ void rcu_read_unlock(void)
        _rcu_read_unlock();
 }
 
+int rcu_read_ongoing(void)
+{
+       return _rcu_read_ongoing();
+}
+
 /*
  * only grow for now.
  */
 static void resize_arena(struct registry_arena *arena, size_t len)
 {
-       void *new_arena;
+       void *new_p;
+       size_t old_len;
+
+       old_len = arena->len;
 
        if (!arena->p)
-               new_arena = mmap(arena->p, len,
-                                PROT_READ | PROT_WRITE,
-                                MAP_ANONYMOUS | MAP_PRIVATE,
-                                -1, 0);
+               new_p = mmap(arena->p, len,
+                       PROT_READ | PROT_WRITE,
+                       MAP_ANONYMOUS | MAP_PRIVATE,
+                       -1, 0);
        else
-               new_arena = mremap_wrapper(arena->p, arena->len,
-                                       len, MREMAP_MAYMOVE);
-       assert(new_arena != MAP_FAILED);
+               new_p = mremap_wrapper(arena->p, old_len,
+                       len, MREMAP_MAYMOVE);
+       assert(new_p != MAP_FAILED);
+
+       /*
+        * Zero the newly allocated memory. Since mmap() does not
+        * clearly specify if memory is zeroed or not (although it is
+        * very likely that it is), be extra careful by not expecting
+        * the new range to be zeroed by mremap.
+        */
+       bzero(new_p + old_len, len - old_len);
 
        /*
-        * re-used the same region ?
+        * If we did not re-use the same region, we need to update the
+        * arena pointer.
         */
-       if (new_arena == arena->p)
-               return;
+       if (new_p != arena->p)
+               arena->p = new_p;
 
-       bzero(new_arena + arena->len, len - arena->len);
-       arena->p = new_arena;
+       arena->len = len;
 }
 
 /* Called with signals off and mutex locked */
@@ -386,9 +396,9 @@ void rcu_bp_register(void)
        sigset_t newmask, oldmask;
        int ret;
 
-       ret = sigemptyset(&newmask);
+       ret = sigfillset(&newmask);
        assert(!ret);
-       ret = pthread_sigmask(SIG_SETMASK, &newmask, &oldmask);
+       ret = pthread_sigmask(SIG_BLOCK, &newmask, &oldmask);
        assert(!ret);
 
        /*
@@ -421,9 +431,9 @@ void rcu_bp_before_fork(void)
        sigset_t newmask, oldmask;
        int ret;
 
-       ret = sigemptyset(&newmask);
+       ret = sigfillset(&newmask);
        assert(!ret);
-       ret = pthread_sigmask(SIG_SETMASK, &newmask, &oldmask);
+       ret = pthread_sigmask(SIG_BLOCK, &newmask, &oldmask);
        assert(!ret);
        mutex_lock(&rcu_gp_lock);
        saved_fork_signal_mask = oldmask;