a860459d12153ab23017ce64ddebd293e081311c
[gnupg.git] / intl / lock.c
1 /* Locking in multithreaded situations.
2    Copyright (C) 2005 Free Software Foundation, Inc.
3
4    This program is free software; you can redistribute it and/or modify it
5    under the terms of the GNU Library General Public License as published
6    by the Free Software Foundation; either version 2, or (at your option)
7    any later version.
8
9    This program 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 GNU
12    Library General Public License for more details.
13
14    You should have received a copy of the GNU Library General Public
15    License along with this program; if not, write to the Free Software
16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
17    USA.  */
18
19 /* Written by Bruno Haible <bruno@clisp.org>, 2005.
20    Based on GCC's gthr-posix.h, gthr-posix95.h, gthr-solaris.h,
21    gthr-win32.h.  */
22
23 #ifdef HAVE_CONFIG_H
24 # include <config.h>
25 #endif
26
27 #include "lock.h"
28
29 /* ========================================================================= */
30
31 #if USE_POSIX_THREADS
32
33 /* Use the POSIX threads library.  */
34
35 # if PTHREAD_IN_USE_DETECTION_HARD
36
37 /* The function to be executed by a dummy thread.  */
38 static void *
39 dummy_thread_func (void *arg)
40 {
41   return arg;
42 }
43
44 int
45 glthread_in_use (void)
46 {
47   static int tested;
48   static int result; /* 1: linked with -lpthread, 0: only with libc */
49
50   if (!tested)
51     {
52       pthread_t thread;
53
54       if (pthread_create (&thread, NULL, dummy_thread_func, NULL) != 0)
55         /* Thread creation failed.  */
56         result = 0;
57       else
58         {
59           /* Thread creation works.  */
60           void *retval;
61           if (pthread_join (thread, &retval) != 0)
62             abort ();
63           result = 1;
64         }
65       tested = 1;
66     }
67   return result;
68 }
69
70 # endif
71
72 /* -------------------------- gl_lock_t datatype -------------------------- */
73
74 /* ------------------------- gl_rwlock_t datatype ------------------------- */
75
76 # if HAVE_PTHREAD_RWLOCK
77
78 #  if !defined PTHREAD_RWLOCK_INITIALIZER
79
80 void
81 glthread_rwlock_init (gl_rwlock_t *lock)
82 {
83   if (pthread_rwlock_init (&lock->rwlock, NULL) != 0)
84     abort ();
85   lock->initialized = 1;
86 }
87
88 void
89 glthread_rwlock_rdlock (gl_rwlock_t *lock)
90 {
91   if (!lock->initialized)
92     {
93       if (pthread_mutex_lock (&lock->guard) != 0)
94         abort ();
95       if (!lock->initialized)
96         glthread_rwlock_init (lock);
97       if (pthread_mutex_unlock (&lock->guard) != 0)
98         abort ();
99     }
100   if (pthread_rwlock_rdlock (&lock->rwlock) != 0)
101     abort ();
102 }
103
104 void
105 glthread_rwlock_wrlock (gl_rwlock_t *lock)
106 {
107   if (!lock->initialized)
108     {
109       if (pthread_mutex_lock (&lock->guard) != 0)
110         abort ();
111       if (!lock->initialized)
112         glthread_rwlock_init (lock);
113       if (pthread_mutex_unlock (&lock->guard) != 0)
114         abort ();
115     }
116   if (pthread_rwlock_wrlock (&lock->rwlock) != 0)
117     abort ();
118 }
119
120 void
121 glthread_rwlock_unlock (gl_rwlock_t *lock)
122 {
123   if (!lock->initialized)
124     abort ();
125   if (pthread_rwlock_unlock (&lock->rwlock) != 0)
126     abort ();
127 }
128
129 void
130 glthread_rwlock_destroy (gl_rwlock_t *lock)
131 {
132   if (!lock->initialized)
133     abort ();
134   if (pthread_rwlock_destroy (&lock->rwlock) != 0)
135     abort ();
136   lock->initialized = 0;
137 }
138
139 #  endif
140
141 # else
142
143 void
144 glthread_rwlock_init (gl_rwlock_t *lock)
145 {
146   if (pthread_mutex_init (&lock->lock, NULL) != 0)
147     abort ();
148   if (pthread_cond_init (&lock->waiting_readers, NULL) != 0)
149     abort ();
150   if (pthread_cond_init (&lock->waiting_writers, NULL) != 0)
151     abort ();
152   lock->waiting_writers_count = 0;
153   lock->runcount = 0;
154 }
155
156 void
157 glthread_rwlock_rdlock (gl_rwlock_t *lock)
158 {
159   if (pthread_mutex_lock (&lock->lock) != 0)
160     abort ();
161   /* Test whether only readers are currently running, and whether the runcount
162      field will not overflow.  */
163   /* POSIX says: "It is implementation-defined whether the calling thread
164      acquires the lock when a writer does not hold the lock and there are
165      writers blocked on the lock."  Let's say, no: give the writers a higher
166      priority.  */
167   while (!(lock->runcount + 1 > 0 && lock->waiting_writers_count == 0))
168     {
169       /* This thread has to wait for a while.  Enqueue it among the
170          waiting_readers.  */
171       if (pthread_cond_wait (&lock->waiting_readers, &lock->lock) != 0)
172         abort ();
173     }
174   lock->runcount++;
175   if (pthread_mutex_unlock (&lock->lock) != 0)
176     abort ();
177 }
178
179 void
180 glthread_rwlock_wrlock (gl_rwlock_t *lock)
181 {
182   if (pthread_mutex_lock (&lock->lock) != 0)
183     abort ();
184   /* Test whether no readers or writers are currently running.  */
185   while (!(lock->runcount == 0))
186     {
187       /* This thread has to wait for a while.  Enqueue it among the
188          waiting_writers.  */
189       lock->waiting_writers_count++;
190       if (pthread_cond_wait (&lock->waiting_writers, &lock->lock) != 0)
191         abort ();
192       lock->waiting_writers_count--;
193     }
194   lock->runcount--; /* runcount becomes -1 */
195   if (pthread_mutex_unlock (&lock->lock) != 0)
196     abort ();
197 }
198
199 void
200 glthread_rwlock_unlock (gl_rwlock_t *lock)
201 {
202   if (pthread_mutex_lock (&lock->lock) != 0)
203     abort ();
204   if (lock->runcount < 0)
205     {
206       /* Drop a writer lock.  */
207       if (!(lock->runcount == -1))
208         abort ();
209       lock->runcount = 0;
210     }
211   else
212     {
213       /* Drop a reader lock.  */
214       if (!(lock->runcount > 0))
215         abort ();
216       lock->runcount--;
217     }
218   if (lock->runcount == 0)
219     {
220       /* POSIX recommends that "write locks shall take precedence over read
221          locks", to avoid "writer starvation".  */
222       if (lock->waiting_writers_count > 0)
223         {
224           /* Wake up one of the waiting writers.  */
225           if (pthread_cond_signal (&lock->waiting_writers) != 0)
226             abort ();
227         }
228       else
229         {
230           /* Wake up all waiting readers.  */
231           if (pthread_cond_broadcast (&lock->waiting_readers) != 0)
232             abort ();
233         }
234     }
235   if (pthread_mutex_unlock (&lock->lock) != 0)
236     abort ();
237 }
238
239 void
240 glthread_rwlock_destroy (gl_rwlock_t *lock)
241 {
242   if (pthread_mutex_destroy (&lock->lock) != 0)
243     abort ();
244   if (pthread_cond_destroy (&lock->waiting_readers) != 0)
245     abort ();
246   if (pthread_cond_destroy (&lock->waiting_writers) != 0)
247     abort ();
248 }
249
250 # endif
251
252 /* --------------------- gl_recursive_lock_t datatype --------------------- */
253
254 # if HAVE_PTHREAD_MUTEX_RECURSIVE
255
256 #  if !(defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER || defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
257
258 void
259 glthread_recursive_lock_init (gl_recursive_lock_t *lock)
260 {
261   pthread_mutexattr_t attributes;
262
263   if (pthread_mutexattr_init (&attributes) != 0)
264     abort ();
265   if (pthread_mutexattr_settype (&attributes, PTHREAD_MUTEX_RECURSIVE) != 0)
266     abort ();
267   if (pthread_mutex_init (&lock->recmutex, &attributes) != 0)
268     abort ();
269   if (pthread_mutexattr_destroy (&attributes) != 0)
270     abort ();
271   lock->initialized = 1;
272 }
273
274 void
275 glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
276 {
277   if (!lock->initialized)
278     {
279       if (pthread_mutex_lock (&lock->guard) != 0)
280         abort ();
281       if (!lock->initialized)
282         glthread_recursive_lock_init (lock);
283       if (pthread_mutex_unlock (&lock->guard) != 0)
284         abort ();
285     }
286   if (pthread_mutex_lock (&lock->recmutex) != 0)
287     abort ();
288 }
289
290 void
291 glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
292 {
293   if (!lock->initialized)
294     abort ();
295   if (pthread_mutex_unlock (&lock->recmutex) != 0)
296     abort ();
297 }
298
299 void
300 glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
301 {
302   if (!lock->initialized)
303     abort ();
304   if (pthread_mutex_destroy (&lock->recmutex) != 0)
305     abort ();
306   lock->initialized = 0;
307 }
308
309 #  endif
310
311 # else
312
313 void
314 glthread_recursive_lock_init (gl_recursive_lock_t *lock)
315 {
316   if (pthread_mutex_init (&lock->mutex, NULL) != 0)
317     abort ();
318   lock->owner = (pthread_t) 0;
319   lock->depth = 0;
320 }
321
322 void
323 glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
324 {
325   pthread_t self = pthread_self ();
326   if (lock->owner != self)
327     {
328       if (pthread_mutex_lock (&lock->mutex) != 0)
329         abort ();
330       lock->owner = self;
331     }
332   if (++(lock->depth) == 0) /* wraparound? */
333     abort ();
334 }
335
336 void
337 glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
338 {
339   if (lock->owner != pthread_self ())
340     abort ();
341   if (lock->depth == 0)
342     abort ();
343   if (--(lock->depth) == 0)
344     {
345       lock->owner = (pthread_t) 0;
346       if (pthread_mutex_unlock (&lock->mutex) != 0)
347         abort ();
348     }
349 }
350
351 void
352 glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
353 {
354   if (lock->owner != (pthread_t) 0)
355     abort ();
356   if (pthread_mutex_destroy (&lock->mutex) != 0)
357     abort ();
358 }
359
360 # endif
361
362 /* -------------------------- gl_once_t datatype -------------------------- */
363
364 static const pthread_once_t fresh_once = PTHREAD_ONCE_INIT;
365
366 int
367 glthread_once_singlethreaded (pthread_once_t *once_control)
368 {
369   /* We don't know whether pthread_once_t is an integer type, a floating-point
370      type, a pointer type, or a structure type.  */
371   char *firstbyte = (char *)once_control;
372   if (*firstbyte == *(const char *)&fresh_once)
373     {
374       /* First time use of once_control.  Invert the first byte.  */
375       *firstbyte = ~ *(const char *)&fresh_once;
376       return 1;
377     }
378   else
379     return 0;
380 }
381
382 #endif
383
384 /* ========================================================================= */
385
386 #if USE_PTH_THREADS
387
388 /* Use the GNU Pth threads library.  */
389
390 /* -------------------------- gl_lock_t datatype -------------------------- */
391
392 /* ------------------------- gl_rwlock_t datatype ------------------------- */
393
394 /* --------------------- gl_recursive_lock_t datatype --------------------- */
395
396 /* -------------------------- gl_once_t datatype -------------------------- */
397
398 void
399 glthread_once_call (void *arg)
400 {
401   void (**gl_once_temp_addr) (void) = (void (**) (void)) arg;
402   void (*initfunction) (void) = *gl_once_temp_addr;
403   initfunction ();
404 }
405
406 int
407 glthread_once_singlethreaded (pth_once_t *once_control)
408 {
409   /* We know that pth_once_t is an integer type.  */
410   if (*once_control == PTH_ONCE_INIT)
411     {
412       /* First time use of once_control.  Invert the marker.  */
413       *once_control = ~ PTH_ONCE_INIT;
414       return 1;
415     }
416   else
417     return 0;
418 }
419
420 #endif
421
422 /* ========================================================================= */
423
424 #if USE_SOLARIS_THREADS
425
426 /* Use the old Solaris threads library.  */
427
428 /* -------------------------- gl_lock_t datatype -------------------------- */
429
430 /* ------------------------- gl_rwlock_t datatype ------------------------- */
431
432 /* --------------------- gl_recursive_lock_t datatype --------------------- */
433
434 void
435 glthread_recursive_lock_init (gl_recursive_lock_t *lock)
436 {
437   if (mutex_init (&lock->mutex, USYNC_THREAD, NULL) != 0)
438     abort ();
439   lock->owner = (thread_t) 0;
440   lock->depth = 0;
441 }
442
443 void
444 glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
445 {
446   thread_t self = thr_self ();
447   if (lock->owner != self)
448     {
449       if (mutex_lock (&lock->mutex) != 0)
450         abort ();
451       lock->owner = self;
452     }
453   if (++(lock->depth) == 0) /* wraparound? */
454     abort ();
455 }
456
457 void
458 glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
459 {
460   if (lock->owner != thr_self ())
461     abort ();
462   if (lock->depth == 0)
463     abort ();
464   if (--(lock->depth) == 0)
465     {
466       lock->owner = (thread_t) 0;
467       if (mutex_unlock (&lock->mutex) != 0)
468         abort ();
469     }
470 }
471
472 void
473 glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
474 {
475   if (lock->owner != (thread_t) 0)
476     abort ();
477   if (mutex_destroy (&lock->mutex) != 0)
478     abort ();
479 }
480
481 /* -------------------------- gl_once_t datatype -------------------------- */
482
483 void
484 glthread_once (gl_once_t *once_control, void (*initfunction) (void))
485 {
486   if (!once_control->inited)
487     {
488       /* Use the mutex to guarantee that if another thread is already calling
489          the initfunction, this thread waits until it's finished.  */
490       if (mutex_lock (&once_control->mutex) != 0)
491         abort ();
492       if (!once_control->inited)
493         {
494           once_control->inited = 1;
495           initfunction ();
496         }
497       if (mutex_unlock (&once_control->mutex) != 0)
498         abort ();
499     }
500 }
501
502 int
503 glthread_once_singlethreaded (gl_once_t *once_control)
504 {
505   /* We know that gl_once_t contains an integer type.  */
506   if (!once_control->inited)
507     {
508       /* First time use of once_control.  Invert the marker.  */
509       once_control->inited = ~ 0;
510       return 1;
511     }
512   else
513     return 0;
514 }
515
516 #endif
517
518 /* ========================================================================= */
519
520 #if USE_WIN32_THREADS
521
522 /* -------------------------- gl_lock_t datatype -------------------------- */
523
524 void
525 glthread_lock_init (gl_lock_t *lock)
526 {
527   InitializeCriticalSection (&lock->lock);
528   lock->guard.done = 1;
529 }
530
531 void
532 glthread_lock_lock (gl_lock_t *lock)
533 {
534   if (!lock->guard.done)
535     {
536       if (InterlockedIncrement (&lock->guard.started) == 0)
537         /* This thread is the first one to need this lock.  Initialize it.  */
538         glthread_lock_init (lock);
539       else
540         /* Yield the CPU while waiting for another thread to finish
541            initializing this lock.  */
542         while (!lock->guard.done)
543           Sleep (0);
544     }
545   EnterCriticalSection (&lock->lock);
546 }
547
548 void
549 glthread_lock_unlock (gl_lock_t *lock)
550 {
551   if (!lock->guard.done)
552     abort ();
553   LeaveCriticalSection (&lock->lock);
554 }
555
556 void
557 glthread_lock_destroy (gl_lock_t *lock)
558 {
559   if (!lock->guard.done)
560     abort ();
561   DeleteCriticalSection (&lock->lock);
562   lock->guard.done = 0;
563 }
564
565 /* ------------------------- gl_rwlock_t datatype ------------------------- */
566
567 static inline void
568 gl_waitqueue_init (gl_waitqueue_t *wq)
569 {
570   wq->array = NULL;
571   wq->count = 0;
572   wq->alloc = 0;
573   wq->offset = 0;
574 }
575
576 /* Enqueues the current thread, represented by an event, in a wait queue.
577    Returns INVALID_HANDLE_VALUE if an allocation failure occurs.  */
578 static HANDLE
579 gl_waitqueue_add (gl_waitqueue_t *wq)
580 {
581   HANDLE event;
582   unsigned int index;
583
584   if (wq->count == wq->alloc)
585     {
586       unsigned int new_alloc = 2 * wq->alloc + 1;
587       HANDLE *new_array =
588         (HANDLE *) realloc (wq->array, new_alloc * sizeof (HANDLE));
589       if (new_array == NULL)
590         /* No more memory.  */
591         return INVALID_HANDLE_VALUE;
592       /* Now is a good opportunity to rotate the array so that its contents
593          starts at offset 0.  */
594       if (wq->offset > 0)
595         {
596           unsigned int old_count = wq->count;
597           unsigned int old_alloc = wq->alloc;
598           unsigned int old_offset = wq->offset;
599           unsigned int i;
600           if (old_offset + old_count > old_alloc)
601             {
602               unsigned int limit = old_offset + old_count - old_alloc;
603               for (i = 0; i < limit; i++)
604                 new_array[old_alloc + i] = new_array[i];
605             }
606           for (i = 0; i < old_count; i++)
607             new_array[i] = new_array[old_offset + i];
608           wq->offset = 0;
609         }
610       wq->array = new_array;
611       wq->alloc = new_alloc;
612     }
613   event = CreateEvent (NULL, TRUE, FALSE, NULL);
614   if (event == INVALID_HANDLE_VALUE)
615     /* No way to allocate an event.  */
616     return INVALID_HANDLE_VALUE;
617   index = wq->offset + wq->count;
618   if (index >= wq->alloc)
619     index -= wq->alloc;
620   wq->array[index] = event;
621   wq->count++;
622   return event;
623 }
624
625 /* Notifies the first thread from a wait queue and dequeues it.  */
626 static inline void
627 gl_waitqueue_notify_first (gl_waitqueue_t *wq)
628 {
629   SetEvent (wq->array[wq->offset + 0]);
630   wq->offset++;
631   wq->count--;
632   if (wq->count == 0 || wq->offset == wq->alloc)
633     wq->offset = 0;
634 }
635
636 /* Notifies all threads from a wait queue and dequeues them all.  */
637 static inline void
638 gl_waitqueue_notify_all (gl_waitqueue_t *wq)
639 {
640   unsigned int i;
641
642   for (i = 0; i < wq->count; i++)
643     {
644       unsigned int index = wq->offset + i;
645       if (index >= wq->alloc)
646         index -= wq->alloc;
647       SetEvent (wq->array[index]);
648     }
649   wq->count = 0;
650   wq->offset = 0;
651 }
652
653 void
654 glthread_rwlock_init (gl_rwlock_t *lock)
655 {
656   InitializeCriticalSection (&lock->lock);
657   gl_waitqueue_init (&lock->waiting_readers);
658   gl_waitqueue_init (&lock->waiting_writers);
659   lock->runcount = 0;
660   lock->guard.done = 1;
661 }
662
663 void
664 glthread_rwlock_rdlock (gl_rwlock_t *lock)
665 {
666   if (!lock->guard.done)
667     {
668       if (InterlockedIncrement (&lock->guard.started) == 0)
669         /* This thread is the first one to need this lock.  Initialize it.  */
670         glthread_rwlock_init (lock);
671       else
672         /* Yield the CPU while waiting for another thread to finish
673            initializing this lock.  */
674         while (!lock->guard.done)
675           Sleep (0);
676     }
677   EnterCriticalSection (&lock->lock);
678   /* Test whether only readers are currently running, and whether the runcount
679      field will not overflow.  */
680   if (!(lock->runcount + 1 > 0))
681     {
682       /* This thread has to wait for a while.  Enqueue it among the
683          waiting_readers.  */
684       HANDLE event = gl_waitqueue_add (&lock->waiting_readers);
685       if (event != INVALID_HANDLE_VALUE)
686         {
687           DWORD result;
688           LeaveCriticalSection (&lock->lock);
689           /* Wait until another thread signals this event.  */
690           result = WaitForSingleObject (event, INFINITE);
691           if (result == WAIT_FAILED || result == WAIT_TIMEOUT)
692             abort ();
693           CloseHandle (event);
694           /* The thread which signalled the event already did the bookkeeping:
695              removed us from the waiting_readers, incremented lock->runcount.  */
696           if (!(lock->runcount > 0))
697             abort ();
698           return;
699         }
700       else
701         {
702           /* Allocation failure.  Weird.  */
703           do
704             {
705               LeaveCriticalSection (&lock->lock);
706               Sleep (1);
707               EnterCriticalSection (&lock->lock);
708             }
709           while (!(lock->runcount + 1 > 0));
710         }
711     }
712   lock->runcount++;
713   LeaveCriticalSection (&lock->lock);
714 }
715
716 void
717 glthread_rwlock_wrlock (gl_rwlock_t *lock)
718 {
719   if (!lock->guard.done)
720     {
721       if (InterlockedIncrement (&lock->guard.started) == 0)
722         /* This thread is the first one to need this lock.  Initialize it.  */
723         glthread_rwlock_init (lock);
724       else
725         /* Yield the CPU while waiting for another thread to finish
726            initializing this lock.  */
727         while (!lock->guard.done)
728           Sleep (0);
729     }
730   EnterCriticalSection (&lock->lock);
731   /* Test whether no readers or writers are currently running.  */
732   if (!(lock->runcount == 0))
733     {
734       /* This thread has to wait for a while.  Enqueue it among the
735          waiting_writers.  */
736       HANDLE event = gl_waitqueue_add (&lock->waiting_writers);
737       if (event != INVALID_HANDLE_VALUE)
738         {
739           DWORD result;
740           LeaveCriticalSection (&lock->lock);
741           /* Wait until another thread signals this event.  */
742           result = WaitForSingleObject (event, INFINITE);
743           if (result == WAIT_FAILED || result == WAIT_TIMEOUT)
744             abort ();
745           CloseHandle (event);
746           /* The thread which signalled the event already did the bookkeeping:
747              removed us from the waiting_writers, set lock->runcount = -1.  */
748           if (!(lock->runcount == -1))
749             abort ();
750           return;
751         }
752       else
753         {
754           /* Allocation failure.  Weird.  */
755           do
756             {
757               LeaveCriticalSection (&lock->lock);
758               Sleep (1);
759               EnterCriticalSection (&lock->lock);
760             }
761           while (!(lock->runcount == 0));
762         }
763     }
764   lock->runcount--; /* runcount becomes -1 */
765   LeaveCriticalSection (&lock->lock);
766 }
767
768 void
769 glthread_rwlock_unlock (gl_rwlock_t *lock)
770 {
771   if (!lock->guard.done)
772     abort ();
773   EnterCriticalSection (&lock->lock);
774   if (lock->runcount < 0)
775     {
776       /* Drop a writer lock.  */
777       if (!(lock->runcount == -1))
778         abort ();
779       lock->runcount = 0;
780     }
781   else
782     {
783       /* Drop a reader lock.  */
784       if (!(lock->runcount > 0))
785         abort ();
786       lock->runcount--;
787     }
788   if (lock->runcount == 0)
789     {
790       /* POSIX recommends that "write locks shall take precedence over read
791          locks", to avoid "writer starvation".  */
792       if (lock->waiting_writers.count > 0)
793         {
794           /* Wake up one of the waiting writers.  */
795           lock->runcount--;
796           gl_waitqueue_notify_first (&lock->waiting_writers);
797         }
798       else
799         {
800           /* Wake up all waiting readers.  */
801           lock->runcount += lock->waiting_readers.count;
802           gl_waitqueue_notify_all (&lock->waiting_readers);
803         }
804     }
805   LeaveCriticalSection (&lock->lock);
806 }
807
808 void
809 glthread_rwlock_destroy (gl_rwlock_t *lock)
810 {
811   if (!lock->guard.done)
812     abort ();
813   if (lock->runcount != 0)
814     abort ();
815   DeleteCriticalSection (&lock->lock);
816   if (lock->waiting_readers.array != NULL)
817     free (lock->waiting_readers.array);
818   if (lock->waiting_writers.array != NULL)
819     free (lock->waiting_writers.array);
820   lock->guard.done = 0;
821 }
822
823 /* --------------------- gl_recursive_lock_t datatype --------------------- */
824
825 void
826 glthread_recursive_lock_init (gl_recursive_lock_t *lock)
827 {
828   lock->owner = 0;
829   lock->depth = 0;
830   InitializeCriticalSection (&lock->lock);
831   lock->guard.done = 1;
832 }
833
834 void
835 glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
836 {
837   if (!lock->guard.done)
838     {
839       if (InterlockedIncrement (&lock->guard.started) == 0)
840         /* This thread is the first one to need this lock.  Initialize it.  */
841         glthread_recursive_lock_init (lock);
842       else
843         /* Yield the CPU while waiting for another thread to finish
844            initializing this lock.  */
845         while (!lock->guard.done)
846           Sleep (0);
847     }
848   {
849     DWORD self = GetCurrentThreadId ();
850     if (lock->owner != self)
851       {
852         EnterCriticalSection (&lock->lock);
853         lock->owner = self;
854       }
855     if (++(lock->depth) == 0) /* wraparound? */
856       abort ();
857   }
858 }
859
860 void
861 glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
862 {
863   if (lock->owner != GetCurrentThreadId ())
864     abort ();
865   if (lock->depth == 0)
866     abort ();
867   if (--(lock->depth) == 0)
868     {
869       lock->owner = 0;
870       LeaveCriticalSection (&lock->lock);
871     }
872 }
873
874 void
875 glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
876 {
877   if (lock->owner != 0)
878     abort ();
879   DeleteCriticalSection (&lock->lock);
880   lock->guard.done = 0;
881 }
882
883 /* -------------------------- gl_once_t datatype -------------------------- */
884
885 void
886 glthread_once (gl_once_t *once_control, void (*initfunction) (void))
887 {
888   if (once_control->inited <= 0)
889     {
890       if (InterlockedIncrement (&once_control->started) == 0)
891         {
892           /* This thread is the first one to come to this once_control.  */
893           InitializeCriticalSection (&once_control->lock);
894           EnterCriticalSection (&once_control->lock);
895           once_control->inited = 0;
896           initfunction ();
897           once_control->inited = 1;
898           LeaveCriticalSection (&once_control->lock);
899         }
900       else
901         {
902           /* Undo last operation.  */
903           InterlockedDecrement (&once_control->started);
904           /* Some other thread has already started the initialization.
905              Yield the CPU while waiting for the other thread to finish
906              initializing and taking the lock.  */
907           while (once_control->inited < 0)
908             Sleep (0);
909           if (once_control->inited <= 0)
910             {
911               /* Take the lock.  This blocks until the other thread has
912                  finished calling the initfunction.  */
913               EnterCriticalSection (&once_control->lock);
914               LeaveCriticalSection (&once_control->lock);
915               if (!(once_control->inited > 0))
916                 abort ();
917             }
918         }
919     }
920 }
921
922 #endif
923
924 /* ========================================================================= */