1 // SPDX-License-Identifier: GPL-2.0-only 2 #ifndef __LINUX_SPINLOCK_RT_H 3 #define __LINUX_SPINLOCK_RT_H 4 5 #ifndef __LINUX_INSIDE_SPINLOCK_H 6 #error Do not include directly. Use spinlock.h 7 #endif 8 9 #ifdef CONFIG_DEBUG_LOCK_ALLOC 10 extern void __rt_spin_lock_init(spinlock_t *lock, const char *name, 11 struct lock_class_key *key, bool percpu); 12 #else 13 static inline void __rt_spin_lock_init(spinlock_t *lock, const char *name, 14 struct lock_class_key *key, bool percpu) 15 { 16 } 17 #endif 18 19 #define spin_lock_init(slock) \ 20 do { \ 21 static struct lock_class_key __key; \ 22 \ 23 rt_mutex_base_init(&(slock)->lock); \ 24 __rt_spin_lock_init(slock, #slock, &__key, false); \ 25 } while (0) 26 27 #define local_spin_lock_init(slock) \ 28 do { \ 29 static struct lock_class_key __key; \ 30 \ 31 rt_mutex_base_init(&(slock)->lock); \ 32 __rt_spin_lock_init(slock, #slock, &__key, true); \ 33 } while (0) 34 35 extern void rt_spin_lock(spinlock_t *lock); 36 extern void rt_spin_lock_nested(spinlock_t *lock, int subclass); 37 extern void rt_spin_lock_nest_lock(spinlock_t *lock, struct lockdep_map *nest_lock); 38 extern void rt_spin_unlock(spinlock_t *lock); 39 extern void rt_spin_lock_unlock(spinlock_t *lock); 40 extern int rt_spin_trylock_bh(spinlock_t *lock); 41 extern int rt_spin_trylock(spinlock_t *lock); 42 43 static __always_inline void spin_lock(spinlock_t *lock) 44 { 45 rt_spin_lock(lock); 46 } 47 48 #ifdef CONFIG_LOCKDEP 49 # define __spin_lock_nested(lock, subclass) \ 50 rt_spin_lock_nested(lock, subclass) 51 52 # define __spin_lock_nest_lock(lock, nest_lock) \ 53 do { \ 54 typecheck(struct lockdep_map *, &(nest_lock)->dep_map); \ 55 rt_spin_lock_nest_lock(lock, &(nest_lock)->dep_map); \ 56 } while (0) 57 # define __spin_lock_irqsave_nested(lock, flags, subclass) \ 58 do { \ 59 typecheck(unsigned long, flags); \ 60 flags = 0; \ 61 __spin_lock_nested(lock, subclass); \ 62 } while (0) 63 64 #else 65 /* 66 * Always evaluate the 'subclass' argument to avoid that the compiler 67 * warns about set-but-not-used variables when building with 68 * CONFIG_DEBUG_LOCK_ALLOC=n and with W=1. 69 */ 70 # define __spin_lock_nested(lock, subclass) spin_lock(((void)(subclass), (lock))) 71 # define __spin_lock_nest_lock(lock, subclass) spin_lock(((void)(subclass), (lock))) 72 # define __spin_lock_irqsave_nested(lock, flags, subclass) \ 73 spin_lock_irqsave(((void)(subclass), (lock)), flags) 74 #endif 75 76 #define spin_lock_nested(lock, subclass) \ 77 __spin_lock_nested(lock, subclass) 78 79 #define spin_lock_nest_lock(lock, nest_lock) \ 80 __spin_lock_nest_lock(lock, nest_lock) 81 82 #define spin_lock_irqsave_nested(lock, flags, subclass) \ 83 __spin_lock_irqsave_nested(lock, flags, subclass) 84 85 static __always_inline void spin_lock_bh(spinlock_t *lock) 86 { 87 /* Investigate: Drop bh when blocking ? */ 88 local_bh_disable(); 89 rt_spin_lock(lock); 90 } 91 92 static __always_inline void spin_lock_irq(spinlock_t *lock) 93 { 94 rt_spin_lock(lock); 95 } 96 97 #define spin_lock_irqsave(lock, flags) \ 98 do { \ 99 typecheck(unsigned long, flags); \ 100 flags = 0; \ 101 spin_lock(lock); \ 102 } while (0) 103 104 static __always_inline void spin_unlock(spinlock_t *lock) 105 { 106 rt_spin_unlock(lock); 107 } 108 109 static __always_inline void spin_unlock_bh(spinlock_t *lock) 110 { 111 rt_spin_unlock(lock); 112 local_bh_enable(); 113 } 114 115 static __always_inline void spin_unlock_irq(spinlock_t *lock) 116 { 117 rt_spin_unlock(lock); 118 } 119 120 static __always_inline void spin_unlock_irqrestore(spinlock_t *lock, 121 unsigned long flags) 122 { 123 rt_spin_unlock(lock); 124 } 125 126 #define spin_trylock(lock) \ 127 __cond_lock(lock, rt_spin_trylock(lock)) 128 129 #define spin_trylock_bh(lock) \ 130 __cond_lock(lock, rt_spin_trylock_bh(lock)) 131 132 #define spin_trylock_irq(lock) \ 133 __cond_lock(lock, rt_spin_trylock(lock)) 134 135 #define __spin_trylock_irqsave(lock, flags) \ 136 ({ \ 137 int __locked; \ 138 \ 139 typecheck(unsigned long, flags); \ 140 flags = 0; \ 141 __locked = spin_trylock(lock); \ 142 __locked; \ 143 }) 144 145 #define spin_trylock_irqsave(lock, flags) \ 146 __cond_lock(lock, __spin_trylock_irqsave(lock, flags)) 147 148 #define spin_is_contended(lock) (((void)(lock), 0)) 149 150 static inline int spin_is_locked(spinlock_t *lock) 151 { 152 return rt_mutex_base_is_locked(&lock->lock); 153 } 154 155 #define assert_spin_locked(lock) BUG_ON(!spin_is_locked(lock)) 156 157 #include <linux/rwlock_rt.h> 158 159 #endif 160