1 #ifndef __LINUX_SPINLOCK_H
2 #define __LINUX_SPINLOCK_H
5 * include/linux/spinlock.h - generic spinlock/rwlock declarations
7 * here's the role of the various spinlock/rwlock related include files:
11 * asm/spinlock_types.h: contains the arch_spinlock_t/arch_rwlock_t and the
14 * linux/spinlock_types.h:
15 * defines the generic type and initializers
17 * asm/spinlock.h: contains the arch_spin_*()/etc. lowlevel
18 * implementations, mostly inline assembly code
20 * (also included on UP-debug builds:)
22 * linux/spinlock_api_smp.h:
23 * contains the prototypes for the _spin_*() APIs.
25 * linux/spinlock.h: builds the final spin_*() APIs.
29 * linux/spinlock_type_up.h:
30 * contains the generic, simplified UP spinlock type.
31 * (which is an empty structure on non-debug builds)
33 * linux/spinlock_types.h:
34 * defines the generic type and initializers
36 * linux/spinlock_up.h:
37 * contains the arch_spin_*()/etc. version of UP
38 * builds. (which are NOPs on non-debug, non-preempt
41 * (included on UP-non-debug builds:)
43 * linux/spinlock_api_up.h:
44 * builds the _spin_*() APIs.
46 * linux/spinlock.h: builds the final spin_*() APIs.
49 #include <linux/typecheck.h>
50 #include <linux/preempt.h>
51 #include <linux/linkage.h>
52 #include <linux/compiler.h>
53 #include <linux/irqflags.h>
54 #include <linux/thread_info.h>
55 #include <linux/kernel.h>
56 #include <linux/stringify.h>
57 #include <linux/bottom_half.h>
58 #include <asm/barrier.h>
62 * Must define these before including other files, inline functions need them
64 #define LOCK_SECTION_NAME ".text..lock."KBUILD_BASENAME
66 #define LOCK_SECTION_START(extra) \
69 ".ifndef " LOCK_SECTION_NAME "\n\t" \
70 LOCK_SECTION_NAME ":\n\t" \
73 #define LOCK_SECTION_END \
76 #define __lockfunc __attribute__((section(".spinlock.text")))
79 * Pull the arch_spinlock_t and arch_rwlock_t definitions:
81 #include <linux/spinlock_types.h>
84 * Pull the arch_spin*() functions/declarations (UP-nondebug doesn't need them):
87 # include <asm/spinlock.h>
89 # include <linux/spinlock_up.h>
92 #ifdef CONFIG_DEBUG_SPINLOCK
93 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) \
97 static struct lock_class_key __key; \
99 __raw_spin_lock_init((lock), #lock, &__key); \
103 # define raw_spin_lock_init(lock) \
104 do { *(lock) = __RAW_SPIN_LOCK_UNLOCKED(lock); } while (0)
107 #define raw_spin_is_locked(lock) arch_spin_is_locked(&(lock)->raw_lock)
109 #ifdef CONFIG_GENERIC_LOCKBREAK
110 #define raw_spin_is_contended(lock) ((lock)->break_lock)
113 #ifdef arch_spin_is_contended
114 #define raw_spin_is_contended(lock) arch_spin_is_contended(&(lock)->raw_lock)
116 #define raw_spin_is_contended(lock) (((void)(lock), 0))
117 #endif /*arch_spin_is_contended*/
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().
129 #ifndef smp_mb__before_spinlock
130 #define smp_mb__before_spinlock() smp_wmb()
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.
139 #ifndef smp_mb__after_unlock_lock
140 #define smp_mb__after_unlock_lock() do { } while (0)
144 * raw_spin_unlock_wait - wait until the spinlock gets unlocked
145 * @lock: the spinlock in question.
147 #define raw_spin_unlock_wait(lock) arch_spin_unlock_wait(&(lock)->raw_lock)
149 #ifdef CONFIG_DEBUG_SPINLOCK
150 extern void do_raw_spin_lock(raw_spinlock_t
*lock
) __acquires(lock
);
151 #define do_raw_spin_lock_flags(lock, flags) do_raw_spin_lock(lock)
152 extern int do_raw_spin_trylock(raw_spinlock_t
*lock
);
153 extern void do_raw_spin_unlock(raw_spinlock_t
*lock
) __releases(lock
);
155 static inline void do_raw_spin_lock(raw_spinlock_t
*lock
) __acquires(lock
)
158 arch_spin_lock(&lock
->raw_lock
);
162 do_raw_spin_lock_flags(raw_spinlock_t
*lock
, unsigned long *flags
) __acquires(lock
)
165 arch_spin_lock_flags(&lock
->raw_lock
, *flags
);
168 static inline int do_raw_spin_trylock(raw_spinlock_t
*lock
)
170 return arch_spin_trylock(&(lock
)->raw_lock
);
173 static inline void do_raw_spin_unlock(raw_spinlock_t
*lock
) __releases(lock
)
175 arch_spin_unlock(&lock
->raw_lock
);
181 * 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
186 #define raw_spin_trylock(lock) __cond_lock(lock, _raw_spin_trylock(lock))
188 #define raw_spin_lock(lock) _raw_spin_lock(lock)
190 #ifdef CONFIG_DEBUG_LOCK_ALLOC
191 # define raw_spin_lock_nested(lock, subclass) \
192 _raw_spin_lock_nested(lock, subclass)
193 # define raw_spin_lock_bh_nested(lock, subclass) \
194 _raw_spin_lock_bh_nested(lock, subclass)
196 # define raw_spin_lock_nest_lock(lock, nest_lock) \
198 typecheck(struct lockdep_map *, &(nest_lock)->dep_map);\
199 _raw_spin_lock_nest_lock(lock, &(nest_lock)->dep_map); \
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.
207 # define raw_spin_lock_nested(lock, subclass) \
208 _raw_spin_lock(((void)(subclass), (lock)))
209 # define raw_spin_lock_nest_lock(lock, nest_lock) _raw_spin_lock(lock)
210 # define raw_spin_lock_bh_nested(lock, subclass) _raw_spin_lock_bh(lock)
213 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
215 #define raw_spin_lock_irqsave(lock, flags) \
217 typecheck(unsigned long, flags); \
218 flags = _raw_spin_lock_irqsave(lock); \
221 #ifdef CONFIG_DEBUG_LOCK_ALLOC
222 #define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
224 typecheck(unsigned long, flags); \
225 flags = _raw_spin_lock_irqsave_nested(lock, subclass); \
228 #define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
230 typecheck(unsigned long, flags); \
231 flags = _raw_spin_lock_irqsave(lock); \
237 #define raw_spin_lock_irqsave(lock, flags) \
239 typecheck(unsigned long, flags); \
240 _raw_spin_lock_irqsave(lock, flags); \
243 #define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
244 raw_spin_lock_irqsave(lock, flags)
248 #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)
253 #define raw_spin_unlock_irqrestore(lock, flags) \
255 typecheck(unsigned long, flags); \
256 _raw_spin_unlock_irqrestore(lock, flags); \
258 #define raw_spin_unlock_bh(lock) _raw_spin_unlock_bh(lock)
260 #define raw_spin_trylock_bh(lock) \
261 __cond_lock(lock, _raw_spin_trylock_bh(lock))
263 #define raw_spin_trylock_irq(lock) \
265 local_irq_disable(); \
266 raw_spin_trylock(lock) ? \
267 1 : ({ local_irq_enable(); 0; }); \
270 #define raw_spin_trylock_irqsave(lock, flags) \
272 local_irq_save(flags); \
273 raw_spin_trylock(lock) ? \
274 1 : ({ local_irq_restore(flags); 0; }); \
278 * raw_spin_can_lock - would raw_spin_trylock() succeed?
279 * @lock: the spinlock in question.
281 #define raw_spin_can_lock(lock) (!raw_spin_is_locked(lock))
283 /* Include rwlock functions */
284 #include <linux/rwlock.h>
287 * Pull the _spin_*()/_read_*()/_write_*() functions/declarations:
289 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
290 # include <linux/spinlock_api_smp.h>
292 # include <linux/spinlock_api_up.h>
296 * Map the spin_lock functions to the raw variants for PREEMPT_RT=n
299 static inline raw_spinlock_t
*spinlock_check(spinlock_t
*lock
)
304 #define spin_lock_init(_lock) \
306 spinlock_check(_lock); \
307 raw_spin_lock_init(&(_lock)->rlock); \
310 static inline void spin_lock(spinlock_t
*lock
)
312 raw_spin_lock(&lock
->rlock
);
315 static inline void spin_lock_bh(spinlock_t
*lock
)
317 raw_spin_lock_bh(&lock
->rlock
);
320 static inline int spin_trylock(spinlock_t
*lock
)
322 return raw_spin_trylock(&lock
->rlock
);
325 #define spin_lock_nested(lock, subclass) \
327 raw_spin_lock_nested(spinlock_check(lock), subclass); \
330 #define spin_lock_bh_nested(lock, subclass) \
332 raw_spin_lock_bh_nested(spinlock_check(lock), subclass);\
335 #define spin_lock_nest_lock(lock, nest_lock) \
337 raw_spin_lock_nest_lock(spinlock_check(lock), nest_lock); \
340 static inline void spin_lock_irq(spinlock_t
*lock
)
342 raw_spin_lock_irq(&lock
->rlock
);
345 #define spin_lock_irqsave(lock, flags) \
347 raw_spin_lock_irqsave(spinlock_check(lock), flags); \
350 #define spin_lock_irqsave_nested(lock, flags, subclass) \
352 raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
355 static inline void spin_unlock(spinlock_t
*lock
)
357 raw_spin_unlock(&lock
->rlock
);
360 static inline void spin_unlock_bh(spinlock_t
*lock
)
362 raw_spin_unlock_bh(&lock
->rlock
);
365 static inline void spin_unlock_irq(spinlock_t
*lock
)
367 raw_spin_unlock_irq(&lock
->rlock
);
370 static inline void spin_unlock_irqrestore(spinlock_t
*lock
, unsigned long flags
)
372 raw_spin_unlock_irqrestore(&lock
->rlock
, flags
);
375 static inline int spin_trylock_bh(spinlock_t
*lock
)
377 return raw_spin_trylock_bh(&lock
->rlock
);
380 static inline int spin_trylock_irq(spinlock_t
*lock
)
382 return raw_spin_trylock_irq(&lock
->rlock
);
385 #define spin_trylock_irqsave(lock, flags) \
387 raw_spin_trylock_irqsave(spinlock_check(lock), flags); \
390 static inline void spin_unlock_wait(spinlock_t
*lock
)
392 raw_spin_unlock_wait(&lock
->rlock
);
395 static inline int spin_is_locked(spinlock_t
*lock
)
397 return raw_spin_is_locked(&lock
->rlock
);
400 static inline int spin_is_contended(spinlock_t
*lock
)
402 return raw_spin_is_contended(&lock
->rlock
);
405 static inline int spin_can_lock(spinlock_t
*lock
)
407 return raw_spin_can_lock(&lock
->rlock
);
410 #define assert_spin_locked(lock) assert_raw_spin_locked(&(lock)->rlock)
413 * Pull the atomic_t declaration:
414 * (asm-mips/atomic.h needs above definitions)
416 #include <linux/atomic.h>
418 * atomic_dec_and_lock - lock on reaching reference count zero
419 * @atomic: the atomic counter
420 * @lock: the spinlock in question
422 * Decrements @atomic by 1. If the result is 0, returns true and locks
423 * @lock. Returns false for all other cases.
425 extern int _atomic_dec_and_lock(atomic_t
*atomic
, spinlock_t
*lock
);
426 #define atomic_dec_and_lock(atomic, lock) \
427 __cond_lock(lock, _atomic_dec_and_lock(atomic, lock))
429 #endif /* __LINUX_SPINLOCK_H */
This page took 0.040154 seconds and 5 git commands to generate.