1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __LINUX_SPINLOCK_H
3 #define __LINUX_SPINLOCK_H
4 #define __LINUX_INSIDE_SPINLOCK_H
5
6 /*
7 * include/linux/spinlock.h - generic spinlock/rwlock declarations
8 *
9 * here's the role of the various spinlock/rwlock related include files:
10 *
11 * on SMP builds:
12 *
13 * asm/spinlock_types.h: contains the arch_spinlock_t/arch_rwlock_t and the
14 * initializers
15 *
16 * linux/spinlock_types_raw:
17 * The raw types and initializers
18 * linux/spinlock_types.h:
19 * defines the generic type and initializers
20 *
21 * asm/spinlock.h: contains the arch_spin_*()/etc. lowlevel
22 * implementations, mostly inline assembly code
23 *
24 * (also included on UP-debug builds:)
25 *
26 * linux/spinlock_api_smp.h:
27 * contains the prototypes for the _spin_*() APIs.
28 *
29 * linux/spinlock.h: builds the final spin_*() APIs.
30 *
31 * on UP builds:
32 *
33 * linux/spinlock_type_up.h:
34 * contains the generic, simplified UP spinlock type.
35 * (which is an empty structure on non-debug builds)
36 *
37 * linux/spinlock_types_raw:
38 * The raw RT types and initializers
39 * linux/spinlock_types.h:
40 * defines the generic type and initializers
41 *
42 * linux/spinlock_up.h:
43 * contains the arch_spin_*()/etc. version of UP
44 * builds. (which are NOPs on non-debug, non-preempt
45 * builds)
46 *
47 * (included on UP-non-debug builds:)
48 *
49 * linux/spinlock_api_up.h:
50 * builds the _spin_*() APIs.
51 *
52 * linux/spinlock.h: builds the final spin_*() APIs.
53 */
54
55 #include <linux/typecheck.h>
56 #include <linux/preempt.h>
57 #include <linux/linkage.h>
58 #include <linux/compiler.h>
59 #include <linux/irqflags.h>
60 #include <linux/interrupt_rc.h>
61 #include <linux/thread_info.h>
62 #include <linux/stringify.h>
63 #include <linux/bottom_half.h>
64 #include <linux/lockdep.h>
65 #include <linux/cleanup.h>
66 #include <asm/barrier.h>
67 #include <asm/mmiowb.h>
68
69
70 /*
71 * Must define these before including other files, inline functions need them
72 */
73 #define LOCK_SECTION_NAME ".text..lock."KBUILD_BASENAME
74
75 #define LOCK_SECTION_START(extra) \
76 ".subsection 1\n\t" \
77 extra \
78 ".ifndef " LOCK_SECTION_NAME "\n\t" \
79 LOCK_SECTION_NAME ":\n\t" \
80 ".endif\n"
81
82 #define LOCK_SECTION_END \
83 ".previous\n\t"
84
85 #define __lockfunc __section(".spinlock.text")
86
87 /*
88 * Pull the arch_spinlock_t and arch_rwlock_t definitions:
89 */
90 #include <linux/spinlock_types.h>
91
92 /*
93 * Pull the arch_spin*() functions/declarations (UP-nondebug doesn't need them):
94 */
95 #ifdef CONFIG_SMP
96 # include <asm/spinlock.h>
97 #else
98 # include <linux/spinlock_up.h>
99 #endif
100
101 #ifdef CONFIG_DEBUG_SPINLOCK
102 extern void __raw_spin_lock_init(raw_spinlock_t *lock, const char *name,
103 struct lock_class_key *key, short inner);
104
105 # define raw_spin_lock_init(lock) \
106 do { \
107 static struct lock_class_key __key; \
108 \
109 __raw_spin_lock_init((lock), #lock, &__key, LD_WAIT_SPIN); \
110 } while (0)
111
112 #else
113 # define raw_spin_lock_init(lock) \
114 do { *(lock) = __RAW_SPIN_LOCK_UNLOCKED(lock); } while (0)
115 #endif
116
117 #define raw_spin_is_locked(lock) arch_spin_is_locked(&(lock)->raw_lock)
118
119 #ifdef arch_spin_is_contended
120 #define raw_spin_is_contended(lock) arch_spin_is_contended(&(lock)->raw_lock)
121 #else
122 #define raw_spin_is_contended(lock) (((void)(lock), 0))
123 #endif /*arch_spin_is_contended*/
124
125 /*
126 * smp_mb__after_spinlock() provides the equivalent of a full memory barrier
127 * between program-order earlier lock acquisitions and program-order later
128 * memory accesses.
129 *
130 * This guarantees that the following two properties hold:
131 *
132 * 1) Given the snippet:
133 *
134 * { X = 0; Y = 0; }
135 *
136 * CPU0 CPU1
137 *
138 * WRITE_ONCE(X, 1); WRITE_ONCE(Y, 1);
139 * spin_lock(S); smp_mb();
140 * smp_mb__after_spinlock(); r1 = READ_ONCE(X);
141 * r0 = READ_ONCE(Y);
142 * spin_unlock(S);
143 *
144 * it is forbidden that CPU0 does not observe CPU1's store to Y (r0 = 0)
145 * and CPU1 does not observe CPU0's store to X (r1 = 0); see the comments
146 * preceding the call to smp_mb__after_spinlock() in __schedule() and in
147 * try_to_wake_up().
148 *
149 * 2) Given the snippet:
150 *
151 * { X = 0; Y = 0; }
152 *
153 * CPU0 CPU1 CPU2
154 *
155 * spin_lock(S); spin_lock(S); r1 = READ_ONCE(Y);
156 * WRITE_ONCE(X, 1); smp_mb__after_spinlock(); smp_rmb();
157 * spin_unlock(S); r0 = READ_ONCE(X); r2 = READ_ONCE(X);
158 * WRITE_ONCE(Y, 1);
159 * spin_unlock(S);
160 *
161 * it is forbidden that CPU0's critical section executes before CPU1's
162 * critical section (r0 = 1), CPU2 observes CPU1's store to Y (r1 = 1)
163 * and CPU2 does not observe CPU0's store to X (r2 = 0); see the comments
164 * preceding the calls to smp_rmb() in try_to_wake_up() for similar
165 * snippets but "projected" onto two CPUs.
166 *
167 * Property (2) upgrades the lock to an RCsc lock.
168 *
169 * Since most load-store architectures implement ACQUIRE with an smp_mb() after
170 * the LL/SC loop, they need no further barriers. Similarly all our TSO
171 * architectures imply an smp_mb() for each atomic instruction and equally don't
172 * need more.
173 *
174 * Architectures that can implement ACQUIRE better need to take care.
175 */
176 #ifndef smp_mb__after_spinlock
177 #define smp_mb__after_spinlock() kcsan_mb()
178 #endif
179
180 #ifdef CONFIG_DEBUG_SPINLOCK
181 extern void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock);
182 extern int do_raw_spin_trylock(raw_spinlock_t *lock) __cond_acquires(true, lock);
183 extern void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock);
184 #else
do_raw_spin_lock(raw_spinlock_t * lock)185 static inline void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock)
186 {
187 __acquire(lock);
188 arch_spin_lock(&lock->raw_lock);
189 mmiowb_spin_lock();
190 }
191
do_raw_spin_trylock(raw_spinlock_t * lock)192 static inline int do_raw_spin_trylock(raw_spinlock_t *lock)
193 __cond_acquires(true, lock)
194 {
195 int ret = arch_spin_trylock(&(lock)->raw_lock);
196
197 if (ret)
198 mmiowb_spin_lock();
199
200 return ret;
201 }
202
do_raw_spin_unlock(raw_spinlock_t * lock)203 static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock)
204 {
205 mmiowb_spin_unlock();
206 arch_spin_unlock(&lock->raw_lock);
207 __release(lock);
208 }
209 #endif
210
211 /*
212 * Define the various spin_lock methods. Note we define these
213 * regardless of whether CONFIG_SMP or CONFIG_PREEMPTION are set. The
214 * various methods are defined as nops in the case they are not
215 * required.
216 */
217 #define raw_spin_trylock(lock) _raw_spin_trylock(lock)
218
219 #define raw_spin_lock(lock) _raw_spin_lock(lock)
220
221 #ifdef CONFIG_DEBUG_LOCK_ALLOC
222 # define raw_spin_lock_nested(lock, subclass) \
223 _raw_spin_lock_nested(lock, subclass)
224
225 # define raw_spin_lock_nest_lock(lock, nest_lock) \
226 do { \
227 typecheck(struct lockdep_map *, &(nest_lock)->dep_map);\
228 _raw_spin_lock_nest_lock(lock, &(nest_lock)->dep_map); \
229 } while (0)
230 #else
231 /*
232 * Always evaluate the 'subclass' argument to avoid that the compiler
233 * warns about set-but-not-used variables when building with
234 * CONFIG_DEBUG_LOCK_ALLOC=n and with W=1.
235 */
236 # define raw_spin_lock_nested(lock, subclass) \
237 _raw_spin_lock(((void)(subclass), (lock)))
238 # define raw_spin_lock_nest_lock(lock, nest_lock) _raw_spin_lock(lock)
239 #endif
240
241 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
242
243 #define raw_spin_lock_irqsave(lock, flags) \
244 do { \
245 typecheck(unsigned long, flags); \
246 flags = _raw_spin_lock_irqsave(lock); \
247 } while (0)
248
249 #ifdef CONFIG_DEBUG_LOCK_ALLOC
250 #define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
251 do { \
252 typecheck(unsigned long, flags); \
253 flags = _raw_spin_lock_irqsave_nested(lock, subclass); \
254 } while (0)
255 #else
256 #define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
257 do { \
258 typecheck(unsigned long, flags); \
259 flags = _raw_spin_lock_irqsave(lock); \
260 } while (0)
261 #endif
262
263 #else
264
265 #define raw_spin_lock_irqsave(lock, flags) \
266 do { \
267 typecheck(unsigned long, flags); \
268 _raw_spin_lock_irqsave(lock, flags); \
269 } while (0)
270
271 #define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
272 raw_spin_lock_irqsave(lock, flags)
273
274 #endif
275
276 #define raw_spin_lock_irq(lock) _raw_spin_lock_irq(lock)
277 #define raw_spin_lock_irq_disable(lock) _raw_spin_lock_irq_disable(lock)
278 #define raw_spin_lock_bh(lock) _raw_spin_lock_bh(lock)
279 #define raw_spin_unlock(lock) _raw_spin_unlock(lock)
280 #define raw_spin_unlock_irq(lock) _raw_spin_unlock_irq(lock)
281 #define raw_spin_unlock_irq_enable(lock) _raw_spin_unlock_irq_enable(lock)
282
283 #define raw_spin_unlock_irqrestore(lock, flags) \
284 do { \
285 typecheck(unsigned long, flags); \
286 _raw_spin_unlock_irqrestore(lock, flags); \
287 } while (0)
288 #define raw_spin_unlock_bh(lock) _raw_spin_unlock_bh(lock)
289
290 #define raw_spin_trylock_bh(lock) _raw_spin_trylock_bh(lock)
291
292 #define raw_spin_trylock_irq(lock) _raw_spin_trylock_irq(lock)
293
294 #define raw_spin_trylock_irqsave(lock, flags) _raw_spin_trylock_irqsave(lock, &(flags))
295
296 #define raw_spin_trylock_irq_disable(lock) _raw_spin_trylock_irq_disable(lock)
297
298 #ifndef CONFIG_PREEMPT_RT
299 /* Include rwlock functions for !RT */
300 #include <linux/rwlock.h>
301 #endif
302
303 /*
304 * Pull the _spin_*()/_read_*()/_write_*() functions/declarations:
305 */
306 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
307 # include <linux/spinlock_api_smp.h>
308 #else
309 # include <linux/spinlock_api_up.h>
310 #endif
311
312 /* Non PREEMPT_RT kernel, map to raw spinlocks: */
313 #ifndef CONFIG_PREEMPT_RT
314
315 /*
316 * Map the spin_lock functions to the raw variants for PREEMPT_RT=n
317 */
318
spinlock_check(spinlock_t * lock)319 static __always_inline raw_spinlock_t *spinlock_check(spinlock_t *lock)
320 {
321 return &lock->rlock;
322 }
323
324 #ifdef CONFIG_DEBUG_SPINLOCK
325
326 # define spin_lock_init(lock) \
327 do { \
328 static struct lock_class_key __key; \
329 \
330 __raw_spin_lock_init(spinlock_check(lock), \
331 #lock, &__key, LD_WAIT_CONFIG); \
332 } while (0)
333
334 #else
335
336 # define spin_lock_init(_lock) \
337 do { \
338 spinlock_check(_lock); \
339 *(_lock) = __SPIN_LOCK_UNLOCKED(_lock); \
340 } while (0)
341
342 #endif
343
spin_lock(spinlock_t * lock)344 static __always_inline void spin_lock(spinlock_t *lock)
345 __acquires(lock) __no_context_analysis
346 {
347 raw_spin_lock(&lock->rlock);
348 }
349
spin_lock_bh(spinlock_t * lock)350 static __always_inline void spin_lock_bh(spinlock_t *lock)
351 __acquires(lock) __no_context_analysis
352 {
353 raw_spin_lock_bh(&lock->rlock);
354 }
355
spin_trylock(spinlock_t * lock)356 static __always_inline int spin_trylock(spinlock_t *lock)
357 __cond_acquires(true, lock) __no_context_analysis
358 {
359 return raw_spin_trylock(&lock->rlock);
360 }
361
362 #define spin_lock_nested(lock, subclass) \
363 do { \
364 raw_spin_lock_nested(spinlock_check(lock), subclass); \
365 __release(spinlock_check(lock)); __acquire(lock); \
366 } while (0)
367
368 #define spin_lock_nest_lock(lock, nest_lock) \
369 do { \
370 raw_spin_lock_nest_lock(spinlock_check(lock), nest_lock); \
371 __release(spinlock_check(lock)); __acquire(lock); \
372 } while (0)
373
spin_lock_irq(spinlock_t * lock)374 static __always_inline void spin_lock_irq(spinlock_t *lock)
375 __acquires(lock) __no_context_analysis
376 {
377 raw_spin_lock_irq(&lock->rlock);
378 }
379
spin_lock_irq_disable(spinlock_t * lock)380 static __always_inline void spin_lock_irq_disable(spinlock_t *lock)
381 __acquires(lock) __no_context_analysis
382 {
383 raw_spin_lock_irq_disable(&lock->rlock);
384 }
385
386 #define spin_lock_irqsave(lock, flags) \
387 do { \
388 raw_spin_lock_irqsave(spinlock_check(lock), flags); \
389 __release(spinlock_check(lock)); __acquire(lock); \
390 } while (0)
391
392 #define spin_lock_irqsave_nested(lock, flags, subclass) \
393 do { \
394 raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
395 __release(spinlock_check(lock)); __acquire(lock); \
396 } while (0)
397
spin_unlock(spinlock_t * lock)398 static __always_inline void spin_unlock(spinlock_t *lock)
399 __releases(lock) __no_context_analysis
400 {
401 raw_spin_unlock(&lock->rlock);
402 }
403
spin_unlock_bh(spinlock_t * lock)404 static __always_inline void spin_unlock_bh(spinlock_t *lock)
405 __releases(lock) __no_context_analysis
406 {
407 raw_spin_unlock_bh(&lock->rlock);
408 }
409
spin_unlock_irq(spinlock_t * lock)410 static __always_inline void spin_unlock_irq(spinlock_t *lock)
411 __releases(lock) __no_context_analysis
412 {
413 raw_spin_unlock_irq(&lock->rlock);
414 }
415
spin_unlock_irq_enable(spinlock_t * lock)416 static __always_inline void spin_unlock_irq_enable(spinlock_t *lock)
417 __releases(lock) __no_context_analysis
418 {
419 raw_spin_unlock_irq_enable(&lock->rlock);
420 }
421
spin_unlock_irqrestore(spinlock_t * lock,unsigned long flags)422 static __always_inline void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
423 __releases(lock) __no_context_analysis
424 {
425 raw_spin_unlock_irqrestore(&lock->rlock, flags);
426 }
427
spin_trylock_bh(spinlock_t * lock)428 static __always_inline int spin_trylock_bh(spinlock_t *lock)
429 __cond_acquires(true, lock) __no_context_analysis
430 {
431 return raw_spin_trylock_bh(&lock->rlock);
432 }
433
spin_trylock_irq(spinlock_t * lock)434 static __always_inline int spin_trylock_irq(spinlock_t *lock)
435 __cond_acquires(true, lock) __no_context_analysis
436 {
437 return raw_spin_trylock_irq(&lock->rlock);
438 }
439
_spin_trylock_irqsave(spinlock_t * lock,unsigned long * flags)440 static __always_inline bool _spin_trylock_irqsave(spinlock_t *lock, unsigned long *flags)
441 __cond_acquires(true, lock) __no_context_analysis
442 {
443 return raw_spin_trylock_irqsave(spinlock_check(lock), *flags);
444 }
445 #define spin_trylock_irqsave(lock, flags) _spin_trylock_irqsave(lock, &(flags))
446
spin_trylock_irq_disable(spinlock_t * lock)447 static __always_inline int spin_trylock_irq_disable(spinlock_t *lock)
448 __cond_acquires(true, lock) __no_context_analysis
449 {
450 return raw_spin_trylock_irq_disable(&lock->rlock);
451 }
452
453 /**
454 * spin_is_locked() - Check whether a spinlock is locked.
455 * @lock: Pointer to the spinlock.
456 *
457 * This function is NOT required to provide any memory ordering
458 * guarantees; it could be used for debugging purposes or, when
459 * additional synchronization is needed, accompanied with other
460 * constructs (memory barriers) enforcing the synchronization.
461 *
462 * Returns: 1 if @lock is locked, 0 otherwise.
463 *
464 * Note that the function only tells you that the spinlock is
465 * seen to be locked, not that it is locked on your CPU.
466 *
467 * Further, on CONFIG_SMP=n builds with CONFIG_DEBUG_SPINLOCK=n,
468 * the return value is always 0 (see include/linux/spinlock_up.h).
469 * Therefore you should not rely heavily on the return value.
470 */
spin_is_locked(spinlock_t * lock)471 static __always_inline int spin_is_locked(spinlock_t *lock)
472 {
473 return raw_spin_is_locked(&lock->rlock);
474 }
475
spin_is_contended(spinlock_t * lock)476 static __always_inline int spin_is_contended(spinlock_t *lock)
477 {
478 return raw_spin_is_contended(&lock->rlock);
479 }
480
481 #define assert_spin_locked(lock) assert_raw_spin_locked(&(lock)->rlock)
482
483 #else /* !CONFIG_PREEMPT_RT */
484 # include <linux/spinlock_rt.h>
485 #endif /* CONFIG_PREEMPT_RT */
486
487 /*
488 * Does a critical section need to be broken due to another
489 * task waiting?: (technically does not depend on CONFIG_PREEMPTION,
490 * but a general need for low latency)
491 */
spin_needbreak(spinlock_t * lock)492 static inline int spin_needbreak(spinlock_t *lock)
493 {
494 if (!preempt_model_preemptible())
495 return 0;
496
497 return spin_is_contended(lock);
498 }
499
500 /*
501 * Check if a rwlock is contended.
502 * Returns non-zero if there is another task waiting on the rwlock.
503 * Returns zero if the lock is not contended or the system / underlying
504 * rwlock implementation does not support contention detection.
505 * Technically does not depend on CONFIG_PREEMPTION, but a general need
506 * for low latency.
507 */
rwlock_needbreak(rwlock_t * lock)508 static inline int rwlock_needbreak(rwlock_t *lock)
509 {
510 if (!preempt_model_preemptible())
511 return 0;
512
513 return rwlock_is_contended(lock);
514 }
515
516 /*
517 * Pull the atomic_t declaration:
518 * (asm-mips/atomic.h needs above definitions)
519 */
520 #include <linux/atomic.h>
521 /**
522 * atomic_dec_and_lock - lock on reaching reference count zero
523 * @atomic: the atomic counter
524 * @lock: the spinlock in question
525 *
526 * Decrements @atomic by 1. If the result is 0, returns true and locks
527 * @lock. Returns false for all other cases.
528 */
529 extern int atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock) __cond_acquires(true, lock);
530
531 extern int _atomic_dec_and_lock_irqsave(atomic_t *atomic, spinlock_t *lock,
532 unsigned long *flags) __cond_acquires(true, lock);
533 #define atomic_dec_and_lock_irqsave(atomic, lock, flags) _atomic_dec_and_lock_irqsave(atomic, lock, &(flags))
534
535 extern int atomic_dec_and_raw_lock(atomic_t *atomic, raw_spinlock_t *lock) __cond_acquires(true, lock);
536
537 extern int _atomic_dec_and_raw_lock_irqsave(atomic_t *atomic, raw_spinlock_t *lock,
538 unsigned long *flags) __cond_acquires(true, lock);
539 #define atomic_dec_and_raw_lock_irqsave(atomic, lock, flags) _atomic_dec_and_raw_lock_irqsave(atomic, lock, &(flags))
540
541 int __alloc_bucket_spinlocks(spinlock_t **locks, unsigned int *lock_mask,
542 size_t max_size, unsigned int cpu_mult,
543 gfp_t gfp, const char *name,
544 struct lock_class_key *key);
545
546 #define alloc_bucket_spinlocks(locks, lock_mask, max_size, cpu_mult, gfp) \
547 ({ \
548 static struct lock_class_key key; \
549 int ret; \
550 \
551 ret = __alloc_bucket_spinlocks(locks, lock_mask, max_size, \
552 cpu_mult, gfp, #locks, &key); \
553 ret; \
554 })
555
556 void free_bucket_spinlocks(spinlock_t *locks);
557
558 DEFINE_LOCK_GUARD_1(raw_spinlock, raw_spinlock_t,
559 raw_spin_lock(_T->lock),
560 raw_spin_unlock(_T->lock))
561 DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
562 #define class_raw_spinlock_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock, _T)
563
564 DEFINE_LOCK_GUARD_1_COND(raw_spinlock, _try, raw_spin_trylock(_T->lock))
565 DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_try, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
566 #define class_raw_spinlock_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_try, _T)
567
568 DEFINE_LOCK_GUARD_1(raw_spinlock_nested, raw_spinlock_t,
569 raw_spin_lock_nested(_T->lock, SINGLE_DEPTH_NESTING),
570 raw_spin_unlock(_T->lock))
571 DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_nested, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
572 #define class_raw_spinlock_nested_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_nested, _T)
573
574 DEFINE_LOCK_GUARD_1(raw_spinlock_irq, raw_spinlock_t,
575 raw_spin_lock_irq(_T->lock),
576 raw_spin_unlock_irq(_T->lock))
577 DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_irq, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
578 #define class_raw_spinlock_irq_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_irq, _T)
579
580 DEFINE_LOCK_GUARD_1_COND(raw_spinlock_irq, _try, raw_spin_trylock_irq(_T->lock))
581 DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_irq_try, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
582 #define class_raw_spinlock_irq_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_irq_try, _T)
583
584 DEFINE_LOCK_GUARD_1(raw_spinlock_bh, raw_spinlock_t,
585 raw_spin_lock_bh(_T->lock),
586 raw_spin_unlock_bh(_T->lock))
587 DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_bh, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
588 #define class_raw_spinlock_bh_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_bh, _T)
589
590 DEFINE_LOCK_GUARD_1_COND(raw_spinlock_bh, _try, raw_spin_trylock_bh(_T->lock))
591 DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_bh_try, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
592 #define class_raw_spinlock_bh_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_bh_try, _T)
593
594 DEFINE_LOCK_GUARD_1(raw_spinlock_irqsave, raw_spinlock_t,
595 raw_spin_lock_irqsave(_T->lock, _T->flags),
596 raw_spin_unlock_irqrestore(_T->lock, _T->flags),
597 unsigned long flags)
598 DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_irqsave, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
599 #define class_raw_spinlock_irqsave_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_irqsave, _T)
600
601 DEFINE_LOCK_GUARD_1_COND(raw_spinlock_irqsave, _try,
602 raw_spin_trylock_irqsave(_T->lock, _T->flags))
603 DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_irqsave_try, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
604 #define class_raw_spinlock_irqsave_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_irqsave_try, _T)
605
606 DEFINE_LOCK_GUARD_1(raw_spinlock_init, raw_spinlock_t, raw_spin_lock_init(_T->lock), /* */)
607 DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_init, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
608 #define class_raw_spinlock_init_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_init, _T)
609
610 DEFINE_LOCK_GUARD_1(spinlock, spinlock_t,
611 spin_lock(_T->lock),
612 spin_unlock(_T->lock))
613 DECLARE_LOCK_GUARD_1_ATTRS(spinlock, __acquires(_T), __releases(*(spinlock_t **)_T))
614 #define class_spinlock_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock, _T)
615
616 DEFINE_LOCK_GUARD_1_COND(spinlock, _try, spin_trylock(_T->lock))
617 DECLARE_LOCK_GUARD_1_ATTRS(spinlock_try, __acquires(_T), __releases(*(spinlock_t **)_T))
618 #define class_spinlock_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_try, _T)
619
620 DEFINE_LOCK_GUARD_1(spinlock_irq, spinlock_t,
621 spin_lock_irq(_T->lock),
622 spin_unlock_irq(_T->lock))
623 DECLARE_LOCK_GUARD_1_ATTRS(spinlock_irq, __acquires(_T), __releases(*(spinlock_t **)_T))
624 #define class_spinlock_irq_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_irq, _T)
625
626 DEFINE_LOCK_GUARD_1_COND(spinlock_irq, _try,
627 spin_trylock_irq(_T->lock))
628 DECLARE_LOCK_GUARD_1_ATTRS(spinlock_irq_try, __acquires(_T), __releases(*(spinlock_t **)_T))
629 #define class_spinlock_irq_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_irq_try, _T)
630
631 DEFINE_LOCK_GUARD_1(spinlock_bh, spinlock_t,
632 spin_lock_bh(_T->lock),
633 spin_unlock_bh(_T->lock))
634 DECLARE_LOCK_GUARD_1_ATTRS(spinlock_bh, __acquires(_T), __releases(*(spinlock_t **)_T))
635 #define class_spinlock_bh_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_bh, _T)
636
637 DEFINE_LOCK_GUARD_1_COND(spinlock_bh, _try,
638 spin_trylock_bh(_T->lock))
639 DECLARE_LOCK_GUARD_1_ATTRS(spinlock_bh_try, __acquires(_T), __releases(*(spinlock_t **)_T))
640 #define class_spinlock_bh_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_bh_try, _T)
641
642 DEFINE_LOCK_GUARD_1(spinlock_irqsave, spinlock_t,
643 spin_lock_irqsave(_T->lock, _T->flags),
644 spin_unlock_irqrestore(_T->lock, _T->flags),
645 unsigned long flags)
646 DECLARE_LOCK_GUARD_1_ATTRS(spinlock_irqsave, __acquires(_T), __releases(*(spinlock_t **)_T))
647 #define class_spinlock_irqsave_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_irqsave, _T)
648
649 DEFINE_LOCK_GUARD_1_COND(spinlock_irqsave, _try,
650 spin_trylock_irqsave(_T->lock, _T->flags))
651 DECLARE_LOCK_GUARD_1_ATTRS(spinlock_irqsave_try, __acquires(_T), __releases(*(spinlock_t **)_T))
652 #define class_spinlock_irqsave_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_irqsave_try, _T)
653
654 DEFINE_LOCK_GUARD_1(spinlock_init, spinlock_t, spin_lock_init(_T->lock), /* */)
655 DECLARE_LOCK_GUARD_1_ATTRS(spinlock_init, __acquires(_T), __releases(*(spinlock_t **)_T))
656 #define class_spinlock_init_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_init, _T)
657
658 DEFINE_LOCK_GUARD_1(read_lock, rwlock_t,
659 read_lock(_T->lock),
660 read_unlock(_T->lock))
661 DECLARE_LOCK_GUARD_1_ATTRS(read_lock, __acquires(_T), __releases(*(rwlock_t **)_T))
662 #define class_read_lock_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(read_lock, _T)
663
664 DEFINE_LOCK_GUARD_1(read_lock_irq, rwlock_t,
665 read_lock_irq(_T->lock),
666 read_unlock_irq(_T->lock))
667 DECLARE_LOCK_GUARD_1_ATTRS(read_lock_irq, __acquires(_T), __releases(*(rwlock_t **)_T))
668 #define class_read_lock_irq_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(read_lock_irq, _T)
669
670 DEFINE_LOCK_GUARD_1(read_lock_irqsave, rwlock_t,
671 read_lock_irqsave(_T->lock, _T->flags),
672 read_unlock_irqrestore(_T->lock, _T->flags),
673 unsigned long flags)
674 DECLARE_LOCK_GUARD_1_ATTRS(read_lock_irqsave, __acquires(_T), __releases(*(rwlock_t **)_T))
675 #define class_read_lock_irqsave_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(read_lock_irqsave, _T)
676
677 DEFINE_LOCK_GUARD_1(write_lock, rwlock_t,
678 write_lock(_T->lock),
679 write_unlock(_T->lock))
680 DECLARE_LOCK_GUARD_1_ATTRS(write_lock, __acquires(_T), __releases(*(rwlock_t **)_T))
681 #define class_write_lock_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(write_lock, _T)
682
683 DEFINE_LOCK_GUARD_1(write_lock_irq, rwlock_t,
684 write_lock_irq(_T->lock),
685 write_unlock_irq(_T->lock))
686 DECLARE_LOCK_GUARD_1_ATTRS(write_lock_irq, __acquires(_T), __releases(*(rwlock_t **)_T))
687 #define class_write_lock_irq_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(write_lock_irq, _T)
688
689 DEFINE_LOCK_GUARD_1(write_lock_irqsave, rwlock_t,
690 write_lock_irqsave(_T->lock, _T->flags),
691 write_unlock_irqrestore(_T->lock, _T->flags),
692 unsigned long flags)
693 DECLARE_LOCK_GUARD_1_ATTRS(write_lock_irqsave, __acquires(_T), __releases(*(rwlock_t **)_T))
694 #define class_write_lock_irqsave_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(write_lock_irqsave, _T)
695
696 DEFINE_LOCK_GUARD_1(rwlock_init, rwlock_t, rwlock_init(_T->lock), /* */)
697 DECLARE_LOCK_GUARD_1_ATTRS(rwlock_init, __acquires(_T), __releases(*(rwlock_t **)_T))
698 #define class_rwlock_init_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(rwlock_init, _T)
699
700 #undef __LINUX_INSIDE_SPINLOCK_H
701 #endif /* __LINUX_SPINLOCK_H */
702