diff options
Diffstat (limited to 'intl/lock.c')
| -rw-r--r-- | intl/lock.c | 891 |
1 files changed, 514 insertions, 377 deletions
diff --git a/intl/lock.c b/intl/lock.c index f60a8d9b..561423e0 100644 --- a/intl/lock.c +++ b/intl/lock.c @@ -1,5 +1,5 @@ /* Locking in multithreaded situations. - Copyright (C) 2005-2006 Free Software Foundation, Inc. + Copyright (C) 2005-2008 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published @@ -28,45 +28,6 @@ #if USE_POSIX_THREADS -/* Use the POSIX threads library. */ - -# if PTHREAD_IN_USE_DETECTION_HARD - -/* The function to be executed by a dummy thread. */ -static void * -dummy_thread_func (void *arg) -{ - return arg; -} - -int -glthread_in_use (void) -{ - static int tested; - static int result; /* 1: linked with -lpthread, 0: only with libc */ - - if (!tested) - { - pthread_t thread; - - if (pthread_create (&thread, NULL, dummy_thread_func, NULL) != 0) - /* Thread creation failed. */ - result = 0; - else - { - /* Thread creation works. */ - void *retval; - if (pthread_join (thread, &retval) != 0) - abort (); - result = 1; - } - tested = 1; - } - return result; -} - -# endif - /* -------------------------- gl_lock_t datatype -------------------------- */ /* ------------------------- gl_rwlock_t datatype ------------------------- */ @@ -75,87 +36,123 @@ glthread_in_use (void) # if !defined PTHREAD_RWLOCK_INITIALIZER -void -glthread_rwlock_init (gl_rwlock_t *lock) +int +glthread_rwlock_init_multithreaded (gl_rwlock_t *lock) { - if (pthread_rwlock_init (&lock->rwlock, NULL) != 0) - abort (); + int err; + + err = pthread_rwlock_init (&lock->rwlock, NULL); + if (err != 0) + return err; lock->initialized = 1; + return 0; } -void -glthread_rwlock_rdlock (gl_rwlock_t *lock) +int +glthread_rwlock_rdlock_multithreaded (gl_rwlock_t *lock) { if (!lock->initialized) { - if (pthread_mutex_lock (&lock->guard) != 0) - abort (); + int err; + + err = pthread_mutex_lock (&lock->guard); + if (err != 0) + return err; if (!lock->initialized) - glthread_rwlock_init (lock); - if (pthread_mutex_unlock (&lock->guard) != 0) - abort (); + { + err = glthread_rwlock_init_multithreaded (lock); + if (err != 0) + { + pthread_mutex_unlock (&lock->guard); + return err; + } + } + err = pthread_mutex_unlock (&lock->guard); + if (err != 0) + return err; } - if (pthread_rwlock_rdlock (&lock->rwlock) != 0) - abort (); + return pthread_rwlock_rdlock (&lock->rwlock); } -void -glthread_rwlock_wrlock (gl_rwlock_t *lock) +int +glthread_rwlock_wrlock_multithreaded (gl_rwlock_t *lock) { if (!lock->initialized) { - if (pthread_mutex_lock (&lock->guard) != 0) - abort (); + int err; + + err = pthread_mutex_lock (&lock->guard); + if (err != 0) + return err; if (!lock->initialized) - glthread_rwlock_init (lock); - if (pthread_mutex_unlock (&lock->guard) != 0) - abort (); + { + err = glthread_rwlock_init_multithreaded (lock); + if (err != 0) + { + pthread_mutex_unlock (&lock->guard); + return err; + } + } + err = pthread_mutex_unlock (&lock->guard); + if (err != 0) + return err; } - if (pthread_rwlock_wrlock (&lock->rwlock) != 0) - abort (); + return pthread_rwlock_wrlock (&lock->rwlock); } -void -glthread_rwlock_unlock (gl_rwlock_t *lock) +int +glthread_rwlock_unlock_multithreaded (gl_rwlock_t *lock) { if (!lock->initialized) - abort (); - if (pthread_rwlock_unlock (&lock->rwlock) != 0) - abort (); + return EINVAL; + return pthread_rwlock_unlock (&lock->rwlock); } -void -glthread_rwlock_destroy (gl_rwlock_t *lock) +int +glthread_rwlock_destroy_multithreaded (gl_rwlock_t *lock) { + int err; + if (!lock->initialized) - abort (); - if (pthread_rwlock_destroy (&lock->rwlock) != 0) - abort (); + return EINVAL; + err = pthread_rwlock_destroy (&lock->rwlock); + if (err != 0) + return err; lock->initialized = 0; + return 0; } # endif # else -void -glthread_rwlock_init (gl_rwlock_t *lock) -{ - if (pthread_mutex_init (&lock->lock, NULL) != 0) - abort (); - if (pthread_cond_init (&lock->waiting_readers, NULL) != 0) - abort (); - if (pthread_cond_init (&lock->waiting_writers, NULL) != 0) - abort (); +int +glthread_rwlock_init_multithreaded (gl_rwlock_t *lock) +{ + int err; + + err = pthread_mutex_init (&lock->lock, NULL); + if (err != 0) + return err; + err = pthread_cond_init (&lock->waiting_readers, NULL); + if (err != 0) + return err; + err = pthread_cond_init (&lock->waiting_writers, NULL); + if (err != 0) + return err; lock->waiting_writers_count = 0; lock->runcount = 0; + return 0; } -void -glthread_rwlock_rdlock (gl_rwlock_t *lock) +int +glthread_rwlock_rdlock_multithreaded (gl_rwlock_t *lock) { - if (pthread_mutex_lock (&lock->lock) != 0) - abort (); + int err; + + err = pthread_mutex_lock (&lock->lock); + if (err != 0) + return err; /* Test whether only readers are currently running, and whether the runcount field will not overflow. */ /* POSIX says: "It is implementation-defined whether the calling thread @@ -165,84 +162,116 @@ glthread_rwlock_rdlock (gl_rwlock_t *lock) while (!(lock->runcount + 1 > 0 && lock->waiting_writers_count == 0)) { /* This thread has to wait for a while. Enqueue it among the - waiting_readers. */ - if (pthread_cond_wait (&lock->waiting_readers, &lock->lock) != 0) - abort (); + waiting_readers. */ + err = pthread_cond_wait (&lock->waiting_readers, &lock->lock); + if (err != 0) + { + pthread_mutex_unlock (&lock->lock); + return err; + } } lock->runcount++; - if (pthread_mutex_unlock (&lock->lock) != 0) - abort (); + return pthread_mutex_unlock (&lock->lock); } -void -glthread_rwlock_wrlock (gl_rwlock_t *lock) +int +glthread_rwlock_wrlock_multithreaded (gl_rwlock_t *lock) { - if (pthread_mutex_lock (&lock->lock) != 0) - abort (); + int err; + + err = pthread_mutex_lock (&lock->lock); + if (err != 0) + return err; /* Test whether no readers or writers are currently running. */ while (!(lock->runcount == 0)) { /* This thread has to wait for a while. Enqueue it among the - waiting_writers. */ + waiting_writers. */ lock->waiting_writers_count++; - if (pthread_cond_wait (&lock->waiting_writers, &lock->lock) != 0) - abort (); + err = pthread_cond_wait (&lock->waiting_writers, &lock->lock); + if (err != 0) + { + lock->waiting_writers_count--; + pthread_mutex_unlock (&lock->lock); + return err; + } lock->waiting_writers_count--; } lock->runcount--; /* runcount becomes -1 */ - if (pthread_mutex_unlock (&lock->lock) != 0) - abort (); + return pthread_mutex_unlock (&lock->lock); } -void -glthread_rwlock_unlock (gl_rwlock_t *lock) +int +glthread_rwlock_unlock_multithreaded (gl_rwlock_t *lock) { - if (pthread_mutex_lock (&lock->lock) != 0) - abort (); + int err; + + err = pthread_mutex_lock (&lock->lock); + if (err != 0) + return err; if (lock->runcount < 0) { /* Drop a writer lock. */ if (!(lock->runcount == -1)) - abort (); + { + pthread_mutex_unlock (&lock->lock); + return EINVAL; + } lock->runcount = 0; } else { /* Drop a reader lock. */ if (!(lock->runcount > 0)) - abort (); + { + pthread_mutex_unlock (&lock->lock); + return EINVAL; + } lock->runcount--; } if (lock->runcount == 0) { /* POSIX recommends that "write locks shall take precedence over read - locks", to avoid "writer starvation". */ + locks", to avoid "writer starvation". */ if (lock->waiting_writers_count > 0) - { - /* Wake up one of the waiting writers. */ - if (pthread_cond_signal (&lock->waiting_writers) != 0) - abort (); - } + { + /* Wake up one of the waiting writers. */ + err = pthread_cond_signal (&lock->waiting_writers); + if (err != 0) + { + pthread_mutex_unlock (&lock->lock); + return err; + } + } else - { - /* Wake up all waiting readers. */ - if (pthread_cond_broadcast (&lock->waiting_readers) != 0) - abort (); - } + { + /* Wake up all waiting readers. */ + err = pthread_cond_broadcast (&lock->waiting_readers); + if (err != 0) + { + pthread_mutex_unlock (&lock->lock); + return err; + } + } } - if (pthread_mutex_unlock (&lock->lock) != 0) - abort (); + return pthread_mutex_unlock (&lock->lock); } -void -glthread_rwlock_destroy (gl_rwlock_t *lock) +int +glthread_rwlock_destroy_multithreaded (gl_rwlock_t *lock) { - if (pthread_mutex_destroy (&lock->lock) != 0) - abort (); - if (pthread_cond_destroy (&lock->waiting_readers) != 0) - abort (); - if (pthread_cond_destroy (&lock->waiting_writers) != 0) - abort (); + int err; + + err = pthread_mutex_destroy (&lock->lock); + if (err != 0) + return err; + err = pthread_cond_destroy (&lock->waiting_readers); + if (err != 0) + return err; + err = pthread_cond_destroy (&lock->waiting_writers); + if (err != 0) + return err; + return 0; } # endif @@ -251,108 +280,173 @@ glthread_rwlock_destroy (gl_rwlock_t *lock) # if HAVE_PTHREAD_MUTEX_RECURSIVE -# if !(defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER || defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) +# if defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER || defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP -void -glthread_recursive_lock_init (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_init_multithreaded (gl_recursive_lock_t *lock) +{ + pthread_mutexattr_t attributes; + int err; + + err = pthread_mutexattr_init (&attributes); + if (err != 0) + return err; + err = pthread_mutexattr_settype (&attributes, PTHREAD_MUTEX_RECURSIVE); + if (err != 0) + { + pthread_mutexattr_destroy (&attributes); + return err; + } + err = pthread_mutex_init (lock, &attributes); + if (err != 0) + { + pthread_mutexattr_destroy (&attributes); + return err; + } + err = pthread_mutexattr_destroy (&attributes); + if (err != 0) + return err; + return 0; +} + +# else + +int +glthread_recursive_lock_init_multithreaded (gl_recursive_lock_t *lock) { pthread_mutexattr_t attributes; + int err; - if (pthread_mutexattr_init (&attributes) != 0) - abort (); - if (pthread_mutexattr_settype (&attributes, PTHREAD_MUTEX_RECURSIVE) != 0) - abort (); - if (pthread_mutex_init (&lock->recmutex, &attributes) != 0) - abort (); - if (pthread_mutexattr_destroy (&attributes) != 0) - abort (); + err = pthread_mutexattr_init (&attributes); + if (err != 0) + return err; + err = pthread_mutexattr_settype (&attributes, PTHREAD_MUTEX_RECURSIVE); + if (err != 0) + { + pthread_mutexattr_destroy (&attributes); + return err; + } + err = pthread_mutex_init (&lock->recmutex, &attributes); + if (err != 0) + { + pthread_mutexattr_destroy (&attributes); + return err; + } + err = pthread_mutexattr_destroy (&attributes); + if (err != 0) + return err; lock->initialized = 1; + return 0; } -void -glthread_recursive_lock_lock (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_lock_multithreaded (gl_recursive_lock_t *lock) { if (!lock->initialized) { - if (pthread_mutex_lock (&lock->guard) != 0) - abort (); + int err; + + err = pthread_mutex_lock (&lock->guard); + if (err != 0) + return err; if (!lock->initialized) - glthread_recursive_lock_init (lock); - if (pthread_mutex_unlock (&lock->guard) != 0) - abort (); + { + err = glthread_recursive_lock_init_multithreaded (lock); + if (err != 0) + { + pthread_mutex_unlock (&lock->guard); + return err; + } + } + err = pthread_mutex_unlock (&lock->guard); + if (err != 0) + return err; } - if (pthread_mutex_lock (&lock->recmutex) != 0) - abort (); + return pthread_mutex_lock (&lock->recmutex); } -void -glthread_recursive_lock_unlock (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_unlock_multithreaded (gl_recursive_lock_t *lock) { if (!lock->initialized) - abort (); - if (pthread_mutex_unlock (&lock->recmutex) != 0) - abort (); + return EINVAL; + return pthread_mutex_unlock (&lock->recmutex); } -void -glthread_recursive_lock_destroy (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_destroy_multithreaded (gl_recursive_lock_t *lock) { + int err; + if (!lock->initialized) - abort (); - if (pthread_mutex_destroy (&lock->recmutex) != 0) - abort (); + return EINVAL; + err = pthread_mutex_destroy (&lock->recmutex); + if (err != 0) + return err; lock->initialized = 0; + return 0; } # endif # else -void -glthread_recursive_lock_init (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_init_multithreaded (gl_recursive_lock_t *lock) { - if (pthread_mutex_init (&lock->mutex, NULL) != 0) - abort (); + int err; + + err = pthread_mutex_init (&lock->mutex, NULL); + if (err != 0) + return err; lock->owner = (pthread_t) 0; lock->depth = 0; + return 0; } -void -glthread_recursive_lock_lock (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_lock_multithreaded (gl_recursive_lock_t *lock) { pthread_t self = pthread_self (); if (lock->owner != self) { - if (pthread_mutex_lock (&lock->mutex) != 0) - abort (); + int err; + + err = pthread_mutex_lock (&lock->mutex); + if (err != 0) + return err; lock->owner = self; } if (++(lock->depth) == 0) /* wraparound? */ - abort (); + { + lock->depth--; + return EAGAIN; + } + return 0; } -void -glthread_recursive_lock_unlock (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_unlock_multithreaded (gl_recursive_lock_t *lock) { if (lock->owner != pthread_self ()) - abort (); + return EPERM; if (lock->depth == 0) - abort (); + return EINVAL; if (--(lock->depth) == 0) { lock->owner = (pthread_t) 0; - if (pthread_mutex_unlock (&lock->mutex) != 0) - abort (); + return pthread_mutex_unlock (&lock->mutex); } + else + return 0; } -void -glthread_recursive_lock_destroy (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_destroy_multithreaded (gl_recursive_lock_t *lock) { if (lock->owner != (pthread_t) 0) - abort (); - if (pthread_mutex_destroy (&lock->mutex) != 0) - abort (); + return EBUSY; + return pthread_mutex_destroy (&lock->mutex); } # endif @@ -393,7 +487,7 @@ glthread_once_singlethreaded (pthread_once_t *once_control) /* -------------------------- gl_once_t datatype -------------------------- */ -void +static void glthread_once_call (void *arg) { void (**gl_once_temp_addr) (void) = (void (**) (void)) arg; @@ -402,6 +496,13 @@ glthread_once_call (void *arg) } int +glthread_once_multithreaded (pth_once_t *once_control, void (*initfunction) (void)) +{ + void (*temp) (void) = initfunction; + return (!pth_once (once_control, glthread_once_call, &temp) ? errno : 0); +} + +int glthread_once_singlethreaded (pth_once_t *once_control) { /* We know that pth_once_t is an integer type. */ @@ -429,72 +530,87 @@ glthread_once_singlethreaded (pth_once_t *once_control) /* --------------------- gl_recursive_lock_t datatype --------------------- */ -void -glthread_recursive_lock_init (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_init_multithreaded (gl_recursive_lock_t *lock) { - if (mutex_init (&lock->mutex, USYNC_THREAD, NULL) != 0) - abort (); + int err; + + err = mutex_init (&lock->mutex, USYNC_THREAD, NULL); + if (err != 0) + return err; lock->owner = (thread_t) 0; lock->depth = 0; + return 0; } -void -glthread_recursive_lock_lock (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_lock_multithreaded (gl_recursive_lock_t *lock) { thread_t self = thr_self (); if (lock->owner != self) { - if (mutex_lock (&lock->mutex) != 0) - abort (); + int err; + + err = mutex_lock (&lock->mutex); + if (err != 0) + return err; lock->owner = self; } if (++(lock->depth) == 0) /* wraparound? */ - abort (); + { + lock->depth--; + return EAGAIN; + } + return 0; } -void -glthread_recursive_lock_unlock (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_unlock_multithreaded (gl_recursive_lock_t *lock) { if (lock->owner != thr_self ()) - abort (); + return EPERM; if (lock->depth == 0) - abort (); + return EINVAL; if (--(lock->depth) == 0) { lock->owner = (thread_t) 0; - if (mutex_unlock (&lock->mutex) != 0) - abort (); + return mutex_unlock (&lock->mutex); } + else + return 0; } -void -glthread_recursive_lock_destroy (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_destroy_multithreaded (gl_recursive_lock_t *lock) { if (lock->owner != (thread_t) 0) - abort (); - if (mutex_destroy (&lock->mutex) != 0) - abort (); + return EBUSY; + return mutex_destroy (&lock->mutex); } /* -------------------------- gl_once_t datatype -------------------------- */ -void -glthread_once (gl_once_t *once_control, void (*initfunction) (void)) +int +glthread_once_multithreaded (gl_once_t *once_control, void (*initfunction) (void)) { if (!once_control->inited) { + int err; + /* Use the mutex to guarantee that if another thread is already calling - the initfunction, this thread waits until it's finished. */ - if (mutex_lock (&once_control->mutex) != 0) - abort (); + the initfunction, this thread waits until it's finished. */ + err = mutex_lock (&once_control->mutex); + if (err != 0) + return err; if (!once_control->inited) - { - once_control->inited = 1; - initfunction (); - } - if (mutex_unlock (&once_control->mutex) != 0) - abort (); + { + once_control->inited = 1; + initfunction (); + } + return mutex_unlock (&once_control->mutex); } + else + return 0; } int @@ -520,48 +636,54 @@ glthread_once_singlethreaded (gl_once_t *once_control) /* -------------------------- gl_lock_t datatype -------------------------- */ void -glthread_lock_init (gl_lock_t *lock) +glthread_lock_init_func (gl_lock_t *lock) { InitializeCriticalSection (&lock->lock); lock->guard.done = 1; } -void -glthread_lock_lock (gl_lock_t *lock) +int +glthread_lock_lock_func (gl_lock_t *lock) { if (!lock->guard.done) { if (InterlockedIncrement (&lock->guard.started) == 0) - /* This thread is the first one to need this lock. Initialize it. */ - glthread_lock_init (lock); + /* This thread is the first one to need this lock. Initialize it. */ + glthread_lock_init (lock); else - /* Yield the CPU while waiting for another thread to finish - initializing this lock. */ - while (!lock->guard.done) - Sleep (0); + /* Yield the CPU while waiting for another thread to finish + initializing this lock. */ + while (!lock->guard.done) + Sleep (0); } EnterCriticalSection (&lock->lock); + return 0; } -void -glthread_lock_unlock (gl_lock_t *lock) +int +glthread_lock_unlock_func (gl_lock_t *lock) { if (!lock->guard.done) - abort (); + return EINVAL; LeaveCriticalSection (&lock->lock); + return 0; } -void -glthread_lock_destroy (gl_lock_t *lock) +int +glthread_lock_destroy_func (gl_lock_t *lock) { if (!lock->guard.done) - abort (); + return EINVAL; DeleteCriticalSection (&lock->lock); lock->guard.done = 0; + return 0; } /* ------------------------- gl_rwlock_t datatype ------------------------- */ +/* In this file, the waitqueues are implemented as circular arrays. */ +#define gl_waitqueue_t gl_carray_waitqueue_t + static inline void gl_waitqueue_init (gl_waitqueue_t *wq) { @@ -583,31 +705,33 @@ gl_waitqueue_add (gl_waitqueue_t *wq) { unsigned int new_alloc = 2 * wq->alloc + 1; HANDLE *new_array = - (HANDLE *) realloc (wq->array, new_alloc * sizeof (HANDLE)); + (HANDLE *) realloc (wq->array, new_alloc * sizeof (HANDLE)); if (new_array == NULL) - /* No more memory. */ - return INVALID_HANDLE_VALUE; + /* No more memory. */ + return INVALID_HANDLE_VALUE; /* Now is a good opportunity to rotate the array so that its contents - starts at offset 0. */ + starts at offset 0. */ if (wq->offset > 0) - { - unsigned int old_count = wq->count; - unsigned int old_alloc = wq->alloc; - unsigned int old_offset = wq->offset; - unsigned int i; - if (old_offset + old_count > old_alloc) - { - unsigned int limit = old_offset + old_count - old_alloc; - for (i = 0; i < limit; i++) - new_array[old_alloc + i] = new_array[i]; - } - for (i = 0; i < old_count; i++) - new_array[i] = new_array[old_offset + i]; - wq->offset = 0; - } + { + unsigned int old_count = wq->count; + unsigned int old_alloc = wq->alloc; + unsigned int old_offset = wq->offset; + unsigned int i; + if (old_offset + old_count > old_alloc) + { + unsigned int limit = old_offset + old_count - old_alloc; + for (i = 0; i < limit; i++) + new_array[old_alloc + i] = new_array[i]; + } + for (i = 0; i < old_count; i++) + new_array[i] = new_array[old_offset + i]; + wq->offset = 0; + } wq->array = new_array; wq->alloc = new_alloc; } + /* Whether the created event is a manual-reset one or an auto-reset one, + does not matter, since we will wait on it only once. */ event = CreateEvent (NULL, TRUE, FALSE, NULL); if (event == INVALID_HANDLE_VALUE) /* No way to allocate an event. */ @@ -641,7 +765,7 @@ gl_waitqueue_notify_all (gl_waitqueue_t *wq) { unsigned int index = wq->offset + i; if (index >= wq->alloc) - index -= wq->alloc; + index -= wq->alloc; SetEvent (wq->array[index]); } wq->count = 0; @@ -649,7 +773,7 @@ gl_waitqueue_notify_all (gl_waitqueue_t *wq) } void -glthread_rwlock_init (gl_rwlock_t *lock) +glthread_rwlock_init_func (gl_rwlock_t *lock) { InitializeCriticalSection (&lock->lock); gl_waitqueue_init (&lock->waiting_readers); @@ -658,19 +782,19 @@ glthread_rwlock_init (gl_rwlock_t *lock) lock->guard.done = 1; } -void -glthread_rwlock_rdlock (gl_rwlock_t *lock) +int +glthread_rwlock_rdlock_func (gl_rwlock_t *lock) { if (!lock->guard.done) { if (InterlockedIncrement (&lock->guard.started) == 0) - /* This thread is the first one to need this lock. Initialize it. */ - glthread_rwlock_init (lock); + /* This thread is the first one to need this lock. Initialize it. */ + glthread_rwlock_init (lock); else - /* Yield the CPU while waiting for another thread to finish - initializing this lock. */ - while (!lock->guard.done) - Sleep (0); + /* Yield the CPU while waiting for another thread to finish + initializing this lock. */ + while (!lock->guard.done) + Sleep (0); } EnterCriticalSection (&lock->lock); /* Test whether only readers are currently running, and whether the runcount @@ -678,150 +802,157 @@ glthread_rwlock_rdlock (gl_rwlock_t *lock) if (!(lock->runcount + 1 > 0)) { /* This thread has to wait for a while. Enqueue it among the - waiting_readers. */ + waiting_readers. */ HANDLE event = gl_waitqueue_add (&lock->waiting_readers); if (event != INVALID_HANDLE_VALUE) - { - DWORD result; - LeaveCriticalSection (&lock->lock); - /* Wait until another thread signals this event. */ - result = WaitForSingleObject (event, INFINITE); - if (result == WAIT_FAILED || result == WAIT_TIMEOUT) - abort (); - CloseHandle (event); - /* The thread which signalled the event already did the bookkeeping: - removed us from the waiting_readers, incremented lock->runcount. */ - if (!(lock->runcount > 0)) - abort (); - return; - } + { + DWORD result; + LeaveCriticalSection (&lock->lock); + /* Wait until another thread signals this event. */ + result = WaitForSingleObject (event, INFINITE); + if (result == WAIT_FAILED || result == WAIT_TIMEOUT) + abort (); + CloseHandle (event); + /* The thread which signalled the event already did the bookkeeping: + removed us from the waiting_readers, incremented lock->runcount. */ + if (!(lock->runcount > 0)) + abort (); + return 0; + } else - { - /* Allocation failure. Weird. */ - do - { - LeaveCriticalSection (&lock->lock); - Sleep (1); - EnterCriticalSection (&lock->lock); - } - while (!(lock->runcount + 1 > 0)); - } + { + /* Allocation failure. Weird. */ + do + { + LeaveCriticalSection (&lock->lock); + Sleep (1); + EnterCriticalSection (&lock->lock); + } + while (!(lock->runcount + 1 > 0)); + } } lock->runcount++; LeaveCriticalSection (&lock->lock); + return 0; } -void -glthread_rwlock_wrlock (gl_rwlock_t *lock) +int +glthread_rwlock_wrlock_func (gl_rwlock_t *lock) { if (!lock->guard.done) { if (InterlockedIncrement (&lock->guard.started) == 0) - /* This thread is the first one to need this lock. Initialize it. */ - glthread_rwlock_init (lock); + /* This thread is the first one to need this lock. Initialize it. */ + glthread_rwlock_init (lock); else - /* Yield the CPU while waiting for another thread to finish - initializing this lock. */ - while (!lock->guard.done) - Sleep (0); + /* Yield the CPU while waiting for another thread to finish + initializing this lock. */ + while (!lock->guard.done) + Sleep (0); } EnterCriticalSection (&lock->lock); /* Test whether no readers or writers are currently running. */ if (!(lock->runcount == 0)) { /* This thread has to wait for a while. Enqueue it among the - waiting_writers. */ + waiting_writers. */ HANDLE event = gl_waitqueue_add (&lock->waiting_writers); if (event != INVALID_HANDLE_VALUE) - { - DWORD result; - LeaveCriticalSection (&lock->lock); - /* Wait until another thread signals this event. */ - result = WaitForSingleObject (event, INFINITE); - if (result == WAIT_FAILED || result == WAIT_TIMEOUT) - abort (); - CloseHandle (event); - /* The thread which signalled the event already did the bookkeeping: - removed us from the waiting_writers, set lock->runcount = -1. */ - if (!(lock->runcount == -1)) - abort (); - return; - } + { + DWORD result; + LeaveCriticalSection (&lock->lock); + /* Wait until another thread signals this event. */ + result = WaitForSingleObject (event, INFINITE); + if (result == WAIT_FAILED || result == WAIT_TIMEOUT) + abort (); + CloseHandle (event); + /* The thread which signalled the event already did the bookkeeping: + removed us from the waiting_writers, set lock->runcount = -1. */ + if (!(lock->runcount == -1)) + abort (); + return 0; + } else - { - /* Allocation failure. Weird. */ - do - { - LeaveCriticalSection (&lock->lock); - Sleep (1); - EnterCriticalSection (&lock->lock); - } - while (!(lock->runcount == 0)); - } + { + /* Allocation failure. Weird. */ + do + { + LeaveCriticalSection (&lock->lock); + Sleep (1); + EnterCriticalSection (&lock->lock); + } + while (!(lock->runcount == 0)); + } } lock->runcount--; /* runcount becomes -1 */ LeaveCriticalSection (&lock->lock); + return 0; } -void -glthread_rwlock_unlock (gl_rwlock_t *lock) +int +glthread_rwlock_unlock_func (gl_rwlock_t *lock) { if (!lock->guard.done) - abort (); + return EINVAL; EnterCriticalSection (&lock->lock); if (lock->runcount < 0) { /* Drop a writer lock. */ if (!(lock->runcount == -1)) - abort (); + abort (); lock->runcount = 0; } else { /* Drop a reader lock. */ if (!(lock->runcount > 0)) - abort (); + { + LeaveCriticalSection (&lock->lock); + return EPERM; + } lock->runcount--; } if (lock->runcount == 0) { /* POSIX recommends that "write locks shall take precedence over read - locks", to avoid "writer starvation". */ + locks", to avoid "writer starvation". */ if (lock->waiting_writers.count > 0) - { - /* Wake up one of the waiting writers. */ - lock->runcount--; - gl_waitqueue_notify_first (&lock->waiting_writers); - } + { + /* Wake up one of the waiting writers. */ + lock->runcount--; + gl_waitqueue_notify_first (&lock->waiting_writers); + } else - { - /* Wake up all waiting readers. */ - lock->runcount += lock->waiting_readers.count; - gl_waitqueue_notify_all (&lock->waiting_readers); - } + { + /* Wake up all waiting readers. */ + lock->runcount += lock->waiting_readers.count; + gl_waitqueue_notify_all (&lock->waiting_readers); + } } LeaveCriticalSection (&lock->lock); + return 0; } -void -glthread_rwlock_destroy (gl_rwlock_t *lock) +int +glthread_rwlock_destroy_func (gl_rwlock_t *lock) { if (!lock->guard.done) - abort (); + return EINVAL; if (lock->runcount != 0) - abort (); + return EBUSY; DeleteCriticalSection (&lock->lock); if (lock->waiting_readers.array != NULL) free (lock->waiting_readers.array); if (lock->waiting_writers.array != NULL) free (lock->waiting_writers.array); lock->guard.done = 0; + return 0; } /* --------------------- gl_recursive_lock_t datatype --------------------- */ void -glthread_recursive_lock_init (gl_recursive_lock_t *lock) +glthread_recursive_lock_init_func (gl_recursive_lock_t *lock) { lock->owner = 0; lock->depth = 0; @@ -829,91 +960,97 @@ glthread_recursive_lock_init (gl_recursive_lock_t *lock) lock->guard.done = 1; } -void -glthread_recursive_lock_lock (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_lock_func (gl_recursive_lock_t *lock) { if (!lock->guard.done) { if (InterlockedIncrement (&lock->guard.started) == 0) - /* This thread is the first one to need this lock. Initialize it. */ - glthread_recursive_lock_init (lock); + /* This thread is the first one to need this lock. Initialize it. */ + glthread_recursive_lock_init (lock); else - /* Yield the CPU while waiting for another thread to finish - initializing this lock. */ - while (!lock->guard.done) - Sleep (0); + /* Yield the CPU while waiting for another thread to finish + initializing this lock. */ + while (!lock->guard.done) + Sleep (0); } { DWORD self = GetCurrentThreadId (); if (lock->owner != self) { - EnterCriticalSection (&lock->lock); - lock->owner = self; + EnterCriticalSection (&lock->lock); + lock->owner = self; } if (++(lock->depth) == 0) /* wraparound? */ - abort (); + { + lock->depth--; + return EAGAIN; + } } + return 0; } -void -glthread_recursive_lock_unlock (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_unlock_func (gl_recursive_lock_t *lock) { if (lock->owner != GetCurrentThreadId ()) - abort (); + return EPERM; if (lock->depth == 0) - abort (); + return EINVAL; if (--(lock->depth) == 0) { lock->owner = 0; LeaveCriticalSection (&lock->lock); } + return 0; } -void -glthread_recursive_lock_destroy (gl_recursive_lock_t *lock) +int +glthread_recursive_lock_destroy_func (gl_recursive_lock_t *lock) { if (lock->owner != 0) - abort (); + return EBUSY; DeleteCriticalSection (&lock->lock); lock->guard.done = 0; + return 0; } /* -------------------------- gl_once_t datatype -------------------------- */ void -glthread_once (gl_once_t *once_control, void (*initfunction) (void)) +glthread_once_func (gl_once_t *once_control, void (*initfunction) (void)) { if (once_control->inited <= 0) { if (InterlockedIncrement (&once_control->started) == 0) - { - /* This thread is the first one to come to this once_control. */ - InitializeCriticalSection (&once_control->lock); - EnterCriticalSection (&once_control->lock); - once_control->inited = 0; - initfunction (); - once_control->inited = 1; - LeaveCriticalSection (&once_control->lock); - } + { + /* This thread is the first one to come to this once_control. */ + InitializeCriticalSection (&once_control->lock); + EnterCriticalSection (&once_control->lock); + once_control->inited = 0; + initfunction (); + once_control->inited = 1; + LeaveCriticalSection (&once_control->lock); + } else - { - /* Undo last operation. */ - InterlockedDecrement (&once_control->started); - /* Some other thread has already started the initialization. - Yield the CPU while waiting for the other thread to finish - initializing and taking the lock. */ - while (once_control->inited < 0) - Sleep (0); - if (once_control->inited <= 0) - { - /* Take the lock. This blocks until the other thread has - finished calling the initfunction. */ - EnterCriticalSection (&once_control->lock); - LeaveCriticalSection (&once_control->lock); - if (!(once_control->inited > 0)) - abort (); - } - } + { + /* Undo last operation. */ + InterlockedDecrement (&once_control->started); + /* Some other thread has already started the initialization. + Yield the CPU while waiting for the other thread to finish + initializing and taking the lock. */ + while (once_control->inited < 0) + Sleep (0); + if (once_control->inited <= 0) + { + /* Take the lock. This blocks until the other thread has + finished calling the initfunction. */ + EnterCriticalSection (&once_control->lock); + LeaveCriticalSection (&once_control->lock); + if (!(once_control->inited > 0)) + abort (); + } + } } } |