X-Git-Url: http://git.liburcu.org/?p=urcu.git;a=blobdiff_plain;f=compat_arch_x86.c;h=3e73f9c75953a8e967afe9064e3c79609dc0d2d5;hp=fc504c3356c95808d05cc88f5eb3742c631bc9eb;hb=a59f39055b5ecb77b68cf78b9839aa9e8e4ec332;hpb=bf9de1b724767a7b0d9f32385ed3ab8623aabb71 diff --git a/compat_arch_x86.c b/compat_arch_x86.c index fc504c3..3e73f9c 100644 --- 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 + * Copyright (c) 2009 Mathieu Desnoyers * * 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 #include #include -#include +#include + +/* + * 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; }