int glthread_cond_timedwait_func (gl_cond_t *cond, gl_lock_t *lock, struct timespec *abstime) { struct timeval currtime; gettimeofday (&currtime, NULL); if (currtime.tv_sec > abstime->tv_sec || (currtime.tv_sec == abstime->tv_sec && currtime.tv_usec * 1000 >= abstime->tv_nsec)) return ETIMEDOUT; if (!cond->guard.done) { if (InterlockedIncrement (&cond->guard.started) == 0) /* This thread is the first one to need this condition variable. Initialize it. */ glthread_cond_init (cond); else /* Yield the CPU while waiting for another thread to finish initializing this condition variable. */ while (!cond->guard.done) Sleep (0); } EnterCriticalSection (&cond->lock); { struct gl_waitqueue_element *elt = gl_waitqueue_add (&cond->waiters); LeaveCriticalSection (&cond->lock); if (elt == NULL) { /* Allocation failure. Weird. */ return EAGAIN; } else { HANDLE event = elt->event; int err; DWORD timeout; DWORD result; /* Now release the lock and let any other thread take it. */ err = glthread_lock_unlock (lock); if (err != 0) { EnterCriticalSection (&cond->lock); gl_waitqueue_remove (&cond->waiters, elt); LeaveCriticalSection (&cond->lock); CloseHandle (event); free (elt); return err; } /* POSIX says: "If another thread is able to acquire the mutex after the about-to-block thread has released it, then a subsequent call to pthread_cond_broadcast() or pthread_cond_signal() in that thread shall behave as if it were issued after the about-to-block thread has blocked." This is fulfilled here, because the thread signalling is done through SetEvent, not PulseEvent. */ /* Wait until another thread signals this event or until the abstime passes. */ gettimeofday (&currtime, NULL); if (currtime.tv_sec > abstime->tv_sec) timeout = 0; else { unsigned long seconds = abstime->tv_sec - currtime.tv_sec; timeout = seconds * 1000; if (timeout / 1000 != seconds) /* overflow? */ timeout = INFINITE; else { long milliseconds = abstime->tv_nsec / 1000000 - currtime.tv_usec / 1000; if (milliseconds >= 0) { timeout += milliseconds; if (timeout < milliseconds) /* overflow? */ timeout = INFINITE; } else { if (timeout >= - milliseconds) timeout -= (- milliseconds); else timeout = 0; } } } result = WaitForSingleObject (event, timeout); if (result == WAIT_FAILED) abort (); if (result == WAIT_TIMEOUT) { EnterCriticalSection (&cond->lock); if (gl_waitqueue_remove (&cond->waiters, elt)) { /* The event was not signaled between the WaitForSingleObject call and the EnterCriticalSection call. */ if (!(WaitForSingleObject (event, 0) == WAIT_TIMEOUT)) abort (); } else { /* The event was signaled between the WaitForSingleObject call and the EnterCriticalSection call. */ if (!(WaitForSingleObject (event, 0) == WAIT_OBJECT_0)) abort (); /* Produce the right return value. */ result = WAIT_OBJECT_0; } LeaveCriticalSection (&cond->lock); } else { /* The thread which signalled the event already did the bookkeeping: removed us from the waiters. */ } CloseHandle (event); free (elt); /* Take the lock again. It does not matter whether this is done before or after the bookkeeping for WAIT_TIMEOUT. */ err = glthread_lock_lock (lock); return (err ? err : result == WAIT_OBJECT_0 ? 0 : result == WAIT_TIMEOUT ? ETIMEDOUT : /* WAIT_FAILED shouldn't happen */ EAGAIN); } } }
static int gcry_requiem_mutex_unlock(void **lock) { return glthread_lock_unlock((gl_lock_t *) *lock); }
int glthread_cond_wait_func (gl_cond_t *cond, gl_lock_t *lock) { if (!cond->guard.done) { if (InterlockedIncrement (&cond->guard.started) == 0) /* This thread is the first one to need this condition variable. Initialize it. */ glthread_cond_init (cond); else /* Yield the CPU while waiting for another thread to finish initializing this condition variable. */ while (!cond->guard.done) Sleep (0); } EnterCriticalSection (&cond->lock); { struct gl_waitqueue_element *elt = gl_waitqueue_add (&cond->waiters); LeaveCriticalSection (&cond->lock); if (elt == NULL) { /* Allocation failure. Weird. */ return EAGAIN; } else { HANDLE event = elt->event; int err; DWORD result; /* Now release the lock and let any other thread take it. */ err = glthread_lock_unlock (lock); if (err != 0) { EnterCriticalSection (&cond->lock); gl_waitqueue_remove (&cond->waiters, elt); LeaveCriticalSection (&cond->lock); CloseHandle (event); free (elt); return err; } /* POSIX says: "If another thread is able to acquire the mutex after the about-to-block thread has released it, then a subsequent call to pthread_cond_broadcast() or pthread_cond_signal() in that thread shall behave as if it were issued after the about-to-block thread has blocked." This is fulfilled here, because the thread signalling is done through SetEvent, not PulseEvent. */ /* Wait until another thread signals this event. */ result = WaitForSingleObject (event, INFINITE); if (result == WAIT_FAILED || result == WAIT_TIMEOUT) abort (); CloseHandle (event); free (elt); /* The thread which signalled the event already did the bookkeeping: removed us from the waiters. */ return glthread_lock_lock (lock); } } }
static int gcry_prelude_mutex_unlock(void **lock) { return glthread_lock_unlock((gl_lock_t *) *lock); }