1 /* Condition variables (native Windows implementation).
2 Copyright (C) 2008-2023 Free Software Foundation, Inc.
3
4 This file is free software: you can redistribute it and/or modify
5 it under the terms of the GNU Lesser General Public License as
6 published by the Free Software Foundation; either version 2.1 of the
7 License, or (at your option) any later version.
8
9 This file is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
16
17 /* Written by Yoann Vandoorselaere <yoann@prelude-ids.org>, 2008,
18 and Bruno Haible <bruno@clisp.org>, 2008. */
19
20 #include <config.h>
21
22 /* Specification. */
23 #include "windows-cond.h"
24
25 #include <errno.h>
26 #include <stdlib.h>
27 #include <sys/time.h>
28
29 /* Don't assume that UNICODE is not defined. */
30 #undef CreateEvent
31 #define CreateEvent CreateEventA
32
33 /* In this file, the waitqueues are implemented as linked lists. */
34 #define glwthread_waitqueue_t glwthread_linked_waitqueue_t
35
36 /* All links of a circular list, except the anchor, are of this type, carrying
37 a payload. */
38 struct glwthread_waitqueue_element
39 {
40 struct glwthread_waitqueue_link link; /* must be the first field! */
41 HANDLE event; /* Waiting thread, represented by an event.
42 This field is immutable once initialized. */
43 };
44
45 static void
46 glwthread_waitqueue_init (glwthread_waitqueue_t *wq)
47 {
48 wq->wq_list.wql_next = &wq->wq_list;
49 wq->wq_list.wql_prev = &wq->wq_list;
50 }
51
52 /* Enqueues the current thread, represented by an event, in a wait queue.
53 Returns NULL if an allocation failure occurs. */
54 static struct glwthread_waitqueue_element *
55 glwthread_waitqueue_add (glwthread_waitqueue_t *wq)
56 {
57 struct glwthread_waitqueue_element *elt;
58 HANDLE event;
59
60 /* Allocate the memory for the waitqueue element on the heap, not on the
61 thread's stack. If the thread exits unexpectedly, we prefer to leak
62 some memory rather than to access unavailable memory and crash. */
63 elt =
64 (struct glwthread_waitqueue_element *)
65 malloc (sizeof (struct glwthread_waitqueue_element));
66 if (elt == NULL)
67 /* No more memory. */
68 return NULL;
69
70 /* Whether the created event is a manual-reset one or an auto-reset one,
71 does not matter, since we will wait on it only once. */
72 event = CreateEvent (NULL, TRUE, FALSE, NULL);
73 if (event == INVALID_HANDLE_VALUE)
74 {
75 /* No way to allocate an event. */
76 free (elt);
77 return NULL;
78 }
79 elt->event = event;
80 /* Insert elt at the end of the circular list. */
81 (elt->link.wql_prev = wq->wq_list.wql_prev)->wql_next = &elt->link;
82 (elt->link.wql_next = &wq->wq_list)->wql_prev = &elt->link;
83 return elt;
84 }
85
86 /* Removes the current thread, represented by a
87 'struct glwthread_waitqueue_element *', from a wait queue.
88 Returns true if is was found and removed, false if it was not present. */
89 static bool
90 glwthread_waitqueue_remove (glwthread_waitqueue_t *wq,
91 struct glwthread_waitqueue_element *elt)
92 {
93 if (elt->link.wql_next != NULL && elt->link.wql_prev != NULL)
94 {
95 /* Remove elt from the circular list. */
96 struct glwthread_waitqueue_link *prev = elt->link.wql_prev;
97 struct glwthread_waitqueue_link *next = elt->link.wql_next;
98 prev->wql_next = next;
99 next->wql_prev = prev;
100 elt->link.wql_next = NULL;
101 elt->link.wql_prev = NULL;
102 return true;
103 }
104 else
105 return false;
106 }
107
108 /* Notifies the first thread from a wait queue and dequeues it. */
109 static void
110 glwthread_waitqueue_notify_first (glwthread_waitqueue_t *wq)
111 {
112 if (wq->wq_list.wql_next != &wq->wq_list)
113 {
114 struct glwthread_waitqueue_element *elt =
115 (struct glwthread_waitqueue_element *) wq->wq_list.wql_next;
116 struct glwthread_waitqueue_link *prev;
117 struct glwthread_waitqueue_link *next;
118
119 /* Remove elt from the circular list. */
120 prev = &wq->wq_list; /* = elt->link.wql_prev; */
121 next = elt->link.wql_next;
122 prev->wql_next = next;
123 next->wql_prev = prev;
124 elt->link.wql_next = NULL;
125 elt->link.wql_prev = NULL;
126
127 SetEvent (elt->event);
128 /* After the SetEvent, this thread cannot access *elt any more, because
129 the woken-up thread will quickly call free (elt). */
130 }
131 }
132
133 /* Notifies all threads from a wait queue and dequeues them all. */
134 static void
135 glwthread_waitqueue_notify_all (glwthread_waitqueue_t *wq)
136 {
137 struct glwthread_waitqueue_link *l;
138
139 for (l = wq->wq_list.wql_next; l != &wq->wq_list; )
140 {
141 struct glwthread_waitqueue_element *elt =
142 (struct glwthread_waitqueue_element *) l;
143 struct glwthread_waitqueue_link *prev;
144 struct glwthread_waitqueue_link *next;
145
146 /* Remove elt from the circular list. */
147 prev = &wq->wq_list; /* = elt->link.wql_prev; */
148 next = elt->link.wql_next;
149 prev->wql_next = next;
150 next->wql_prev = prev;
151 elt->link.wql_next = NULL;
152 elt->link.wql_prev = NULL;
153
154 SetEvent (elt->event);
155 /* After the SetEvent, this thread cannot access *elt any more, because
156 the woken-up thread will quickly call free (elt). */
157
158 l = next;
159 }
160 if (!(wq->wq_list.wql_next == &wq->wq_list
161 && wq->wq_list.wql_prev == &wq->wq_list))
162 abort ();
163 }
164
165 int
166 glwthread_cond_init (glwthread_cond_t *cond)
167 {
168 InitializeCriticalSection (&cond->lock);
169 glwthread_waitqueue_init (&cond->waiters);
170
171 cond->guard.done = 1;
172 return 0;
173 }
174
175 int
176 glwthread_cond_wait (glwthread_cond_t *cond,
177 void *mutex, int (*mutex_lock) (void *), int (*mutex_unlock) (void *))
178 {
179 if (!cond->guard.done)
180 {
181 if (InterlockedIncrement (&cond->guard.started) == 0)
182 /* This thread is the first one to need this condition variable.
183 Initialize it. */
184 glwthread_cond_init (cond);
185 else
186 {
187 /* Don't let cond->guard.started grow and wrap around. */
188 InterlockedDecrement (&cond->guard.started);
189 /* Yield the CPU while waiting for another thread to finish
190 initializing this condition variable. */
191 while (!cond->guard.done)
192 Sleep (0);
193 }
194 }
195
196 EnterCriticalSection (&cond->lock);
197 {
198 struct glwthread_waitqueue_element *elt =
199 glwthread_waitqueue_add (&cond->waiters);
200 LeaveCriticalSection (&cond->lock);
201 if (elt == NULL)
202 {
203 /* Allocation failure. Weird. */
204 return EAGAIN;
205 }
206 else
207 {
208 HANDLE event = elt->event;
209 int err;
210 DWORD result;
211
212 /* Now release the mutex and let any other thread take it. */
213 err = mutex_unlock (mutex);
214 if (err != 0)
215 {
216 EnterCriticalSection (&cond->lock);
217 glwthread_waitqueue_remove (&cond->waiters, elt);
218 LeaveCriticalSection (&cond->lock);
219 CloseHandle (event);
220 free (elt);
221 return err;
222 }
223 /* POSIX says:
224 "If another thread is able to acquire the mutex after the
225 about-to-block thread has released it, then a subsequent call to
226 pthread_cond_broadcast() or pthread_cond_signal() in that thread
227 shall behave as if it were issued after the about-to-block thread
228 has blocked."
229 This is fulfilled here, because the thread signalling is done
230 through SetEvent, not PulseEvent. */
231 /* Wait until another thread signals this event. */
232 result = WaitForSingleObject (event, INFINITE);
233 if (result == WAIT_FAILED || result == WAIT_TIMEOUT)
234 abort ();
235 CloseHandle (event);
236 free (elt);
237 /* The thread which signalled the event already did the bookkeeping:
238 removed us from the waiters. */
239 return mutex_lock (mutex);
240 }
241 }
242 }
243
244 int
245 glwthread_cond_timedwait (glwthread_cond_t *cond,
246 void *mutex, int (*mutex_lock) (void *), int (*mutex_unlock) (void *),
247 const struct timespec *abstime)
248 {
249 if (!cond->guard.done)
250 {
251 if (InterlockedIncrement (&cond->guard.started) == 0)
252 /* This thread is the first one to need this condition variable.
253 Initialize it. */
254 glwthread_cond_init (cond);
255 else
256 {
257 /* Don't let cond->guard.started grow and wrap around. */
258 InterlockedDecrement (&cond->guard.started);
259 /* Yield the CPU while waiting for another thread to finish
260 initializing this condition variable. */
261 while (!cond->guard.done)
262 Sleep (0);
263 }
264 }
265
266 {
267 struct timeval currtime;
268
269 gettimeofday (&currtime, NULL);
270 if (currtime.tv_sec > abstime->tv_sec
271 || (currtime.tv_sec == abstime->tv_sec
272 && currtime.tv_usec * 1000 >= abstime->tv_nsec))
273 return ETIMEDOUT;
274
275 EnterCriticalSection (&cond->lock);
276 {
277 struct glwthread_waitqueue_element *elt =
278 glwthread_waitqueue_add (&cond->waiters);
279 LeaveCriticalSection (&cond->lock);
280 if (elt == NULL)
281 {
282 /* Allocation failure. Weird. */
283 return EAGAIN;
284 }
285 else
286 {
287 HANDLE event = elt->event;
288 int err;
289 DWORD timeout;
290 DWORD result;
291
292 /* Now release the mutex and let any other thread take it. */
293 err = mutex_unlock (mutex);
294 if (err != 0)
295 {
296 EnterCriticalSection (&cond->lock);
297 glwthread_waitqueue_remove (&cond->waiters, elt);
298 LeaveCriticalSection (&cond->lock);
299 CloseHandle (event);
300 free (elt);
301 return err;
302 }
303 /* POSIX says:
304 "If another thread is able to acquire the mutex after the
305 about-to-block thread has released it, then a subsequent call to
306 pthread_cond_broadcast() or pthread_cond_signal() in that thread
307 shall behave as if it were issued after the about-to-block thread
308 has blocked."
309 This is fulfilled here, because the thread signalling is done
310 through SetEvent, not PulseEvent. */
311 /* Wait until another thread signals this event or until the abstime
312 passes. */
313 gettimeofday (&currtime, NULL);
314 if (currtime.tv_sec > abstime->tv_sec)
315 timeout = 0;
316 else
317 {
318 unsigned long seconds = abstime->tv_sec - currtime.tv_sec;
319 timeout = seconds * 1000;
320 if (timeout / 1000 != seconds) /* overflow? */
321 timeout = INFINITE;
322 else
323 {
324 long milliseconds =
325 abstime->tv_nsec / 1000000 - currtime.tv_usec / 1000;
326 if (milliseconds >= 0)
327 {
328 timeout += milliseconds;
329 if (timeout < milliseconds) /* overflow? */
330 timeout = INFINITE;
331 }
332 else
333 {
334 if (timeout >= - milliseconds)
335 timeout -= (- milliseconds);
336 else
337 timeout = 0;
338 }
339 }
340 }
341 result = WaitForSingleObject (event, timeout);
342 if (result == WAIT_FAILED)
343 abort ();
344 if (result == WAIT_TIMEOUT)
345 {
346 EnterCriticalSection (&cond->lock);
347 if (glwthread_waitqueue_remove (&cond->waiters, elt))
348 {
349 /* The event was not signaled between the WaitForSingleObject
350 call and the EnterCriticalSection call. */
351 if (!(WaitForSingleObject (event, 0) == WAIT_TIMEOUT))
352 abort ();
353 }
354 else
355 {
356 /* The event was signaled between the WaitForSingleObject
357 call and the EnterCriticalSection call. */
358 if (!(WaitForSingleObject (event, 0) == WAIT_OBJECT_0))
359 abort ();
360 /* Produce the right return value. */
361 result = WAIT_OBJECT_0;
362 }
363 LeaveCriticalSection (&cond->lock);
364 }
365 else
366 {
367 /* The thread which signalled the event already did the
368 bookkeeping: removed us from the waiters. */
369 }
370 CloseHandle (event);
371 free (elt);
372 /* Take the mutex again. It does not matter whether this is done
373 before or after the bookkeeping for WAIT_TIMEOUT. */
374 err = mutex_lock (mutex);
375 return (err ? err :
376 result == WAIT_OBJECT_0 ? 0 :
377 result == WAIT_TIMEOUT ? ETIMEDOUT :
378 /* WAIT_FAILED shouldn't happen */ EAGAIN);
379 }
380 }
381 }
382 }
383
384 int
385 glwthread_cond_signal (glwthread_cond_t *cond)
386 {
387 if (!cond->guard.done)
388 return EINVAL;
389
390 EnterCriticalSection (&cond->lock);
391 /* POSIX says:
392 "The pthread_cond_broadcast() and pthread_cond_signal() functions shall
393 have no effect if there are no threads currently blocked on cond." */
394 if (cond->waiters.wq_list.wql_next != &cond->waiters.wq_list)
395 glwthread_waitqueue_notify_first (&cond->waiters);
396 LeaveCriticalSection (&cond->lock);
397
398 return 0;
399 }
400
401 int
402 glwthread_cond_broadcast (glwthread_cond_t *cond)
403 {
404 if (!cond->guard.done)
405 return EINVAL;
406
407 EnterCriticalSection (&cond->lock);
408 /* POSIX says:
409 "The pthread_cond_broadcast() and pthread_cond_signal() functions shall
410 have no effect if there are no threads currently blocked on cond."
411 glwthread_waitqueue_notify_all is a nop in this case. */
412 glwthread_waitqueue_notify_all (&cond->waiters);
413 LeaveCriticalSection (&cond->lock);
414
415 return 0;
416 }
417
418 int
419 glwthread_cond_destroy (glwthread_cond_t *cond)
420 {
421 if (!cond->guard.done)
422 return EINVAL;
423 if (cond->waiters.wq_list.wql_next != &cond->waiters.wq_list)
424 return EBUSY;
425 DeleteCriticalSection (&cond->lock);
426 cond->guard.done = 0;
427 return 0;
428 }