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 wait_queue_t; 37 38 typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key); 39 40 int default_wake_function(wait_queue_t *wait, unsigned mode, int flags, void *key); 41 int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key); 42 43 struct __wait_queue { 44 unsigned int flags; 45 void *private; 46 wait_queue_func_t func; 47 struct list_head task_list; 48 }; 49 50 typedef struct { 51 struct lock lock; 52 struct list_head task_list; 53 } wait_queue_head_t; 54 55 static inline void 56 init_waitqueue_head(wait_queue_head_t *eq) 57 { 58 lockinit(&eq->lock, "lwq", 0, LK_CANRECURSE); 59 INIT_LIST_HEAD(&eq->task_list); 60 } 61 62 void __wake_up_core(wait_queue_head_t *q, int num_to_wake_up); 63 64 static inline void 65 wake_up(wait_queue_head_t *q) 66 { 67 lockmgr(&q->lock, LK_EXCLUSIVE); 68 __wake_up_core(q, 1); 69 lockmgr(&q->lock, LK_RELEASE); 70 wakeup_one(q); 71 } 72 73 static inline void 74 wake_up_all(wait_queue_head_t *q) 75 { 76 lockmgr(&q->lock, LK_EXCLUSIVE); 77 __wake_up_core(q, 0); 78 lockmgr(&q->lock, LK_RELEASE); 79 wakeup(q); 80 } 81 82 #define wake_up_all_locked(eq) __wake_up_core(eq, 0) 83 84 #define wake_up_interruptible(eq) wake_up(eq) 85 #define wake_up_interruptible_all(eq) wake_up_all(eq) 86 87 void __wait_event_prefix(wait_queue_head_t *wq, int flags); 88 void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state); 89 void finish_wait(wait_queue_head_t *q, wait_queue_t *wait); 90 91 /* 92 * wait_event_interruptible_timeout: 93 * - The process is put to sleep until the condition evaluates to true. 94 * - The condition is checked each time the waitqueue wq is woken up. 95 * - wake_up has to be called after changing any variable that could change 96 * the result of the wait condition. 97 * 98 * returns: 99 * - 0 if the timeout elapsed 100 * - the remaining jiffies if the condition evaluated to true before 101 * the timeout elapsed. 102 * - remaining jiffies are always at least 1 103 * - -ERESTARTSYS if interrupted by a signal (when PCATCH is set in flags) 104 */ 105 #define __wait_event_common(wq, condition, timeout_jiffies, flags, \ 106 locked) \ 107 ({ \ 108 int start_jiffies, elapsed_jiffies, remaining_jiffies, ret; \ 109 bool timeout_expired = false; \ 110 bool interrupted = false; \ 111 long retval; \ 112 wait_queue_t tmp_wq; \ 113 \ 114 start_jiffies = ticks; \ 115 INIT_LIST_HEAD(&tmp_wq.task_list); \ 116 \ 117 while (1) { \ 118 __wait_event_prefix(&wq, flags); \ 119 \ 120 if (condition) \ 121 break; \ 122 \ 123 ret = tsleep(&wq, flags, "lwe", timeout_jiffies); \ 124 if (ret == EINTR || ret == ERESTART) { \ 125 interrupted = true; \ 126 break; \ 127 } \ 128 if (ret == EWOULDBLOCK) { \ 129 timeout_expired = true; \ 130 break; \ 131 } \ 132 } \ 133 \ 134 elapsed_jiffies = ticks - start_jiffies; \ 135 remaining_jiffies = timeout_jiffies - elapsed_jiffies; \ 136 if (remaining_jiffies <= 0) \ 137 remaining_jiffies = 1; \ 138 \ 139 if (timeout_expired) \ 140 retval = 0; \ 141 else if (interrupted) \ 142 retval = -ERESTARTSYS; \ 143 else if (timeout_jiffies > 0) \ 144 retval = remaining_jiffies; \ 145 else \ 146 retval = 1; \ 147 \ 148 finish_wait(&wq, &tmp_wq); \ 149 retval; \ 150 }) 151 152 #define wait_event(wq, condition) \ 153 __wait_event_common(wq, condition, 0, 0, false) 154 155 #define wait_event_timeout(wq, condition, timeout) \ 156 __wait_event_common(wq, condition, timeout, 0, false) 157 158 #define wait_event_interruptible(wq, condition) \ 159 ({ \ 160 long retval; \ 161 \ 162 retval = __wait_event_common(wq, condition, 0, PCATCH, false); \ 163 if (retval != -ERESTARTSYS) \ 164 retval = 0; \ 165 retval; \ 166 }) 167 168 #define wait_event_interruptible_locked(wq, condition) \ 169 ({ \ 170 long retval; \ 171 \ 172 retval = __wait_event_common(wq, condition, 0, PCATCH, true); \ 173 if (retval != -ERESTARTSYS) \ 174 retval = 0; \ 175 retval; \ 176 }) 177 178 #define wait_event_interruptible_timeout(wq, condition, timeout) \ 179 __wait_event_common(wq, condition, timeout, PCATCH, false) 180 181 static inline int 182 waitqueue_active(wait_queue_head_t *q) 183 { 184 return !list_empty(&q->task_list); 185 } 186 187 #define DEFINE_WAIT(name) \ 188 wait_queue_t name = { \ 189 .private = current, \ 190 .task_list = LIST_HEAD_INIT((name).task_list), \ 191 .func = autoremove_wake_function, \ 192 } 193 194 static inline void 195 __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new) 196 { 197 list_add(&new->task_list, &head->task_list); 198 } 199 200 static inline void 201 add_wait_queue(wait_queue_head_t *head, wait_queue_t *wq) 202 { 203 lockmgr(&head->lock, LK_EXCLUSIVE); 204 __add_wait_queue(head, wq); 205 lockmgr(&head->lock, LK_RELEASE); 206 } 207 208 #define DECLARE_WAIT_QUEUE_HEAD(name) \ 209 wait_queue_head_t name = { \ 210 .lock = LOCK_INITIALIZER("name", 0, LK_CANRECURSE), \ 211 .task_list = { &(name).task_list, &(name).task_list } \ 212 } 213 214 static inline void 215 __remove_wait_queue(wait_queue_head_t *head, wait_queue_t *old) 216 { 217 list_del(&old->task_list); 218 } 219 220 static inline void 221 remove_wait_queue(wait_queue_head_t *head, wait_queue_t *wq) 222 { 223 lockmgr(&head->lock, LK_EXCLUSIVE); 224 __remove_wait_queue(head, wq); 225 lockmgr(&head->lock, LK_RELEASE); 226 } 227 228 #endif /* _LINUX_WAIT_H_ */ 229