blob: 262ba4ef9a8ebacb24e7f7326a05bbcb2f666c69 [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)
193
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100194# define raw_spin_lock_nest_lock(lock, nest_lock) \
Peter Zijlstrab7d39af2008-08-11 09:30:24 +0200195 do { \
196 typecheck(struct lockdep_map *, &(nest_lock)->dep_map);\
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100197 _raw_spin_lock_nest_lock(lock, &(nest_lock)->dep_map); \
Peter Zijlstrab7d39af2008-08-11 09:30:24 +0200198 } while (0)
Ingo Molnar8a25d5d2006-07-03 00:24:54 -0700199#else
Bart Van Assche49992012014-08-08 12:35:36 +0200200/*
201 * Always evaluate the 'subclass' argument to avoid that the compiler
202 * warns about set-but-not-used variables when building with
203 * CONFIG_DEBUG_LOCK_ALLOC=n and with W=1.
204 */
205# define raw_spin_lock_nested(lock, subclass) \
206 _raw_spin_lock(((void)(subclass), (lock)))
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100207# define raw_spin_lock_nest_lock(lock, nest_lock) _raw_spin_lock(lock)
Ingo Molnar8a25d5d2006-07-03 00:24:54 -0700208#endif
209
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700210#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
Linus Torvaldsb8e6ec82006-11-26 16:27:17 -0800211
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100212#define raw_spin_lock_irqsave(lock, flags) \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700213 do { \
214 typecheck(unsigned long, flags); \
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100215 flags = _raw_spin_lock_irqsave(lock); \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700216 } while (0)
Arjan van de Vencfd3ef22006-11-25 11:09:37 -0800217
218#ifdef CONFIG_DEBUG_LOCK_ALLOC
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100219#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700220 do { \
221 typecheck(unsigned long, flags); \
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100222 flags = _raw_spin_lock_irqsave_nested(lock, subclass); \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700223 } while (0)
Arjan van de Vencfd3ef22006-11-25 11:09:37 -0800224#else
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100225#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700226 do { \
227 typecheck(unsigned long, flags); \
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100228 flags = _raw_spin_lock_irqsave(lock); \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700229 } while (0)
Arjan van de Vencfd3ef22006-11-25 11:09:37 -0800230#endif
231
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232#else
Linus Torvaldsb8e6ec82006-11-26 16:27:17 -0800233
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100234#define raw_spin_lock_irqsave(lock, flags) \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700235 do { \
236 typecheck(unsigned long, flags); \
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100237 _raw_spin_lock_irqsave(lock, flags); \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700238 } while (0)
Thomas Gleixneref12f102009-11-07 23:04:15 +0100239
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100240#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
241 raw_spin_lock_irqsave(lock, flags)
Arjan van de Vencfd3ef22006-11-25 11:09:37 -0800242
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243#endif
244
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100245#define raw_spin_lock_irq(lock) _raw_spin_lock_irq(lock)
246#define raw_spin_lock_bh(lock) _raw_spin_lock_bh(lock)
247#define raw_spin_unlock(lock) _raw_spin_unlock(lock)
248#define raw_spin_unlock_irq(lock) _raw_spin_unlock_irq(lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100250#define raw_spin_unlock_irqrestore(lock, flags) \
251 do { \
252 typecheck(unsigned long, flags); \
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100253 _raw_spin_unlock_irqrestore(lock, flags); \
Steven Rostedt3f3078912008-07-25 01:45:25 -0700254 } while (0)
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100255#define raw_spin_unlock_bh(lock) _raw_spin_unlock_bh(lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Thomas Gleixner9c1721a2009-12-03 21:52:18 +0100257#define raw_spin_trylock_bh(lock) \
258 __cond_lock(lock, _raw_spin_trylock_bh(lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100260#define raw_spin_trylock_irq(lock) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261({ \
262 local_irq_disable(); \
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100263 raw_spin_trylock(lock) ? \
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700264 1 : ({ local_irq_enable(); 0; }); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265})
266
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100267#define raw_spin_trylock_irqsave(lock, flags) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268({ \
269 local_irq_save(flags); \
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100270 raw_spin_trylock(lock) ? \
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700271 1 : ({ local_irq_restore(flags); 0; }); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272})
273
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100274/**
275 * raw_spin_can_lock - would raw_spin_trylock() succeed?
276 * @lock: the spinlock in question.
277 */
278#define raw_spin_can_lock(lock) (!raw_spin_is_locked(lock))
279
280/* Include rwlock functions */
281#include <linux/rwlock.h>
282
283/*
284 * Pull the _spin_*()/_read_*()/_write_*() functions/declarations:
285 */
286#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
287# include <linux/spinlock_api_smp.h>
288#else
289# include <linux/spinlock_api_up.h>
290#endif
291
292/*
293 * Map the spin_lock functions to the raw variants for PREEMPT_RT=n
294 */
295
296static inline raw_spinlock_t *spinlock_check(spinlock_t *lock)
297{
298 return &lock->rlock;
299}
300
301#define spin_lock_init(_lock) \
302do { \
303 spinlock_check(_lock); \
304 raw_spin_lock_init(&(_lock)->rlock); \
305} while (0)
306
307static inline void spin_lock(spinlock_t *lock)
308{
309 raw_spin_lock(&lock->rlock);
310}
311
312static inline void spin_lock_bh(spinlock_t *lock)
313{
314 raw_spin_lock_bh(&lock->rlock);
315}
316
317static inline int spin_trylock(spinlock_t *lock)
318{
319 return raw_spin_trylock(&lock->rlock);
320}
321
322#define spin_lock_nested(lock, subclass) \
323do { \
324 raw_spin_lock_nested(spinlock_check(lock), subclass); \
325} while (0)
326
327#define spin_lock_nest_lock(lock, nest_lock) \
328do { \
329 raw_spin_lock_nest_lock(spinlock_check(lock), nest_lock); \
330} while (0)
331
332static inline void spin_lock_irq(spinlock_t *lock)
333{
334 raw_spin_lock_irq(&lock->rlock);
335}
336
337#define spin_lock_irqsave(lock, flags) \
338do { \
339 raw_spin_lock_irqsave(spinlock_check(lock), flags); \
340} while (0)
341
342#define spin_lock_irqsave_nested(lock, flags, subclass) \
343do { \
344 raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
345} while (0)
346
347static inline void spin_unlock(spinlock_t *lock)
348{
349 raw_spin_unlock(&lock->rlock);
350}
351
352static inline void spin_unlock_bh(spinlock_t *lock)
353{
354 raw_spin_unlock_bh(&lock->rlock);
355}
356
357static inline void spin_unlock_irq(spinlock_t *lock)
358{
359 raw_spin_unlock_irq(&lock->rlock);
360}
361
362static inline void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
363{
364 raw_spin_unlock_irqrestore(&lock->rlock, flags);
365}
366
367static inline int spin_trylock_bh(spinlock_t *lock)
368{
369 return raw_spin_trylock_bh(&lock->rlock);
370}
371
372static inline int spin_trylock_irq(spinlock_t *lock)
373{
374 return raw_spin_trylock_irq(&lock->rlock);
375}
376
377#define spin_trylock_irqsave(lock, flags) \
378({ \
379 raw_spin_trylock_irqsave(spinlock_check(lock), flags); \
380})
381
382static inline void spin_unlock_wait(spinlock_t *lock)
383{
384 raw_spin_unlock_wait(&lock->rlock);
385}
386
387static inline int spin_is_locked(spinlock_t *lock)
388{
389 return raw_spin_is_locked(&lock->rlock);
390}
391
392static inline int spin_is_contended(spinlock_t *lock)
393{
394 return raw_spin_is_contended(&lock->rlock);
395}
396
397static inline int spin_can_lock(spinlock_t *lock)
398{
399 return raw_spin_can_lock(&lock->rlock);
400}
401
Paul Gortmaker4ebc1b42012-01-20 18:20:37 -0500402#define assert_spin_locked(lock) assert_raw_spin_locked(&(lock)->rlock)
Thomas Gleixnerc2f21ce2009-12-02 20:02:59 +0100403
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700404/*
405 * Pull the atomic_t declaration:
406 * (asm-mips/atomic.h needs above definitions)
407 */
Arun Sharma600634972011-07-26 16:09:06 -0700408#include <linux/atomic.h>
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700409/**
410 * atomic_dec_and_lock - lock on reaching reference count zero
411 * @atomic: the atomic counter
412 * @lock: the spinlock in question
J. Bruce Fieldsdc07e722008-04-07 15:59:05 -0400413 *
414 * Decrements @atomic by 1. If the result is 0, returns true and locks
415 * @lock. Returns false for all other cases.
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700416 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
Ingo Molnarfb1c8f92005-09-10 00:25:56 -0700418#define atomic_dec_and_lock(atomic, lock) \
Josh Triplettdcc8e552006-09-29 02:01:03 -0700419 __cond_lock(lock, _atomic_dec_and_lock(atomic, lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421#endif /* __LINUX_SPINLOCK_H */