summaryrefslogtreecommitdiff
path: root/libpthread/linuxthreads/spinlock.h
diff options
context:
space:
mode:
Diffstat (limited to 'libpthread/linuxthreads/spinlock.h')
-rw-r--r--libpthread/linuxthreads/spinlock.h132
1 files changed, 124 insertions, 8 deletions
diff --git a/libpthread/linuxthreads/spinlock.h b/libpthread/linuxthreads/spinlock.h
index aae18a27b..0ec40c57c 100644
--- a/libpthread/linuxthreads/spinlock.h
+++ b/libpthread/linuxthreads/spinlock.h
@@ -12,6 +12,27 @@
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU Library General Public License for more details. */
+#include <bits/initspin.h>
+
+
+/* There are 2 compare and swap synchronization primitives with
+ different semantics:
+
+ 1. compare_and_swap, which has acquire semantics (i.e. it
+ completes befor subsequent writes.)
+ 2. compare_and_swap_with_release_semantics, which has release
+ semantics (it completes after previous writes.)
+
+ For those platforms on which they are the same. HAS_COMPARE_AND_SWAP
+ should be defined. For those platforms on which they are different,
+ HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS has to be defined. */
+
+#ifndef HAS_COMPARE_AND_SWAP
+#ifdef HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS
+#define HAS_COMPARE_AND_SWAP
+#endif
+#endif
+
#if defined(TEST_FOR_COMPARE_AND_SWAP)
extern int __pthread_has_cas;
@@ -29,6 +50,22 @@ static inline int compare_and_swap(long * ptr, long oldval, long newval,
#elif defined(HAS_COMPARE_AND_SWAP)
+#ifdef IMPLEMENT_TAS_WITH_CAS
+#define testandset(p) !__compare_and_swap((long int *) p, 0, 1)
+#endif
+
+#ifdef HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS
+
+static inline int
+compare_and_swap_with_release_semantics (long * ptr, long oldval,
+ long newval, int * spinlock)
+{
+ return __compare_and_swap_with_release_semantics (ptr, oldval,
+ newval);
+}
+
+#endif
+
static inline int compare_and_swap(long * ptr, long oldval, long newval,
int * spinlock)
{
@@ -48,30 +85,90 @@ static inline int compare_and_swap(long * ptr, long oldval, long newval,
#endif
+#ifndef HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS
+#define compare_and_swap_with_release_semantics compare_and_swap
+#define __compare_and_swap_with_release_semantics __compare_and_swap
+#endif
+
/* Internal locks */
extern void internal_function __pthread_lock(struct _pthread_fastlock * lock,
pthread_descr self);
-extern void internal_function __pthread_unlock(struct _pthread_fastlock *lock);
+extern int __pthread_unlock(struct _pthread_fastlock *lock);
static inline void __pthread_init_lock(struct _pthread_fastlock * lock)
{
lock->__status = 0;
- lock->__spinlock = 0;
+ lock->__spinlock = __LT_SPINLOCK_INIT;
}
static inline int __pthread_trylock (struct _pthread_fastlock * lock)
{
- long oldstatus;
+#if defined TEST_FOR_COMPARE_AND_SWAP
+ if (!__pthread_has_cas)
+#endif
+#if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP
+ {
+ return (testandset(&lock->__spinlock) ? EBUSY : 0);
+ }
+#endif
+#if defined HAS_COMPARE_AND_SWAP
do {
- oldstatus = lock->__status;
- if (oldstatus != 0) return EBUSY;
- } while(! compare_and_swap(&lock->__status, 0, 1, &lock->__spinlock));
+ if (lock->__status != 0) return EBUSY;
+ } while(! __compare_and_swap(&lock->__status, 0, 1));
return 0;
+#endif
+}
+
+/* Variation of internal lock used for pthread_mutex_t, supporting
+ timed-out waits. Warning: do not mix these operations with the above ones
+ over the same lock object! */
+
+extern void __pthread_alt_lock(struct _pthread_fastlock * lock,
+ pthread_descr self);
+
+extern int __pthread_alt_timedlock(struct _pthread_fastlock * lock,
+ pthread_descr self, const struct timespec *abstime);
+
+extern void __pthread_alt_unlock(struct _pthread_fastlock *lock);
+
+static inline void __pthread_alt_init_lock(struct _pthread_fastlock * lock)
+{
+ lock->__status = 0;
+ lock->__spinlock = __LT_SPINLOCK_INIT;
}
-#define LOCK_INITIALIZER {0, 0}
+static inline int __pthread_alt_trylock (struct _pthread_fastlock * lock)
+{
+#if defined TEST_FOR_COMPARE_AND_SWAP
+ if (!__pthread_has_cas)
+#endif
+#if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP
+ {
+ int res = EBUSY;
+
+ if (testandset(&lock->__spinlock) == 0)
+ {
+ if (lock->__status == 0)
+ {
+ lock->__status = 1;
+ WRITE_MEMORY_BARRIER();
+ res = 0;
+ }
+ lock->__spinlock = __LT_SPINLOCK_INIT;
+ }
+ return res;
+ }
+#endif
+
+#if defined HAS_COMPARE_AND_SWAP
+ do {
+ if (lock->__status != 0) return EBUSY;
+ } while(! compare_and_swap(&lock->__status, 0, 1, &lock->__spinlock));
+ return 0;
+#endif
+}
/* Operations on pthread_atomic, which is defined in internals.h */
@@ -98,5 +195,24 @@ static inline long atomic_decrement(struct pthread_atomic *pa)
return oldval;
}
-#define ATOMIC_INITIALIZER { 0, 0 }
+static inline void
+__pthread_set_own_extricate_if (pthread_descr self, pthread_extricate_if *peif)
+{
+ /* Only store a non-null peif if the thread has cancellation enabled.
+ Otherwise pthread_cancel will unconditionally call the extricate handler,
+ and restart the thread giving rise to forbidden spurious wakeups. */
+ if (peif == NULL
+ || THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE)
+ {
+ /* If we are removing the extricate interface, we need to synchronize
+ against pthread_cancel so that it does not continue with a pointer
+ to a deallocated pthread_extricate_if struct! The thread lock
+ is (ab)used for this synchronization purpose. */
+ if (peif == NULL)
+ __pthread_lock (THREAD_GETMEM(self, p_lock), self);
+ THREAD_SETMEM(self, p_extricate, peif);
+ if (peif == NULL)
+ __pthread_unlock (THREAD_GETMEM(self, p_lock));
+ }
+}