]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
1da177e4 LT |
2 | #ifndef _LINUX_WAIT_H |
3 | #define _LINUX_WAIT_H | |
fb869b6e IM |
4 | /* |
5 | * Linux wait queue related types and methods | |
6 | */ | |
1da177e4 LT |
7 | #include <linux/list.h> |
8 | #include <linux/stddef.h> | |
9 | #include <linux/spinlock.h> | |
5b825c3a | 10 | |
1da177e4 | 11 | #include <asm/current.h> |
607ca46e | 12 | #include <uapi/linux/wait.h> |
1da177e4 | 13 | |
ac6424b9 | 14 | typedef struct wait_queue_entry wait_queue_entry_t; |
50816c48 IM |
15 | |
16 | typedef int (*wait_queue_func_t)(struct wait_queue_entry *wq_entry, unsigned mode, int flags, void *key); | |
17 | int default_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int flags, void *key); | |
1da177e4 | 18 | |
ac6424b9 | 19 | /* wait_queue_entry::flags */ |
61ada528 PZ |
20 | #define WQ_FLAG_EXCLUSIVE 0x01 |
21 | #define WQ_FLAG_WOKEN 0x02 | |
2554db91 | 22 | #define WQ_FLAG_BOOKMARK 0x04 |
61ada528 | 23 | |
ac6424b9 IM |
24 | /* |
25 | * A single wait-queue entry structure: | |
26 | */ | |
27 | struct wait_queue_entry { | |
fb869b6e | 28 | unsigned int flags; |
fb869b6e IM |
29 | void *private; |
30 | wait_queue_func_t func; | |
2055da97 | 31 | struct list_head entry; |
1da177e4 LT |
32 | }; |
33 | ||
9d9d676f | 34 | struct wait_queue_head { |
fb869b6e | 35 | spinlock_t lock; |
2055da97 | 36 | struct list_head head; |
1da177e4 | 37 | }; |
9d9d676f | 38 | typedef struct wait_queue_head wait_queue_head_t; |
1da177e4 | 39 | |
8c65b4a6 | 40 | struct task_struct; |
1da177e4 LT |
41 | |
42 | /* | |
43 | * Macros for declaration and initialisaton of the datatypes | |
44 | */ | |
45 | ||
4b1c480b IM |
46 | #define __WAITQUEUE_INITIALIZER(name, tsk) { \ |
47 | .private = tsk, \ | |
48 | .func = default_wake_function, \ | |
2055da97 | 49 | .entry = { NULL, NULL } } |
1da177e4 | 50 | |
4b1c480b | 51 | #define DECLARE_WAITQUEUE(name, tsk) \ |
50816c48 | 52 | struct wait_queue_entry name = __WAITQUEUE_INITIALIZER(name, tsk) |
1da177e4 | 53 | |
4b1c480b IM |
54 | #define __WAIT_QUEUE_HEAD_INITIALIZER(name) { \ |
55 | .lock = __SPIN_LOCK_UNLOCKED(name.lock), \ | |
2055da97 | 56 | .head = { &(name).head, &(name).head } } |
1da177e4 LT |
57 | |
58 | #define DECLARE_WAIT_QUEUE_HEAD(name) \ | |
9d9d676f | 59 | struct wait_queue_head name = __WAIT_QUEUE_HEAD_INITIALIZER(name) |
1da177e4 | 60 | |
9d9d676f | 61 | extern void __init_waitqueue_head(struct wait_queue_head *wq_head, const char *name, struct lock_class_key *); |
2fc39111 | 62 | |
4b1c480b IM |
63 | #define init_waitqueue_head(wq_head) \ |
64 | do { \ | |
65 | static struct lock_class_key __key; \ | |
66 | \ | |
67 | __init_waitqueue_head((wq_head), #wq_head, &__key); \ | |
2fc39111 | 68 | } while (0) |
1da177e4 | 69 | |
7259f0d0 PZ |
70 | #ifdef CONFIG_LOCKDEP |
71 | # define __WAIT_QUEUE_HEAD_INIT_ONSTACK(name) \ | |
72 | ({ init_waitqueue_head(&name); name; }) | |
73 | # define DECLARE_WAIT_QUEUE_HEAD_ONSTACK(name) \ | |
9d9d676f | 74 | struct wait_queue_head name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name) |
7259f0d0 PZ |
75 | #else |
76 | # define DECLARE_WAIT_QUEUE_HEAD_ONSTACK(name) DECLARE_WAIT_QUEUE_HEAD(name) | |
77 | #endif | |
78 | ||
50816c48 | 79 | static inline void init_waitqueue_entry(struct wait_queue_entry *wq_entry, struct task_struct *p) |
1da177e4 | 80 | { |
50816c48 IM |
81 | wq_entry->flags = 0; |
82 | wq_entry->private = p; | |
83 | wq_entry->func = default_wake_function; | |
1da177e4 LT |
84 | } |
85 | ||
fb869b6e | 86 | static inline void |
50816c48 | 87 | init_waitqueue_func_entry(struct wait_queue_entry *wq_entry, wait_queue_func_t func) |
1da177e4 | 88 | { |
50816c48 IM |
89 | wq_entry->flags = 0; |
90 | wq_entry->private = NULL; | |
91 | wq_entry->func = func; | |
1da177e4 LT |
92 | } |
93 | ||
69e51e92 PZ |
94 | /** |
95 | * waitqueue_active -- locklessly test for waiters on the queue | |
9d9d676f | 96 | * @wq_head: the waitqueue to test for waiters |
69e51e92 PZ |
97 | * |
98 | * returns true if the wait list is not empty | |
99 | * | |
100 | * NOTE: this function is lockless and requires care, incorrect usage _will_ | |
101 | * lead to sporadic and non-obvious failure. | |
102 | * | |
9d9d676f | 103 | * Use either while holding wait_queue_head::lock or when used for wakeups |
8c1007fd | 104 | * with an extra smp_mb() like:: |
69e51e92 PZ |
105 | * |
106 | * CPU0 - waker CPU1 - waiter | |
107 | * | |
108 | * for (;;) { | |
4b1c480b | 109 | * @cond = true; prepare_to_wait(&wq_head, &wait, state); |
69e51e92 | 110 | * smp_mb(); // smp_mb() from set_current_state() |
4b1c480b IM |
111 | * if (waitqueue_active(wq_head)) if (@cond) |
112 | * wake_up(wq_head); break; | |
69e51e92 PZ |
113 | * schedule(); |
114 | * } | |
4b1c480b | 115 | * finish_wait(&wq_head, &wait); |
69e51e92 PZ |
116 | * |
117 | * Because without the explicit smp_mb() it's possible for the | |
118 | * waitqueue_active() load to get hoisted over the @cond store such that we'll | |
119 | * observe an empty wait list while the waiter might not observe @cond. | |
120 | * | |
121 | * Also note that this 'optimization' trades a spin_lock() for an smp_mb(), | |
122 | * which (when the lock is uncontended) are of roughly equal cost. | |
123 | */ | |
9d9d676f | 124 | static inline int waitqueue_active(struct wait_queue_head *wq_head) |
1da177e4 | 125 | { |
2055da97 | 126 | return !list_empty(&wq_head->head); |
1da177e4 LT |
127 | } |
128 | ||
1ce0bf50 HX |
129 | /** |
130 | * wq_has_sleeper - check if there are any waiting processes | |
4b1c480b | 131 | * @wq_head: wait queue head |
1ce0bf50 | 132 | * |
4b1c480b | 133 | * Returns true if wq_head has waiting processes |
1ce0bf50 HX |
134 | * |
135 | * Please refer to the comment for waitqueue_active. | |
136 | */ | |
9d9d676f | 137 | static inline bool wq_has_sleeper(struct wait_queue_head *wq_head) |
1ce0bf50 HX |
138 | { |
139 | /* | |
140 | * We need to be sure we are in sync with the | |
141 | * add_wait_queue modifications to the wait queue. | |
142 | * | |
143 | * This memory barrier should be paired with one on the | |
144 | * waiting side. | |
145 | */ | |
146 | smp_mb(); | |
9d9d676f | 147 | return waitqueue_active(wq_head); |
1ce0bf50 HX |
148 | } |
149 | ||
9d9d676f IM |
150 | extern void add_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry); |
151 | extern void add_wait_queue_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry); | |
152 | extern void remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry); | |
1da177e4 | 153 | |
9d9d676f | 154 | static inline void __add_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry) |
1da177e4 | 155 | { |
2055da97 | 156 | list_add(&wq_entry->entry, &wq_head->head); |
1da177e4 LT |
157 | } |
158 | ||
159 | /* | |
160 | * Used for wake-one threads: | |
161 | */ | |
fb869b6e | 162 | static inline void |
9d9d676f | 163 | __add_wait_queue_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry) |
a93d2f17 | 164 | { |
50816c48 | 165 | wq_entry->flags |= WQ_FLAG_EXCLUSIVE; |
9d9d676f | 166 | __add_wait_queue(wq_head, wq_entry); |
a93d2f17 CG |
167 | } |
168 | ||
9d9d676f | 169 | static inline void __add_wait_queue_entry_tail(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry) |
1da177e4 | 170 | { |
2055da97 | 171 | list_add_tail(&wq_entry->entry, &wq_head->head); |
1da177e4 LT |
172 | } |
173 | ||
fb869b6e | 174 | static inline void |
9d9d676f | 175 | __add_wait_queue_entry_tail_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry) |
a93d2f17 | 176 | { |
50816c48 | 177 | wq_entry->flags |= WQ_FLAG_EXCLUSIVE; |
9d9d676f | 178 | __add_wait_queue_entry_tail(wq_head, wq_entry); |
a93d2f17 CG |
179 | } |
180 | ||
fb869b6e | 181 | static inline void |
9d9d676f | 182 | __remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry) |
1da177e4 | 183 | { |
2055da97 | 184 | list_del(&wq_entry->entry); |
1da177e4 LT |
185 | } |
186 | ||
9d9d676f IM |
187 | void __wake_up(struct wait_queue_head *wq_head, unsigned int mode, int nr, void *key); |
188 | void __wake_up_locked_key(struct wait_queue_head *wq_head, unsigned int mode, void *key); | |
11a19c7b TC |
189 | void __wake_up_locked_key_bookmark(struct wait_queue_head *wq_head, |
190 | unsigned int mode, void *key, wait_queue_entry_t *bookmark); | |
9d9d676f IM |
191 | void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode, int nr, void *key); |
192 | void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr); | |
193 | void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode, int nr); | |
1da177e4 | 194 | |
e64d66c8 MW |
195 | #define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL) |
196 | #define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL) | |
197 | #define wake_up_all(x) __wake_up(x, TASK_NORMAL, 0, NULL) | |
63b20011 TG |
198 | #define wake_up_locked(x) __wake_up_locked((x), TASK_NORMAL, 1) |
199 | #define wake_up_all_locked(x) __wake_up_locked((x), TASK_NORMAL, 0) | |
e64d66c8 | 200 | |
1da177e4 LT |
201 | #define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL) |
202 | #define wake_up_interruptible_nr(x, nr) __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL) | |
203 | #define wake_up_interruptible_all(x) __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL) | |
e64d66c8 | 204 | #define wake_up_interruptible_sync(x) __wake_up_sync((x), TASK_INTERRUPTIBLE, 1) |
1da177e4 | 205 | |
0ccf831c | 206 | /* |
c0da3775 | 207 | * Wakeup macros to be used to report events to the targets. |
0ccf831c | 208 | */ |
3ad6f93e AV |
209 | #define poll_to_key(m) ((void *)(__force uintptr_t)(__poll_t)(m)) |
210 | #define key_to_poll(m) ((__force __poll_t)(uintptr_t)(void *)(m)) | |
4b1c480b | 211 | #define wake_up_poll(x, m) \ |
3ad6f93e | 212 | __wake_up(x, TASK_NORMAL, 1, poll_to_key(m)) |
4b1c480b | 213 | #define wake_up_locked_poll(x, m) \ |
3ad6f93e | 214 | __wake_up_locked_key((x), TASK_NORMAL, poll_to_key(m)) |
4b1c480b | 215 | #define wake_up_interruptible_poll(x, m) \ |
3ad6f93e | 216 | __wake_up(x, TASK_INTERRUPTIBLE, 1, poll_to_key(m)) |
4b1c480b | 217 | #define wake_up_interruptible_sync_poll(x, m) \ |
3ad6f93e | 218 | __wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, poll_to_key(m)) |
0ccf831c | 219 | |
4b1c480b IM |
220 | #define ___wait_cond_timeout(condition) \ |
221 | ({ \ | |
222 | bool __cond = (condition); \ | |
223 | if (__cond && !__ret) \ | |
224 | __ret = 1; \ | |
225 | __cond || !__ret; \ | |
2953ef24 PZ |
226 | }) |
227 | ||
4b1c480b IM |
228 | #define ___wait_is_interruptible(state) \ |
229 | (!__builtin_constant_p(state) || \ | |
230 | state == TASK_INTERRUPTIBLE || state == TASK_KILLABLE) \ | |
41a1431b | 231 | |
50816c48 | 232 | extern void init_wait_entry(struct wait_queue_entry *wq_entry, int flags); |
0176beaf | 233 | |
8b32201d PZ |
234 | /* |
235 | * The below macro ___wait_event() has an explicit shadow of the __ret | |
236 | * variable when used from the wait_event_*() macros. | |
237 | * | |
238 | * This is so that both can use the ___wait_cond_timeout() construct | |
239 | * to wrap the condition. | |
240 | * | |
241 | * The type inconsistency of the wait_event_*() __ret variable is also | |
242 | * on purpose; we use long where we can return timeout values and int | |
243 | * otherwise. | |
244 | */ | |
245 | ||
4b1c480b IM |
246 | #define ___wait_event(wq_head, condition, state, exclusive, ret, cmd) \ |
247 | ({ \ | |
248 | __label__ __out; \ | |
249 | struct wait_queue_entry __wq_entry; \ | |
250 | long __ret = ret; /* explicit shadow */ \ | |
251 | \ | |
252 | init_wait_entry(&__wq_entry, exclusive ? WQ_FLAG_EXCLUSIVE : 0); \ | |
253 | for (;;) { \ | |
254 | long __int = prepare_to_wait_event(&wq_head, &__wq_entry, state);\ | |
255 | \ | |
256 | if (condition) \ | |
257 | break; \ | |
258 | \ | |
259 | if (___wait_is_interruptible(state) && __int) { \ | |
260 | __ret = __int; \ | |
261 | goto __out; \ | |
262 | } \ | |
263 | \ | |
264 | cmd; \ | |
265 | } \ | |
266 | finish_wait(&wq_head, &__wq_entry); \ | |
267 | __out: __ret; \ | |
35a2af94 | 268 | }) |
41a1431b | 269 | |
4b1c480b IM |
270 | #define __wait_event(wq_head, condition) \ |
271 | (void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 0, 0, \ | |
35a2af94 | 272 | schedule()) |
1da177e4 LT |
273 | |
274 | /** | |
275 | * wait_event - sleep until a condition gets true | |
4b1c480b | 276 | * @wq_head: the waitqueue to wait on |
1da177e4 LT |
277 | * @condition: a C expression for the event to wait for |
278 | * | |
279 | * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the | |
280 | * @condition evaluates to true. The @condition is checked each time | |
4b1c480b | 281 | * the waitqueue @wq_head is woken up. |
1da177e4 LT |
282 | * |
283 | * wake_up() has to be called after changing any variable that could | |
284 | * change the result of the wait condition. | |
285 | */ | |
4b1c480b IM |
286 | #define wait_event(wq_head, condition) \ |
287 | do { \ | |
288 | might_sleep(); \ | |
289 | if (condition) \ | |
290 | break; \ | |
291 | __wait_event(wq_head, condition); \ | |
1da177e4 LT |
292 | } while (0) |
293 | ||
4b1c480b IM |
294 | #define __io_wait_event(wq_head, condition) \ |
295 | (void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 0, 0, \ | |
2c561246 PZ |
296 | io_schedule()) |
297 | ||
298 | /* | |
299 | * io_wait_event() -- like wait_event() but with io_schedule() | |
300 | */ | |
4b1c480b IM |
301 | #define io_wait_event(wq_head, condition) \ |
302 | do { \ | |
303 | might_sleep(); \ | |
304 | if (condition) \ | |
305 | break; \ | |
306 | __io_wait_event(wq_head, condition); \ | |
2c561246 PZ |
307 | } while (0) |
308 | ||
4b1c480b IM |
309 | #define __wait_event_freezable(wq_head, condition) \ |
310 | ___wait_event(wq_head, condition, TASK_INTERRUPTIBLE, 0, 0, \ | |
2b9c2a48 | 311 | freezable_schedule()) |
36df04bc PZ |
312 | |
313 | /** | |
f4bcfa1d | 314 | * wait_event_freezable - sleep (or freeze) until a condition gets true |
4b1c480b | 315 | * @wq_head: the waitqueue to wait on |
36df04bc PZ |
316 | * @condition: a C expression for the event to wait for |
317 | * | |
318 | * The process is put to sleep (TASK_INTERRUPTIBLE -- so as not to contribute | |
319 | * to system load) until the @condition evaluates to true. The | |
4b1c480b | 320 | * @condition is checked each time the waitqueue @wq_head is woken up. |
36df04bc PZ |
321 | * |
322 | * wake_up() has to be called after changing any variable that could | |
323 | * change the result of the wait condition. | |
324 | */ | |
4b1c480b IM |
325 | #define wait_event_freezable(wq_head, condition) \ |
326 | ({ \ | |
327 | int __ret = 0; \ | |
328 | might_sleep(); \ | |
329 | if (!(condition)) \ | |
330 | __ret = __wait_event_freezable(wq_head, condition); \ | |
331 | __ret; \ | |
36df04bc PZ |
332 | }) |
333 | ||
4b1c480b IM |
334 | #define __wait_event_timeout(wq_head, condition, timeout) \ |
335 | ___wait_event(wq_head, ___wait_cond_timeout(condition), \ | |
336 | TASK_UNINTERRUPTIBLE, 0, timeout, \ | |
35a2af94 | 337 | __ret = schedule_timeout(__ret)) |
1da177e4 LT |
338 | |
339 | /** | |
340 | * wait_event_timeout - sleep until a condition gets true or a timeout elapses | |
4b1c480b | 341 | * @wq_head: the waitqueue to wait on |
1da177e4 LT |
342 | * @condition: a C expression for the event to wait for |
343 | * @timeout: timeout, in jiffies | |
344 | * | |
345 | * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the | |
346 | * @condition evaluates to true. The @condition is checked each time | |
4b1c480b | 347 | * the waitqueue @wq_head is woken up. |
1da177e4 LT |
348 | * |
349 | * wake_up() has to be called after changing any variable that could | |
350 | * change the result of the wait condition. | |
351 | * | |
6b44f519 SD |
352 | * Returns: |
353 | * 0 if the @condition evaluated to %false after the @timeout elapsed, | |
354 | * 1 if the @condition evaluated to %true after the @timeout elapsed, | |
355 | * or the remaining jiffies (at least 1) if the @condition evaluated | |
356 | * to %true before the @timeout elapsed. | |
1da177e4 | 357 | */ |
4b1c480b IM |
358 | #define wait_event_timeout(wq_head, condition, timeout) \ |
359 | ({ \ | |
360 | long __ret = timeout; \ | |
361 | might_sleep(); \ | |
362 | if (!___wait_cond_timeout(condition)) \ | |
363 | __ret = __wait_event_timeout(wq_head, condition, timeout); \ | |
364 | __ret; \ | |
1da177e4 LT |
365 | }) |
366 | ||
4b1c480b IM |
367 | #define __wait_event_freezable_timeout(wq_head, condition, timeout) \ |
368 | ___wait_event(wq_head, ___wait_cond_timeout(condition), \ | |
369 | TASK_INTERRUPTIBLE, 0, timeout, \ | |
2b9c2a48 | 370 | __ret = freezable_schedule_timeout(__ret)) |
36df04bc PZ |
371 | |
372 | /* | |
373 | * like wait_event_timeout() -- except it uses TASK_INTERRUPTIBLE to avoid | |
374 | * increasing load and is freezable. | |
375 | */ | |
4b1c480b IM |
376 | #define wait_event_freezable_timeout(wq_head, condition, timeout) \ |
377 | ({ \ | |
378 | long __ret = timeout; \ | |
379 | might_sleep(); \ | |
380 | if (!___wait_cond_timeout(condition)) \ | |
381 | __ret = __wait_event_freezable_timeout(wq_head, condition, timeout); \ | |
382 | __ret; \ | |
36df04bc PZ |
383 | }) |
384 | ||
4b1c480b IM |
385 | #define __wait_event_exclusive_cmd(wq_head, condition, cmd1, cmd2) \ |
386 | (void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 1, 0, \ | |
9f3520c3 YL |
387 | cmd1; schedule(); cmd2) |
388 | /* | |
389 | * Just like wait_event_cmd(), except it sets exclusive flag | |
390 | */ | |
4b1c480b IM |
391 | #define wait_event_exclusive_cmd(wq_head, condition, cmd1, cmd2) \ |
392 | do { \ | |
393 | if (condition) \ | |
394 | break; \ | |
395 | __wait_event_exclusive_cmd(wq_head, condition, cmd1, cmd2); \ | |
9f3520c3 YL |
396 | } while (0) |
397 | ||
4b1c480b IM |
398 | #define __wait_event_cmd(wq_head, condition, cmd1, cmd2) \ |
399 | (void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 0, 0, \ | |
82e06c81 SL |
400 | cmd1; schedule(); cmd2) |
401 | ||
402 | /** | |
403 | * wait_event_cmd - sleep until a condition gets true | |
4b1c480b | 404 | * @wq_head: the waitqueue to wait on |
82e06c81 | 405 | * @condition: a C expression for the event to wait for |
f434f7af MI |
406 | * @cmd1: the command will be executed before sleep |
407 | * @cmd2: the command will be executed after sleep | |
82e06c81 SL |
408 | * |
409 | * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the | |
410 | * @condition evaluates to true. The @condition is checked each time | |
4b1c480b | 411 | * the waitqueue @wq_head is woken up. |
82e06c81 SL |
412 | * |
413 | * wake_up() has to be called after changing any variable that could | |
414 | * change the result of the wait condition. | |
415 | */ | |
4b1c480b IM |
416 | #define wait_event_cmd(wq_head, condition, cmd1, cmd2) \ |
417 | do { \ | |
418 | if (condition) \ | |
419 | break; \ | |
420 | __wait_event_cmd(wq_head, condition, cmd1, cmd2); \ | |
82e06c81 SL |
421 | } while (0) |
422 | ||
4b1c480b IM |
423 | #define __wait_event_interruptible(wq_head, condition) \ |
424 | ___wait_event(wq_head, condition, TASK_INTERRUPTIBLE, 0, 0, \ | |
f13f4c41 | 425 | schedule()) |
1da177e4 LT |
426 | |
427 | /** | |
428 | * wait_event_interruptible - sleep until a condition gets true | |
4b1c480b | 429 | * @wq_head: the waitqueue to wait on |
1da177e4 LT |
430 | * @condition: a C expression for the event to wait for |
431 | * | |
432 | * The process is put to sleep (TASK_INTERRUPTIBLE) until the | |
433 | * @condition evaluates to true or a signal is received. | |
4b1c480b | 434 | * The @condition is checked each time the waitqueue @wq_head is woken up. |
1da177e4 LT |
435 | * |
436 | * wake_up() has to be called after changing any variable that could | |
437 | * change the result of the wait condition. | |
438 | * | |
439 | * The function will return -ERESTARTSYS if it was interrupted by a | |
440 | * signal and 0 if @condition evaluated to true. | |
441 | */ | |
4b1c480b IM |
442 | #define wait_event_interruptible(wq_head, condition) \ |
443 | ({ \ | |
444 | int __ret = 0; \ | |
445 | might_sleep(); \ | |
446 | if (!(condition)) \ | |
447 | __ret = __wait_event_interruptible(wq_head, condition); \ | |
448 | __ret; \ | |
1da177e4 LT |
449 | }) |
450 | ||
4b1c480b IM |
451 | #define __wait_event_interruptible_timeout(wq_head, condition, timeout) \ |
452 | ___wait_event(wq_head, ___wait_cond_timeout(condition), \ | |
453 | TASK_INTERRUPTIBLE, 0, timeout, \ | |
35a2af94 | 454 | __ret = schedule_timeout(__ret)) |
1da177e4 LT |
455 | |
456 | /** | |
457 | * wait_event_interruptible_timeout - sleep until a condition gets true or a timeout elapses | |
4b1c480b | 458 | * @wq_head: the waitqueue to wait on |
1da177e4 LT |
459 | * @condition: a C expression for the event to wait for |
460 | * @timeout: timeout, in jiffies | |
461 | * | |
462 | * The process is put to sleep (TASK_INTERRUPTIBLE) until the | |
463 | * @condition evaluates to true or a signal is received. | |
4b1c480b | 464 | * The @condition is checked each time the waitqueue @wq_head is woken up. |
1da177e4 LT |
465 | * |
466 | * wake_up() has to be called after changing any variable that could | |
467 | * change the result of the wait condition. | |
468 | * | |
4c663cfc | 469 | * Returns: |
6b44f519 SD |
470 | * 0 if the @condition evaluated to %false after the @timeout elapsed, |
471 | * 1 if the @condition evaluated to %true after the @timeout elapsed, | |
472 | * the remaining jiffies (at least 1) if the @condition evaluated | |
473 | * to %true before the @timeout elapsed, or -%ERESTARTSYS if it was | |
474 | * interrupted by a signal. | |
1da177e4 | 475 | */ |
4b1c480b IM |
476 | #define wait_event_interruptible_timeout(wq_head, condition, timeout) \ |
477 | ({ \ | |
478 | long __ret = timeout; \ | |
479 | might_sleep(); \ | |
480 | if (!___wait_cond_timeout(condition)) \ | |
481 | __ret = __wait_event_interruptible_timeout(wq_head, \ | |
482 | condition, timeout); \ | |
483 | __ret; \ | |
1da177e4 LT |
484 | }) |
485 | ||
4b1c480b IM |
486 | #define __wait_event_hrtimeout(wq_head, condition, timeout, state) \ |
487 | ({ \ | |
488 | int __ret = 0; \ | |
489 | struct hrtimer_sleeper __t; \ | |
490 | \ | |
491 | hrtimer_init_on_stack(&__t.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); \ | |
492 | hrtimer_init_sleeper(&__t, current); \ | |
493 | if ((timeout) != KTIME_MAX) \ | |
494 | hrtimer_start_range_ns(&__t.timer, timeout, \ | |
495 | current->timer_slack_ns, \ | |
496 | HRTIMER_MODE_REL); \ | |
497 | \ | |
498 | __ret = ___wait_event(wq_head, condition, state, 0, 0, \ | |
499 | if (!__t.task) { \ | |
500 | __ret = -ETIME; \ | |
501 | break; \ | |
502 | } \ | |
503 | schedule()); \ | |
504 | \ | |
505 | hrtimer_cancel(&__t.timer); \ | |
506 | destroy_hrtimer_on_stack(&__t.timer); \ | |
507 | __ret; \ | |
774a08b3 KO |
508 | }) |
509 | ||
510 | /** | |
511 | * wait_event_hrtimeout - sleep until a condition gets true or a timeout elapses | |
4b1c480b | 512 | * @wq_head: the waitqueue to wait on |
774a08b3 KO |
513 | * @condition: a C expression for the event to wait for |
514 | * @timeout: timeout, as a ktime_t | |
515 | * | |
516 | * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the | |
517 | * @condition evaluates to true or a signal is received. | |
4b1c480b | 518 | * The @condition is checked each time the waitqueue @wq_head is woken up. |
774a08b3 KO |
519 | * |
520 | * wake_up() has to be called after changing any variable that could | |
521 | * change the result of the wait condition. | |
522 | * | |
523 | * The function returns 0 if @condition became true, or -ETIME if the timeout | |
524 | * elapsed. | |
525 | */ | |
4b1c480b IM |
526 | #define wait_event_hrtimeout(wq_head, condition, timeout) \ |
527 | ({ \ | |
528 | int __ret = 0; \ | |
529 | might_sleep(); \ | |
530 | if (!(condition)) \ | |
531 | __ret = __wait_event_hrtimeout(wq_head, condition, timeout, \ | |
532 | TASK_UNINTERRUPTIBLE); \ | |
533 | __ret; \ | |
774a08b3 KO |
534 | }) |
535 | ||
536 | /** | |
537 | * wait_event_interruptible_hrtimeout - sleep until a condition gets true or a timeout elapses | |
6c423f57 | 538 | * @wq: the waitqueue to wait on |
774a08b3 KO |
539 | * @condition: a C expression for the event to wait for |
540 | * @timeout: timeout, as a ktime_t | |
541 | * | |
542 | * The process is put to sleep (TASK_INTERRUPTIBLE) until the | |
543 | * @condition evaluates to true or a signal is received. | |
6c423f57 | 544 | * The @condition is checked each time the waitqueue @wq is woken up. |
774a08b3 KO |
545 | * |
546 | * wake_up() has to be called after changing any variable that could | |
547 | * change the result of the wait condition. | |
548 | * | |
549 | * The function returns 0 if @condition became true, -ERESTARTSYS if it was | |
550 | * interrupted by a signal, or -ETIME if the timeout elapsed. | |
551 | */ | |
4b1c480b IM |
552 | #define wait_event_interruptible_hrtimeout(wq, condition, timeout) \ |
553 | ({ \ | |
554 | long __ret = 0; \ | |
555 | might_sleep(); \ | |
556 | if (!(condition)) \ | |
557 | __ret = __wait_event_hrtimeout(wq, condition, timeout, \ | |
558 | TASK_INTERRUPTIBLE); \ | |
559 | __ret; \ | |
774a08b3 KO |
560 | }) |
561 | ||
4b1c480b IM |
562 | #define __wait_event_interruptible_exclusive(wq, condition) \ |
563 | ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 1, 0, \ | |
48c25217 | 564 | schedule()) |
1da177e4 | 565 | |
4b1c480b IM |
566 | #define wait_event_interruptible_exclusive(wq, condition) \ |
567 | ({ \ | |
568 | int __ret = 0; \ | |
569 | might_sleep(); \ | |
570 | if (!(condition)) \ | |
571 | __ret = __wait_event_interruptible_exclusive(wq, condition); \ | |
572 | __ret; \ | |
1da177e4 LT |
573 | }) |
574 | ||
4b1c480b IM |
575 | #define __wait_event_killable_exclusive(wq, condition) \ |
576 | ___wait_event(wq, condition, TASK_KILLABLE, 1, 0, \ | |
6a0fb306 AV |
577 | schedule()) |
578 | ||
4b1c480b IM |
579 | #define wait_event_killable_exclusive(wq, condition) \ |
580 | ({ \ | |
581 | int __ret = 0; \ | |
582 | might_sleep(); \ | |
583 | if (!(condition)) \ | |
584 | __ret = __wait_event_killable_exclusive(wq, condition); \ | |
585 | __ret; \ | |
6a0fb306 AV |
586 | }) |
587 | ||
22c43c81 | 588 | |
4b1c480b IM |
589 | #define __wait_event_freezable_exclusive(wq, condition) \ |
590 | ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 1, 0, \ | |
2b9c2a48 | 591 | freezable_schedule()) |
36df04bc | 592 | |
4b1c480b IM |
593 | #define wait_event_freezable_exclusive(wq, condition) \ |
594 | ({ \ | |
595 | int __ret = 0; \ | |
596 | might_sleep(); \ | |
597 | if (!(condition)) \ | |
598 | __ret = __wait_event_freezable_exclusive(wq, condition); \ | |
599 | __ret; \ | |
36df04bc PZ |
600 | }) |
601 | ||
0957a2c1 N |
602 | /** |
603 | * wait_event_idle - wait for a condition without contributing to system load | |
604 | * @wq_head: the waitqueue to wait on | |
605 | * @condition: a C expression for the event to wait for | |
606 | * | |
607 | * The process is put to sleep (TASK_IDLE) until the | |
608 | * @condition evaluates to true. | |
609 | * The @condition is checked each time the waitqueue @wq_head is woken up. | |
610 | * | |
611 | * wake_up() has to be called after changing any variable that could | |
612 | * change the result of the wait condition. | |
613 | * | |
614 | */ | |
615 | #define wait_event_idle(wq_head, condition) \ | |
616 | do { \ | |
617 | might_sleep(); \ | |
618 | if (!(condition)) \ | |
619 | ___wait_event(wq_head, condition, TASK_IDLE, 0, 0, schedule()); \ | |
620 | } while (0) | |
621 | ||
622 | /** | |
623 | * wait_event_idle_exclusive - wait for a condition with contributing to system load | |
624 | * @wq_head: the waitqueue to wait on | |
625 | * @condition: a C expression for the event to wait for | |
626 | * | |
627 | * The process is put to sleep (TASK_IDLE) until the | |
628 | * @condition evaluates to true. | |
629 | * The @condition is checked each time the waitqueue @wq_head is woken up. | |
630 | * | |
631 | * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag | |
632 | * set thus if other processes wait on the same list, when this | |
633 | * process is woken further processes are not considered. | |
634 | * | |
635 | * wake_up() has to be called after changing any variable that could | |
636 | * change the result of the wait condition. | |
637 | * | |
638 | */ | |
639 | #define wait_event_idle_exclusive(wq_head, condition) \ | |
640 | do { \ | |
641 | might_sleep(); \ | |
642 | if (!(condition)) \ | |
643 | ___wait_event(wq_head, condition, TASK_IDLE, 1, 0, schedule()); \ | |
644 | } while (0) | |
645 | ||
646 | #define __wait_event_idle_timeout(wq_head, condition, timeout) \ | |
647 | ___wait_event(wq_head, ___wait_cond_timeout(condition), \ | |
648 | TASK_IDLE, 0, timeout, \ | |
649 | __ret = schedule_timeout(__ret)) | |
650 | ||
651 | /** | |
652 | * wait_event_idle_timeout - sleep without load until a condition becomes true or a timeout elapses | |
653 | * @wq_head: the waitqueue to wait on | |
654 | * @condition: a C expression for the event to wait for | |
655 | * @timeout: timeout, in jiffies | |
656 | * | |
657 | * The process is put to sleep (TASK_IDLE) until the | |
658 | * @condition evaluates to true. The @condition is checked each time | |
659 | * the waitqueue @wq_head is woken up. | |
660 | * | |
661 | * wake_up() has to be called after changing any variable that could | |
662 | * change the result of the wait condition. | |
663 | * | |
664 | * Returns: | |
665 | * 0 if the @condition evaluated to %false after the @timeout elapsed, | |
666 | * 1 if the @condition evaluated to %true after the @timeout elapsed, | |
667 | * or the remaining jiffies (at least 1) if the @condition evaluated | |
668 | * to %true before the @timeout elapsed. | |
669 | */ | |
670 | #define wait_event_idle_timeout(wq_head, condition, timeout) \ | |
671 | ({ \ | |
672 | long __ret = timeout; \ | |
673 | might_sleep(); \ | |
674 | if (!___wait_cond_timeout(condition)) \ | |
675 | __ret = __wait_event_idle_timeout(wq_head, condition, timeout); \ | |
676 | __ret; \ | |
677 | }) | |
678 | ||
679 | #define __wait_event_idle_exclusive_timeout(wq_head, condition, timeout) \ | |
680 | ___wait_event(wq_head, ___wait_cond_timeout(condition), \ | |
681 | TASK_IDLE, 1, timeout, \ | |
682 | __ret = schedule_timeout(__ret)) | |
683 | ||
684 | /** | |
685 | * wait_event_idle_exclusive_timeout - sleep without load until a condition becomes true or a timeout elapses | |
686 | * @wq_head: the waitqueue to wait on | |
687 | * @condition: a C expression for the event to wait for | |
688 | * @timeout: timeout, in jiffies | |
689 | * | |
690 | * The process is put to sleep (TASK_IDLE) until the | |
691 | * @condition evaluates to true. The @condition is checked each time | |
692 | * the waitqueue @wq_head is woken up. | |
693 | * | |
694 | * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag | |
695 | * set thus if other processes wait on the same list, when this | |
696 | * process is woken further processes are not considered. | |
697 | * | |
698 | * wake_up() has to be called after changing any variable that could | |
699 | * change the result of the wait condition. | |
700 | * | |
701 | * Returns: | |
702 | * 0 if the @condition evaluated to %false after the @timeout elapsed, | |
703 | * 1 if the @condition evaluated to %true after the @timeout elapsed, | |
704 | * or the remaining jiffies (at least 1) if the @condition evaluated | |
705 | * to %true before the @timeout elapsed. | |
706 | */ | |
707 | #define wait_event_idle_exclusive_timeout(wq_head, condition, timeout) \ | |
708 | ({ \ | |
709 | long __ret = timeout; \ | |
710 | might_sleep(); \ | |
711 | if (!___wait_cond_timeout(condition)) \ | |
712 | __ret = __wait_event_idle_exclusive_timeout(wq_head, condition, timeout);\ | |
713 | __ret; \ | |
714 | }) | |
715 | ||
ac6424b9 IM |
716 | extern int do_wait_intr(wait_queue_head_t *, wait_queue_entry_t *); |
717 | extern int do_wait_intr_irq(wait_queue_head_t *, wait_queue_entry_t *); | |
36df04bc | 718 | |
4b1c480b IM |
719 | #define __wait_event_interruptible_locked(wq, condition, exclusive, fn) \ |
720 | ({ \ | |
721 | int __ret; \ | |
722 | DEFINE_WAIT(__wait); \ | |
723 | if (exclusive) \ | |
724 | __wait.flags |= WQ_FLAG_EXCLUSIVE; \ | |
725 | do { \ | |
726 | __ret = fn(&(wq), &__wait); \ | |
727 | if (__ret) \ | |
728 | break; \ | |
729 | } while (!(condition)); \ | |
730 | __remove_wait_queue(&(wq), &__wait); \ | |
731 | __set_current_state(TASK_RUNNING); \ | |
732 | __ret; \ | |
22c43c81 MN |
733 | }) |
734 | ||
735 | ||
736 | /** | |
737 | * wait_event_interruptible_locked - sleep until a condition gets true | |
738 | * @wq: the waitqueue to wait on | |
739 | * @condition: a C expression for the event to wait for | |
740 | * | |
741 | * The process is put to sleep (TASK_INTERRUPTIBLE) until the | |
742 | * @condition evaluates to true or a signal is received. | |
743 | * The @condition is checked each time the waitqueue @wq is woken up. | |
744 | * | |
745 | * It must be called with wq.lock being held. This spinlock is | |
746 | * unlocked while sleeping but @condition testing is done while lock | |
747 | * is held and when this macro exits the lock is held. | |
748 | * | |
749 | * The lock is locked/unlocked using spin_lock()/spin_unlock() | |
750 | * functions which must match the way they are locked/unlocked outside | |
751 | * of this macro. | |
752 | * | |
753 | * wake_up_locked() has to be called after changing any variable that could | |
754 | * change the result of the wait condition. | |
755 | * | |
756 | * The function will return -ERESTARTSYS if it was interrupted by a | |
757 | * signal and 0 if @condition evaluated to true. | |
758 | */ | |
4b1c480b IM |
759 | #define wait_event_interruptible_locked(wq, condition) \ |
760 | ((condition) \ | |
bd0f9b35 | 761 | ? 0 : __wait_event_interruptible_locked(wq, condition, 0, do_wait_intr)) |
22c43c81 MN |
762 | |
763 | /** | |
764 | * wait_event_interruptible_locked_irq - sleep until a condition gets true | |
765 | * @wq: the waitqueue to wait on | |
766 | * @condition: a C expression for the event to wait for | |
767 | * | |
768 | * The process is put to sleep (TASK_INTERRUPTIBLE) until the | |
769 | * @condition evaluates to true or a signal is received. | |
770 | * The @condition is checked each time the waitqueue @wq is woken up. | |
771 | * | |
772 | * It must be called with wq.lock being held. This spinlock is | |
773 | * unlocked while sleeping but @condition testing is done while lock | |
774 | * is held and when this macro exits the lock is held. | |
775 | * | |
776 | * The lock is locked/unlocked using spin_lock_irq()/spin_unlock_irq() | |
777 | * functions which must match the way they are locked/unlocked outside | |
778 | * of this macro. | |
779 | * | |
780 | * wake_up_locked() has to be called after changing any variable that could | |
781 | * change the result of the wait condition. | |
782 | * | |
783 | * The function will return -ERESTARTSYS if it was interrupted by a | |
784 | * signal and 0 if @condition evaluated to true. | |
785 | */ | |
4b1c480b IM |
786 | #define wait_event_interruptible_locked_irq(wq, condition) \ |
787 | ((condition) \ | |
bd0f9b35 | 788 | ? 0 : __wait_event_interruptible_locked(wq, condition, 0, do_wait_intr_irq)) |
22c43c81 MN |
789 | |
790 | /** | |
791 | * wait_event_interruptible_exclusive_locked - sleep exclusively until a condition gets true | |
792 | * @wq: the waitqueue to wait on | |
793 | * @condition: a C expression for the event to wait for | |
794 | * | |
795 | * The process is put to sleep (TASK_INTERRUPTIBLE) until the | |
796 | * @condition evaluates to true or a signal is received. | |
797 | * The @condition is checked each time the waitqueue @wq is woken up. | |
798 | * | |
799 | * It must be called with wq.lock being held. This spinlock is | |
800 | * unlocked while sleeping but @condition testing is done while lock | |
801 | * is held and when this macro exits the lock is held. | |
802 | * | |
803 | * The lock is locked/unlocked using spin_lock()/spin_unlock() | |
804 | * functions which must match the way they are locked/unlocked outside | |
805 | * of this macro. | |
806 | * | |
807 | * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag | |
808 | * set thus when other process waits process on the list if this | |
809 | * process is awaken further processes are not considered. | |
810 | * | |
811 | * wake_up_locked() has to be called after changing any variable that could | |
812 | * change the result of the wait condition. | |
813 | * | |
814 | * The function will return -ERESTARTSYS if it was interrupted by a | |
815 | * signal and 0 if @condition evaluated to true. | |
816 | */ | |
4b1c480b IM |
817 | #define wait_event_interruptible_exclusive_locked(wq, condition) \ |
818 | ((condition) \ | |
bd0f9b35 | 819 | ? 0 : __wait_event_interruptible_locked(wq, condition, 1, do_wait_intr)) |
22c43c81 MN |
820 | |
821 | /** | |
822 | * wait_event_interruptible_exclusive_locked_irq - sleep until a condition gets true | |
823 | * @wq: the waitqueue to wait on | |
824 | * @condition: a C expression for the event to wait for | |
825 | * | |
826 | * The process is put to sleep (TASK_INTERRUPTIBLE) until the | |
827 | * @condition evaluates to true or a signal is received. | |
828 | * The @condition is checked each time the waitqueue @wq is woken up. | |
829 | * | |
830 | * It must be called with wq.lock being held. This spinlock is | |
831 | * unlocked while sleeping but @condition testing is done while lock | |
832 | * is held and when this macro exits the lock is held. | |
833 | * | |
834 | * The lock is locked/unlocked using spin_lock_irq()/spin_unlock_irq() | |
835 | * functions which must match the way they are locked/unlocked outside | |
836 | * of this macro. | |
837 | * | |
838 | * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag | |
839 | * set thus when other process waits process on the list if this | |
840 | * process is awaken further processes are not considered. | |
841 | * | |
842 | * wake_up_locked() has to be called after changing any variable that could | |
843 | * change the result of the wait condition. | |
844 | * | |
845 | * The function will return -ERESTARTSYS if it was interrupted by a | |
846 | * signal and 0 if @condition evaluated to true. | |
847 | */ | |
4b1c480b IM |
848 | #define wait_event_interruptible_exclusive_locked_irq(wq, condition) \ |
849 | ((condition) \ | |
bd0f9b35 | 850 | ? 0 : __wait_event_interruptible_locked(wq, condition, 1, do_wait_intr_irq)) |
22c43c81 MN |
851 | |
852 | ||
4b1c480b | 853 | #define __wait_event_killable(wq, condition) \ |
35a2af94 | 854 | ___wait_event(wq, condition, TASK_KILLABLE, 0, 0, schedule()) |
1411d5a7 MW |
855 | |
856 | /** | |
857 | * wait_event_killable - sleep until a condition gets true | |
6c423f57 | 858 | * @wq_head: the waitqueue to wait on |
1411d5a7 MW |
859 | * @condition: a C expression for the event to wait for |
860 | * | |
861 | * The process is put to sleep (TASK_KILLABLE) until the | |
862 | * @condition evaluates to true or a signal is received. | |
6c423f57 | 863 | * The @condition is checked each time the waitqueue @wq_head is woken up. |
1411d5a7 MW |
864 | * |
865 | * wake_up() has to be called after changing any variable that could | |
866 | * change the result of the wait condition. | |
867 | * | |
868 | * The function will return -ERESTARTSYS if it was interrupted by a | |
869 | * signal and 0 if @condition evaluated to true. | |
870 | */ | |
4b1c480b IM |
871 | #define wait_event_killable(wq_head, condition) \ |
872 | ({ \ | |
873 | int __ret = 0; \ | |
874 | might_sleep(); \ | |
875 | if (!(condition)) \ | |
876 | __ret = __wait_event_killable(wq_head, condition); \ | |
877 | __ret; \ | |
1411d5a7 MW |
878 | }) |
879 | ||
8ada9279 LR |
880 | #define __wait_event_killable_timeout(wq_head, condition, timeout) \ |
881 | ___wait_event(wq_head, ___wait_cond_timeout(condition), \ | |
882 | TASK_KILLABLE, 0, timeout, \ | |
883 | __ret = schedule_timeout(__ret)) | |
884 | ||
885 | /** | |
886 | * wait_event_killable_timeout - sleep until a condition gets true or a timeout elapses | |
887 | * @wq_head: the waitqueue to wait on | |
888 | * @condition: a C expression for the event to wait for | |
889 | * @timeout: timeout, in jiffies | |
890 | * | |
891 | * The process is put to sleep (TASK_KILLABLE) until the | |
892 | * @condition evaluates to true or a kill signal is received. | |
893 | * The @condition is checked each time the waitqueue @wq_head is woken up. | |
894 | * | |
895 | * wake_up() has to be called after changing any variable that could | |
896 | * change the result of the wait condition. | |
897 | * | |
898 | * Returns: | |
899 | * 0 if the @condition evaluated to %false after the @timeout elapsed, | |
900 | * 1 if the @condition evaluated to %true after the @timeout elapsed, | |
901 | * the remaining jiffies (at least 1) if the @condition evaluated | |
902 | * to %true before the @timeout elapsed, or -%ERESTARTSYS if it was | |
903 | * interrupted by a kill signal. | |
904 | * | |
905 | * Only kill signals interrupt this process. | |
906 | */ | |
907 | #define wait_event_killable_timeout(wq_head, condition, timeout) \ | |
908 | ({ \ | |
909 | long __ret = timeout; \ | |
910 | might_sleep(); \ | |
911 | if (!___wait_cond_timeout(condition)) \ | |
912 | __ret = __wait_event_killable_timeout(wq_head, \ | |
913 | condition, timeout); \ | |
914 | __ret; \ | |
915 | }) | |
916 | ||
eed8c02e | 917 | |
4b1c480b IM |
918 | #define __wait_event_lock_irq(wq_head, condition, lock, cmd) \ |
919 | (void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 0, 0, \ | |
920 | spin_unlock_irq(&lock); \ | |
921 | cmd; \ | |
922 | schedule(); \ | |
35a2af94 | 923 | spin_lock_irq(&lock)) |
eed8c02e LC |
924 | |
925 | /** | |
926 | * wait_event_lock_irq_cmd - sleep until a condition gets true. The | |
927 | * condition is checked under the lock. This | |
928 | * is expected to be called with the lock | |
929 | * taken. | |
4b1c480b | 930 | * @wq_head: the waitqueue to wait on |
eed8c02e LC |
931 | * @condition: a C expression for the event to wait for |
932 | * @lock: a locked spinlock_t, which will be released before cmd | |
933 | * and schedule() and reacquired afterwards. | |
934 | * @cmd: a command which is invoked outside the critical section before | |
935 | * sleep | |
936 | * | |
937 | * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the | |
938 | * @condition evaluates to true. The @condition is checked each time | |
4b1c480b | 939 | * the waitqueue @wq_head is woken up. |
eed8c02e LC |
940 | * |
941 | * wake_up() has to be called after changing any variable that could | |
942 | * change the result of the wait condition. | |
943 | * | |
944 | * This is supposed to be called while holding the lock. The lock is | |
945 | * dropped before invoking the cmd and going to sleep and is reacquired | |
946 | * afterwards. | |
947 | */ | |
4b1c480b IM |
948 | #define wait_event_lock_irq_cmd(wq_head, condition, lock, cmd) \ |
949 | do { \ | |
950 | if (condition) \ | |
951 | break; \ | |
952 | __wait_event_lock_irq(wq_head, condition, lock, cmd); \ | |
eed8c02e LC |
953 | } while (0) |
954 | ||
955 | /** | |
956 | * wait_event_lock_irq - sleep until a condition gets true. The | |
957 | * condition is checked under the lock. This | |
958 | * is expected to be called with the lock | |
959 | * taken. | |
4b1c480b | 960 | * @wq_head: the waitqueue to wait on |
eed8c02e LC |
961 | * @condition: a C expression for the event to wait for |
962 | * @lock: a locked spinlock_t, which will be released before schedule() | |
963 | * and reacquired afterwards. | |
964 | * | |
965 | * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the | |
966 | * @condition evaluates to true. The @condition is checked each time | |
4b1c480b | 967 | * the waitqueue @wq_head is woken up. |
eed8c02e LC |
968 | * |
969 | * wake_up() has to be called after changing any variable that could | |
970 | * change the result of the wait condition. | |
971 | * | |
972 | * This is supposed to be called while holding the lock. The lock is | |
973 | * dropped before going to sleep and is reacquired afterwards. | |
974 | */ | |
4b1c480b IM |
975 | #define wait_event_lock_irq(wq_head, condition, lock) \ |
976 | do { \ | |
977 | if (condition) \ | |
978 | break; \ | |
979 | __wait_event_lock_irq(wq_head, condition, lock, ); \ | |
eed8c02e LC |
980 | } while (0) |
981 | ||
982 | ||
4b1c480b IM |
983 | #define __wait_event_interruptible_lock_irq(wq_head, condition, lock, cmd) \ |
984 | ___wait_event(wq_head, condition, TASK_INTERRUPTIBLE, 0, 0, \ | |
985 | spin_unlock_irq(&lock); \ | |
986 | cmd; \ | |
987 | schedule(); \ | |
8fbd88fa | 988 | spin_lock_irq(&lock)) |
eed8c02e LC |
989 | |
990 | /** | |
991 | * wait_event_interruptible_lock_irq_cmd - sleep until a condition gets true. | |
992 | * The condition is checked under the lock. This is expected to | |
993 | * be called with the lock taken. | |
4b1c480b | 994 | * @wq_head: the waitqueue to wait on |
eed8c02e LC |
995 | * @condition: a C expression for the event to wait for |
996 | * @lock: a locked spinlock_t, which will be released before cmd and | |
997 | * schedule() and reacquired afterwards. | |
998 | * @cmd: a command which is invoked outside the critical section before | |
999 | * sleep | |
1000 | * | |
1001 | * The process is put to sleep (TASK_INTERRUPTIBLE) until the | |
1002 | * @condition evaluates to true or a signal is received. The @condition is | |
4b1c480b | 1003 | * checked each time the waitqueue @wq_head is woken up. |
eed8c02e LC |
1004 | * |
1005 | * wake_up() has to be called after changing any variable that could | |
1006 | * change the result of the wait condition. | |
1007 | * | |
1008 | * This is supposed to be called while holding the lock. The lock is | |
1009 | * dropped before invoking the cmd and going to sleep and is reacquired | |
1010 | * afterwards. | |
1011 | * | |
1012 | * The macro will return -ERESTARTSYS if it was interrupted by a signal | |
1013 | * and 0 if @condition evaluated to true. | |
1014 | */ | |
4b1c480b IM |
1015 | #define wait_event_interruptible_lock_irq_cmd(wq_head, condition, lock, cmd) \ |
1016 | ({ \ | |
1017 | int __ret = 0; \ | |
1018 | if (!(condition)) \ | |
1019 | __ret = __wait_event_interruptible_lock_irq(wq_head, \ | |
1020 | condition, lock, cmd); \ | |
1021 | __ret; \ | |
eed8c02e LC |
1022 | }) |
1023 | ||
1024 | /** | |
1025 | * wait_event_interruptible_lock_irq - sleep until a condition gets true. | |
1026 | * The condition is checked under the lock. This is expected | |
1027 | * to be called with the lock taken. | |
4b1c480b | 1028 | * @wq_head: the waitqueue to wait on |
eed8c02e LC |
1029 | * @condition: a C expression for the event to wait for |
1030 | * @lock: a locked spinlock_t, which will be released before schedule() | |
1031 | * and reacquired afterwards. | |
1032 | * | |
1033 | * The process is put to sleep (TASK_INTERRUPTIBLE) until the | |
1034 | * @condition evaluates to true or signal is received. The @condition is | |
4b1c480b | 1035 | * checked each time the waitqueue @wq_head is woken up. |
eed8c02e LC |
1036 | * |
1037 | * wake_up() has to be called after changing any variable that could | |
1038 | * change the result of the wait condition. | |
1039 | * | |
1040 | * This is supposed to be called while holding the lock. The lock is | |
1041 | * dropped before going to sleep and is reacquired afterwards. | |
1042 | * | |
1043 | * The macro will return -ERESTARTSYS if it was interrupted by a signal | |
1044 | * and 0 if @condition evaluated to true. | |
1045 | */ | |
4b1c480b IM |
1046 | #define wait_event_interruptible_lock_irq(wq_head, condition, lock) \ |
1047 | ({ \ | |
1048 | int __ret = 0; \ | |
1049 | if (!(condition)) \ | |
1050 | __ret = __wait_event_interruptible_lock_irq(wq_head, \ | |
1051 | condition, lock,); \ | |
1052 | __ret; \ | |
eed8c02e LC |
1053 | }) |
1054 | ||
25ab0bc3 | 1055 | #define __wait_event_lock_irq_timeout(wq_head, condition, lock, timeout, state) \ |
4b1c480b | 1056 | ___wait_event(wq_head, ___wait_cond_timeout(condition), \ |
25ab0bc3 | 1057 | state, 0, timeout, \ |
4b1c480b IM |
1058 | spin_unlock_irq(&lock); \ |
1059 | __ret = schedule_timeout(__ret); \ | |
a1dc6852 | 1060 | spin_lock_irq(&lock)); |
d79ff142 MP |
1061 | |
1062 | /** | |
fb869b6e IM |
1063 | * wait_event_interruptible_lock_irq_timeout - sleep until a condition gets |
1064 | * true or a timeout elapses. The condition is checked under | |
1065 | * the lock. This is expected to be called with the lock taken. | |
4b1c480b | 1066 | * @wq_head: the waitqueue to wait on |
d79ff142 MP |
1067 | * @condition: a C expression for the event to wait for |
1068 | * @lock: a locked spinlock_t, which will be released before schedule() | |
1069 | * and reacquired afterwards. | |
1070 | * @timeout: timeout, in jiffies | |
1071 | * | |
1072 | * The process is put to sleep (TASK_INTERRUPTIBLE) until the | |
1073 | * @condition evaluates to true or signal is received. The @condition is | |
4b1c480b | 1074 | * checked each time the waitqueue @wq_head is woken up. |
d79ff142 MP |
1075 | * |
1076 | * wake_up() has to be called after changing any variable that could | |
1077 | * change the result of the wait condition. | |
1078 | * | |
1079 | * This is supposed to be called while holding the lock. The lock is | |
1080 | * dropped before going to sleep and is reacquired afterwards. | |
1081 | * | |
1082 | * The function returns 0 if the @timeout elapsed, -ERESTARTSYS if it | |
1083 | * was interrupted by a signal, and the remaining jiffies otherwise | |
1084 | * if the condition evaluated to true before the timeout elapsed. | |
1085 | */ | |
4b1c480b IM |
1086 | #define wait_event_interruptible_lock_irq_timeout(wq_head, condition, lock, \ |
1087 | timeout) \ | |
1088 | ({ \ | |
1089 | long __ret = timeout; \ | |
1090 | if (!___wait_cond_timeout(condition)) \ | |
25ab0bc3 NB |
1091 | __ret = __wait_event_lock_irq_timeout( \ |
1092 | wq_head, condition, lock, timeout, \ | |
1093 | TASK_INTERRUPTIBLE); \ | |
1094 | __ret; \ | |
1095 | }) | |
1096 | ||
1097 | #define wait_event_lock_irq_timeout(wq_head, condition, lock, timeout) \ | |
1098 | ({ \ | |
1099 | long __ret = timeout; \ | |
1100 | if (!___wait_cond_timeout(condition)) \ | |
1101 | __ret = __wait_event_lock_irq_timeout( \ | |
1102 | wq_head, condition, lock, timeout, \ | |
1103 | TASK_UNINTERRUPTIBLE); \ | |
4b1c480b | 1104 | __ret; \ |
d79ff142 MP |
1105 | }) |
1106 | ||
1da177e4 LT |
1107 | /* |
1108 | * Waitqueues which are removed from the waitqueue_head at wakeup time | |
1109 | */ | |
9d9d676f IM |
1110 | void prepare_to_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state); |
1111 | void prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state); | |
1112 | long prepare_to_wait_event(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state); | |
1113 | void finish_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry); | |
50816c48 IM |
1114 | long wait_woken(struct wait_queue_entry *wq_entry, unsigned mode, long timeout); |
1115 | int woken_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key); | |
1116 | int autoremove_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key); | |
1da177e4 | 1117 | |
4b1c480b IM |
1118 | #define DEFINE_WAIT_FUNC(name, function) \ |
1119 | struct wait_queue_entry name = { \ | |
1120 | .private = current, \ | |
1121 | .func = function, \ | |
2055da97 | 1122 | .entry = LIST_HEAD_INIT((name).entry), \ |
1da177e4 LT |
1123 | } |
1124 | ||
bf368e4e ED |
1125 | #define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function) |
1126 | ||
4b1c480b IM |
1127 | #define init_wait(wait) \ |
1128 | do { \ | |
1129 | (wait)->private = current; \ | |
1130 | (wait)->func = autoremove_wake_function; \ | |
2055da97 | 1131 | INIT_LIST_HEAD(&(wait)->entry); \ |
4b1c480b | 1132 | (wait)->flags = 0; \ |
1da177e4 LT |
1133 | } while (0) |
1134 | ||
fb869b6e | 1135 | #endif /* _LINUX_WAIT_H */ |