1 /*
2 * Copyright (c) 2014 Imre Vadász
3 * Copyright (c) 2014-2020 François Tigeot <ftigeot@wolfpond.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice unmodified, this list of conditions, and the following
11 * disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifndef _LINUX_WAIT_H_
29 #define _LINUX_WAIT_H_
30
31 #include <linux/list.h>
32 #include <linux/stddef.h>
33 #include <linux/spinlock.h>
34 #include <asm/current.h>
35
36 typedef struct wait_queue_entry wait_queue_entry_t;
37
38 typedef int (*wait_queue_func_t)(wait_queue_entry_t *wait, unsigned mode, int flags, void *key);
39
40 int default_wake_function(wait_queue_entry_t *wait, unsigned mode, int flags, void *key);
41 int autoremove_wake_function(wait_queue_entry_t *wait, unsigned mode, int sync, void *key);
42
43 struct wait_queue_entry {
44 unsigned int flags;
45 void *private;
46 wait_queue_func_t func;
47 struct list_head entry;
48 };
49
50 void init_wait_entry(struct wait_queue_entry *wq_entry, int flags);
51
52 typedef struct {
53 struct lock lock;
54 struct list_head head;
55 } wait_queue_head_t;
56
57 void __init_waitqueue_head(wait_queue_head_t *q, const char *name, struct lock_class_key *);
58
59 static inline void
init_waitqueue_head(wait_queue_head_t * q)60 init_waitqueue_head(wait_queue_head_t *q)
61 {
62 __init_waitqueue_head(q, "", NULL);
63 }
64
65 void __wake_up_core(wait_queue_head_t *q, int num_to_wake_up);
66
67 static inline void
wake_up(wait_queue_head_t * q)68 wake_up(wait_queue_head_t *q)
69 {
70 lockmgr(&q->lock, LK_EXCLUSIVE);
71 __wake_up_core(q, 1);
72 lockmgr(&q->lock, LK_RELEASE);
73 wakeup_one(q);
74 }
75
76 static inline void
wake_up_all(wait_queue_head_t * q)77 wake_up_all(wait_queue_head_t *q)
78 {
79 lockmgr(&q->lock, LK_EXCLUSIVE);
80 __wake_up_core(q, 0);
81 lockmgr(&q->lock, LK_RELEASE);
82 wakeup(q);
83 }
84
85 void wake_up_bit(void *, int);
86
87 #define wake_up_all_locked(eq) __wake_up_core(eq, 0)
88
89 #define wake_up_interruptible(eq) wake_up(eq)
90 #define wake_up_interruptible_all(eq) wake_up_all(eq)
91
92 void __wait_event_prefix(wait_queue_head_t *wq, int flags);
93 void prepare_to_wait(wait_queue_head_t *q, wait_queue_entry_t *wait, int state);
94 void finish_wait(wait_queue_head_t *q, wait_queue_entry_t *wait);
95
96 /*
97 * wait_event_interruptible_timeout:
98 * - The process is put to sleep until the condition evaluates to true.
99 * - The condition is checked each time the waitqueue wq is woken up.
100 * - wake_up has to be called after changing any variable that could change
101 * the result of the wait condition.
102 *
103 * returns:
104 * - 0 if the timeout elapsed
105 * - the remaining jiffies if the condition evaluated to true before
106 * the timeout elapsed.
107 * - remaining jiffies are always at least 1
108 * - -ERESTARTSYS if interrupted by a signal (when PCATCH is set in flags)
109 */
110 #define __wait_event_common(wq, condition, timeout_jiffies, flags, \
111 locked) \
112 ({ \
113 int start_jiffies, elapsed_jiffies, remaining_jiffies, ret; \
114 bool timeout_expired = false; \
115 bool interrupted = false; \
116 long retval; \
117 int state; \
118 DEFINE_WAIT(tmp_wq); \
119 \
120 start_jiffies = ticks; \
121 state = (flags & PCATCH) ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE; \
122 prepare_to_wait(&wq, &tmp_wq, state); \
123 \
124 while (1) { \
125 __wait_event_prefix(&wq, flags); \
126 \
127 if (condition) \
128 break; \
129 \
130 tsleep_interlock(current, flags); \
131 \
132 if ((timeout_jiffies) != 0) { \
133 ret = tsleep(current, PINTERLOCKED|flags, "lwe", timeout_jiffies); \
134 } else { \
135 ret = tsleep(current, PINTERLOCKED|flags, "lwe", hz);\
136 if (ret == EWOULDBLOCK) { \
137 /*kprintf("F");*/ \
138 /*print_backtrace(-1);*/ \
139 ret = 0; \
140 } \
141 } \
142 \
143 if (ret == EINTR || ret == ERESTART) { \
144 interrupted = true; \
145 break; \
146 } \
147 if (ret == EWOULDBLOCK) { \
148 timeout_expired = true; \
149 break; \
150 } \
151 } \
152 \
153 elapsed_jiffies = ticks - start_jiffies; \
154 remaining_jiffies = timeout_jiffies - elapsed_jiffies; \
155 if (remaining_jiffies <= 0) \
156 remaining_jiffies = 1; \
157 \
158 if (timeout_expired) \
159 retval = 0; \
160 else if (interrupted) \
161 retval = -ERESTARTSYS; \
162 else if (timeout_jiffies > 0) \
163 retval = remaining_jiffies; \
164 else \
165 retval = 1; \
166 \
167 finish_wait(&wq, &tmp_wq); \
168 retval; \
169 })
170
171 #define wait_event(wq, condition) \
172 __wait_event_common(wq, condition, 0, 0, false)
173
174 #define wait_event_timeout(wq, condition, timeout) \
175 __wait_event_common(wq, condition, timeout, 0, false)
176
177 #define wait_event_interruptible(wq, condition) \
178 ({ \
179 long retval; \
180 \
181 retval = __wait_event_common(wq, condition, 0, PCATCH, false); \
182 if (retval != -ERESTARTSYS) \
183 retval = 0; \
184 retval; \
185 })
186
187 #define wait_event_interruptible_locked(wq, condition) \
188 ({ \
189 long retval; \
190 \
191 retval = __wait_event_common(wq, condition, 0, PCATCH, true); \
192 if (retval != -ERESTARTSYS) \
193 retval = 0; \
194 retval; \
195 })
196
197 #define wait_event_interruptible_timeout(wq, condition, timeout) \
198 __wait_event_common(wq, condition, timeout, PCATCH, false)
199
200 static inline int
waitqueue_active(wait_queue_head_t * q)201 waitqueue_active(wait_queue_head_t *q)
202 {
203 return !list_empty(&q->head);
204 }
205
206 #define DEFINE_WAIT_FUNC(name, _function) \
207 wait_queue_entry_t name = { \
208 .private = current, \
209 .entry = LIST_HEAD_INIT((name).entry), \
210 .func = _function, \
211 }
212
213 #define DEFINE_WAIT(name) \
214 DEFINE_WAIT_FUNC((name), autoremove_wake_function)
215
216 static inline void
__add_wait_queue(wait_queue_head_t * head,wait_queue_entry_t * new)217 __add_wait_queue(wait_queue_head_t *head, wait_queue_entry_t *new)
218 {
219 list_add(&new->entry, &head->head);
220 }
221
222 static inline void
add_wait_queue(wait_queue_head_t * head,wait_queue_entry_t * wait)223 add_wait_queue(wait_queue_head_t *head, wait_queue_entry_t *wait)
224 {
225 lockmgr(&head->lock, LK_EXCLUSIVE);
226 __add_wait_queue(head, wait);
227 lockmgr(&head->lock, LK_RELEASE);
228 }
229
230 #define DECLARE_WAIT_QUEUE_HEAD(name) \
231 wait_queue_head_t name = { \
232 .lock = LOCK_INITIALIZER("name", 0, LK_CANRECURSE), \
233 .head = { &(name).head, &(name).head } \
234 }
235
236 static inline void
__remove_wait_queue(wait_queue_head_t * head,wait_queue_entry_t * old)237 __remove_wait_queue(wait_queue_head_t *head, wait_queue_entry_t *old)
238 {
239 list_del(&old->entry);
240 }
241
242 static inline void
remove_wait_queue(wait_queue_head_t * head,wait_queue_entry_t * wq)243 remove_wait_queue(wait_queue_head_t *head, wait_queue_entry_t *wq)
244 {
245 lockmgr(&head->lock, LK_EXCLUSIVE);
246 __remove_wait_queue(head, wq);
247 lockmgr(&head->lock, LK_RELEASE);
248 }
249
250 static inline void
__add_wait_queue_entry_tail(wait_queue_head_t * wqh,wait_queue_entry_t * wq)251 __add_wait_queue_entry_tail(wait_queue_head_t *wqh, wait_queue_entry_t *wq)
252 {
253 list_add_tail(&wq->entry, &wqh->head);
254 }
255
256 #endif /* _LINUX_WAIT_H_ */
257