Fix: compat_futex.c: *uaddr should be read as volatile

[urcu.git] / compat_futex.c

diff --git a/compat_futex.c b/compat_futex.c
index 27fc66bb4ff7e1318f6bde0788498505319ff02e..6ec0b3912b34afbda58c873371f83aec55d35f68 100644 (file)
--- a/compat_futex.c
+++ b/compat_futex.c
@@ -3,7 +3,7 @@
  *
  * Userspace RCU library - sys_futex compatibility code
  *
- * Copyright (c) 2009 Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Copyright (c) 2009 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -26,12 +26,24 @@
 #include <assert.h>
 #include <errno.h>
 #include <poll.h>
+#include <stdint.h>
 
 #include <urcu/arch.h>
-#include <urcu/urcu-futex.h>
+#include <urcu/futex.h>
+#include <urcu/system.h>
 
-static pthread_mutex_t compat_futex_lock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t compat_futex_cond = PTHREAD_COND_INITIALIZER;
+/*
+ * Using attribute "weak" for __urcu_compat_futex_lock and
+ * __urcu_compat_futex_cond. Those are globally visible by the entire
+ * program, even though many shared objects may have their own version.
+ * The first version that gets loaded will be used by the entire program
+ * (executable and all shared objects).
+ */
+
+__attribute__((weak))
+pthread_mutex_t __urcu_compat_futex_lock = PTHREAD_MUTEX_INITIALIZER;
+__attribute__((weak))
+pthread_cond_t __urcu_compat_futex_cond = PTHREAD_COND_INITIALIZER;
 
 /*
  * _NOT SIGNAL-SAFE_. pthread_cond is not signal-safe anyway. Though.
@@ -39,10 +51,10 @@ static pthread_cond_t compat_futex_cond = PTHREAD_COND_INITIALIZER;
  * Waiter will relinquish the CPU until woken up.
  */
 
-int compat_futex_noasync(int *uaddr, int op, int val,
-       const struct timespec *timeout, int *uaddr2, int val3)
+int compat_futex_noasync(int32_t *uaddr, int op, int32_t val,
+       const struct timespec *timeout, int32_t *uaddr2, int32_t val3)
 {
-       int ret, i, gret = 0;
+       int ret, gret = 0;
 
        /*
         * Check if NULL. Don't let users expect that they are taken into
@@ -55,25 +67,33 @@ int compat_futex_noasync(int *uaddr, int op, int val,
        /*
         * memory barriers to serialize with the previous uaddr modification.
         */
-       smp_mb();
+       cmm_smp_mb();
 
-       ret = pthread_mutex_lock(&compat_futex_lock);
+       ret = pthread_mutex_lock(&__urcu_compat_futex_lock);
        assert(!ret);
        switch (op) {
        case FUTEX_WAIT:
-               if (*uaddr != val)
-                       goto end;
-               pthread_cond_wait(&compat_futex_cond, &compat_futex_lock);
+               /*
+                * Wait until *uaddr is changed to something else than "val".
+                * Comparing *uaddr content against val figures out which
+                * thread has been awakened.
+                */
+               while (CMM_LOAD_SHARED(*uaddr) == val)
+                       pthread_cond_wait(&__urcu_compat_futex_cond,
+                               &__urcu_compat_futex_lock);
                break;
        case FUTEX_WAKE:
-               for (i = 0; i < val; i++)
-                       pthread_cond_signal(&compat_futex_cond);
+               /*
+                * Each wake is sending a broadcast, thus attempting wakeup of
+                * all awaiting threads, independently of their respective
+                * uaddr.
+                */
+               pthread_cond_broadcast(&__urcu_compat_futex_cond);
                break;
        default:
                gret = -EINVAL;
        }
-end:
-       ret = pthread_mutex_unlock(&compat_futex_lock);
+       ret = pthread_mutex_unlock(&__urcu_compat_futex_lock);
        assert(!ret);
        return gret;
 }
@@ -84,11 +104,9 @@ end:
  * Waiter will busy-loop trying to read the condition.
  */
 
-int compat_futex_async(int *uaddr, int op, int val,
-       const struct timespec *timeout, int *uaddr2, int val3)
+int compat_futex_async(int32_t *uaddr, int op, int32_t val,
+       const struct timespec *timeout, int32_t *uaddr2, int32_t val3)
 {
-       int ret, i;
-
        /*
         * Check if NULL. Don't let users expect that they are taken into
         * account. 
@@ -100,11 +118,11 @@ int compat_futex_async(int *uaddr, int op, int val,
        /*
         * Ensure previous memory operations on uaddr have completed.
         */
-       smp_mb();
+       cmm_smp_mb();
 
        switch (op) {
        case FUTEX_WAIT:
-               while (*uaddr == val)
+               while (CMM_LOAD_SHARED(*uaddr) == val)
                        poll(NULL, 0, 10);
                break;
        case FUTEX_WAKE:
@@ -112,4 +130,5 @@ int compat_futex_async(int *uaddr, int op, int val,
        default:
                return -EINVAL;
        }
+       return 0;
 }