#include "pthread_internals.h"
int
pthread_mutex_destroy(pthread_mutex_t *mutex)
{
if (mutex->sig != _PTHREAD_MUTEX_SIG)
return (EINVAL);
if ((mutex->owner != (pthread_t)NULL) ||
(mutex->busy != (pthread_cond_t *)NULL))
return (EBUSY);
mutex->sig = _PTHREAD_NO_SIG;
return (ESUCCESS);
}
int
pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
{
LOCK_INIT(mutex->lock);
mutex->sig = _PTHREAD_MUTEX_SIG;
if (attr)
{
if (attr->sig != _PTHREAD_MUTEX_ATTR_SIG)
return (EINVAL);
mutex->prioceiling = attr->prioceiling;
mutex->protocol = attr->protocol;
} else
{
mutex->prioceiling = _PTHREAD_DEFAULT_PRIOCEILING;
mutex->protocol = _PTHREAD_DEFAULT_PROTOCOL;
}
mutex->owner = (pthread_t)NULL;
mutex->next = (pthread_mutex_t *)NULL;
mutex->prev = (pthread_mutex_t *)NULL;
mutex->busy = (pthread_cond_t *)NULL;
mutex->waiters = 0;
mutex->cond_lock = 0;
mutex->sem = MACH_PORT_NULL;
return (ESUCCESS);
}
#if defined(DEBUG)
static void
_pthread_mutex_add(pthread_mutex_t *mutex)
{
pthread_mutex_t *m;
pthread_t self = pthread_self();
if (self != (pthread_t)0) {
mutex->owner = self;
if ((m = self->mutexes) != (pthread_mutex_t *)NULL)
{
m->prev = mutex;
}
mutex->next = m;
mutex->prev = (pthread_mutex_t *)NULL;
self->mutexes = mutex;
}
}
static void
_pthread_mutex_remove(pthread_mutex_t *mutex, pthread_t self)
{
pthread_mutex_t *n, *prev;
if ((n = mutex->next) != (pthread_mutex_t *)NULL)
{
n->prev = mutex->prev;
}
if ((prev = mutex->prev) != (pthread_mutex_t *)NULL)
{
prev->next = mutex->next;
} else
{
if (self != (pthread_t)0) {
self->mutexes = n;
}
}
mutex->owner = (pthread_t)NULL;
}
#endif
int
pthread_mutex_lock(pthread_mutex_t *mutex)
{
kern_return_t kern_res;
if (mutex->sig == _PTHREAD_MUTEX_SIG_init)
{
int res;
if (res = pthread_mutex_init(mutex, NULL))
return (res);
}
if (mutex->sig != _PTHREAD_MUTEX_SIG)
return (EINVAL);
LOCK(mutex->lock);
if (mutex->waiters || (mutex->owner != (pthread_t)NULL))
{
mutex->waiters++;
if (mutex->sem == MACH_PORT_NULL) {
mutex->sem = new_sem_from_pool();
}
UNLOCK(mutex->lock);
PTHREAD_MACH_CALL(semaphore_wait(mutex->sem), kern_res);
LOCK(mutex->lock);
mutex->waiters--;
if (mutex->waiters == 0) {
restore_sem_to_pool(mutex->sem);
mutex->sem = MACH_PORT_NULL;
}
if (mutex->cond_lock) {
mutex->cond_lock = 0;
}
}
#if defined(DEBUG)
_pthread_mutex_add(mutex);
#else
mutex->owner = (pthread_t)0x12141968;
#endif
UNLOCK(mutex->lock);
return (ESUCCESS);
}
int
pthread_mutex_trylock(pthread_mutex_t *mutex)
{
kern_return_t kern_res;
if (mutex->sig == _PTHREAD_MUTEX_SIG_init)
{
int res;
if (res = pthread_mutex_init(mutex, NULL))
return (res);
}
if (mutex->sig != _PTHREAD_MUTEX_SIG)
return (EINVAL);
if (!TRY_LOCK(mutex->lock)) {
return (EBUSY);
}
if (mutex->waiters ||
((mutex->owner != (pthread_t)NULL) && (mutex->cond_lock == 0)))
{
UNLOCK(mutex->lock);
return (EBUSY);
} else
{
#if defined(DEBUG)
_pthread_mutex_add(mutex);
#else
mutex->owner = (pthread_t)0x12141968;
#endif
if (mutex->cond_lock) {
PTHREAD_MACH_CALL(semaphore_wait(mutex->sem), kern_res);
mutex->cond_lock = 0;
restore_sem_to_pool(mutex->sem);
mutex->sem = MACH_PORT_NULL;
}
UNLOCK(mutex->lock);
return (ESUCCESS);
}
}
int
pthread_mutex_unlock(pthread_mutex_t *mutex)
{
kern_return_t kern_res;
int waiters;
if (mutex->sig == _PTHREAD_MUTEX_SIG_init)
{
int res;
if (res = pthread_mutex_init(mutex, NULL))
return (res);
}
if (mutex->sig != _PTHREAD_MUTEX_SIG)
return (EINVAL);
LOCK(mutex->lock);
#if defined(DEBUG)
if (mutex->owner != pthread_self())
{
UNLOCK(mutex->lock);
abort();
return (EPERM);
} else
#endif
{
#if defined(DEBUG)
_pthread_mutex_remove(mutex, mutex->owner);
#else
mutex->owner = (pthread_t)NULL;
#endif
waiters = mutex->waiters;
UNLOCK(mutex->lock);
if (waiters)
{
PTHREAD_MACH_CALL(semaphore_signal(mutex->sem), kern_res);
}
return (ESUCCESS);
}
}
int
pthread_mutex_getprioceiling(const pthread_mutex_t *mutex,
int *prioceiling)
{
if (mutex->sig == _PTHREAD_MUTEX_SIG)
{
*prioceiling = mutex->prioceiling;
return (ESUCCESS);
} else
{
return (EINVAL);
}
}
int
pthread_mutex_setprioceiling(pthread_mutex_t *mutex,
int prioceiling,
int *old_prioceiling)
{
if (mutex->sig == _PTHREAD_MUTEX_SIG)
{
if ((prioceiling >= -999) ||
(prioceiling <= 999))
{
*old_prioceiling = mutex->prioceiling;
mutex->prioceiling = prioceiling;
return (ESUCCESS);
} else
{
return (EINVAL);
}
} else
{
return (EINVAL);
}
}
int
pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
{
attr->sig = _PTHREAD_NO_SIG;
return (ESUCCESS);
}
int
pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr,
int *prioceiling)
{
if (attr->sig == _PTHREAD_MUTEX_ATTR_SIG)
{
*prioceiling = attr->prioceiling;
return (ESUCCESS);
} else
{
return (EINVAL);
}
}
int
pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr,
int *protocol)
{
if (attr->sig == _PTHREAD_MUTEX_ATTR_SIG)
{
*protocol = attr->protocol;
return (ESUCCESS);
} else
{
return (EINVAL);
}
}
int
pthread_mutexattr_init(pthread_mutexattr_t *attr)
{
attr->prioceiling = _PTHREAD_DEFAULT_PRIOCEILING;
attr->protocol = _PTHREAD_DEFAULT_PROTOCOL;
attr->sig = _PTHREAD_MUTEX_ATTR_SIG;
return (ESUCCESS);
}
int
pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr,
int prioceiling)
{
if (attr->sig == _PTHREAD_MUTEX_ATTR_SIG)
{
if ((prioceiling >= -999) ||
(prioceiling <= 999))
{
attr->prioceiling = prioceiling;
return (ESUCCESS);
} else
{
return (EINVAL);
}
} else
{
return (EINVAL);
}
}
int
pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr,
int protocol)
{
if (attr->sig == _PTHREAD_MUTEX_ATTR_SIG)
{
if ((protocol == PTHREAD_PRIO_NONE) ||
(protocol == PTHREAD_PRIO_INHERIT) ||
(protocol == PTHREAD_PRIO_PROTECT))
{
attr->protocol = protocol;
return (ESUCCESS);
} else
{
return (EINVAL);
}
} else
{
return (EINVAL);
}
}
int mutex_try_lock(int *x) {
return _spin_lock_try((pthread_lock_t *)x);
}
void mutex_wait_lock(int *x) {
for (;;) {
if( _spin_lock_try((pthread_lock_t *)x)) {
return;
}
swtch_pri(0);
}
}
void cthread_yield(void) {
sched_yield();
}