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