1#ifndef __LINUX_SPINLOCK_H
2#define __LINUX_SPINLOCK_H
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
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>
59
60
61
62
63
64#define LOCK_SECTION_NAME ".text..lock."KBUILD_BASENAME
65
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
76#define __lockfunc __attribute__((section(".spinlock.text")))
77
78
79
80
81#include <linux/spinlock_types.h>
82
83
84
85
86#ifdef CONFIG_SMP
87# include <asm/spinlock.h>
88#else
89# include <linux/spinlock_up.h>
90#endif
91
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) \
96do { \
97 static struct lock_class_key __key; \
98 \
99 __raw_spin_lock_init((lock), #lock, &__key); \
100} while (0)
101
102#else
103# define raw_spin_lock_init(lock) \
104 do { *(lock) = __RAW_SPIN_LOCK_UNLOCKED(lock); } while (0)
105#endif
106
107#define raw_spin_is_locked(lock) arch_spin_is_locked(&(lock)->raw_lock)
108
109#ifdef CONFIG_GENERIC_LOCKBREAK
110#define raw_spin_is_contended(lock) ((lock)->break_lock)
111#else
112
113#ifdef arch_spin_is_contended
114#define raw_spin_is_contended(lock) arch_spin_is_contended(&(lock)->raw_lock)
115#else
116#define raw_spin_is_contended(lock) (((void)(lock), 0))
117#endif
118#endif
119
120
121
122
123
124
125
126
127
128
129#ifndef smp_mb__before_spinlock
130#define smp_mb__before_spinlock() smp_wmb()
131#endif
132
133
134
135
136
137
138
139#ifndef smp_mb__after_unlock_lock
140#define smp_mb__after_unlock_lock() do { } while (0)
141#endif
142
143
144
145
146
147#define raw_spin_unlock_wait(lock) arch_spin_unlock_wait(&(lock)->raw_lock)
148
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);
154#else
155static inline void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock)
156{
157 __acquire(lock);
158 arch_spin_lock(&lock->raw_lock);
159}
160
161static inline void
162do_raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long *flags) __acquires(lock)
163{
164 __acquire(lock);
165 arch_spin_lock_flags(&lock->raw_lock, *flags);
166}
167
168static inline int do_raw_spin_trylock(raw_spinlock_t *lock)
169{
170 return arch_spin_trylock(&(lock)->raw_lock);
171}
172
173static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock)
174{
175 arch_spin_unlock(&lock->raw_lock);
176 __release(lock);
177}
178#endif
179
180
181
182
183
184
185
186#define raw_spin_trylock(lock) __cond_lock(lock, _raw_spin_trylock(lock))
187
188#define raw_spin_lock(lock) _raw_spin_lock(lock)
189
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)
195
196# define raw_spin_lock_nest_lock(lock, nest_lock) \
197 do { \
198 typecheck(struct lockdep_map *, &(nest_lock)->dep_map);\
199 _raw_spin_lock_nest_lock(lock, &(nest_lock)->dep_map); \
200 } while (0)
201#else
202
203
204
205
206
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)
211#endif
212
213#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
214
215#define raw_spin_lock_irqsave(lock, flags) \
216 do { \
217 typecheck(unsigned long, flags); \
218 flags = _raw_spin_lock_irqsave(lock); \
219 } while (0)
220
221#ifdef CONFIG_DEBUG_LOCK_ALLOC
222#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
223 do { \
224 typecheck(unsigned long, flags); \
225 flags = _raw_spin_lock_irqsave_nested(lock, subclass); \
226 } while (0)
227#else
228#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
229 do { \
230 typecheck(unsigned long, flags); \
231 flags = _raw_spin_lock_irqsave(lock); \
232 } while (0)
233#endif
234
235#else
236
237#define raw_spin_lock_irqsave(lock, flags) \
238 do { \
239 typecheck(unsigned long, flags); \
240 _raw_spin_lock_irqsave(lock, flags); \
241 } while (0)
242
243#define raw_spin_lock_irqsave_nested(lock, flags, subclass) \
244 raw_spin_lock_irqsave(lock, flags)
245
246#endif
247
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)
252
253#define raw_spin_unlock_irqrestore(lock, flags) \
254 do { \
255 typecheck(unsigned long, flags); \
256 _raw_spin_unlock_irqrestore(lock, flags); \
257 } while (0)
258#define raw_spin_unlock_bh(lock) _raw_spin_unlock_bh(lock)
259
260#define raw_spin_trylock_bh(lock) \
261 __cond_lock(lock, _raw_spin_trylock_bh(lock))
262
263#define raw_spin_trylock_irq(lock) \
264({ \
265 local_irq_disable(); \
266 raw_spin_trylock(lock) ? \
267 1 : ({ local_irq_enable(); 0; }); \
268})
269
270#define raw_spin_trylock_irqsave(lock, flags) \
271({ \
272 local_irq_save(flags); \
273 raw_spin_trylock(lock) ? \
274 1 : ({ local_irq_restore(flags); 0; }); \
275})
276
277
278
279
280
281#define raw_spin_can_lock(lock) (!raw_spin_is_locked(lock))
282
283
284#include <linux/rwlock.h>
285
286
287
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
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
330#define spin_lock_bh_nested(lock, subclass) \
331do { \
332 raw_spin_lock_bh_nested(spinlock_check(lock), subclass);\
333} while (0)
334
335#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
410#define assert_spin_locked(lock) assert_raw_spin_locked(&(lock)->rlock)
411
412
413
414
415
416#include <linux/atomic.h>
417
418
419
420
421
422
423
424
425extern 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))
428
429#endif
430