static __attribute__((noinline)) int
_mutex_trylock(pthread_mutex_t *m)
{
int r = 0;
mutex_t *_m = (mutex_t *)*m;
if (_m->type != PTHREAD_MUTEX_NORMAL)
{
if (COND_LOCKED(_m))
{
if (_m->type == PTHREAD_MUTEX_RECURSIVE && COND_OWNER(_m))
{
InterlockedIncrement(&_m->count);
return 0;
}
return EBUSY;
}
} else if (COND_LOCKED(_m))
return EBUSY;
#if defined USE_MUTEX_Mutex
r = do_sema_b_wait_intern (_m->h, 1, 0);
if (r == ETIMEDOUT) r = EBUSY;
#else /* USE_MUTEX_CriticalSection */
r = TryEnterCriticalSection(&_m->cs.cs) ? 0 : EBUSY;
#endif
if (!r)
{
_m->count = 1;
SET_OWNER(_m);
}
return r;
}
int pthread_mutex_timedlock(pthread_mutex_t *m, const struct timespec *ts)
{
unsigned long long t, ct;
int r;
mutex_t *_m;
if (!ts)
return pthread_mutex_lock(m);
r = mutex_ref(m);
if (r)
return r;
/* Try to lock it without waiting */
r = _mutex_trylock (m);
if (r != EBUSY)
return mutex_unref(m,r);
_m = (mutex_t *)*m;
if (_m->type != PTHREAD_MUTEX_NORMAL && COND_LOCKED(_m) && COND_OWNER(_m))
return mutex_unref(m,EDEADLK);
ct = _pthread_time_in_ms();
t = _pthread_time_in_ms_from_timespec(ts);
mutex_unref(m,r);
r = pthread_mutex_lock_intern(m, (ct > t ? 0 : (t - ct)));
return r;
}
int pthread_mutex_unlock(pthread_mutex_t *m)
{
int r = mutex_ref_unlock(m);
if(r) return r;
mutex_t *_m = (mutex_t *)*m;
if (_m->type == PTHREAD_MUTEX_NORMAL)
{
if (!COND_LOCKED(_m))
return mutex_unref(m,EPERM);
}
else if (!COND_LOCKED(_m) || !COND_OWNER(_m))
return mutex_unref(m,EPERM);
if (_m->type == PTHREAD_MUTEX_RECURSIVE)
{
if(InterlockedDecrement(&_m->count))
return mutex_unref(m,0);
}
#if defined USE_MUTEX_Mutex
UNSET_OWNER(_m);
if (_m->h != NULL && !ReleaseSemaphore(_m->h, 1, NULL)) {
SET_OWNER(_m);
/* restore our own bookkeeping */
return mutex_unref(m,EPERM);
}
#else /* USE_MUTEX_CriticalSection */
UNSET_OWNER(_m);
LeaveCriticalSection(&_m->cs.cs);
#endif
return mutex_unref(m,0);
}
static WINPTHREADS_ATTRIBUTE((noinline)) int
_mutex_trylock(pthread_mutex_t *m)
{
int r = 0;
mutex_t *_m = (mutex_t *)*m;
if (_m->type != PTHREAD_MUTEX_NORMAL)
{
if (COND_LOCKED(_m))
{
if (_m->type == PTHREAD_MUTEX_RECURSIVE && COND_OWNER(_m))
{
InterlockedIncrement(&_m->count);
return 0;
}
return EBUSY;
}
} else if (COND_LOCKED(_m))
return EBUSY;
r = do_sema_b_wait_intern (_m->h, 1, 0);
if (r == ETIMEDOUT)
r = EBUSY;
else if (!r)
{
_m->count = 1;
SET_OWNER(_m);
}
return r;
}
static int pthread_mutex_lock_intern(pthread_mutex_t *m, DWORD timeout)
{
mutex_t *_m;
int r;
r = mutex_ref(m);
if(r) return r;
_m = (mutex_t *)*m;
if (_m->type != PTHREAD_MUTEX_NORMAL)
{
if (COND_LOCKED(_m))
{
if (COND_OWNER(_m))
{
if (_m->type == PTHREAD_MUTEX_RECURSIVE)
{
InterlockedIncrement(&_m->count);
return mutex_unref(m,0);
}
return mutex_unref(m, EDEADLK);
}
}
} else {
#if !defined USE_MUTEX_Mutex
if (COND_OWNER(_m))
{
do {
Sleep(0); /* waiter that owner gets released. */
} while (COND_OWNER(_m));
}
#endif
}
#if defined USE_MUTEX_Mutex
r = do_sema_b_wait_intern (_m->h, 1, timeout);
#else /* USE_MUTEX_CriticalSection */
EnterCriticalSection(&_m->cs.cs);
r = 0;
#endif
if (r == 0)
{
_m->count = 1;
SET_OWNER(_m);
}
return mutex_unref(m,r);
}
int pthread_mutex_unlock(pthread_mutex_t *m)
{
mutex_t *_m;
int r = mutex_ref_unlock(m);
if(r) {
#if 0
printf("thread %d, la pool, no user unset in mutex %p\n", GetCurrentThreadId(), m);
#endif
return r;
}
_m = (mutex_t *)*m;
if (_m->type == PTHREAD_MUTEX_NORMAL)
{
if (!COND_LOCKED(_m))
{
#if 0
printf("thread %d, mutex %p never locked, actually :p\n", GetCurrentThreadId(), m);
#endif
return mutex_unref(m, EPERM);
}
}
else if (!COND_LOCKED(_m) || !COND_OWNER(_m)) {
#if 0
printf("thread %d, mutex %p never locked or not owner, actually :p\n", GetCurrentThreadId(), m);
#endif
return mutex_unref(m,EPERM);
}
if (_m->type == PTHREAD_MUTEX_RECURSIVE)
{
if(InterlockedDecrement(&_m->count)) {
#if 0
printf("thread %d, mutex %p decreasing recursive\n", GetCurrentThreadId(), m);
#endif
return mutex_unref(m,0);
}
}
#if 0
printf("thread %d,unsetting owner of mutex %p\n", GetCurrentThreadId(), m);
#endif
UNSET_OWNER(_m);
if (_m->h != NULL && !ReleaseSemaphore(_m->h, 1, NULL)) {
SET_OWNER(_m);
#if 0
printf("Error, not released! thread %d, setting owner of mutex m\n", GetCurrentThreadId(), m);
#endif
/* restore our own bookkeeping */
return mutex_unref(m,EPERM);
}
return mutex_unref(m,0);
}
static int
pthread_mutex_lock_intern (pthread_mutex_t *m, DWORD timeout)
{
mutex_t *_m;
int r;
HANDLE h;
r = mutex_ref (m);
if (r)
return r;
_m = (mutex_t *) *m;
if (_m->type != PTHREAD_MUTEX_NORMAL)
{
if (COND_LOCKED(_m))
{
if (COND_OWNER(_m))
{
if (_m->type == PTHREAD_MUTEX_RECURSIVE)
{
InterlockedIncrement(&_m->count);
return mutex_unref(m,0);
}
return mutex_unref(m, EDEADLK);
}
}
}
h = _m->h;
mutex_unref (m, 0);
r = do_sema_b_wait_intern (h, 1, timeout);
if (r != 0)
return r;
r = mutex_ref (m);
if (r)
return r;
_m->count = 1;
SET_OWNER(_m);
return mutex_unref (m, r);
}
int pthread_mutex_timedlock(pthread_mutex_t *m, const struct timespec *ts)
{
unsigned long long t, ct;
#ifndef USE_MUTEX_Mutex
int i = 0;
#endif
int r;
if (!ts) return pthread_mutex_lock(m);
r = mutex_ref(m);
if (r) return r;
/* Try to lock it without waiting */
r=_mutex_trylock(m);
if (r != EBUSY) return mutex_unref(m,r);
mutex_t *_m = (mutex_t *)*m;
if (_m->type != PTHREAD_MUTEX_NORMAL && COND_LOCKED(_m) && COND_OWNER(_m))
return mutex_unref(m,EDEADLK);
ct = _pthread_time_in_ms();
t = _pthread_time_in_ms_from_timespec(ts);
#ifdef USE_MUTEX_Mutex
mutex_unref(m,r);
r = pthread_mutex_lock_intern(m, (ct > t ? 0 : (t - ct)));
#else
mutex_unref(m,EDEADLK);
while (1)
{
/* Have we waited long enough? A high count means we busy-waited probably.*/
if (ct >= t) {
printf("%d: Timeout after %d times\n",(int)GetCurrentThreadId(), i);
return ETIMEDOUT;
}
if ((i & 1) == 0)
Sleep(0); /* waiter that owner gets released. */
/* Try to grab lock */
r = pthread_mutex_trylock(m);
if (r != EBUSY) break;
/* Get current time */
ct = _pthread_time_in_ms();
i ++;
}
#endif
return r;
}
int pthread_mutex_unlock(pthread_mutex_t *m)
{
mutex_t *_m;
int r = mutex_ref_unlock(m);
if(r) {
return r;
}
_m = (mutex_t *)*m;
if (_m->type == PTHREAD_MUTEX_NORMAL)
{
if (!COND_LOCKED(_m))
{
return mutex_unref(m, EPERM);
}
}
else if (!COND_LOCKED(_m) || !COND_OWNER(_m)) {
return mutex_unref(m,EPERM);
}
if (_m->type == PTHREAD_MUTEX_RECURSIVE)
{
if(InterlockedDecrement(&_m->count)) {
return mutex_unref(m,0);
}
}
UNSET_OWNER(_m);
if (_m->h != NULL && !ReleaseSemaphore(_m->h, 1, NULL)) {
SET_OWNER(_m);
/* restore our own bookkeeping */
return mutex_unref(m,EPERM);
}
return mutex_unref(m,0);
}
static int
pthread_mutex_lock_intern (pthread_mutex_t *m, DWORD timeout)
{
mutex_t *_m;
int r;
HANDLE h;
#if 0
int waited = 0;
#endif
r = mutex_ref (m);
if (r)
return r;
_m = (mutex_t *) *m;
if (_m->type != PTHREAD_MUTEX_NORMAL)
{
if (COND_LOCKED(_m))
{
if (COND_OWNER(_m))
{
if (_m->type == PTHREAD_MUTEX_RECURSIVE)
{
#if 0
printf("thread %d, recursive increment %p\n", GetCurrentThreadId(), m);
#endif
InterlockedIncrement(&_m->count);
return mutex_unref(m,0);
}
#if 0
printf("thread %d, non recursive increment?!? %p\n", GetCurrentThreadId(), m);
#endif
return mutex_unref(m, EDEADLK);
}
}
}
h = _m->h;
mutex_unref (m, 0);
if(_m->owner) {
#if 0
waited = 1;
printf("thread %d, waiting for thread: %d on mutex %p for %d time\n", GetCurrentThreadId(), _m->owner, m, timeout);
#endif
}
r = do_sema_b_wait_intern (h, 1, timeout);
#if 0
if(waited) {
printf("thread %d, resumed\n", GetCurrentThreadId());
}
#endif
if (r != 0)
return r;
r = mutex_ref (m);
if (r)
return r;
_m->count = 1;
SET_OWNER(_m);
#if 0
printf("thread %d, setting owner of mutex %p\n", GetCurrentThreadId(), m);
#endif
return mutex_unref (m, r);
}
