Cleanup: remove leftover manual pthread detection

[urcu.git] / compat_arch_x86.c

diff --git a/compat_arch_x86.c b/compat_arch_x86.c
index fc504c3356c95808d05cc88f5eb3742c631bc9eb..3e73f9c75953a8e967afe9064e3c79609dc0d2d5 100644 (file)
--- a/compat_arch_x86.c
+++ b/compat_arch_x86.c
@@ -3,7 +3,7 @@
  *
  * Userspace RCU library - x86 compatibility checks
  *
- * 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
@@ -24,23 +24,33 @@
 #include <pthread.h>
 #include <signal.h>
 #include <assert.h>
-#include <urcu/uatomic_arch.h>
+#include <urcu/uatomic.h>
+
+/*
+ * Using attribute "weak" for __rcu_cas_avail and
+ * __urcu_x86_compat_mutex. 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).
+ */
 
 /*
  * It does not really matter if the constructor is called before using
- * the library, as long as the caller checks if __urcu_cas_avail < 0 and calls
+ * the library, as long as the caller checks if __rcu_cas_avail < 0 and calls
  * compat_arch_init() explicitely if needed.
  */
-int __attribute__((constructor)) __urcu_cas_init(void);
+int __attribute__((constructor)) __rcu_cas_init(void);
 
 /*
  * -1: unknown
  *  1: available
  *  0: unavailable
  */
-int __urcu_cas_avail = -1;
+__attribute__((weak))
+int __rcu_cas_avail = -1;
 
-static pthread_mutex_t compat_mutex = PTHREAD_MUTEX_INITIALIZER;
+__attribute__((weak))
+pthread_mutex_t __urcu_x86_compat_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 /*
  * get_eflags/set_eflags/compare_and_swap_is_available imported from glibc
@@ -80,11 +90,11 @@ static void mutex_lock_signal_save(pthread_mutex_t *mutex, sigset_t *oldmask)
        int ret;
 
        /* Disable signals */
-       ret = sigemptyset(&newmask);
+       ret = sigfillset(&newmask);
        assert(!ret);
-       ret = pthread_sigmask(SIG_SETMASK, &newmask, oldmask);
+       ret = pthread_sigmask(SIG_BLOCK, &newmask, oldmask);
        assert(!ret);
-       ret = pthread_mutex_lock(&compat_mutex);
+       ret = pthread_mutex_lock(&__urcu_x86_compat_mutex);
        assert(!ret);
 }
 
@@ -92,7 +102,7 @@ static void mutex_lock_signal_restore(pthread_mutex_t *mutex, sigset_t *oldmask)
 {
        int ret;
 
-       ret = pthread_mutex_unlock(&compat_mutex);
+       ret = pthread_mutex_unlock(&__urcu_x86_compat_mutex);
        assert(!ret);
        ret = pthread_sigmask(SIG_SETMASK, oldmask, NULL);
        assert(!ret);
@@ -103,7 +113,7 @@ unsigned long _compat_uatomic_set(void *addr, unsigned long _new, int len)
        sigset_t mask;
        unsigned long result;
 
-       mutex_lock_signal_save(&compat_mutex, &mask);
+       mutex_lock_signal_save(&__urcu_x86_compat_mutex, &mask);
        switch (len) {
        case 1:
                *(unsigned char *)addr = (unsigned char)_new;
@@ -122,10 +132,11 @@ unsigned long _compat_uatomic_set(void *addr, unsigned long _new, int len)
                 * generate an illegal instruction. Cannot catch this with
                 * linker tricks when optimizations are disabled.
                 */
+               result = 0;
                __asm__ __volatile__("ud2");
        }
-       mutex_lock_signal_restore(&compat_mutex, &mask);
-       return _new;
+       mutex_lock_signal_restore(&__urcu_x86_compat_mutex, &mask);
+       return result;
 }
 
 unsigned long _compat_uatomic_xchg(void *addr, unsigned long _new, int len)
@@ -133,7 +144,7 @@ unsigned long _compat_uatomic_xchg(void *addr, unsigned long _new, int len)
        sigset_t mask;
        unsigned long retval;
 
-       mutex_lock_signal_save(&compat_mutex, &mask);
+       mutex_lock_signal_save(&__urcu_x86_compat_mutex, &mask);
        switch (len) {
        case 1:
                retval = *(unsigned char *)addr;
@@ -152,9 +163,10 @@ unsigned long _compat_uatomic_xchg(void *addr, unsigned long _new, int len)
                 * generate an illegal instruction. Cannot catch this with
                 * linker tricks when optimizations are disabled.
                 */
+               retval = 0;     /* silence gcc warnings */
                __asm__ __volatile__("ud2");
        }
-       mutex_lock_signal_restore(&compat_mutex, &mask);
+       mutex_lock_signal_restore(&__urcu_x86_compat_mutex, &mask);
        return retval;
 }
 
@@ -164,7 +176,7 @@ unsigned long _compat_uatomic_cmpxchg(void *addr, unsigned long old,
        unsigned long retval;
        sigset_t mask;
 
-       mutex_lock_signal_save(&compat_mutex, &mask);
+       mutex_lock_signal_save(&__urcu_x86_compat_mutex, &mask);
        switch (len) {
        case 1:
        {
@@ -195,18 +207,69 @@ unsigned long _compat_uatomic_cmpxchg(void *addr, unsigned long old,
                 * generate an illegal instruction. Cannot catch this with
                 * linker tricks when optimizations are disabled.
                 */
+               retval = 0;     /* silence gcc warnings */
                __asm__ __volatile__("ud2");
        }
-       mutex_lock_signal_restore(&compat_mutex, &mask);
+       mutex_lock_signal_restore(&__urcu_x86_compat_mutex, &mask);
        return retval;
 }
 
+void _compat_uatomic_or(void *addr, unsigned long v, int len)
+{
+       sigset_t mask;
+
+       mutex_lock_signal_save(&__urcu_x86_compat_mutex, &mask);
+       switch (len) {
+       case 1:
+               *(unsigned char *)addr |= (unsigned char)v;
+               break;
+       case 2:
+               *(unsigned short *)addr |= (unsigned short)v;
+               break;
+       case 4:
+               *(unsigned int *)addr |= (unsigned int)v;
+               break;
+       default:
+               /*
+                * generate an illegal instruction. Cannot catch this with
+                * linker tricks when optimizations are disabled.
+                */
+               __asm__ __volatile__("ud2");
+       }
+       mutex_lock_signal_restore(&__urcu_x86_compat_mutex, &mask);
+}
+
+void _compat_uatomic_and(void *addr, unsigned long v, int len)
+{
+       sigset_t mask;
+
+       mutex_lock_signal_save(&__urcu_x86_compat_mutex, &mask);
+       switch (len) {
+       case 1:
+               *(unsigned char *)addr &= (unsigned char)v;
+               break;
+       case 2:
+               *(unsigned short *)addr &= (unsigned short)v;
+               break;
+       case 4:
+               *(unsigned int *)addr &= (unsigned int)v;
+               break;
+       default:
+               /*
+                * generate an illegal instruction. Cannot catch this with
+                * linker tricks when optimizations are disabled.
+                */
+               __asm__ __volatile__("ud2");
+       }
+       mutex_lock_signal_restore(&__urcu_x86_compat_mutex, &mask);
+}
+
 unsigned long _compat_uatomic_add_return(void *addr, unsigned long v, int len)
 {
        sigset_t mask;
        unsigned long result;
 
-       mutex_lock_signal_save(&compat_mutex, &mask);
+       mutex_lock_signal_save(&__urcu_x86_compat_mutex, &mask);
        switch (len) {
        case 1:
                *(unsigned char *)addr += (unsigned char)v;
@@ -225,15 +288,16 @@ unsigned long _compat_uatomic_add_return(void *addr, unsigned long v, int len)
                 * generate an illegal instruction. Cannot catch this with
                 * linker tricks when optimizations are disabled.
                 */
+               result = 0;     /* silence gcc warnings */
                __asm__ __volatile__("ud2");
        }
-       mutex_lock_signal_restore(&compat_mutex, &mask);
+       mutex_lock_signal_restore(&__urcu_x86_compat_mutex, &mask);
        return result;
 }
 
-int __urcu_cas_init(void)
+int __rcu_cas_init(void)
 {
-       if (__urcu_cas_avail < 0)
-               __urcu_cas_avail = compare_and_swap_is_available();
-       return __urcu_cas_avail;
+       if (__rcu_cas_avail < 0)
+               __rcu_cas_avail = compare_and_swap_is_available();
+       return __rcu_cas_avail;
 }