Rev 5270 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 5270 | Rev 5272 | ||
---|---|---|---|
Line 45... | Line 45... | ||
45 | * |
45 | * |
46 | * linux/spinlock.h: builds the final spin_*() APIs. |
46 | * linux/spinlock.h: builds the final spin_*() APIs. |
47 | */ |
47 | */ |
Line 48... | Line 48... | ||
48 | 48 | ||
49 | #include |
49 | #include |
50 | //#include |
50 | #include |
51 | #include |
51 | #include |
52 | #include |
52 | #include |
53 | //#include |
53 | #include |
54 | #include |
54 | #include |
55 | #include |
55 | #include |
56 | //#include |
56 | #include |
Line 57... | Line 57... | ||
57 | #include |
57 | #include |
58 | 58 | ||
Line 87... | Line 87... | ||
87 | #else |
87 | #else |
88 | # include |
88 | # include |
89 | #endif |
89 | #endif |
Line 90... | Line 90... | ||
90 | 90 | ||
91 | #ifdef CONFIG_DEBUG_SPINLOCK |
91 | #ifdef CONFIG_DEBUG_SPINLOCK |
92 | extern void __spin_lock_init(spinlock_t *lock, const char *name, |
92 | extern void __raw_spin_lock_init(raw_spinlock_t *lock, const char *name, |
93 | struct lock_class_key *key); |
93 | struct lock_class_key *key); |
94 | # define spin_lock_init(lock) \ |
94 | # define raw_spin_lock_init(lock) \ |
95 | do { \ |
95 | do { \ |
96 | static struct lock_class_key __key; \ |
96 | static struct lock_class_key __key; \ |
97 | \ |
97 | \ |
98 | __spin_lock_init((lock), #lock, &__key); \ |
98 | __raw_spin_lock_init((lock), #lock, &__key); \ |
Line 99... | Line 99... | ||
99 | } while (0) |
99 | } while (0) |
100 | 100 | ||
101 | #else |
101 | #else |
102 | # define spin_lock_init(lock) \ |
102 | # define raw_spin_lock_init(lock) \ |
Line 103... | Line -... | ||
103 | do { *(lock) = __SPIN_LOCK_UNLOCKED(lock); } while (0) |
- | |
104 | #endif |
- | |
105 | - | ||
106 | #ifdef CONFIG_DEBUG_SPINLOCK |
- | |
107 | extern void __rwlock_init(rwlock_t *lock, const char *name, |
- | |
108 | struct lock_class_key *key); |
- | |
109 | # define rwlock_init(lock) \ |
- | |
110 | do { \ |
- | |
111 | static struct lock_class_key __key; \ |
- | |
112 | \ |
- | |
113 | __rwlock_init((lock), #lock, &__key); \ |
- | |
114 | } while (0) |
- | |
115 | #else |
- | |
116 | # define rwlock_init(lock) \ |
- | |
117 | do { *(lock) = __RW_LOCK_UNLOCKED(lock); } while (0) |
103 | do { *(lock) = __RAW_SPIN_LOCK_UNLOCKED(lock); } while (0) |
Line 118... | Line 104... | ||
118 | #endif |
104 | #endif |
119 | 105 | ||
120 | #define spin_is_locked(lock) __raw_spin_is_locked(&(lock)->raw_lock) |
106 | #define raw_spin_is_locked(lock) arch_spin_is_locked(&(lock)->raw_lock) |
Line 121... | Line 107... | ||
121 | 107 | ||
122 | #ifdef CONFIG_GENERIC_LOCKBREAK |
108 | #ifdef CONFIG_GENERIC_LOCKBREAK |
123 | #define spin_is_contended(lock) ((lock)->break_lock) |
109 | #define raw_spin_is_contended(lock) ((lock)->break_lock) |
124 | #else |
110 | #else |
125 | 111 | ||
126 | #ifdef __raw_spin_is_contended |
112 | #ifdef arch_spin_is_contended |
Line -... | Line 113... | ||
- | 113 | #define raw_spin_is_contended(lock) arch_spin_is_contended(&(lock)->raw_lock) |
|
127 | #define spin_is_contended(lock) __raw_spin_is_contended(&(lock)->raw_lock) |
114 | #else |
- | 115 | #define raw_spin_is_contended(lock) (((void)(lock), 0)) |
|
- | 116 | #endif /*arch_spin_is_contended*/ |
|
- | 117 | #endif |
|
- | 118 | ||
- | 119 | /* |
|
- | 120 | * Despite its name it doesn't necessarily has to be a full barrier. |
|
- | 121 | * It should only guarantee that a STORE before the critical section |
|
- | 122 | * can not be reordered with a LOAD inside this section. |
|
- | 123 | * spin_lock() is the one-way barrier, this LOAD can not escape out |
|
- | 124 | * of the region. So the default implementation simply ensures that |
|
- | 125 | * a STORE can not move into the critical section, smp_wmb() should |
|
- | 126 | * serialize it with another STORE done by spin_lock(). |
|
- | 127 | */ |
|
- | 128 | #ifndef smp_mb__before_spinlock |
|
- | 129 | #define smp_mb__before_spinlock() smp_wmb() |
|
- | 130 | #endif |
|
- | 131 | ||
128 | #else |
132 | /* |
129 | #define spin_is_contended(lock) (((void)(lock), 0)) |
133 | * Place this after a lock-acquisition primitive to guarantee that |
130 | #endif /*__raw_spin_is_contended*/ |
134 | * an UNLOCK+LOCK pair act as a full barrier. This guarantee applies |
Line 131... | Line 135... | ||
131 | #endif |
135 | * if the UNLOCK and LOCK are executed by the same CPU or if the |
132 | 136 | * UNLOCK and LOCK operate on the same lock variable. |
|
133 | /* The lock does not imply full memory barrier. */ |
137 | */ |
134 | #ifndef ARCH_HAS_SMP_MB_AFTER_LOCK |
138 | #ifndef smp_mb__after_unlock_lock |
135 | static inline void smp_mb__after_lock(void) { smp_mb(); } |
139 | #define smp_mb__after_unlock_lock() do { } while (0) |
Line 136... | Line 140... | ||
136 | #endif |
140 | #endif |
137 | 141 | ||
138 | /** |
142 | /** |
139 | * spin_unlock_wait - wait until the spinlock gets unlocked |
143 | * raw_spin_unlock_wait - wait until the spinlock gets unlocked |
140 | * @lock: the spinlock in question. |
144 | * @lock: the spinlock in question. |
141 | */ |
- | |
142 | #define spin_unlock_wait(lock) __raw_spin_unlock_wait(&(lock)->raw_lock) |
- | |
143 | - | ||
144 | #ifdef CONFIG_DEBUG_SPINLOCK |
- | |
145 | extern void _raw_spin_lock(spinlock_t *lock); |
- | |
146 | #define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock) |
- | |
147 | extern int _raw_spin_trylock(spinlock_t *lock); |
- | |
148 | extern void _raw_spin_unlock(spinlock_t *lock); |
- | |
149 | extern void _raw_read_lock(rwlock_t *lock); |
145 | */ |
150 | #define _raw_read_lock_flags(lock, flags) _raw_read_lock(lock) |
146 | #define raw_spin_unlock_wait(lock) arch_spin_unlock_wait(&(lock)->raw_lock) |
- | 147 | ||
151 | extern int _raw_read_trylock(rwlock_t *lock); |
148 | #ifdef CONFIG_DEBUG_SPINLOCK |
152 | extern void _raw_read_unlock(rwlock_t *lock); |
149 | extern void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock); |
- | 150 | #define do_raw_spin_lock_flags(lock, flags) do_raw_spin_lock(lock) |
|
- | 151 | extern int do_raw_spin_trylock(raw_spinlock_t *lock); |
|
153 | extern void _raw_write_lock(rwlock_t *lock); |
152 | extern void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock); |
154 | #define _raw_write_lock_flags(lock, flags) _raw_write_lock(lock) |
153 | #else |
155 | extern int _raw_write_trylock(rwlock_t *lock); |
- | |
- | 154 | static inline void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock) |
|
156 | extern void _raw_write_unlock(rwlock_t *lock); |
155 | { |
157 | #else |
156 | __acquire(lock); |
- | 157 | arch_spin_lock(&lock->raw_lock); |
|
- | 158 | } |
|
158 | # define _raw_spin_lock(lock) __raw_spin_lock(&(lock)->raw_lock) |
159 | |
- | 160 | static inline void |
|
159 | # define _raw_spin_lock_flags(lock, flags) \ |
161 | do_raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long *flags) __acquires(lock) |
- | 162 | { |
|
- | 163 | __acquire(lock); |
|
160 | __raw_spin_lock_flags(&(lock)->raw_lock, *(flags)) |
164 | arch_spin_lock_flags(&lock->raw_lock, *flags); |
- | 165 | } |
|
161 | # define _raw_spin_trylock(lock) __raw_spin_trylock(&(lock)->raw_lock) |
166 | |
162 | # define _raw_spin_unlock(lock) __raw_spin_unlock(&(lock)->raw_lock) |
167 | static inline int do_raw_spin_trylock(raw_spinlock_t *lock) |
163 | # define _raw_read_lock(rwlock) __raw_read_lock(&(rwlock)->raw_lock) |
- | |
164 | # define _raw_read_lock_flags(lock, flags) \ |
- | |
- | 168 | { |
|
165 | __raw_read_lock_flags(&(lock)->raw_lock, *(flags)) |
169 | return arch_spin_trylock(&(lock)->raw_lock); |
Line 166... | Line -... | ||
166 | # define _raw_read_trylock(rwlock) __raw_read_trylock(&(rwlock)->raw_lock) |
- | |
167 | # define _raw_read_unlock(rwlock) __raw_read_unlock(&(rwlock)->raw_lock) |
- | |
168 | # define _raw_write_lock(rwlock) __raw_write_lock(&(rwlock)->raw_lock) |
- | |
169 | # define _raw_write_lock_flags(lock, flags) \ |
170 | } |
170 | __raw_write_lock_flags(&(lock)->raw_lock, *(flags)) |
171 | |
171 | # define _raw_write_trylock(rwlock) __raw_write_trylock(&(rwlock)->raw_lock) |
172 | static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock) |
172 | # define _raw_write_unlock(rwlock) __raw_write_unlock(&(rwlock)->raw_lock) |
173 | { |
- | 174 | arch_spin_unlock(&lock->raw_lock); |
|
173 | #endif |
175 | __release(lock); |
174 | 176 | } |
|
175 | #define read_can_lock(rwlock) __raw_read_can_lock(&(rwlock)->raw_lock) |
- | |
176 | #define write_can_lock(rwlock) __raw_write_can_lock(&(rwlock)->raw_lock) |
- | |
Line 177... | Line 177... | ||
177 | 177 | #endif |
|
Line 178... | Line 178... | ||
178 | /* |
178 | |
179 | * Define the various spin_lock and rw_lock methods. Note we define these |
179 | /* |
- | 180 | * Define the various spin_lock methods. Note we define these |
|
- | 181 | * regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The |
|
180 | * regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The various |
182 | * various methods are defined as nops in the case they are not |
181 | * methods are defined as nops in the case they are not required. |
183 | * required. |
182 | */ |
184 | */ |
183 | #define spin_trylock(lock) __cond_lock(lock, _spin_trylock(lock)) |
185 | #define raw_spin_trylock(lock) __cond_lock(lock, _raw_spin_trylock(lock)) |
184 | #define read_trylock(lock) __cond_lock(lock, _read_trylock(lock)) |
186 | |
185 | #define write_trylock(lock) __cond_lock(lock, _write_trylock(lock)) |
187 | #define raw_spin_lock(lock) _raw_spin_lock(lock) |
- | 188 | ||
- | 189 | #ifdef CONFIG_DEBUG_LOCK_ALLOC |
|
- | 190 | # define raw_spin_lock_nested(lock, subclass) \ |
|
- | 191 | _raw_spin_lock_nested(lock, subclass) |
|
- | 192 | ||
186 | 193 | # define raw_spin_lock_nest_lock(lock, nest_lock) \ |
|
- | 194 | do { \ |
|
187 | #define spin_lock(lock) _spin_lock(lock) |
195 | typecheck(struct lockdep_map *, &(nest_lock)->dep_map);\ |
188 | 196 | _raw_spin_lock_nest_lock(lock, &(nest_lock)->dep_map); \ |
|
Line 189... | Line -... | ||
189 | #ifdef CONFIG_DEBUG_LOCK_ALLOC |
- | |
190 | # define spin_lock_nested(lock, subclass) _spin_lock_nested(lock, subclass) |
- | |
191 | # define spin_lock_nest_lock(lock, nest_lock) \ |
- | |
192 | do { \ |
197 | } while (0) |
Line 193... | Line 198... | ||
193 | typecheck(struct lockdep_map *, &(nest_lock)->dep_map);\ |
198 | #else |
194 | _spin_lock_nest_lock(lock, &(nest_lock)->dep_map); \ |
- | |
195 | } while (0) |
- | |
196 | #else |
- | |
197 | # define spin_lock_nested(lock, subclass) _spin_lock(lock) |
- | |
198 | # define spin_lock_nest_lock(lock, nest_lock) _spin_lock(lock) |
- | |
199 | #endif |
199 | /* |
200 | 200 | * Always evaluate the 'subclass' argument to avoid that the compiler |
|
201 | #define write_lock(lock) _write_lock(lock) |
- | |
202 | #define read_lock(lock) _read_lock(lock) |
- | |
203 | - | ||
204 | #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) |
- | |
205 | - | ||
206 | #define spin_lock_irqsave(lock, flags) \ |
201 | * warns about set-but-not-used variables when building with |
207 | do { \ |
202 | * CONFIG_DEBUG_LOCK_ALLOC=n and with W=1. |
Line 208... | Line 203... | ||
208 | typecheck(unsigned long, flags); \ |
203 | */ |
209 | flags = _spin_lock_irqsave(lock); \ |
204 | # define raw_spin_lock_nested(lock, subclass) \ |
210 | } while (0) |
205 | _raw_spin_lock(((void)(subclass), (lock))) |
211 | #define read_lock_irqsave(lock, flags) \ |
206 | # define raw_spin_lock_nest_lock(lock, nest_lock) _raw_spin_lock(lock) |
212 | do { \ |
207 | #endif |
213 | typecheck(unsigned long, flags); \ |
208 | |
214 | flags = _read_lock_irqsave(lock); \ |
209 | #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) |
215 | } while (0) |
210 | |
216 | #define write_lock_irqsave(lock, flags) \ |
211 | #define raw_spin_lock_irqsave(lock, flags) \ |
217 | do { \ |
212 | do { \ |
218 | typecheck(unsigned long, flags); \ |
213 | typecheck(unsigned long, flags); \ |
219 | flags = _write_lock_irqsave(lock); \ |
214 | flags = _raw_spin_lock_irqsave(lock); \ |
220 | } while (0) |
215 | } while (0) |
Line 221... | Line 216... | ||
221 | 216 | ||
Line 222... | Line 217... | ||
222 | #ifdef CONFIG_DEBUG_LOCK_ALLOC |
217 | #ifdef CONFIG_DEBUG_LOCK_ALLOC |
223 | #define spin_lock_irqsave_nested(lock, flags, subclass) \ |
218 | #define raw_spin_lock_irqsave_nested(lock, flags, subclass) \ |
224 | do { \ |
219 | do { \ |
225 | typecheck(unsigned long, flags); \ |
220 | typecheck(unsigned long, flags); \ |
226 | flags = _spin_lock_irqsave_nested(lock, subclass); \ |
221 | flags = _raw_spin_lock_irqsave_nested(lock, subclass); \ |
- | 222 | } while (0) |
|
- | 223 | #else |
|
- | 224 | #define raw_spin_lock_irqsave_nested(lock, flags, subclass) \ |
|
- | 225 | do { \ |
|
- | 226 | typecheck(unsigned long, flags); \ |
|
- | 227 | flags = _raw_spin_lock_irqsave(lock); \ |
|
- | 228 | } while (0) |
|
- | 229 | #endif |
|
- | 230 | ||
- | 231 | #else |
|
- | 232 | ||
227 | } while (0) |
233 | #define raw_spin_lock_irqsave(lock, flags) \ |
228 | #else |
234 | do { \ |
229 | #define spin_lock_irqsave_nested(lock, flags, subclass) \ |
235 | typecheck(unsigned long, flags); \ |
230 | do { \ |
236 | _raw_spin_lock_irqsave(lock, flags); \ |
231 | typecheck(unsigned long, flags); \ |
237 | } while (0) |
- | 238 | ||
- | 239 | #define raw_spin_lock_irqsave_nested(lock, flags, subclass) \ |
|
- | 240 | raw_spin_lock_irqsave(lock, flags) |
|
- | 241 | ||
- | 242 | #endif |
|
- | 243 | ||
- | 244 | #define raw_spin_lock_irq(lock) _raw_spin_lock_irq(lock) |
|
- | 245 | #define raw_spin_lock_bh(lock) _raw_spin_lock_bh(lock) |
|
- | 246 | #define raw_spin_unlock(lock) _raw_spin_unlock(lock) |
|
- | 247 | #define raw_spin_unlock_irq(lock) _raw_spin_unlock_irq(lock) |
|
- | 248 | ||
- | 249 | #define raw_spin_unlock_irqrestore(lock, flags) \ |
|
232 | flags = _spin_lock_irqsave(lock); \ |
250 | do { \ |
- | 251 | typecheck(unsigned long, flags); \ |
|
- | 252 | _raw_spin_unlock_irqrestore(lock, flags); \ |
|
- | 253 | } while (0) |
|
- | 254 | #define raw_spin_unlock_bh(lock) _raw_spin_unlock_bh(lock) |
|
- | 255 | ||
- | 256 | #define raw_spin_trylock_bh(lock) \ |
|
- | 257 | __cond_lock(lock, _raw_spin_trylock_bh(lock)) |
|
- | 258 | ||
- | 259 | #define raw_spin_trylock_irq(lock) \ |
|
- | 260 | ({ \ |
|
- | 261 | local_irq_disable(); \ |
|
- | 262 | raw_spin_trylock(lock) ? \ |
|
- | 263 | 1 : ({ local_irq_enable(); 0; }); \ |
|
- | 264 | }) |
|
- | 265 | ||
- | 266 | #define raw_spin_trylock_irqsave(lock, flags) \ |
|
- | 267 | ({ \ |
|
- | 268 | local_irq_save(flags); \ |
|
- | 269 | raw_spin_trylock(lock) ? \ |
|
- | 270 | 1 : ({ local_irq_restore(flags); 0; }); \ |
|
- | 271 | }) |
|
- | 272 | ||
- | 273 | /** |
|
- | 274 | * raw_spin_can_lock - would raw_spin_trylock() succeed? |
|
- | 275 | * @lock: the spinlock in question. |
|
- | 276 | */ |
|
- | 277 | #define raw_spin_can_lock(lock) (!raw_spin_is_locked(lock)) |
|
- | 278 | ||
- | 279 | /* Include rwlock functions */ |
|
- | 280 | #include |
|
- | 281 | ||
- | 282 | /* |
|
- | 283 | * Pull the _spin_*()/_read_*()/_write_*() functions/declarations: |
|
- | 284 | */ |
|
233 | } while (0) |
285 | #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) |
234 | #endif |
286 | # include |
235 | 287 | #else |
|
236 | #else |
288 | # include |
237 | - | ||
238 | #define spin_lock_irqsave(lock, flags) \ |
- | |
Line -... | Line 289... | ||
- | 289 | #endif |
|
- | 290 | ||
- | 291 | /* |
|
239 | do { \ |
292 | * Map the spin_lock functions to the raw variants for PREEMPT_RT=n |
Line 240... | Line 293... | ||
240 | typecheck(unsigned long, flags); \ |
293 | */ |
- | 294 | ||
241 | _spin_lock_irqsave(lock, flags); \ |
295 | static inline raw_spinlock_t *spinlock_check(spinlock_t *lock) |
242 | } while (0) |
- | |
243 | #define read_lock_irqsave(lock, flags) \ |
- | |
244 | do { \ |
- | |
245 | typecheck(unsigned long, flags); \ |
- | |
246 | _read_lock_irqsave(lock, flags); \ |
- | |
247 | } while (0) |
- | |
248 | #define write_lock_irqsave(lock, flags) \ |
- | |
249 | do { \ |
- | |
250 | typecheck(unsigned long, flags); \ |
- | |
251 | _write_lock_irqsave(lock, flags); \ |
- | |
- | 296 | { |
|
Line -... | Line 297... | ||
- | 297 | return &lock->rlock; |
|
- | 298 | } |
|
- | 299 | ||
- | 300 | #define spin_lock_init(_lock) \ |
|
- | 301 | do { \ |
|
252 | } while (0) |
302 | spinlock_check(_lock); \ |
253 | #define spin_lock_irqsave_nested(lock, flags, subclass) \ |
303 | raw_spin_lock_init(&(_lock)->rlock); \ |
254 | spin_lock_irqsave(lock, flags) |
- | |
255 | 304 | } while (0) |
|
256 | #endif |
305 | |
257 | - | ||
Line 258... | Line 306... | ||
258 | #define spin_lock_irq(lock) _spin_lock_irq(lock) |
306 | static inline void spin_lock(spinlock_t *lock) |
259 | #define spin_lock_bh(lock) _spin_lock_bh(lock) |
307 | { |
260 | #define read_lock_irq(lock) _read_lock_irq(lock) |
- | |
261 | #define read_lock_bh(lock) _read_lock_bh(lock) |
308 | raw_spin_lock(&lock->rlock); |
262 | #define write_lock_irq(lock) _write_lock_irq(lock) |
309 | } |
263 | #define write_lock_bh(lock) _write_lock_bh(lock) |
- | |
Line -... | Line 310... | ||
- | 310 | ||
- | 311 | static inline void spin_lock_bh(spinlock_t *lock) |
|
- | 312 | { |
|
- | 313 | raw_spin_lock_bh(&lock->rlock); |
|
- | 314 | } |
|
264 | #define spin_unlock(lock) _spin_unlock(lock) |
315 | |
265 | #define read_unlock(lock) _read_unlock(lock) |
316 | static inline int spin_trylock(spinlock_t *lock) |
266 | #define write_unlock(lock) _write_unlock(lock) |
- | |
267 | #define spin_unlock_irq(lock) _spin_unlock_irq(lock) |
317 | { |
268 | #define read_unlock_irq(lock) _read_unlock_irq(lock) |
318 | return raw_spin_trylock(&lock->rlock); |
269 | #define write_unlock_irq(lock) _write_unlock_irq(lock) |
- | |
Line 270... | Line 319... | ||
270 | 319 | } |
|
- | 320 | ||
- | 321 | #define spin_lock_nested(lock, subclass) \ |
|
- | 322 | do { \ |
|
Line -... | Line 323... | ||
- | 323 | raw_spin_lock_nested(spinlock_check(lock), subclass); \ |
|
- | 324 | } while (0) |
|
271 | #define spin_unlock_irqrestore(lock, flags) \ |
325 | |
- | 326 | #define spin_lock_nest_lock(lock, nest_lock) \ |
|
- | 327 | do { \ |
|
- | 328 | raw_spin_lock_nest_lock(spinlock_check(lock), nest_lock); \ |
|
- | 329 | } while (0) |
|
- | 330 | ||
- | 331 | static inline void spin_lock_irq(spinlock_t *lock) |
|
- | 332 | { |
|
- | 333 | raw_spin_lock_irq(&lock->rlock); |
|
272 | do { \ |
334 | } |
273 | typecheck(unsigned long, flags); \ |
335 | |
- | 336 | #define spin_lock_irqsave(lock, flags) \ |
|
- | 337 | do { \ |
|
- | 338 | raw_spin_lock_irqsave(spinlock_check(lock), flags); \ |
|
- | 339 | } while (0) |
|
- | 340 | ||
- | 341 | #define spin_lock_irqsave_nested(lock, flags, subclass) \ |
|
- | 342 | do { \ |
|
- | 343 | raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \ |
|
- | 344 | } while (0) |
|
274 | _spin_unlock_irqrestore(lock, flags); \ |
345 | |
- | 346 | static inline void spin_unlock(spinlock_t *lock) |
|
- | 347 | { |
|
- | 348 | raw_spin_unlock(&lock->rlock); |
|
- | 349 | } |
|
275 | } while (0) |
350 | |
276 | #define spin_unlock_bh(lock) _spin_unlock_bh(lock) |
351 | static inline void spin_unlock_bh(spinlock_t *lock) |
Line 277... | Line 352... | ||
277 | 352 | { |
|
278 | #define read_unlock_irqrestore(lock, flags) \ |
353 | raw_spin_unlock_bh(&lock->rlock); |
279 | do { \ |
- | |
280 | typecheck(unsigned long, flags); \ |
- | |
281 | _read_unlock_irqrestore(lock, flags); \ |
354 | } |
282 | } while (0) |
355 | |
Line 283... | Line 356... | ||
283 | #define read_unlock_bh(lock) _read_unlock_bh(lock) |
356 | static inline void spin_unlock_irq(spinlock_t *lock) |
284 | 357 | { |
|
285 | #define write_unlock_irqrestore(lock, flags) \ |
358 | raw_spin_unlock_irq(&lock->rlock); |
- | 359 | } |
|
- | 360 | ||
- | 361 | static inline void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags) |
|
- | 362 | { |
|
286 | do { \ |
363 | raw_spin_unlock_irqrestore(&lock->rlock, flags); |
- | 364 | } |
|
- | 365 | ||
- | 366 | static inline int spin_trylock_bh(spinlock_t *lock) |
|
- | 367 | { |
|
- | 368 | return raw_spin_trylock_bh(&lock->rlock); |
|
- | 369 | } |
|
- | 370 | ||
- | 371 | static inline int spin_trylock_irq(spinlock_t *lock) |
|
- | 372 | { |
|
287 | typecheck(unsigned long, flags); \ |
373 | return raw_spin_trylock_irq(&lock->rlock); |
288 | _write_unlock_irqrestore(lock, flags); \ |
374 | } |
- | 375 | ||
- | 376 | #define spin_trylock_irqsave(lock, flags) \ |
|
Line 289... | Line 377... | ||
289 | } while (0) |
377 | ({ \ |
290 | #define write_unlock_bh(lock) _write_unlock_bh(lock) |
378 | raw_spin_trylock_irqsave(spinlock_check(lock), flags); \ |
291 | 379 | }) |
|
292 | #define spin_trylock_bh(lock) __cond_lock(lock, _spin_trylock_bh(lock)) |
380 | |
293 | 381 | static inline void spin_unlock_wait(spinlock_t *lock) |
|
294 | #define spin_trylock_irq(lock) \ |
382 | { |
295 | ({ \ |
383 | raw_spin_unlock_wait(&lock->rlock); |
296 | local_irq_disable(); \ |
384 | } |
297 | spin_trylock(lock) ? \ |
385 | |
298 | 1 : ({ local_irq_enable(); 0; }); \ |
386 | static inline int spin_is_locked(spinlock_t *lock) |
Line 327... | Line 415... | ||
327 | */ |
415 | */ |
328 | extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock); |
416 | extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock); |
329 | #define atomic_dec_and_lock(atomic, lock) \ |
417 | #define atomic_dec_and_lock(atomic, lock) \ |
330 | __cond_lock(lock, _atomic_dec_and_lock(atomic, lock)) |
418 | __cond_lock(lock, _atomic_dec_and_lock(atomic, lock)) |
Line 331... | Line -... | ||
331 | - | ||
332 | /** |
- | |
333 | * spin_can_lock - would spin_trylock() succeed? |
- | |
334 | * @lock: the spinlock in question. |
- | |
335 | */ |
- | |
336 | #define spin_can_lock(lock) (!spin_is_locked(lock)) |
- | |
337 | - | ||
338 | /* |
- | |
339 | * Pull the _spin_*()/_read_*()/_write_*() functions/declarations: |
- | |
340 | */ |
- | |
341 | #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) |
- | |
342 | # include |
- | |
343 | #else |
- | |
344 | # include |
- | |
345 | #endif |
- | |
346 | - | ||
347 | struct rw_semaphore { |
- | |
348 | signed long count; |
- | |
349 | spinlock_t wait_lock; |
- | |
350 | struct list_head wait_list; |
- | |
351 | }; |
- | |
352 | 419 |