1 // SPDX-License-Identifier: GPL-2.0-only 2 #ifndef __LINUX_RWLOCK_RT_H 3 #define __LINUX_RWLOCK_RT_H 4 5 #ifndef __LINUX_SPINLOCK_RT_H 6 #error Do not #include directly. Use <linux/spinlock.h>. 7 #endif 8 9 #ifdef CONFIG_DEBUG_LOCK_ALLOC 10 extern void __rt_rwlock_init(rwlock_t *rwlock, const char *name, 11 struct lock_class_key *key); 12 #else 13 static inline void __rt_rwlock_init(rwlock_t *rwlock, char *name, 14 struct lock_class_key *key) 15 { 16 } 17 #endif 18 19 #define rwlock_init(rwl) \ 20 do { \ 21 static struct lock_class_key __key; \ 22 \ 23 init_rwbase_rt(&(rwl)->rwbase); \ 24 __rt_rwlock_init(rwl, #rwl, &__key); \ 25 } while (0) 26 27 extern void rt_read_lock(rwlock_t *rwlock); 28 extern int rt_read_trylock(rwlock_t *rwlock); 29 extern void rt_read_unlock(rwlock_t *rwlock); 30 extern void rt_write_lock(rwlock_t *rwlock); 31 extern int rt_write_trylock(rwlock_t *rwlock); 32 extern void rt_write_unlock(rwlock_t *rwlock); 33 34 static __always_inline void read_lock(rwlock_t *rwlock) 35 { 36 rt_read_lock(rwlock); 37 } 38 39 static __always_inline void read_lock_bh(rwlock_t *rwlock) 40 { 41 local_bh_disable(); 42 rt_read_lock(rwlock); 43 } 44 45 static __always_inline void read_lock_irq(rwlock_t *rwlock) 46 { 47 rt_read_lock(rwlock); 48 } 49 50 #define read_lock_irqsave(lock, flags) \ 51 do { \ 52 typecheck(unsigned long, flags); \ 53 rt_read_lock(lock); \ 54 flags = 0; \ 55 } while (0) 56 57 #define read_trylock(lock) __cond_lock(lock, rt_read_trylock(lock)) 58 59 static __always_inline void read_unlock(rwlock_t *rwlock) 60 { 61 rt_read_unlock(rwlock); 62 } 63 64 static __always_inline void read_unlock_bh(rwlock_t *rwlock) 65 { 66 rt_read_unlock(rwlock); 67 local_bh_enable(); 68 } 69 70 static __always_inline void read_unlock_irq(rwlock_t *rwlock) 71 { 72 rt_read_unlock(rwlock); 73 } 74 75 static __always_inline void read_unlock_irqrestore(rwlock_t *rwlock, 76 unsigned long flags) 77 { 78 rt_read_unlock(rwlock); 79 } 80 81 static __always_inline void write_lock(rwlock_t *rwlock) 82 { 83 rt_write_lock(rwlock); 84 } 85 86 static __always_inline void write_lock_bh(rwlock_t *rwlock) 87 { 88 local_bh_disable(); 89 rt_write_lock(rwlock); 90 } 91 92 static __always_inline void write_lock_irq(rwlock_t *rwlock) 93 { 94 rt_write_lock(rwlock); 95 } 96 97 #define write_lock_irqsave(lock, flags) \ 98 do { \ 99 typecheck(unsigned long, flags); \ 100 rt_write_lock(lock); \ 101 flags = 0; \ 102 } while (0) 103 104 #define write_trylock(lock) __cond_lock(lock, rt_write_trylock(lock)) 105 106 #define write_trylock_irqsave(lock, flags) \ 107 ({ \ 108 int __locked; \ 109 \ 110 typecheck(unsigned long, flags); \ 111 flags = 0; \ 112 __locked = write_trylock(lock); \ 113 __locked; \ 114 }) 115 116 static __always_inline void write_unlock(rwlock_t *rwlock) 117 { 118 rt_write_unlock(rwlock); 119 } 120 121 static __always_inline void write_unlock_bh(rwlock_t *rwlock) 122 { 123 rt_write_unlock(rwlock); 124 local_bh_enable(); 125 } 126 127 static __always_inline void write_unlock_irq(rwlock_t *rwlock) 128 { 129 rt_write_unlock(rwlock); 130 } 131 132 static __always_inline void write_unlock_irqrestore(rwlock_t *rwlock, 133 unsigned long flags) 134 { 135 rt_write_unlock(rwlock); 136 } 137 138 #define rwlock_is_contended(lock) (((void)(lock), 0)) 139 140 #endif /* __LINUX_RWLOCK_RT_H */ 141