2 * Copyright (c) 2010 Isilon Systems, Inc.
3 * Copyright (c) 2010 iX Systems, Inc.
4 * Copyright (c) 2010 Panasas, Inc.
5 * Copyright (c) 2013, 2014 Mellanox Technologies, Ltd.
6 * Copyright (c) 2017 Mark Johnston <markj@FreeBSD.org>
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice unmodified, this list of conditions, and the following
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 #ifndef _LINUX_WAIT_H_
34 #define _LINUX_WAIT_H_
36 #include <linux/compiler.h>
37 #include <linux/list.h>
38 #include <linux/spinlock.h>
40 #include <asm/atomic.h>
42 #include <sys/param.h>
43 #include <sys/systm.h>
45 #define SKIP_SLEEP() (SCHEDULER_STOPPED() || kdb_active)
47 #define might_sleep() \
48 WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, "might_sleep()")
51 struct wait_queue_head;
53 typedef struct wait_queue wait_queue_t;
54 typedef struct wait_queue_head wait_queue_head_t;
56 typedef int wait_queue_func_t(wait_queue_t *, unsigned int, int, void *);
59 * Many API consumers directly reference these fields and those of
63 unsigned int flags; /* always 0 */
65 wait_queue_func_t *func;
66 struct list_head task_list;
69 struct wait_queue_head {
71 struct list_head task_list;
75 * This function is referenced by at least one DRM driver, so it may not be
76 * renamed and furthermore must be the default wait queue callback.
78 extern wait_queue_func_t autoremove_wake_function;
80 #define DEFINE_WAIT(name) \
81 wait_queue_t name = { \
83 .func = autoremove_wake_function, \
84 .task_list = LINUX_LIST_HEAD_INIT(name.task_list) \
87 #define DECLARE_WAITQUEUE(name, task) \
88 wait_queue_t name = { \
90 .task_list = LINUX_LIST_HEAD_INIT(name.task_list) \
93 #define DECLARE_WAIT_QUEUE_HEAD(name) \
94 wait_queue_head_t name = { \
95 .task_list = LINUX_LIST_HEAD_INIT(name.task_list), \
97 MTX_SYSINIT(name, &(name).lock.m, spin_lock_name("wqhead"), MTX_DEF)
99 #define init_waitqueue_head(wqh) do { \
100 mtx_init(&(wqh)->lock.m, spin_lock_name("wqhead"), \
101 NULL, MTX_DEF | MTX_NEW | MTX_NOWITNESS); \
102 INIT_LIST_HEAD(&(wqh)->task_list); \
105 void linux_wake_up(wait_queue_head_t *, unsigned int, int, bool);
107 #define wake_up(wqh) \
108 linux_wake_up(wqh, TASK_NORMAL, 1, false)
109 #define wake_up_all(wqh) \
110 linux_wake_up(wqh, TASK_NORMAL, 0, false)
111 #define wake_up_locked(wqh) \
112 linux_wake_up(wqh, TASK_NORMAL, 1, true)
113 #define wake_up_all_locked(wqh) \
114 linux_wake_up(wqh, TASK_NORMAL, 0, true)
115 #define wake_up_interruptible(wqh) \
116 linux_wake_up(wqh, TASK_INTERRUPTIBLE, 1, false)
117 #define wake_up_interruptible_all(wqh) \
118 linux_wake_up(wqh, TASK_INTERRUPTIBLE, 0, false)
120 int linux_wait_event_common(wait_queue_head_t *, wait_queue_t *, int,
121 unsigned int, spinlock_t *);
124 * Returns -ERESTARTSYS for a signal, 0 if cond is false after timeout, 1 if
125 * cond is true after timeout, remaining jiffies (> 0) if cond is true before
128 #define __wait_event_common(wqh, cond, timeout, state, lock) ({ \
130 const int __timeout = ((int)(timeout)) < 1 ? 1 : (timeout); \
131 int __start = ticks; \
135 linux_prepare_to_wait(&(wqh), &__wq, state); \
138 __ret = linux_wait_event_common(&(wqh), &__wq, \
139 __timeout, state, lock); \
143 linux_finish_wait(&(wqh), &__wq); \
144 if (__timeout != MAX_SCHEDULE_TIMEOUT) { \
145 if (__ret == -EWOULDBLOCK) \
147 else if (__ret != -ERESTARTSYS) { \
148 __ret = __timeout + __start - ticks; \
149 /* range check return value */ \
152 else if (__ret > __timeout) \
159 #define wait_event(wqh, cond) do { \
160 (void) __wait_event_common(wqh, cond, MAX_SCHEDULE_TIMEOUT, \
161 TASK_UNINTERRUPTIBLE, NULL); \
164 #define wait_event_timeout(wqh, cond, timeout) ({ \
165 __wait_event_common(wqh, cond, timeout, TASK_UNINTERRUPTIBLE, \
169 #define wait_event_interruptible(wqh, cond) ({ \
170 __wait_event_common(wqh, cond, MAX_SCHEDULE_TIMEOUT, \
171 TASK_INTERRUPTIBLE, NULL); \
174 #define wait_event_interruptible_timeout(wqh, cond, timeout) ({ \
175 __wait_event_common(wqh, cond, timeout, TASK_INTERRUPTIBLE, \
180 * Wait queue is already locked.
182 #define wait_event_interruptible_locked(wqh, cond) ({ \
185 spin_unlock(&(wqh).lock); \
186 __ret = __wait_event_common(wqh, cond, MAX_SCHEDULE_TIMEOUT, \
187 TASK_INTERRUPTIBLE, NULL); \
188 spin_lock(&(wqh).lock); \
193 * Hold the (locked) spinlock when testing the cond.
195 #define wait_event_interruptible_lock_irq(wqh, cond, lock) ({ \
196 __wait_event_common(wqh, cond, MAX_SCHEDULE_TIMEOUT, \
197 TASK_INTERRUPTIBLE, &(lock)); \
201 __add_wait_queue(wait_queue_head_t *wqh, wait_queue_t *wq)
203 list_add(&wq->task_list, &wqh->task_list);
207 add_wait_queue(wait_queue_head_t *wqh, wait_queue_t *wq)
210 spin_lock(&wqh->lock);
211 __add_wait_queue(wqh, wq);
212 spin_unlock(&wqh->lock);
216 __add_wait_queue_tail(wait_queue_head_t *wqh, wait_queue_t *wq)
218 list_add_tail(&wq->task_list, &wqh->task_list);
222 __remove_wait_queue(wait_queue_head_t *wqh, wait_queue_t *wq)
224 list_del(&wq->task_list);
228 remove_wait_queue(wait_queue_head_t *wqh, wait_queue_t *wq)
231 spin_lock(&wqh->lock);
232 __remove_wait_queue(wqh, wq);
233 spin_unlock(&wqh->lock);
236 bool linux_waitqueue_active(wait_queue_head_t *);
238 #define waitqueue_active(wqh) linux_waitqueue_active(wqh)
240 void linux_prepare_to_wait(wait_queue_head_t *, wait_queue_t *, int);
241 void linux_finish_wait(wait_queue_head_t *, wait_queue_t *);
243 #define prepare_to_wait(wqh, wq, state) linux_prepare_to_wait(wqh, wq, state)
244 #define finish_wait(wqh, wq) linux_finish_wait(wqh, wq)
246 void linux_wake_up_bit(void *, int);
247 int linux_wait_on_bit_timeout(unsigned long *, int, unsigned int, int);
248 void linux_wake_up_atomic_t(atomic_t *);
249 int linux_wait_on_atomic_t(atomic_t *, unsigned int);
251 #define wake_up_bit(word, bit) linux_wake_up_bit(word, bit)
252 #define wait_on_bit_timeout(word, bit, state, timeout) \
253 linux_wait_on_bit_timeout(word, bit, state, timeout)
254 #define wake_up_atomic_t(a) linux_wake_up_atomic_t(a)
256 * All existing callers have a cb that just schedule()s. To avoid adding
257 * complexity, just emulate that internally. The prototype is different so that
258 * callers must be manually modified; a cb that does something other than call
259 * schedule() will require special treatment.
261 #define wait_on_atomic_t(a, state) linux_wait_on_atomic_t(a, state)
264 bool linux_wake_up_state(struct task_struct *, unsigned int);
266 #define wake_up_process(task) linux_wake_up_state(task, TASK_NORMAL)
267 #define wake_up_state(task, state) linux_wake_up_state(task, state)
269 #endif /* _LINUX_WAIT_H_ */