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