1 #ifndef __LINUX_RWLOCK_API_SMP_H
2 #define __LINUX_RWLOCK_API_SMP_H
3
4 #ifndef __LINUX_SPINLOCK_API_SMP_H
5 # error "Please do not include this file directly."
6 #endif
7
8 /*
9 * include/linux/rwlock_api_smp.h
10 *
11 * spinlock API declarations on SMP (and debug)
12 * (implemented in kernel/spinlock.c)
13 *
14 * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
15 * Released under the General Public License (GPL).
16 */
17
18 void __lockfunc _raw_read_lock(rwlock_t *lock) __acquires_shared(lock);
19 void __lockfunc _raw_write_lock(rwlock_t *lock) __acquires(lock);
20 void __lockfunc _raw_write_lock_nested(rwlock_t *lock, int subclass) __acquires(lock);
21 void __lockfunc _raw_read_lock_bh(rwlock_t *lock) __acquires_shared(lock);
22 void __lockfunc _raw_write_lock_bh(rwlock_t *lock) __acquires(lock);
23 void __lockfunc _raw_read_lock_irq(rwlock_t *lock) __acquires_shared(lock);
24 void __lockfunc _raw_write_lock_irq(rwlock_t *lock) __acquires(lock);
25 unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)
26 __acquires_shared(lock);
27 unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)
28 __acquires(lock);
29 int __lockfunc _raw_read_trylock(rwlock_t *lock) __cond_acquires_shared(true, lock);
30 int __lockfunc _raw_write_trylock(rwlock_t *lock) __cond_acquires(true, lock);
31 void __lockfunc _raw_read_unlock(rwlock_t *lock) __releases_shared(lock);
32 void __lockfunc _raw_write_unlock(rwlock_t *lock) __releases(lock);
33 void __lockfunc _raw_read_unlock_bh(rwlock_t *lock) __releases_shared(lock);
34 void __lockfunc _raw_write_unlock_bh(rwlock_t *lock) __releases(lock);
35 void __lockfunc _raw_read_unlock_irq(rwlock_t *lock) __releases_shared(lock);
36 void __lockfunc _raw_write_unlock_irq(rwlock_t *lock) __releases(lock);
37 void __lockfunc
38 _raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
39 __releases_shared(lock);
40 void __lockfunc
41 _raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
42 __releases(lock);
43
44 #ifdef CONFIG_INLINE_READ_LOCK
45 #define _raw_read_lock(lock) __raw_read_lock(lock)
46 #endif
47
48 #ifdef CONFIG_INLINE_WRITE_LOCK
49 #define _raw_write_lock(lock) __raw_write_lock(lock)
50 #endif
51
52 #ifdef CONFIG_INLINE_READ_LOCK_BH
53 #define _raw_read_lock_bh(lock) __raw_read_lock_bh(lock)
54 #endif
55
56 #ifdef CONFIG_INLINE_WRITE_LOCK_BH
57 #define _raw_write_lock_bh(lock) __raw_write_lock_bh(lock)
58 #endif
59
60 #ifdef CONFIG_INLINE_READ_LOCK_IRQ
61 #define _raw_read_lock_irq(lock) __raw_read_lock_irq(lock)
62 #endif
63
64 #ifdef CONFIG_INLINE_WRITE_LOCK_IRQ
65 #define _raw_write_lock_irq(lock) __raw_write_lock_irq(lock)
66 #endif
67
68 #ifdef CONFIG_INLINE_READ_LOCK_IRQSAVE
69 #define _raw_read_lock_irqsave(lock) __raw_read_lock_irqsave(lock)
70 #endif
71
72 #ifdef CONFIG_INLINE_WRITE_LOCK_IRQSAVE
73 #define _raw_write_lock_irqsave(lock) __raw_write_lock_irqsave(lock)
74 #endif
75
76 #ifdef CONFIG_INLINE_READ_TRYLOCK
77 #define _raw_read_trylock(lock) __raw_read_trylock(lock)
78 #endif
79
80 #ifdef CONFIG_INLINE_WRITE_TRYLOCK
81 #define _raw_write_trylock(lock) __raw_write_trylock(lock)
82 #endif
83
84 #ifdef CONFIG_INLINE_READ_UNLOCK
85 #define _raw_read_unlock(lock) __raw_read_unlock(lock)
86 #endif
87
88 #ifdef CONFIG_INLINE_WRITE_UNLOCK
89 #define _raw_write_unlock(lock) __raw_write_unlock(lock)
90 #endif
91
92 #ifdef CONFIG_INLINE_READ_UNLOCK_BH
93 #define _raw_read_unlock_bh(lock) __raw_read_unlock_bh(lock)
94 #endif
95
96 #ifdef CONFIG_INLINE_WRITE_UNLOCK_BH
97 #define _raw_write_unlock_bh(lock) __raw_write_unlock_bh(lock)
98 #endif
99
100 #ifdef CONFIG_INLINE_READ_UNLOCK_IRQ
101 #define _raw_read_unlock_irq(lock) __raw_read_unlock_irq(lock)
102 #endif
103
104 #ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQ
105 #define _raw_write_unlock_irq(lock) __raw_write_unlock_irq(lock)
106 #endif
107
108 #ifdef CONFIG_INLINE_READ_UNLOCK_IRQRESTORE
109 #define _raw_read_unlock_irqrestore(lock, flags) \
110 __raw_read_unlock_irqrestore(lock, flags)
111 #endif
112
113 #ifdef CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE
114 #define _raw_write_unlock_irqrestore(lock, flags) \
115 __raw_write_unlock_irqrestore(lock, flags)
116 #endif
117
__raw_read_trylock(rwlock_t * lock)118 static inline int __raw_read_trylock(rwlock_t *lock)
119 __cond_acquires_shared(true, lock)
120 {
121 preempt_disable();
122 if (do_raw_read_trylock(lock)) {
123 rwlock_acquire_read(&lock->dep_map, 0, 1, _RET_IP_);
124 return 1;
125 }
126 preempt_enable();
127 return 0;
128 }
129
__raw_write_trylock(rwlock_t * lock)130 static inline int __raw_write_trylock(rwlock_t *lock)
131 __cond_acquires(true, lock)
132 {
133 preempt_disable();
134 if (do_raw_write_trylock(lock)) {
135 rwlock_acquire(&lock->dep_map, 0, 1, _RET_IP_);
136 return 1;
137 }
138 preempt_enable();
139 return 0;
140 }
141
_raw_write_trylock_irqsave(rwlock_t * lock,unsigned long * flags)142 static inline bool _raw_write_trylock_irqsave(rwlock_t *lock, unsigned long *flags)
143 __cond_acquires(true, lock) __no_context_analysis
144 {
145 local_irq_save(*flags);
146 if (_raw_write_trylock(lock))
147 return true;
148 local_irq_restore(*flags);
149 return false;
150 }
151
152 /*
153 * If lockdep is enabled then we use the non-preemption spin-ops
154 * even on CONFIG_PREEMPT, because lockdep assumes that interrupts are
155 * not re-enabled during lock-acquire (which the preempt-spin-ops do):
156 */
157 #if !defined(CONFIG_GENERIC_LOCKBREAK) || defined(CONFIG_DEBUG_LOCK_ALLOC)
158
__raw_read_lock(rwlock_t * lock)159 static inline void __raw_read_lock(rwlock_t *lock)
160 __acquires_shared(lock) __no_context_analysis
161 {
162 preempt_disable();
163 rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
164 LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
165 }
166
__raw_read_lock_irqsave(rwlock_t * lock)167 static inline unsigned long __raw_read_lock_irqsave(rwlock_t *lock)
168 __acquires_shared(lock) __no_context_analysis
169 {
170 unsigned long flags;
171
172 local_irq_save(flags);
173 preempt_disable();
174 rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
175 LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
176 return flags;
177 }
178
__raw_read_lock_irq(rwlock_t * lock)179 static inline void __raw_read_lock_irq(rwlock_t *lock)
180 __acquires_shared(lock) __no_context_analysis
181 {
182 local_irq_disable();
183 preempt_disable();
184 rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
185 LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
186 }
187
__raw_read_lock_bh(rwlock_t * lock)188 static inline void __raw_read_lock_bh(rwlock_t *lock)
189 __acquires_shared(lock) __no_context_analysis
190 {
191 __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
192 rwlock_acquire_read(&lock->dep_map, 0, 0, _RET_IP_);
193 LOCK_CONTENDED(lock, do_raw_read_trylock, do_raw_read_lock);
194 }
195
__raw_write_lock_irqsave(rwlock_t * lock)196 static inline unsigned long __raw_write_lock_irqsave(rwlock_t *lock)
197 __acquires(lock) __no_context_analysis
198 {
199 unsigned long flags;
200
201 local_irq_save(flags);
202 preempt_disable();
203 rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
204 LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
205 return flags;
206 }
207
__raw_write_lock_irq(rwlock_t * lock)208 static inline void __raw_write_lock_irq(rwlock_t *lock)
209 __acquires(lock) __no_context_analysis
210 {
211 local_irq_disable();
212 preempt_disable();
213 rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
214 LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
215 }
216
__raw_write_lock_bh(rwlock_t * lock)217 static inline void __raw_write_lock_bh(rwlock_t *lock)
218 __acquires(lock) __no_context_analysis
219 {
220 __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
221 rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
222 LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
223 }
224
__raw_write_lock(rwlock_t * lock)225 static inline void __raw_write_lock(rwlock_t *lock)
226 __acquires(lock) __no_context_analysis
227 {
228 preempt_disable();
229 rwlock_acquire(&lock->dep_map, 0, 0, _RET_IP_);
230 LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
231 }
232
__raw_write_lock_nested(rwlock_t * lock,int subclass)233 static inline void __raw_write_lock_nested(rwlock_t *lock, int subclass)
234 __acquires(lock) __no_context_analysis
235 {
236 preempt_disable();
237 rwlock_acquire(&lock->dep_map, subclass, 0, _RET_IP_);
238 LOCK_CONTENDED(lock, do_raw_write_trylock, do_raw_write_lock);
239 }
240
241 #endif /* !CONFIG_GENERIC_LOCKBREAK || CONFIG_DEBUG_LOCK_ALLOC */
242
__raw_write_unlock(rwlock_t * lock)243 static inline void __raw_write_unlock(rwlock_t *lock)
244 __releases(lock)
245 {
246 rwlock_release(&lock->dep_map, _RET_IP_);
247 do_raw_write_unlock(lock);
248 preempt_enable();
249 }
250
__raw_read_unlock(rwlock_t * lock)251 static inline void __raw_read_unlock(rwlock_t *lock)
252 __releases_shared(lock)
253 {
254 rwlock_release(&lock->dep_map, _RET_IP_);
255 do_raw_read_unlock(lock);
256 preempt_enable();
257 }
258
259 static inline void
__raw_read_unlock_irqrestore(rwlock_t * lock,unsigned long flags)260 __raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
261 __releases_shared(lock)
262 {
263 rwlock_release(&lock->dep_map, _RET_IP_);
264 do_raw_read_unlock(lock);
265 local_irq_restore(flags);
266 preempt_enable();
267 }
268
__raw_read_unlock_irq(rwlock_t * lock)269 static inline void __raw_read_unlock_irq(rwlock_t *lock)
270 __releases_shared(lock)
271 {
272 rwlock_release(&lock->dep_map, _RET_IP_);
273 do_raw_read_unlock(lock);
274 local_irq_enable();
275 preempt_enable();
276 }
277
__raw_read_unlock_bh(rwlock_t * lock)278 static inline void __raw_read_unlock_bh(rwlock_t *lock)
279 __releases_shared(lock)
280 {
281 rwlock_release(&lock->dep_map, _RET_IP_);
282 do_raw_read_unlock(lock);
283 __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
284 }
285
__raw_write_unlock_irqrestore(rwlock_t * lock,unsigned long flags)286 static inline void __raw_write_unlock_irqrestore(rwlock_t *lock,
287 unsigned long flags)
288 __releases(lock)
289 {
290 rwlock_release(&lock->dep_map, _RET_IP_);
291 do_raw_write_unlock(lock);
292 local_irq_restore(flags);
293 preempt_enable();
294 }
295
__raw_write_unlock_irq(rwlock_t * lock)296 static inline void __raw_write_unlock_irq(rwlock_t *lock)
297 __releases(lock)
298 {
299 rwlock_release(&lock->dep_map, _RET_IP_);
300 do_raw_write_unlock(lock);
301 local_irq_enable();
302 preempt_enable();
303 }
304
__raw_write_unlock_bh(rwlock_t * lock)305 static inline void __raw_write_unlock_bh(rwlock_t *lock)
306 __releases(lock)
307 {
308 rwlock_release(&lock->dep_map, _RET_IP_);
309 do_raw_write_unlock(lock);
310 __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
311 }
312
313 #endif /* __LINUX_RWLOCK_API_SMP_H */
314