1 #ifndef __LINUX_RWLOCK_API_SMP_H 2 #define __LINUX_RWLOCK_API_SMP_H 3 4 #ifndef __LINUX_SPINLOCK_API_SMP_H 5 # error "please don't include this file directly" 6 #endif 7 8 /* 9 * include/linux/rwlock_api_smp.h 10 * 11 * spinlock API declarations on SMP (and debug) 12 * (implemented in kernel/spinlock.c) 13 * 14 * portions Copyright 2005, Red Hat, Inc., Ingo Molnar 15 * Released under the General Public License (GPL). 16 */ 17 18 void __lockfunc _raw_read_lock(rwlock_t *lock) __acquires(lock); 19 void __lockfunc _raw_write_lock(rwlock_t *lock) __acquires(lock); 20 void __lockfunc _raw_write_lock_nested(rwlock_t *lock, int subclass) __acquires(lock); 21 void __lockfunc _raw_read_lock_bh(rwlock_t *lock) __acquires(lock); 22 void __lockfunc _raw_write_lock_bh(rwlock_t *lock) __acquires(lock); 23 void __lockfunc _raw_read_lock_irq(rwlock_t *lock) __acquires(lock); 24 void __lockfunc _raw_write_lock_irq(rwlock_t *lock) __acquires(lock); 25 unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock) 26 __acquires(lock); 27 unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock) 28 __acquires(lock); 29 int __lockfunc _raw_read_trylock(rwlock_t *lock); 30 int __lockfunc _raw_write_trylock(rwlock_t *lock); 31 void __lockfunc _raw_read_unlock(rwlock_t *lock) __releases(lock); 32 void __lockfunc _raw_write_unlock(rwlock_t *lock) __releases(lock); 33 void __lockfunc _raw_read_unlock_bh(rwlock_t *lock) __releases(lock); 34 void __lockfunc _raw_write_unlock_bh(rwlock_t *lock) __releases(lock); 35 void __lockfunc _raw_read_unlock_irq(rwlock_t *lock) __releases(lock); 36 void __lockfunc _raw_write_unlock_irq(rwlock_t *lock) __releases(lock); 37 void __lockfunc 38 _raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags) 39 __releases(lock); 40 void __lockfunc 41 _raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags) 42 __releases(lock); 43 44 #ifdef CONFIG_INLINE_READ_LOCK 45 #define _raw_read_lock(lock) __raw_read_lock(lock) 46 #endif 47 48 #ifdef CONFIG_INLINE_WRITE_LOCK 49 #define _raw_write_lock(lock) __raw_write_lock(lock) 50 #endif 51 52 #ifdef CONFIG_INLINE_READ_LOCK_BH 53 #define _raw_read_lock_bh(lock) __raw_read_lock_bh(lock) 54 #endif 55 56 #ifdef CONFIG_INLINE_WRITE_LOCK_BH 57 #define _raw_write_lock_bh(lock) __raw_write_lock_bh(lock) 58 #endif 59 60 #ifdef CONFIG_INLINE_READ_LOCK_IRQ 61 #define _raw_read_lock_irq(lock) __raw_read_lock_irq(lock) 62 #endif 63 64 #ifdef CONFIG_INLINE_WRITE_LOCK_IRQ 65 #define _raw_write_lock_irq(lock) __raw_write_lock_irq(lock) 66 #endif 67 68 #ifdef CONFIG_INLINE_READ_LOCK_IRQSAVE 69 #define _raw_read_lock_irqsave(lock) __raw_read_lock_irqsave(lock) 70 #endif 71 72 #ifdef CONFIG_INLINE_WRITE_LOCK_IRQSAVE 73 #define _raw_write_lock_irqsave(lock) __raw_write_lock_irqsave(lock) 74 #endif 75 76 #ifdef CONFIG_INLINE_READ_TRYLOCK 77 #define _raw_read_trylock(lock) __raw_read_trylock(lock) 78 #endif 79 80 #ifdef CONFIG_INLINE_WRITE_TRYLOCK 81 #define _raw_write_trylock(lock) __raw_write_trylock(lock) 82 #endif 83 84 #ifdef CONFIG_INLINE_READ_UNLOCK 85 #define _raw_read_unlock(lock) __raw_read_unlock(lock) 86 #endif 87 88 #ifdef CONFIG_INLINE_WRITE_UNLOCK 89 #define _raw_write_unlock(lock) __raw_write_unlock(lock) 90 #endif 91 92 #ifdef CONFIG_INLINE_READ_UNLOCK_BH 93 #define _raw_read_unlock_bh(lock) __raw_read_unlock_bh(lock) 94 #endif 95 96 #ifdef CONFIG_INLINE_WRITE_UNLOCK_BH 97 #define _raw_write_unlock_bh(lock) __raw_write_unlock_bh(lock) 98 #endif 99 100 #ifdef CONFIG_INLINE_READ_UNLOCK_IRQ 101 #define _raw_read_unlock_irq(lock) __raw_read_unlock_irq(lock) 102 #endif 103 104 #ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQ 105 #define _raw_write_unlock_irq(lock) __raw_write_unlock_irq(lock) 106 #endif 107 108 #ifdef CONFIG_INLINE_READ_UNLOCK_IRQRESTORE 109 #define _raw_read_unlock_irqrestore(lock, flags) \ 110 __raw_read_unlock_irqrestore(lock, flags) 111 #endif 112 113 #ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE 114 #define _raw_write_unlock_irqrestore(lock, flags) \ 115 __raw_write_unlock_irqrestore(lock, flags) 116 #endif 117 118 static inline int __raw_read_trylock(rwlock_t *lock) 119 { 120 preempt_disable(); 121 if (do_raw_read_trylock(lock)) { 122 rwlock_acquire_read(&lock->dep_map, 0, 1, _RET_IP_); 123 return 1; 124 } 125 preempt_enable(); 126 return 0; 127 } 128 129 static inline int __raw_write_trylock(rwlock_t *lock) 130 { 131 preempt_disable(); 132 if (do_raw_write_trylock(lock)) { 133 rwlock_acquire(&lock->dep_map, 0, 1, _RET_IP_); 134 return 1; 135 } 136 preempt_enable(); 137 return 0; 138 } 139 140 /* 141 * If lockdep is enabled then we use the non-preemption spin-ops 142 * even on CONFIG_PREEMPT, because lockdep assumes that interrupts are 143 * not re-enabled during lock-acquire (which the preempt-spin-ops do): 144 */ 145 #if !defined(CONFIG_GENERIC_LOCKBREAK) || defined(CONFIG_DEBUG_LOCK_ALLOC) 146 147 static inline void __raw_read_lock(rwlock_t *lock) 148 { 149 preempt_disable(); 150 rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_); 151 LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock); 152 } 153 154 static inline unsigned long __raw_read_lock_irqsave(rwlock_t *lock) 155 { 156 unsigned long flags; 157 158 local_irq_save(flags); 159 preempt_disable(); 160 rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_); 161 LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock); 162 return flags; 163 } 164 165 static inline void __raw_read_lock_irq(rwlock_t *lock) 166 { 167 local_irq_disable(); 168 preempt_disable(); 169 rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_); 170 LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock); 171 } 172 173 static inline void __raw_read_lock_bh(rwlock_t *lock) 174 { 175 __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET); 176 rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_); 177 LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock); 178 } 179 180 static inline unsigned long __raw_write_lock_irqsave(rwlock_t *lock) 181 { 182 unsigned long flags; 183 184 local_irq_save(flags); 185 preempt_disable(); 186 rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_); 187 LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock); 188 return flags; 189 } 190 191 static inline void __raw_write_lock_irq(rwlock_t *lock) 192 { 193 local_irq_disable(); 194 preempt_disable(); 195 rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_); 196 LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock); 197 } 198 199 static inline void __raw_write_lock_bh(rwlock_t *lock) 200 { 201 __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET); 202 rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_); 203 LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock); 204 } 205 206 static inline void __raw_write_lock(rwlock_t *lock) 207 { 208 preempt_disable(); 209 rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_); 210 LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock); 211 } 212 213 static inline void __raw_write_lock_nested(rwlock_t *lock, int subclass) 214 { 215 preempt_disable(); 216 rwlock_acquire(&lock->dep_map, subclass, 0, _RET_IP_); 217 LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock); 218 } 219 220 #endif /* !CONFIG_GENERIC_LOCKBREAK || CONFIG_DEBUG_LOCK_ALLOC */ 221 222 static inline void __raw_write_unlock(rwlock_t *lock) 223 { 224 rwlock_release(&lock->dep_map, _RET_IP_); 225 do_raw_write_unlock(lock); 226 preempt_enable(); 227 } 228 229 static inline void __raw_read_unlock(rwlock_t *lock) 230 { 231 rwlock_release(&lock->dep_map, _RET_IP_); 232 do_raw_read_unlock(lock); 233 preempt_enable(); 234 } 235 236 static inline void 237 __raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags) 238 { 239 rwlock_release(&lock->dep_map, _RET_IP_); 240 do_raw_read_unlock(lock); 241 local_irq_restore(flags); 242 preempt_enable(); 243 } 244 245 static inline void __raw_read_unlock_irq(rwlock_t *lock) 246 { 247 rwlock_release(&lock->dep_map, _RET_IP_); 248 do_raw_read_unlock(lock); 249 local_irq_enable(); 250 preempt_enable(); 251 } 252 253 static inline void __raw_read_unlock_bh(rwlock_t *lock) 254 { 255 rwlock_release(&lock->dep_map, _RET_IP_); 256 do_raw_read_unlock(lock); 257 __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET); 258 } 259 260 static inline void __raw_write_unlock_irqrestore(rwlock_t *lock, 261 unsigned long flags) 262 { 263 rwlock_release(&lock->dep_map, _RET_IP_); 264 do_raw_write_unlock(lock); 265 local_irq_restore(flags); 266 preempt_enable(); 267 } 268 269 static inline void __raw_write_unlock_irq(rwlock_t *lock) 270 { 271 rwlock_release(&lock->dep_map, _RET_IP_); 272 do_raw_write_unlock(lock); 273 local_irq_enable(); 274 preempt_enable(); 275 } 276 277 static inline void __raw_write_unlock_bh(rwlock_t *lock) 278 { 279 rwlock_release(&lock->dep_map, _RET_IP_); 280 do_raw_write_unlock(lock); 281 __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET); 282 } 283 284 #endif /* __LINUX_RWLOCK_API_SMP_H */ 285