include/linux/rwlock_api_smp.h

0001 #ifndef __LINUX_RWLOCK_API_SMP_H
0002 #define __LINUX_RWLOCK_API_SMP_H
0003
0004 #ifndef __LINUX_SPINLOCK_API_SMP_H
0005 # error "please don't include this file directly"
0006 #endif
0007
0008 /*
0009  * include/linux/rwlock_api_smp.h
0010  *
0011  * spinlock API declarations on SMP (and debug)
0012  * (implemented in kernel/spinlock.c)
0013  *
0014  * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
0015  * Released under the General Public License (GPL).
0016  */
0017
0018 void __lockfunc _raw_read_lock(rwlock_t *lock)      __acquires(lock);
0019 void __lockfunc _raw_write_lock(rwlock_t *lock)     __acquires(lock);
0020 void __lockfunc _raw_write_lock_nested(rwlock_t *lock, int subclass)    __acquires(lock);
0021 void __lockfunc _raw_read_lock_bh(rwlock_t *lock)   __acquires(lock);
0022 void __lockfunc _raw_write_lock_bh(rwlock_t *lock)  __acquires(lock);
0023 void __lockfunc _raw_read_lock_irq(rwlock_t *lock)  __acquires(lock);
0024 void __lockfunc _raw_write_lock_irq(rwlock_t *lock) __acquires(lock);
0025 unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)
0026                             __acquires(lock);
0027 unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)
0028                             __acquires(lock);
0029 int __lockfunc _raw_read_trylock(rwlock_t *lock);
0030 int __lockfunc _raw_write_trylock(rwlock_t *lock);
0031 void __lockfunc _raw_read_unlock(rwlock_t *lock)    __releases(lock);
0032 void __lockfunc _raw_write_unlock(rwlock_t *lock)   __releases(lock);
0033 void __lockfunc _raw_read_unlock_bh(rwlock_t *lock) __releases(lock);
0034 void __lockfunc _raw_write_unlock_bh(rwlock_t *lock)    __releases(lock);
0035 void __lockfunc _raw_read_unlock_irq(rwlock_t *lock)    __releases(lock);
0036 void __lockfunc _raw_write_unlock_irq(rwlock_t *lock)   __releases(lock);
0037 void __lockfunc
0038 _raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
0039                             __releases(lock);
0040 void __lockfunc
0041 _raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
0042                             __releases(lock);
0043
0044 #ifdef CONFIG_INLINE_READ_LOCK
0045 #define _raw_read_lock(lock) __raw_read_lock(lock)
0046 #endif
0047
0048 #ifdef CONFIG_INLINE_WRITE_LOCK
0049 #define _raw_write_lock(lock) __raw_write_lock(lock)
0050 #endif
0051
0052 #ifdef CONFIG_INLINE_READ_LOCK_BH
0053 #define _raw_read_lock_bh(lock) __raw_read_lock_bh(lock)
0054 #endif
0055
0056 #ifdef CONFIG_INLINE_WRITE_LOCK_BH
0057 #define _raw_write_lock_bh(lock) __raw_write_lock_bh(lock)
0058 #endif
0059
0060 #ifdef CONFIG_INLINE_READ_LOCK_IRQ
0061 #define _raw_read_lock_irq(lock) __raw_read_lock_irq(lock)
0062 #endif
0063
0064 #ifdef CONFIG_INLINE_WRITE_LOCK_IRQ
0065 #define _raw_write_lock_irq(lock) __raw_write_lock_irq(lock)
0066 #endif
0067
0068 #ifdef CONFIG_INLINE_READ_LOCK_IRQSAVE
0069 #define _raw_read_lock_irqsave(lock) __raw_read_lock_irqsave(lock)
0070 #endif
0071
0072 #ifdef CONFIG_INLINE_WRITE_LOCK_IRQSAVE
0073 #define _raw_write_lock_irqsave(lock) __raw_write_lock_irqsave(lock)
0074 #endif
0075
0076 #ifdef CONFIG_INLINE_READ_TRYLOCK
0077 #define _raw_read_trylock(lock) __raw_read_trylock(lock)
0078 #endif
0079
0080 #ifdef CONFIG_INLINE_WRITE_TRYLOCK
0081 #define _raw_write_trylock(lock) __raw_write_trylock(lock)
0082 #endif
0083
0084 #ifdef CONFIG_INLINE_READ_UNLOCK
0085 #define _raw_read_unlock(lock) __raw_read_unlock(lock)
0086 #endif
0087
0088 #ifdef CONFIG_INLINE_WRITE_UNLOCK
0089 #define _raw_write_unlock(lock) __raw_write_unlock(lock)
0090 #endif
0091
0092 #ifdef CONFIG_INLINE_READ_UNLOCK_BH
0093 #define _raw_read_unlock_bh(lock) __raw_read_unlock_bh(lock)
0094 #endif
0095
0096 #ifdef CONFIG_INLINE_WRITE_UNLOCK_BH
0097 #define _raw_write_unlock_bh(lock) __raw_write_unlock_bh(lock)
0098 #endif
0099
0100 #ifdef CONFIG_INLINE_READ_UNLOCK_IRQ
0101 #define _raw_read_unlock_irq(lock) __raw_read_unlock_irq(lock)
0102 #endif
0103
0104 #ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQ
0105 #define _raw_write_unlock_irq(lock) __raw_write_unlock_irq(lock)
0106 #endif
0107
0108 #ifdef CONFIG_INLINE_READ_UNLOCK_IRQRESTORE
0109 #define _raw_read_unlock_irqrestore(lock, flags) \
0110     __raw_read_unlock_irqrestore(lock, flags)
0111 #endif
0112
0113 #ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE
0114 #define _raw_write_unlock_irqrestore(lock, flags) \
0115     __raw_write_unlock_irqrestore(lock, flags)
0116 #endif
0117
0118 static inline int __raw_read_trylock(rwlock_t *lock)
0119 {
0120     preempt_disable();
0121     if (do_raw_read_trylock(lock)) {
0122         rwlock_acquire_read(&lock->dep_map, 0, 1, _RET_IP_);
0123         return 1;
0124     }
0125     preempt_enable();
0126     return 0;
0127 }
0128
0129 static inline int __raw_write_trylock(rwlock_t *lock)
0130 {
0131     preempt_disable();
0132     if (do_raw_write_trylock(lock)) {
0133         rwlock_acquire(&lock->dep_map, 0, 1, _RET_IP_);
0134         return 1;
0135     }
0136     preempt_enable();
0137     return 0;
0138 }
0139
0140 /*
0141  * If lockdep is enabled then we use the non-preemption spin-ops
0142  * even on CONFIG_PREEMPT, because lockdep assumes that interrupts are
0143  * not re-enabled during lock-acquire (which the preempt-spin-ops do):
0144  */
0145 #if !defined(CONFIG_GENERIC_LOCKBREAK) || defined(CONFIG_DEBUG_LOCK_ALLOC)
0146
0147 static inline void __raw_read_lock(rwlock_t *lock)
0148 {
0149     preempt_disable();
0150     rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
0151     LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
0152 }
0153
0154 static inline unsigned long __raw_read_lock_irqsave(rwlock_t *lock)
0155 {
0156     unsigned long flags;
0157
0158     local_irq_save(flags);
0159     preempt_disable();
0160     rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
0161     LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
0162     return flags;
0163 }
0164
0165 static inline void __raw_read_lock_irq(rwlock_t *lock)
0166 {
0167     local_irq_disable();
0168     preempt_disable();
0169     rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
0170     LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
0171 }
0172
0173 static inline void __raw_read_lock_bh(rwlock_t *lock)
0174 {
0175     __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
0176     rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
0177     LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
0178 }
0179
0180 static inline unsigned long __raw_write_lock_irqsave(rwlock_t *lock)
0181 {
0182     unsigned long flags;
0183
0184     local_irq_save(flags);
0185     preempt_disable();
0186     rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
0187     LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
0188     return flags;
0189 }
0190
0191 static inline void __raw_write_lock_irq(rwlock_t *lock)
0192 {
0193     local_irq_disable();
0194     preempt_disable();
0195     rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
0196     LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
0197 }
0198
0199 static inline void __raw_write_lock_bh(rwlock_t *lock)
0200 {
0201     __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
0202     rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
0203     LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
0204 }
0205
0206 static inline void __raw_write_lock(rwlock_t *lock)
0207 {
0208     preempt_disable();
0209     rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
0210     LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
0211 }
0212
0213 static inline void __raw_write_lock_nested(rwlock_t *lock, int subclass)
0214 {
0215     preempt_disable();
0216     rwlock_acquire(&lock->dep_map, subclass, 0, _RET_IP_);
0217     LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
0218 }
0219
0220 #endif /* !CONFIG_GENERIC_LOCKBREAK || CONFIG_DEBUG_LOCK_ALLOC */
0221
0222 static inline void __raw_write_unlock(rwlock_t *lock)
0223 {
0224     rwlock_release(&lock->dep_map, _RET_IP_);
0225     do_raw_write_unlock(lock);
0226     preempt_enable();
0227 }
0228
0229 static inline void __raw_read_unlock(rwlock_t *lock)
0230 {
0231     rwlock_release(&lock->dep_map, _RET_IP_);
0232     do_raw_read_unlock(lock);
0233     preempt_enable();
0234 }
0235
0236 static inline void
0237 __raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
0238 {
0239     rwlock_release(&lock->dep_map, _RET_IP_);
0240     do_raw_read_unlock(lock);
0241     local_irq_restore(flags);
0242     preempt_enable();
0243 }
0244
0245 static inline void __raw_read_unlock_irq(rwlock_t *lock)
0246 {
0247     rwlock_release(&lock->dep_map, _RET_IP_);
0248     do_raw_read_unlock(lock);
0249     local_irq_enable();
0250     preempt_enable();
0251 }
0252
0253 static inline void __raw_read_unlock_bh(rwlock_t *lock)
0254 {
0255     rwlock_release(&lock->dep_map, _RET_IP_);
0256     do_raw_read_unlock(lock);
0257     __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
0258 }
0259
0260 static inline void __raw_write_unlock_irqrestore(rwlock_t *lock,
0261                          unsigned long flags)
0262 {
0263     rwlock_release(&lock->dep_map, _RET_IP_);
0264     do_raw_write_unlock(lock);
0265     local_irq_restore(flags);
0266     preempt_enable();
0267 }
0268
0269 static inline void __raw_write_unlock_irq(rwlock_t *lock)
0270 {
0271     rwlock_release(&lock->dep_map, _RET_IP_);
0272     do_raw_write_unlock(lock);
0273     local_irq_enable();
0274     preempt_enable();
0275 }
0276
0277 static inline void __raw_write_unlock_bh(rwlock_t *lock)
0278 {
0279     rwlock_release(&lock->dep_map, _RET_IP_);
0280     do_raw_write_unlock(lock);
0281     __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
0282 }
0283
0284 #endif /* __LINUX_RWLOCK_API_SMP_H */