blob: 3e18379dfa6f349ba48edfc6615232af41ccfb99 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef __LINUX_SPINLOCK_H
2#define __LINUX_SPINLOCK_H
3
4/*
Ingo Molnarfb1c8f92005-09-10 00:25:56 -07005 * include/linux/spinlock.h - generic spinlock/rwlock declarations
6 *
7 * here's the role of the various spinlock/rwlock related include files:
8 *
9 * on SMP builds:
10 *
Thomas Gleixnerfb3a6bb2009-12-03 20:01:19 +010011 * asm/spinlock_types.h: contains the arch_spinlock_t/arch_rwlock_t and the
Ingo Molnarfb1c8f92005-09-10 00:25:56 -070012 * initializers
13 *
14 * linux/spinlock_types.h:
15 * defines the generic type and initializers
16 *
Thomas Gleixner0199c4e2009-12-02 20:01:25 +010017 * asm/spinlock.h: contains the arch_spin_*()/etc. lowlevel
Ingo Molnarfb1c8f92005-09-10 00:25:56 -070018 * implementations, mostly inline assembly code
19 *
20 * (also included on UP-debug builds:)
21 *
22 * linux/spinlock_api_smp.h:
23 * contains the prototypes for the _spin_*() APIs.
24 *
25 * linux/spinlock.h: builds the final spin_*() APIs.
26 *
27 * on UP builds:
28 *
29 * linux/spinlock_type_up.h:
30 * contains the generic, simplified UP spinlock type.
31 * (which is an empty structure on non-debug builds)
32 *
33 * linux/spinlock_types.h:
34 * defines the generic type and initializers
35 *
36 * linux/spinlock_up.h:
Thomas Gleixner0199c4e2009-12-02 20:01:25 +010037 * contains the arch_spin_*()/etc. version of UP
Ingo Molnarfb1c8f92005-09-10 00:25:56 -070038 * builds. (which are NOPs on non-debug, non-preempt
39 * builds)
40 *
41 * (included on UP-non-debug builds:)
42 *
43 * linux/spinlock_api_up.h:
44 * builds the _spin_*() APIs.
45 *
46 * linux/spinlock.h: builds the final spin_*() APIs.
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 */
48
Steven Rostedt3f3078912008-07-25 01:45:25 -070049#include <linux/typecheck.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <linux/preempt.h>
51#include <linux/linkage.h>
52#include <linux/compiler.h>
David Howellsdf9ee292010-10-07 14:08:55 +010053#include <linux/irqflags.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#include <linux/thread_info.h>
55#include <linux/kernel.h>
56#include <linux/stringify.h>
Andrew Morton676dcb82006-12-06 20:31:30 -080057#include <linux/bottom_half.h>
David Howells96f951e2012-03-28 18:30:03 +010058#include <asm/barrier.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
61/*
62 * Must define these before including other files, inline functions need them
63 */
Denys Vlasenko75ddb0e2010-02-20 01:03:48 +010064#define LOCK_SECTION_NAME ".text..lock."KBUILD_BASENAME
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66#define LOCK_SECTION_START(extra) \
67 ".subsection 1\n\t" \
68 extra \
69 ".ifndef " LOCK_SECTION_NAME "\n\t" \
70 LOCK_SECTION_NAME ":\n\t" \
71 ".endif\n"
72
73#define LOCK_SECTION_END \
74 ".previous\n\t"
75
Harvey Harrisonec701582008-02-08 04:19:55 -080076#define __lockfunc __attribute__((section(".spinlock.text")))
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78/*
Thomas Gleixnerfb3a6bb2009-12-03 20:01:19 +010079 * Pull the arch_spinlock_t and arch_rwlock_t definitions:
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 */
Ingo Molnarfb1c8f92005-09-10 00:25:56 -070081#include <linux/spinlock_types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
Ingo Molnarfb1c8f92005-09-10 00:25:56 -070083/*
Lucas De Marchi25985ed2011-03-30 22:57:33 -030084 * Pull the arch_spin*() functions/declarations (UP-nondebug doesn't need them):
Ingo Molnarfb1c8f92005-09-10 00:25:56 -070085 */
Ingo Molnar8a25d5d2006-07-03 00:24:54 -070086#ifdef CONFIG_SMP
Ingo Molnarfb1c8f92005-09-10 00:25:56 -070087# include <asm/spinlock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070088#else
Ingo Molnarfb1c8f92005-09-10 00:25:56 -070089# include <linux/spinlock_up.h>
90#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Ingo Molnar8a25d5d2006-07-03 00:24:54 -070092#ifdef CONFIG_DEBUG_SPINLOCK
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +010093 extern void __raw_spin_lock_init(raw_spinlock_t *lock, const char *name,
94 struct lock_class_key *key);
95# define raw_spin_lock_init(lock) \
Ingo Molnar8a25d5d2006-07-03 00:24:54 -070096do { \
97 static struct lock_class_key __key; \
98 \
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +010099 __raw_spin_lock_init((lock), #lock, &__key); \
Ingo Molnar8a25d5d2006-07-03 00:24:54 -0700100} while (0)
101
102#else
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100103# define raw_spin_lock_init(lock) \
104 do { *(lock) = __RAW_SPIN_LOCK_UNLOCKED(lock); } while (0)
Ingo Molnar8a25d5d2006-07-03 00:24:54 -0700105#endif
106
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100107#define raw_spin_is_locked(lock) arch_spin_is_locked(&(lock)->raw_lock)
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700108
Nick Piggin95c354f2008-01-30 13:31:20 +0100109#ifdef CONFIG_GENERIC_LOCKBREAK
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100110#define raw_spin_is_contended(lock) ((lock)->break_lock)
Nick Piggin95c354f2008-01-30 13:31:20 +0100111#else
Kyle McMartina5ef7ca2009-02-08 17:39:58 -0500112
Thomas Gleixner0199c4e2009-12-02 20:01:25 +0100113#ifdef arch_spin_is_contended
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100114#define raw_spin_is_contended(lock) arch_spin_is_contended(&(lock)->raw_lock)
Kyle McMartina5ef7ca2009-02-08 17:39:58 -0500115#else
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100116#define raw_spin_is_contended(lock) (((void)(lock), 0))
Thomas Gleixner0199c4e2009-12-02 20:01:25 +0100117#endif /*arch_spin_is_contended*/
Nick Piggin95c354f2008-01-30 13:31:20 +0100118#endif
119
Oleg Nesterove0acd0a2013-08-12 18:14:00 +0200120/*
121 * Despite its name it doesn't necessarily has to be a full barrier.
122 * It should only guarantee that a STORE before the critical section
123 * can not be reordered with a LOAD inside this section.
124 * spin_lock() is the one-way barrier, this LOAD can not escape out
125 * of the region. So the default implementation simply ensures that
126 * a STORE can not move into the critical section, smp_wmb() should
127 * serialize it with another STORE done by spin_lock().
128 */
129#ifndef smp_mb__before_spinlock
130#define smp_mb__before_spinlock() smp_wmb()
Jiri Olsaad462762009-07-08 12:10:31 +0000131#endif
132
Paul E. McKenney01352fb2013-12-11 13:59:08 -0800133/*
134 * Place this after a lock-acquisition primitive to guarantee that
135 * an UNLOCK+LOCK pair act as a full barrier. This guarantee applies
136 * if the UNLOCK and LOCK are executed by the same CPU or if the
137 * UNLOCK and LOCK operate on the same lock variable.
138 */
139#ifndef smp_mb__after_unlock_lock
140#define smp_mb__after_unlock_lock() do { } while (0)
141#endif
142
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700143/**
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100144 * raw_spin_unlock_wait - wait until the spinlock gets unlocked
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700145 * @lock: the spinlock in question.
146 */
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100147#define raw_spin_unlock_wait(lock) arch_spin_unlock_wait(&(lock)->raw_lock)
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149#ifdef CONFIG_DEBUG_SPINLOCK
Luca Barbierib97c4bc2010-03-11 14:08:45 -0800150 extern void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock);
Thomas Gleixner9828ea92009-12-03 20:55:53 +0100151#define do_raw_spin_lock_flags(lock, flags) do_raw_spin_lock(lock)
152 extern int do_raw_spin_trylock(raw_spinlock_t *lock);
Luca Barbierib97c4bc2010-03-11 14:08:45 -0800153 extern void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154#else
Luca Barbierib97c4bc2010-03-11 14:08:45 -0800155static inline void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock)
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100156{
Luca Barbierib97c4bc2010-03-11 14:08:45 -0800157 __acquire(lock);
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100158 arch_spin_lock(&lock->raw_lock);
159}
160
161static inline void
Luca Barbierib97c4bc2010-03-11 14:08:45 -0800162do_raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long *flags) __acquires(lock)
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100163{
Luca Barbierib97c4bc2010-03-11 14:08:45 -0800164 __acquire(lock);
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100165 arch_spin_lock_flags(&lock->raw_lock, *flags);
166}
167
Thomas Gleixner9828ea92009-12-03 20:55:53 +0100168static inline int do_raw_spin_trylock(raw_spinlock_t *lock)
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100169{
170 return arch_spin_trylock(&(lock)->raw_lock);
171}
172
Luca Barbierib97c4bc2010-03-11 14:08:45 -0800173static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock)
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100174{
175 arch_spin_unlock(&lock->raw_lock);
Luca Barbierib97c4bc2010-03-11 14:08:45 -0800176 __release(lock);
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100177}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178#endif
179
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180/*
Thomas Gleixneref12f102009-11-07 23:04:15 +0100181 * Define the various spin_lock methods. Note we define these
182 * regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The
183 * various methods are defined as nops in the case they are not
184 * required.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 */
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100186#define raw_spin_trylock(lock) __cond_lock(lock, _raw_spin_trylock(lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100188#define raw_spin_lock(lock) _raw_spin_lock(lock)
Ingo Molnar8a25d5d2006-07-03 00:24:54 -0700189
190#ifdef CONFIG_DEBUG_LOCK_ALLOC
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100191# define raw_spin_lock_nested(lock, subclass) \
192 _raw_spin_lock_nested(lock, subclass)
Thomas Graf113948d2015-01-02 23:00:19 +0100193# define raw_spin_lock_bh_nested(lock, subclass) \
194 _raw_spin_lock_bh_nested(lock, subclass)
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100195
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100196# define raw_spin_lock_nest_lock(lock, nest_lock) \
Peter Zijlstrab7d39af2008-08-11 09:30:24 +0200197 do { \
198 typecheck(struct lockdep_map *, &(nest_lock)->dep_map);\
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100199 _raw_spin_lock_nest_lock(lock, &(nest_lock)->dep_map); \
Peter Zijlstrab7d39af2008-08-11 09:30:24 +0200200 } while (0)
Ingo Molnar8a25d5d2006-07-03 00:24:54 -0700201#else
Bart Van Assche49992012014-08-08 12:35:36 +0200202/*
203 * Always evaluate the 'subclass' argument to avoid that the compiler
204 * warns about set-but-not-used variables when building with
205 * CONFIG_DEBUG_LOCK_ALLOC=n and with W=1.
206 */
207# define raw_spin_lock_nested(lock, subclass) \
208 _raw_spin_lock(((void)(subclass), (lock)))
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100209# define raw_spin_lock_nest_lock(lock, nest_lock) _raw_spin_lock(lock)
Thomas Graf113948d2015-01-02 23:00:19 +0100210# define raw_spin_lock_bh_nested(lock, subclass) _raw_spin_lock_bh(lock)
Ingo Molnar8a25d5d2006-07-03 00:24:54 -0700211#endif
212
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700213#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
Linus Torvaldsb8e6ec82006-11-26 16:27:17 -0800214
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100215#define raw_spin_lock_irqsave(lock, flags) \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700216 do { \
217 typecheck(unsigned long, flags); \
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100218 flags = _raw_spin_lock_irqsave(lock); \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700219 } while (0)
Arjan van de Vencfd3ef22006-11-25 11:09:37 -0800220
221#ifdef CONFIG_DEBUG_LOCK_ALLOC
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100222#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700223 do { \
224 typecheck(unsigned long, flags); \
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100225 flags = _raw_spin_lock_irqsave_nested(lock, subclass); \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700226 } while (0)
Arjan van de Vencfd3ef22006-11-25 11:09:37 -0800227#else
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100228#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700229 do { \
230 typecheck(unsigned long, flags); \
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100231 flags = _raw_spin_lock_irqsave(lock); \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700232 } while (0)
Arjan van de Vencfd3ef22006-11-25 11:09:37 -0800233#endif
234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235#else
Linus Torvaldsb8e6ec82006-11-26 16:27:17 -0800236
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100237#define raw_spin_lock_irqsave(lock, flags) \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700238 do { \
239 typecheck(unsigned long, flags); \
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100240 _raw_spin_lock_irqsave(lock, flags); \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700241 } while (0)
Thomas Gleixneref12f102009-11-07 23:04:15 +0100242
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100243#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
244 raw_spin_lock_irqsave(lock, flags)
Arjan van de Vencfd3ef22006-11-25 11:09:37 -0800245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246#endif
247
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100248#define raw_spin_lock_irq(lock) _raw_spin_lock_irq(lock)
249#define raw_spin_lock_bh(lock) _raw_spin_lock_bh(lock)
250#define raw_spin_unlock(lock) _raw_spin_unlock(lock)
251#define raw_spin_unlock_irq(lock) _raw_spin_unlock_irq(lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100253#define raw_spin_unlock_irqrestore(lock, flags) \
254 do { \
255 typecheck(unsigned long, flags); \
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100256 _raw_spin_unlock_irqrestore(lock, flags); \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700257 } while (0)
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100258#define raw_spin_unlock_bh(lock) _raw_spin_unlock_bh(lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100260#define raw_spin_trylock_bh(lock) \
261 __cond_lock(lock, _raw_spin_trylock_bh(lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100263#define raw_spin_trylock_irq(lock) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264({ \
265 local_irq_disable(); \
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100266 raw_spin_trylock(lock) ? \
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700267 1 : ({ local_irq_enable(); 0; }); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268})
269
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100270#define raw_spin_trylock_irqsave(lock, flags) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271({ \
272 local_irq_save(flags); \
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100273 raw_spin_trylock(lock) ? \
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700274 1 : ({ local_irq_restore(flags); 0; }); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275})
276
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100277/**
278 * raw_spin_can_lock - would raw_spin_trylock() succeed?
279 * @lock: the spinlock in question.
280 */
281#define raw_spin_can_lock(lock) (!raw_spin_is_locked(lock))
282
283/* Include rwlock functions */
284#include <linux/rwlock.h>
285
286/*
287 * Pull the _spin_*()/_read_*()/_write_*() functions/declarations:
288 */
289#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
290# include <linux/spinlock_api_smp.h>
291#else
292# include <linux/spinlock_api_up.h>
293#endif
294
295/*
296 * Map the spin_lock functions to the raw variants for PREEMPT_RT=n
297 */
298
299static inline raw_spinlock_t *spinlock_check(spinlock_t *lock)
300{
301 return &lock->rlock;
302}
303
304#define spin_lock_init(_lock) \
305do { \
306 spinlock_check(_lock); \
307 raw_spin_lock_init(&(_lock)->rlock); \
308} while (0)
309
310static inline void spin_lock(spinlock_t *lock)
311{
312 raw_spin_lock(&lock->rlock);
313}
314
315static inline void spin_lock_bh(spinlock_t *lock)
316{
317 raw_spin_lock_bh(&lock->rlock);
318}
319
320static inline int spin_trylock(spinlock_t *lock)
321{
322 return raw_spin_trylock(&lock->rlock);
323}
324
325#define spin_lock_nested(lock, subclass) \
326do { \
327 raw_spin_lock_nested(spinlock_check(lock), subclass); \
328} while (0)
329
Thomas Graf113948d2015-01-02 23:00:19 +0100330#define spin_lock_bh_nested(lock, subclass) \
331do { \
332 raw_spin_lock_bh_nested(spinlock_check(lock), subclass);\
333} while (0)
334
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100335#define spin_lock_nest_lock(lock, nest_lock) \
336do { \
337 raw_spin_lock_nest_lock(spinlock_check(lock), nest_lock); \
338} while (0)
339
340static inline void spin_lock_irq(spinlock_t *lock)
341{
342 raw_spin_lock_irq(&lock->rlock);
343}
344
345#define spin_lock_irqsave(lock, flags) \
346do { \
347 raw_spin_lock_irqsave(spinlock_check(lock), flags); \
348} while (0)
349
350#define spin_lock_irqsave_nested(lock, flags, subclass) \
351do { \
352 raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
353} while (0)
354
355static inline void spin_unlock(spinlock_t *lock)
356{
357 raw_spin_unlock(&lock->rlock);
358}
359
360static inline void spin_unlock_bh(spinlock_t *lock)
361{
362 raw_spin_unlock_bh(&lock->rlock);
363}
364
365static inline void spin_unlock_irq(spinlock_t *lock)
366{
367 raw_spin_unlock_irq(&lock->rlock);
368}
369
370static inline void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
371{
372 raw_spin_unlock_irqrestore(&lock->rlock, flags);
373}
374
375static inline int spin_trylock_bh(spinlock_t *lock)
376{
377 return raw_spin_trylock_bh(&lock->rlock);
378}
379
380static inline int spin_trylock_irq(spinlock_t *lock)
381{
382 return raw_spin_trylock_irq(&lock->rlock);
383}
384
385#define spin_trylock_irqsave(lock, flags) \
386({ \
387 raw_spin_trylock_irqsave(spinlock_check(lock), flags); \
388})
389
390static inline void spin_unlock_wait(spinlock_t *lock)
391{
392 raw_spin_unlock_wait(&lock->rlock);
393}
394
395static inline int spin_is_locked(spinlock_t *lock)
396{
397 return raw_spin_is_locked(&lock->rlock);
398}
399
400static inline int spin_is_contended(spinlock_t *lock)
401{
402 return raw_spin_is_contended(&lock->rlock);
403}
404
405static inline int spin_can_lock(spinlock_t *lock)
406{
407 return raw_spin_can_lock(&lock->rlock);
408}
409
Paul Gortmaker4ebc1b42012-01-20 18:20:37 -0500410#define assert_spin_locked(lock) assert_raw_spin_locked(&(lock)->rlock)
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100411
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700412/*
413 * Pull the atomic_t declaration:
414 * (asm-mips/atomic.h needs above definitions)
415 */
Arun Sharma600634972011-07-26 16:09:06 -0700416#include <linux/atomic.h>
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700417/**
418 * atomic_dec_and_lock - lock on reaching reference count zero
419 * @atomic: the atomic counter
420 * @lock: the spinlock in question
J. Bruce Fieldsdc07e722008-04-07 15:59:05 -0400421 *
422 * Decrements @atomic by 1. If the result is 0, returns true and locks
423 * @lock. Returns false for all other cases.
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700424 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700426#define atomic_dec_and_lock(atomic, lock) \
Josh Triplettdcc8e552006-09-29 02:01:03 -0700427 __cond_lock(lock, _atomic_dec_and_lock(atomic, lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429#endif /* __LINUX_SPINLOCK_H */