include/linux/rwlock_rt.h

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 #ifndef __LINUX_RWLOCK_RT_H
0003 #define __LINUX_RWLOCK_RT_H
0004
0005 #ifndef __LINUX_SPINLOCK_RT_H
0006 #error Do not #include directly. Use <linux/spinlock.h>.
0007 #endif
0008
0009 #ifdef CONFIG_DEBUG_LOCK_ALLOC
0010 extern void __rt_rwlock_init(rwlock_t *rwlock, const char *name,
0011                  struct lock_class_key *key);
0012 #else
0013 static inline void __rt_rwlock_init(rwlock_t *rwlock, char *name,
0014                     struct lock_class_key *key)
0015 {
0016 }
0017 #endif
0018
0019 #define rwlock_init(rwl)                \
0020 do {                            \
0021     static struct lock_class_key __key;     \
0022                             \
0023     init_rwbase_rt(&(rwl)->rwbase);         \
0024     __rt_rwlock_init(rwl, #rwl, &__key);        \
0025 } while (0)
0026
0027 extern void rt_read_lock(rwlock_t *rwlock);
0028 extern int rt_read_trylock(rwlock_t *rwlock);
0029 extern void rt_read_unlock(rwlock_t *rwlock);
0030 extern void rt_write_lock(rwlock_t *rwlock);
0031 extern void rt_write_lock_nested(rwlock_t *rwlock, int subclass);
0032 extern int rt_write_trylock(rwlock_t *rwlock);
0033 extern void rt_write_unlock(rwlock_t *rwlock);
0034
0035 static __always_inline void read_lock(rwlock_t *rwlock)
0036 {
0037     rt_read_lock(rwlock);
0038 }
0039
0040 static __always_inline void read_lock_bh(rwlock_t *rwlock)
0041 {
0042     local_bh_disable();
0043     rt_read_lock(rwlock);
0044 }
0045
0046 static __always_inline void read_lock_irq(rwlock_t *rwlock)
0047 {
0048     rt_read_lock(rwlock);
0049 }
0050
0051 #define read_lock_irqsave(lock, flags)          \
0052     do {                        \
0053         typecheck(unsigned long, flags);    \
0054         rt_read_lock(lock);         \
0055         flags = 0;              \
0056     } while (0)
0057
0058 #define read_trylock(lock)  __cond_lock(lock, rt_read_trylock(lock))
0059
0060 static __always_inline void read_unlock(rwlock_t *rwlock)
0061 {
0062     rt_read_unlock(rwlock);
0063 }
0064
0065 static __always_inline void read_unlock_bh(rwlock_t *rwlock)
0066 {
0067     rt_read_unlock(rwlock);
0068     local_bh_enable();
0069 }
0070
0071 static __always_inline void read_unlock_irq(rwlock_t *rwlock)
0072 {
0073     rt_read_unlock(rwlock);
0074 }
0075
0076 static __always_inline void read_unlock_irqrestore(rwlock_t *rwlock,
0077                            unsigned long flags)
0078 {
0079     rt_read_unlock(rwlock);
0080 }
0081
0082 static __always_inline void write_lock(rwlock_t *rwlock)
0083 {
0084     rt_write_lock(rwlock);
0085 }
0086
0087 #ifdef CONFIG_DEBUG_LOCK_ALLOC
0088 static __always_inline void write_lock_nested(rwlock_t *rwlock, int subclass)
0089 {
0090     rt_write_lock_nested(rwlock, subclass);
0091 }
0092 #else
0093 #define write_lock_nested(lock, subclass)   rt_write_lock(((void)(subclass), (lock)))
0094 #endif
0095
0096 static __always_inline void write_lock_bh(rwlock_t *rwlock)
0097 {
0098     local_bh_disable();
0099     rt_write_lock(rwlock);
0100 }
0101
0102 static __always_inline void write_lock_irq(rwlock_t *rwlock)
0103 {
0104     rt_write_lock(rwlock);
0105 }
0106
0107 #define write_lock_irqsave(lock, flags)         \
0108     do {                        \
0109         typecheck(unsigned long, flags);    \
0110         rt_write_lock(lock);            \
0111         flags = 0;              \
0112     } while (0)
0113
0114 #define write_trylock(lock) __cond_lock(lock, rt_write_trylock(lock))
0115
0116 #define write_trylock_irqsave(lock, flags)      \
0117 ({                          \
0118     int __locked;                   \
0119                             \
0120     typecheck(unsigned long, flags);        \
0121     flags = 0;                  \
0122     __locked = write_trylock(lock);         \
0123     __locked;                   \
0124 })
0125
0126 static __always_inline void write_unlock(rwlock_t *rwlock)
0127 {
0128     rt_write_unlock(rwlock);
0129 }
0130
0131 static __always_inline void write_unlock_bh(rwlock_t *rwlock)
0132 {
0133     rt_write_unlock(rwlock);
0134     local_bh_enable();
0135 }
0136
0137 static __always_inline void write_unlock_irq(rwlock_t *rwlock)
0138 {
0139     rt_write_unlock(rwlock);
0140 }
0141
0142 static __always_inline void write_unlock_irqrestore(rwlock_t *rwlock,
0143                             unsigned long flags)
0144 {
0145     rt_write_unlock(rwlock);
0146 }
0147
0148 #define rwlock_is_contended(lock)       (((void)(lock), 0))
0149
0150 #endif /* __LINUX_RWLOCK_RT_H */