include/linux/rwlock.h

0001 #ifndef __LINUX_RWLOCK_H
0002 #define __LINUX_RWLOCK_H
0003
0004 #ifndef __LINUX_SPINLOCK_H
0005 # error "please don't include this file directly"
0006 #endif
0007
0008 /*
0009  * rwlock related methods
0010  *
0011  * split out from spinlock.h
0012  *
0013  * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
0014  * Released under the General Public License (GPL).
0015  */
0016
0017 #ifdef CONFIG_DEBUG_SPINLOCK
0018   extern void __rwlock_init(rwlock_t *lock, const char *name,
0019                 struct lock_class_key *key);
0020 # define rwlock_init(lock)                  \
0021 do {                                \
0022     static struct lock_class_key __key;         \
0023                                 \
0024     __rwlock_init((lock), #lock, &__key);           \
0025 } while (0)
0026 #else
0027 # define rwlock_init(lock)                  \
0028     do { *(lock) = __RW_LOCK_UNLOCKED(lock); } while (0)
0029 #endif
0030
0031 #ifdef CONFIG_DEBUG_SPINLOCK
0032  extern void do_raw_read_lock(rwlock_t *lock) __acquires(lock);
0033  extern int do_raw_read_trylock(rwlock_t *lock);
0034  extern void do_raw_read_unlock(rwlock_t *lock) __releases(lock);
0035  extern void do_raw_write_lock(rwlock_t *lock) __acquires(lock);
0036  extern int do_raw_write_trylock(rwlock_t *lock);
0037  extern void do_raw_write_unlock(rwlock_t *lock) __releases(lock);
0038 #else
0039 # define do_raw_read_lock(rwlock)   do {__acquire(lock); arch_read_lock(&(rwlock)->raw_lock); } while (0)
0040 # define do_raw_read_trylock(rwlock)    arch_read_trylock(&(rwlock)->raw_lock)
0041 # define do_raw_read_unlock(rwlock) do {arch_read_unlock(&(rwlock)->raw_lock); __release(lock); } while (0)
0042 # define do_raw_write_lock(rwlock)  do {__acquire(lock); arch_write_lock(&(rwlock)->raw_lock); } while (0)
0043 # define do_raw_write_trylock(rwlock)   arch_write_trylock(&(rwlock)->raw_lock)
0044 # define do_raw_write_unlock(rwlock)    do {arch_write_unlock(&(rwlock)->raw_lock); __release(lock); } while (0)
0045 #endif
0046
0047 /*
0048  * Define the various rw_lock methods.  Note we define these
0049  * regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The various
0050  * methods are defined as nops in the case they are not required.
0051  */
0052 #define read_trylock(lock)  __cond_lock(lock, _raw_read_trylock(lock))
0053 #define write_trylock(lock) __cond_lock(lock, _raw_write_trylock(lock))
0054
0055 #define write_lock(lock)    _raw_write_lock(lock)
0056 #define read_lock(lock)     _raw_read_lock(lock)
0057
0058 #ifdef CONFIG_DEBUG_LOCK_ALLOC
0059 #define write_lock_nested(lock, subclass)   _raw_write_lock_nested(lock, subclass)
0060 #else
0061 #define write_lock_nested(lock, subclass)   _raw_write_lock(lock)
0062 #endif
0063
0064 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
0065
0066 #define read_lock_irqsave(lock, flags)          \
0067     do {                        \
0068         typecheck(unsigned long, flags);    \
0069         flags = _raw_read_lock_irqsave(lock);   \
0070     } while (0)
0071 #define write_lock_irqsave(lock, flags)         \
0072     do {                        \
0073         typecheck(unsigned long, flags);    \
0074         flags = _raw_write_lock_irqsave(lock);  \
0075     } while (0)
0076
0077 #else
0078
0079 #define read_lock_irqsave(lock, flags)          \
0080     do {                        \
0081         typecheck(unsigned long, flags);    \
0082         _raw_read_lock_irqsave(lock, flags);    \
0083     } while (0)
0084 #define write_lock_irqsave(lock, flags)         \
0085     do {                        \
0086         typecheck(unsigned long, flags);    \
0087         _raw_write_lock_irqsave(lock, flags);   \
0088     } while (0)
0089
0090 #endif
0091
0092 #define read_lock_irq(lock)     _raw_read_lock_irq(lock)
0093 #define read_lock_bh(lock)      _raw_read_lock_bh(lock)
0094 #define write_lock_irq(lock)        _raw_write_lock_irq(lock)
0095 #define write_lock_bh(lock)     _raw_write_lock_bh(lock)
0096 #define read_unlock(lock)       _raw_read_unlock(lock)
0097 #define write_unlock(lock)      _raw_write_unlock(lock)
0098 #define read_unlock_irq(lock)       _raw_read_unlock_irq(lock)
0099 #define write_unlock_irq(lock)      _raw_write_unlock_irq(lock)
0100
0101 #define read_unlock_irqrestore(lock, flags)         \
0102     do {                            \
0103         typecheck(unsigned long, flags);        \
0104         _raw_read_unlock_irqrestore(lock, flags);   \
0105     } while (0)
0106 #define read_unlock_bh(lock)        _raw_read_unlock_bh(lock)
0107
0108 #define write_unlock_irqrestore(lock, flags)        \
0109     do {                        \
0110         typecheck(unsigned long, flags);    \
0111         _raw_write_unlock_irqrestore(lock, flags);  \
0112     } while (0)
0113 #define write_unlock_bh(lock)       _raw_write_unlock_bh(lock)
0114
0115 #define write_trylock_irqsave(lock, flags) \
0116 ({ \
0117     local_irq_save(flags); \
0118     write_trylock(lock) ? \
0119     1 : ({ local_irq_restore(flags); 0; }); \
0120 })
0121
0122 #ifdef arch_rwlock_is_contended
0123 #define rwlock_is_contended(lock) \
0124      arch_rwlock_is_contended(&(lock)->raw_lock)
0125 #else
0126 #define rwlock_is_contended(lock)   ((void)(lock), 0)
0127 #endif /* arch_rwlock_is_contended */
0128
0129 #endif /* __LINUX_RWLOCK_H */