Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Tony Luck | 7f30491 | 2008-08-01 10:13:32 -0700 | [diff] [blame] | 2 | * R/W semaphores for ia64 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * |
| 4 | * Copyright (C) 2003 Ken Chen <kenneth.w.chen@intel.com> |
| 5 | * Copyright (C) 2003 Asit Mallick <asit.k.mallick@intel.com> |
Christoph Lameter | 93e205a | 2016-03-17 14:21:15 -0700 | [diff] [blame] | 6 | * Copyright (C) 2005 Christoph Lameter <cl@linux.com> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | * |
| 8 | * Based on asm-i386/rwsem.h and other architecture implementation. |
| 9 | * |
| 10 | * The MSW of the count is the negated number of active writers and |
| 11 | * waiting lockers, and the LSW is the total number of active locks. |
| 12 | * |
| 13 | * The lock count is initialized to 0 (no active and no waiting lockers). |
| 14 | * |
Christoph Lameter | 16592d2 | 2005-08-22 12:20:00 -0700 | [diff] [blame] | 15 | * When a writer subtracts WRITE_BIAS, it'll get 0xffffffff00000001 for |
| 16 | * the case of an uncontended lock. Readers increment by 1 and see a positive |
| 17 | * value when uncontended, negative if there are writers (and maybe) readers |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | * waiting (in which case it goes to sleep). |
| 19 | */ |
| 20 | |
| 21 | #ifndef _ASM_IA64_RWSEM_H |
| 22 | #define _ASM_IA64_RWSEM_H |
| 23 | |
Robert P. J. Day | bd807f9 | 2007-07-18 07:33:08 -0400 | [diff] [blame] | 24 | #ifndef _LINUX_RWSEM_H |
| 25 | #error "Please don't include <asm/rwsem.h> directly, use <linux/rwsem.h> instead." |
| 26 | #endif |
| 27 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | #include <asm/intrinsics.h> |
| 29 | |
Christoph Lameter | 16592d2 | 2005-08-22 12:20:00 -0700 | [diff] [blame] | 30 | #define RWSEM_UNLOCKED_VALUE __IA64_UL_CONST(0x0000000000000000) |
Tony Luck | b680f09 | 2010-08-12 09:14:56 -0700 | [diff] [blame] | 31 | #define RWSEM_ACTIVE_BIAS (1L) |
| 32 | #define RWSEM_ACTIVE_MASK (0xffffffffL) |
| 33 | #define RWSEM_WAITING_BIAS (-0x100000000L) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | #define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS |
| 35 | #define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS) |
| 36 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | /* |
| 38 | * lock for reading |
| 39 | */ |
| 40 | static inline void |
| 41 | __down_read (struct rw_semaphore *sem) |
| 42 | { |
Jason Low | 8ee62b1 | 2016-06-03 22:26:02 -0700 | [diff] [blame] | 43 | long result = ia64_fetchadd8_acq((unsigned long *)&sem->count.counter, 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | |
| 45 | if (result < 0) |
| 46 | rwsem_down_read_failed(sem); |
| 47 | } |
| 48 | |
| 49 | /* |
| 50 | * lock for writing |
| 51 | */ |
Michal Hocko | a02137e | 2016-04-07 17:12:28 +0200 | [diff] [blame] | 52 | static inline long |
| 53 | ___down_write (struct rw_semaphore *sem) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | { |
Christoph Lameter | 16592d2 | 2005-08-22 12:20:00 -0700 | [diff] [blame] | 55 | long old, new; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 56 | |
| 57 | do { |
Jason Low | 8ee62b1 | 2016-06-03 22:26:02 -0700 | [diff] [blame] | 58 | old = atomic_long_read(&sem->count); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | new = old + RWSEM_ACTIVE_WRITE_BIAS; |
Jason Low | 8ee62b1 | 2016-06-03 22:26:02 -0700 | [diff] [blame] | 60 | } while (atomic_long_cmpxchg_acquire(&sem->count, old, new) != old); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | |
Michal Hocko | a02137e | 2016-04-07 17:12:28 +0200 | [diff] [blame] | 62 | return old; |
| 63 | } |
| 64 | |
| 65 | static inline void |
| 66 | __down_write (struct rw_semaphore *sem) |
| 67 | { |
| 68 | if (___down_write(sem)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | rwsem_down_write_failed(sem); |
| 70 | } |
| 71 | |
Michal Hocko | a02137e | 2016-04-07 17:12:28 +0200 | [diff] [blame] | 72 | static inline int |
| 73 | __down_write_killable (struct rw_semaphore *sem) |
| 74 | { |
| 75 | if (___down_write(sem)) |
| 76 | if (IS_ERR(rwsem_down_write_failed_killable(sem))) |
| 77 | return -EINTR; |
| 78 | |
| 79 | return 0; |
| 80 | } |
| 81 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 82 | /* |
| 83 | * unlock after reading |
| 84 | */ |
| 85 | static inline void |
| 86 | __up_read (struct rw_semaphore *sem) |
| 87 | { |
Jason Low | 8ee62b1 | 2016-06-03 22:26:02 -0700 | [diff] [blame] | 88 | long result = ia64_fetchadd8_rel((unsigned long *)&sem->count.counter, -1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | |
| 90 | if (result < 0 && (--result & RWSEM_ACTIVE_MASK) == 0) |
| 91 | rwsem_wake(sem); |
| 92 | } |
| 93 | |
| 94 | /* |
| 95 | * unlock after writing |
| 96 | */ |
| 97 | static inline void |
| 98 | __up_write (struct rw_semaphore *sem) |
| 99 | { |
Christoph Lameter | 16592d2 | 2005-08-22 12:20:00 -0700 | [diff] [blame] | 100 | long old, new; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | |
| 102 | do { |
Jason Low | 8ee62b1 | 2016-06-03 22:26:02 -0700 | [diff] [blame] | 103 | old = atomic_long_read(&sem->count); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | new = old - RWSEM_ACTIVE_WRITE_BIAS; |
Jason Low | 8ee62b1 | 2016-06-03 22:26:02 -0700 | [diff] [blame] | 105 | } while (atomic_long_cmpxchg_release(&sem->count, old, new) != old); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | |
| 107 | if (new < 0 && (new & RWSEM_ACTIVE_MASK) == 0) |
| 108 | rwsem_wake(sem); |
| 109 | } |
| 110 | |
| 111 | /* |
| 112 | * trylock for reading -- returns 1 if successful, 0 if contention |
| 113 | */ |
| 114 | static inline int |
| 115 | __down_read_trylock (struct rw_semaphore *sem) |
| 116 | { |
Christoph Lameter | 16592d2 | 2005-08-22 12:20:00 -0700 | [diff] [blame] | 117 | long tmp; |
Jason Low | 8ee62b1 | 2016-06-03 22:26:02 -0700 | [diff] [blame] | 118 | while ((tmp = atomic_long_read(&sem->count)) >= 0) { |
| 119 | if (tmp == atomic_long_cmpxchg_acquire(&sem->count, tmp, tmp+1)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | return 1; |
| 121 | } |
| 122 | } |
| 123 | return 0; |
| 124 | } |
| 125 | |
| 126 | /* |
| 127 | * trylock for writing -- returns 1 if successful, 0 if contention |
| 128 | */ |
| 129 | static inline int |
| 130 | __down_write_trylock (struct rw_semaphore *sem) |
| 131 | { |
Jason Low | 8ee62b1 | 2016-06-03 22:26:02 -0700 | [diff] [blame] | 132 | long tmp = atomic_long_cmpxchg_acquire(&sem->count, |
| 133 | RWSEM_UNLOCKED_VALUE, RWSEM_ACTIVE_WRITE_BIAS); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | return tmp == RWSEM_UNLOCKED_VALUE; |
| 135 | } |
| 136 | |
| 137 | /* |
| 138 | * downgrade write lock to read lock |
| 139 | */ |
| 140 | static inline void |
| 141 | __downgrade_write (struct rw_semaphore *sem) |
| 142 | { |
Christoph Lameter | 16592d2 | 2005-08-22 12:20:00 -0700 | [diff] [blame] | 143 | long old, new; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | |
| 145 | do { |
Jason Low | 8ee62b1 | 2016-06-03 22:26:02 -0700 | [diff] [blame] | 146 | old = atomic_long_read(&sem->count); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | new = old - RWSEM_WAITING_BIAS; |
Jason Low | 8ee62b1 | 2016-06-03 22:26:02 -0700 | [diff] [blame] | 148 | } while (atomic_long_cmpxchg_release(&sem->count, old, new) != old); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | |
| 150 | if (old < 0) |
| 151 | rwsem_downgrade_wake(sem); |
| 152 | } |
| 153 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | #endif /* _ASM_IA64_RWSEM_H */ |