diff options
Diffstat (limited to 'arch/x86/include/asm/mutex_32.h')
| -rw-r--r-- | arch/x86/include/asm/mutex_32.h | 110 |
1 files changed, 0 insertions, 110 deletions
diff --git a/arch/x86/include/asm/mutex_32.h b/arch/x86/include/asm/mutex_32.h deleted file mode 100644 index e9355a84fc67..000000000000 --- a/arch/x86/include/asm/mutex_32.h +++ /dev/null | |||
| @@ -1,110 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * Assembly implementation of the mutex fastpath, based on atomic | ||
| 3 | * decrement/increment. | ||
| 4 | * | ||
| 5 | * started by Ingo Molnar: | ||
| 6 | * | ||
| 7 | * Copyright (C) 2004, 2005, 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com> | ||
| 8 | */ | ||
| 9 | #ifndef _ASM_X86_MUTEX_32_H | ||
| 10 | #define _ASM_X86_MUTEX_32_H | ||
| 11 | |||
| 12 | #include <asm/alternative.h> | ||
| 13 | |||
| 14 | /** | ||
| 15 | * __mutex_fastpath_lock - try to take the lock by moving the count | ||
| 16 | * from 1 to a 0 value | ||
| 17 | * @count: pointer of type atomic_t | ||
| 18 | * @fn: function to call if the original value was not 1 | ||
| 19 | * | ||
| 20 | * Change the count from 1 to a value lower than 1, and call <fn> if it | ||
| 21 | * wasn't 1 originally. This function MUST leave the value lower than 1 | ||
| 22 | * even when the "1" assertion wasn't true. | ||
| 23 | */ | ||
| 24 | #define __mutex_fastpath_lock(count, fail_fn) \ | ||
| 25 | do { \ | ||
| 26 | unsigned int dummy; \ | ||
| 27 | \ | ||
| 28 | typecheck(atomic_t *, count); \ | ||
| 29 | typecheck_fn(void (*)(atomic_t *), fail_fn); \ | ||
| 30 | \ | ||
| 31 | asm volatile(LOCK_PREFIX " decl (%%eax)\n" \ | ||
| 32 | " jns 1f \n" \ | ||
| 33 | " call " #fail_fn "\n" \ | ||
| 34 | "1:\n" \ | ||
| 35 | : "=a" (dummy) \ | ||
| 36 | : "a" (count) \ | ||
| 37 | : "memory", "ecx", "edx"); \ | ||
| 38 | } while (0) | ||
| 39 | |||
| 40 | |||
| 41 | /** | ||
| 42 | * __mutex_fastpath_lock_retval - try to take the lock by moving the count | ||
| 43 | * from 1 to a 0 value | ||
| 44 | * @count: pointer of type atomic_t | ||
| 45 | * | ||
| 46 | * Change the count from 1 to a value lower than 1. This function returns 0 | ||
| 47 | * if the fastpath succeeds, or -1 otherwise. | ||
| 48 | */ | ||
| 49 | static inline int __mutex_fastpath_lock_retval(atomic_t *count) | ||
| 50 | { | ||
| 51 | if (unlikely(atomic_dec_return(count) < 0)) | ||
| 52 | return -1; | ||
| 53 | else | ||
| 54 | return 0; | ||
| 55 | } | ||
| 56 | |||
| 57 | /** | ||
| 58 | * __mutex_fastpath_unlock - try to promote the mutex from 0 to 1 | ||
| 59 | * @count: pointer of type atomic_t | ||
| 60 | * @fail_fn: function to call if the original value was not 0 | ||
| 61 | * | ||
| 62 | * try to promote the mutex from 0 to 1. if it wasn't 0, call <fail_fn>. | ||
| 63 | * In the failure case, this function is allowed to either set the value | ||
| 64 | * to 1, or to set it to a value lower than 1. | ||
| 65 | * | ||
| 66 | * If the implementation sets it to a value of lower than 1, the | ||
| 67 | * __mutex_slowpath_needs_to_unlock() macro needs to return 1, it needs | ||
| 68 | * to return 0 otherwise. | ||
| 69 | */ | ||
| 70 | #define __mutex_fastpath_unlock(count, fail_fn) \ | ||
| 71 | do { \ | ||
| 72 | unsigned int dummy; \ | ||
| 73 | \ | ||
| 74 | typecheck(atomic_t *, count); \ | ||
| 75 | typecheck_fn(void (*)(atomic_t *), fail_fn); \ | ||
| 76 | \ | ||
| 77 | asm volatile(LOCK_PREFIX " incl (%%eax)\n" \ | ||
| 78 | " jg 1f\n" \ | ||
| 79 | " call " #fail_fn "\n" \ | ||
| 80 | "1:\n" \ | ||
| 81 | : "=a" (dummy) \ | ||
| 82 | : "a" (count) \ | ||
| 83 | : "memory", "ecx", "edx"); \ | ||
| 84 | } while (0) | ||
| 85 | |||
| 86 | #define __mutex_slowpath_needs_to_unlock() 1 | ||
| 87 | |||
| 88 | /** | ||
| 89 | * __mutex_fastpath_trylock - try to acquire the mutex, without waiting | ||
| 90 | * | ||
| 91 | * @count: pointer of type atomic_t | ||
| 92 | * @fail_fn: fallback function | ||
| 93 | * | ||
| 94 | * Change the count from 1 to a value lower than 1, and return 0 (failure) | ||
| 95 | * if it wasn't 1 originally, or return 1 (success) otherwise. This function | ||
| 96 | * MUST leave the value lower than 1 even when the "1" assertion wasn't true. | ||
| 97 | * Additionally, if the value was < 0 originally, this function must not leave | ||
| 98 | * it to 0 on failure. | ||
| 99 | */ | ||
| 100 | static inline int __mutex_fastpath_trylock(atomic_t *count, | ||
| 101 | int (*fail_fn)(atomic_t *)) | ||
| 102 | { | ||
| 103 | /* cmpxchg because it never induces a false contention state. */ | ||
| 104 | if (likely(atomic_read(count) == 1 && atomic_cmpxchg(count, 1, 0) == 1)) | ||
| 105 | return 1; | ||
| 106 | |||
| 107 | return 0; | ||
| 108 | } | ||
| 109 | |||
| 110 | #endif /* _ASM_X86_MUTEX_32_H */ | ||