128 lines
3.0 KiB
C
128 lines
3.0 KiB
C
/*
|
|
* include/asm-arm/mutex.h
|
|
*
|
|
* ARM optimized mutex locking primitives
|
|
*
|
|
* Please look into asm-generic/mutex-xchg.h for a formal definition.
|
|
*/
|
|
#ifndef _ASM_MUTEX_H
|
|
#define _ASM_MUTEX_H
|
|
|
|
#if __LINUX_ARM_ARCH__ < 6
|
|
/* On pre-ARMv6 hardware the swp based implementation is the most efficient. */
|
|
# include <asm-generic/mutex-xchg.h>
|
|
#else
|
|
|
|
/*
|
|
* Attempting to lock a mutex on ARMv6+ can be done with a bastardized
|
|
* atomic decrement (it is not a reliable atomic decrement but it satisfies
|
|
* the defined semantics for our purpose, while being smaller and faster
|
|
* than a real atomic decrement or atomic swap. The idea is to attempt
|
|
* decrementing the lock value only once. If once decremented it isn't zero,
|
|
* or if its store-back fails due to a dispute on the exclusive store, we
|
|
* simply bail out immediately through the slow path where the lock will be
|
|
* reattempted until it succeeds.
|
|
*/
|
|
static inline void
|
|
__mutex_fastpath_lock(atomic_t *count, fastcall void (*fail_fn)(atomic_t *))
|
|
{
|
|
int __ex_flag, __res;
|
|
|
|
__asm__ (
|
|
|
|
"ldrex %0, [%2] \n\t"
|
|
"sub %0, %0, #1 \n\t"
|
|
"strex %1, %0, [%2] "
|
|
|
|
: "=&r" (__res), "=&r" (__ex_flag)
|
|
: "r" (&(count)->counter)
|
|
: "cc","memory" );
|
|
|
|
__res |= __ex_flag;
|
|
if (unlikely(__res != 0))
|
|
fail_fn(count);
|
|
}
|
|
|
|
static inline int
|
|
__mutex_fastpath_lock_retval(atomic_t *count, fastcall int (*fail_fn)(atomic_t *))
|
|
{
|
|
int __ex_flag, __res;
|
|
|
|
__asm__ (
|
|
|
|
"ldrex %0, [%2] \n\t"
|
|
"sub %0, %0, #1 \n\t"
|
|
"strex %1, %0, [%2] "
|
|
|
|
: "=&r" (__res), "=&r" (__ex_flag)
|
|
: "r" (&(count)->counter)
|
|
: "cc","memory" );
|
|
|
|
__res |= __ex_flag;
|
|
if (unlikely(__res != 0))
|
|
__res = fail_fn(count);
|
|
return __res;
|
|
}
|
|
|
|
/*
|
|
* Same trick is used for the unlock fast path. However the original value,
|
|
* rather than the result, is used to test for success in order to have
|
|
* better generated assembly.
|
|
*/
|
|
static inline void
|
|
__mutex_fastpath_unlock(atomic_t *count, fastcall void (*fail_fn)(atomic_t *))
|
|
{
|
|
int __ex_flag, __res, __orig;
|
|
|
|
__asm__ (
|
|
|
|
"ldrex %0, [%3] \n\t"
|
|
"add %1, %0, #1 \n\t"
|
|
"strex %2, %1, [%3] "
|
|
|
|
: "=&r" (__orig), "=&r" (__res), "=&r" (__ex_flag)
|
|
: "r" (&(count)->counter)
|
|
: "cc","memory" );
|
|
|
|
__orig |= __ex_flag;
|
|
if (unlikely(__orig != 0))
|
|
fail_fn(count);
|
|
}
|
|
|
|
/*
|
|
* If the unlock was done on a contended lock, or if the unlock simply fails
|
|
* then the mutex remains locked.
|
|
*/
|
|
#define __mutex_slowpath_needs_to_unlock() 1
|
|
|
|
/*
|
|
* For __mutex_fastpath_trylock we use another construct which could be
|
|
* described as a "single value cmpxchg".
|
|
*
|
|
* This provides the needed trylock semantics like cmpxchg would, but it is
|
|
* lighter and less generic than a true cmpxchg implementation.
|
|
*/
|
|
static inline int
|
|
__mutex_fastpath_trylock(atomic_t *count, int (*fail_fn)(atomic_t *))
|
|
{
|
|
int __ex_flag, __res, __orig;
|
|
|
|
__asm__ (
|
|
|
|
"1: ldrex %0, [%3] \n\t"
|
|
"subs %1, %0, #1 \n\t"
|
|
"strexeq %2, %1, [%3] \n\t"
|
|
"movlt %0, #0 \n\t"
|
|
"cmpeq %2, #0 \n\t"
|
|
"bgt 1b "
|
|
|
|
: "=&r" (__orig), "=&r" (__res), "=&r" (__ex_flag)
|
|
: "r" (&count->counter)
|
|
: "cc", "memory" );
|
|
|
|
return __orig;
|
|
}
|
|
|
|
#endif
|
|
#endif
|