2019-03-11 03:26:37 -07:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
|
|
|
/*
|
|
|
|
** File: ptsynch.c
|
|
|
|
** Descritpion: Implemenation for thread synchronization using pthreads
|
|
|
|
** Exports: prlock.h, prcvar.h, prmon.h, prcmon.h
|
|
|
|
*/
|
|
|
|
|
|
|
|
#if defined(_PR_PTHREADS)
|
|
|
|
|
|
|
|
#include "primpl.h"
|
|
|
|
#include "obsolete/prsem.h"
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
#include <pthread.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
|
|
|
|
static pthread_mutexattr_t _pt_mattr;
|
|
|
|
static pthread_condattr_t _pt_cvar_attr;
|
|
|
|
|
|
|
|
#if defined(DEBUG)
|
|
|
|
extern PTDebug pt_debug; /* this is shared between several modules */
|
|
|
|
#endif /* defined(DEBUG) */
|
|
|
|
|
|
|
|
#if defined(FREEBSD)
|
|
|
|
/*
|
|
|
|
* On older versions of FreeBSD, pthread_mutex_trylock returns EDEADLK.
|
|
|
|
* Newer versions return EBUSY. We still need to support both.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
pt_pthread_mutex_is_locked(pthread_mutex_t *m)
|
|
|
|
{
|
|
|
|
int rv = pthread_mutex_trylock(m);
|
|
|
|
return (EBUSY == rv || EDEADLK == rv);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**************************************************************/
|
|
|
|
/**************************************************************/
|
|
|
|
/*****************************LOCKS****************************/
|
|
|
|
/**************************************************************/
|
|
|
|
/**************************************************************/
|
|
|
|
|
|
|
|
void _PR_InitLocks(void)
|
|
|
|
{
|
|
|
|
int rv;
|
2020-03-12 10:40:28 -07:00
|
|
|
rv = _PT_PTHREAD_MUTEXATTR_INIT(&_pt_mattr);
|
2019-03-11 03:26:37 -07:00
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
|
|
|
|
#if (defined(LINUX) && (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)) || \
|
|
|
|
(defined(FREEBSD) && __FreeBSD_version > 700055)
|
|
|
|
rv = pthread_mutexattr_settype(&_pt_mattr, PTHREAD_MUTEX_ADAPTIVE_NP);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
rv = _PT_PTHREAD_CONDATTR_INIT(&_pt_cvar_attr);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pt_PostNotifies(PRLock *lock, PRBool unlock)
|
|
|
|
{
|
|
|
|
PRIntn index, rv;
|
|
|
|
_PT_Notified post;
|
|
|
|
_PT_Notified *notified, *prev = NULL;
|
|
|
|
/*
|
|
|
|
* Time to actually notify any conditions that were affected
|
|
|
|
* while the lock was held. Get a copy of the list that's in
|
|
|
|
* the lock structure and then zero the original. If it's
|
|
|
|
* linked to other such structures, we own that storage.
|
|
|
|
*/
|
|
|
|
post = lock->notified; /* a safe copy; we own the lock */
|
|
|
|
|
|
|
|
#if defined(DEBUG)
|
|
|
|
memset(&lock->notified, 0, sizeof(_PT_Notified)); /* reset */
|
|
|
|
#else
|
|
|
|
lock->notified.length = 0; /* these are really sufficient */
|
|
|
|
lock->notified.link = NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* should (may) we release lock before notifying? */
|
|
|
|
if (unlock)
|
|
|
|
{
|
|
|
|
rv = pthread_mutex_unlock(&lock->mutex);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
}
|
|
|
|
|
|
|
|
notified = &post; /* this is where we start */
|
|
|
|
do
|
|
|
|
{
|
|
|
|
for (index = 0; index < notified->length; ++index)
|
|
|
|
{
|
|
|
|
PRCondVar *cv = notified->cv[index].cv;
|
|
|
|
PR_ASSERT(NULL != cv);
|
|
|
|
PR_ASSERT(0 != notified->cv[index].times);
|
|
|
|
if (-1 == notified->cv[index].times)
|
|
|
|
{
|
|
|
|
rv = pthread_cond_broadcast(&cv->cv);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
while (notified->cv[index].times-- > 0)
|
|
|
|
{
|
|
|
|
rv = pthread_cond_signal(&cv->cv);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#if defined(DEBUG)
|
|
|
|
pt_debug.cvars_notified += 1;
|
|
|
|
if (0 > PR_ATOMIC_DECREMENT(&cv->notify_pending))
|
|
|
|
{
|
|
|
|
pt_debug.delayed_cv_deletes += 1;
|
|
|
|
PR_DestroyCondVar(cv);
|
|
|
|
}
|
|
|
|
#else /* defined(DEBUG) */
|
2020-03-12 10:40:28 -07:00
|
|
|
if (0 > PR_ATOMIC_DECREMENT(&cv->notify_pending)) {
|
2019-03-11 03:26:37 -07:00
|
|
|
PR_DestroyCondVar(cv);
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
#endif /* defined(DEBUG) */
|
|
|
|
}
|
|
|
|
prev = notified;
|
|
|
|
notified = notified->link;
|
2020-03-12 10:40:28 -07:00
|
|
|
if (&post != prev) {
|
|
|
|
PR_DELETE(prev);
|
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
} while (NULL != notified);
|
|
|
|
} /* pt_PostNotifies */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRLock*) PR_NewLock(void)
|
|
|
|
{
|
|
|
|
PRIntn rv;
|
|
|
|
PRLock *lock;
|
|
|
|
|
2020-03-12 10:40:28 -07:00
|
|
|
if (!_pr_initialized) {
|
|
|
|
_PR_ImplicitInitialization();
|
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
lock = PR_NEWZAP(PRLock);
|
|
|
|
if (lock != NULL)
|
|
|
|
{
|
2020-03-12 10:40:28 -07:00
|
|
|
rv = _PT_PTHREAD_MUTEX_INIT(lock->mutex, _pt_mattr);
|
2019-03-11 03:26:37 -07:00
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
}
|
|
|
|
#if defined(DEBUG)
|
|
|
|
pt_debug.locks_created += 1;
|
|
|
|
#endif
|
|
|
|
return lock;
|
|
|
|
} /* PR_NewLock */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(void) PR_DestroyLock(PRLock *lock)
|
|
|
|
{
|
|
|
|
PRIntn rv;
|
|
|
|
PR_ASSERT(NULL != lock);
|
|
|
|
PR_ASSERT(PR_FALSE == lock->locked);
|
|
|
|
PR_ASSERT(0 == lock->notified.length);
|
|
|
|
PR_ASSERT(NULL == lock->notified.link);
|
|
|
|
rv = pthread_mutex_destroy(&lock->mutex);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
#if defined(DEBUG)
|
|
|
|
memset(lock, 0xaf, sizeof(PRLock));
|
|
|
|
pt_debug.locks_destroyed += 1;
|
|
|
|
#endif
|
|
|
|
PR_Free(lock);
|
|
|
|
} /* PR_DestroyLock */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(void) PR_Lock(PRLock *lock)
|
|
|
|
{
|
|
|
|
/* Nb: PR_Lock must not call PR_GetCurrentThread to access the |id| or
|
|
|
|
* |tid| field of the current thread's PRThread structure because
|
|
|
|
* _pt_root calls PR_Lock before setting thred->id and thred->tid. */
|
|
|
|
PRIntn rv;
|
|
|
|
PR_ASSERT(lock != NULL);
|
|
|
|
rv = pthread_mutex_lock(&lock->mutex);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
PR_ASSERT(0 == lock->notified.length);
|
|
|
|
PR_ASSERT(NULL == lock->notified.link);
|
|
|
|
PR_ASSERT(PR_FALSE == lock->locked);
|
|
|
|
/* Nb: the order of the next two statements is not critical to
|
2020-03-12 10:40:28 -07:00
|
|
|
* the correctness of PR_AssertCurrentThreadOwnsLock(), but
|
2019-03-11 03:26:37 -07:00
|
|
|
* this particular order makes the assertion more likely to
|
|
|
|
* catch errors. */
|
|
|
|
lock->owner = pthread_self();
|
|
|
|
lock->locked = PR_TRUE;
|
|
|
|
#if defined(DEBUG)
|
|
|
|
pt_debug.locks_acquired += 1;
|
|
|
|
#endif
|
|
|
|
} /* PR_Lock */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_Unlock(PRLock *lock)
|
|
|
|
{
|
|
|
|
pthread_t self = pthread_self();
|
|
|
|
PRIntn rv;
|
|
|
|
|
|
|
|
PR_ASSERT(lock != NULL);
|
|
|
|
PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(lock->mutex));
|
|
|
|
PR_ASSERT(PR_TRUE == lock->locked);
|
|
|
|
PR_ASSERT(pthread_equal(lock->owner, self));
|
|
|
|
|
2020-03-12 10:40:28 -07:00
|
|
|
if (!lock->locked || !pthread_equal(lock->owner, self)) {
|
2019-03-11 03:26:37 -07:00
|
|
|
return PR_FAILURE;
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
lock->locked = PR_FALSE;
|
|
|
|
if (0 == lock->notified.length) /* shortcut */
|
|
|
|
{
|
|
|
|
rv = pthread_mutex_unlock(&lock->mutex);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
}
|
2020-03-12 10:40:28 -07:00
|
|
|
else {
|
|
|
|
pt_PostNotifies(lock, PR_TRUE);
|
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
#if defined(DEBUG)
|
|
|
|
pt_debug.locks_released += 1;
|
|
|
|
#endif
|
|
|
|
return PR_SUCCESS;
|
|
|
|
} /* PR_Unlock */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(void) PR_AssertCurrentThreadOwnsLock(PRLock *lock)
|
|
|
|
{
|
2020-03-12 10:40:28 -07:00
|
|
|
/* Nb: the order of the |locked| and |owner==me| checks is not critical
|
|
|
|
* to the correctness of PR_AssertCurrentThreadOwnsLock(), but
|
2019-03-11 03:26:37 -07:00
|
|
|
* this particular order makes the assertion more likely to
|
|
|
|
* catch errors. */
|
|
|
|
PR_ASSERT(lock->locked && pthread_equal(lock->owner, pthread_self()));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************/
|
|
|
|
/**************************************************************/
|
|
|
|
/***************************CONDITIONS*************************/
|
|
|
|
/**************************************************************/
|
|
|
|
/**************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This code is used to compute the absolute time for the wakeup.
|
|
|
|
* It's moderately ugly, so it's defined here and called in a
|
|
|
|
* couple of places.
|
|
|
|
*/
|
|
|
|
#define PT_NANOPERMICRO 1000UL
|
|
|
|
#define PT_BILLION 1000000000UL
|
|
|
|
|
|
|
|
static PRIntn pt_TimedWait(
|
|
|
|
pthread_cond_t *cv, pthread_mutex_t *ml, PRIntervalTime timeout)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
struct timeval now;
|
|
|
|
struct timespec tmo;
|
|
|
|
PRUint32 ticks = PR_TicksPerSecond();
|
|
|
|
|
|
|
|
tmo.tv_sec = (PRInt32)(timeout / ticks);
|
|
|
|
tmo.tv_nsec = (PRInt32)(timeout - (tmo.tv_sec * ticks));
|
|
|
|
tmo.tv_nsec = (PRInt32)PR_IntervalToMicroseconds(PT_NANOPERMICRO * tmo.tv_nsec);
|
|
|
|
|
|
|
|
/* pthreads wants this in absolute time, off we go ... */
|
|
|
|
(void)GETTIMEOFDAY(&now);
|
|
|
|
/* that one's usecs, this one's nsecs - grrrr! */
|
|
|
|
tmo.tv_sec += now.tv_sec;
|
|
|
|
tmo.tv_nsec += (PT_NANOPERMICRO * now.tv_usec);
|
|
|
|
tmo.tv_sec += tmo.tv_nsec / PT_BILLION;
|
|
|
|
tmo.tv_nsec %= PT_BILLION;
|
|
|
|
|
|
|
|
rv = pthread_cond_timedwait(cv, ml, &tmo);
|
|
|
|
|
|
|
|
/* NSPR doesn't report timeouts */
|
|
|
|
return (rv == ETIMEDOUT) ? 0 : rv;
|
|
|
|
} /* pt_TimedWait */
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Notifies just get posted to the protecting mutex. The
|
|
|
|
* actual notification is done when the lock is released so that
|
|
|
|
* MP systems don't contend for a lock that they can't have.
|
|
|
|
*/
|
|
|
|
static void pt_PostNotifyToCvar(PRCondVar *cvar, PRBool broadcast)
|
|
|
|
{
|
|
|
|
PRIntn index = 0;
|
|
|
|
_PT_Notified *notified = &cvar->lock->notified;
|
|
|
|
|
|
|
|
PR_ASSERT(PR_TRUE == cvar->lock->locked);
|
|
|
|
PR_ASSERT(pthread_equal(cvar->lock->owner, pthread_self()));
|
|
|
|
PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(cvar->lock->mutex));
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
for (index = 0; index < notified->length; ++index)
|
|
|
|
{
|
|
|
|
if (notified->cv[index].cv == cvar)
|
|
|
|
{
|
2020-03-12 10:40:28 -07:00
|
|
|
if (broadcast) {
|
2019-03-11 03:26:37 -07:00
|
|
|
notified->cv[index].times = -1;
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
|
|
|
else if (-1 != notified->cv[index].times) {
|
2019-03-11 03:26:37 -07:00
|
|
|
notified->cv[index].times += 1;
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
return; /* we're finished */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* if not full, enter new CV in this array */
|
2020-03-12 10:40:28 -07:00
|
|
|
if (notified->length < PT_CV_NOTIFIED_LENGTH) {
|
|
|
|
break;
|
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
/* if there's no link, create an empty array and link it */
|
2020-03-12 10:40:28 -07:00
|
|
|
if (NULL == notified->link) {
|
2019-03-11 03:26:37 -07:00
|
|
|
notified->link = PR_NEWZAP(_PT_Notified);
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
notified = notified->link;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* A brand new entry in the array */
|
|
|
|
(void)PR_ATOMIC_INCREMENT(&cvar->notify_pending);
|
|
|
|
notified->cv[index].times = (broadcast) ? -1 : 1;
|
|
|
|
notified->cv[index].cv = cvar;
|
|
|
|
notified->length += 1;
|
|
|
|
} /* pt_PostNotifyToCvar */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRCondVar*) PR_NewCondVar(PRLock *lock)
|
|
|
|
{
|
|
|
|
PRCondVar *cv = PR_NEW(PRCondVar);
|
|
|
|
PR_ASSERT(lock != NULL);
|
|
|
|
if (cv != NULL)
|
|
|
|
{
|
|
|
|
int rv = _PT_PTHREAD_COND_INIT(cv->cv, _pt_cvar_attr);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
if (0 == rv)
|
|
|
|
{
|
|
|
|
cv->lock = lock;
|
|
|
|
cv->notify_pending = 0;
|
|
|
|
#if defined(DEBUG)
|
|
|
|
pt_debug.cvars_created += 1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
PR_DELETE(cv);
|
|
|
|
cv = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return cv;
|
|
|
|
} /* PR_NewCondVar */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(void) PR_DestroyCondVar(PRCondVar *cvar)
|
|
|
|
{
|
|
|
|
if (0 > PR_ATOMIC_DECREMENT(&cvar->notify_pending))
|
|
|
|
{
|
|
|
|
PRIntn rv = pthread_cond_destroy(&cvar->cv);
|
|
|
|
#if defined(DEBUG)
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
memset(cvar, 0xaf, sizeof(PRCondVar));
|
|
|
|
pt_debug.cvars_destroyed += 1;
|
|
|
|
#else
|
|
|
|
(void)rv;
|
|
|
|
#endif
|
|
|
|
PR_Free(cvar);
|
|
|
|
}
|
|
|
|
} /* PR_DestroyCondVar */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_WaitCondVar(PRCondVar *cvar, PRIntervalTime timeout)
|
|
|
|
{
|
|
|
|
PRIntn rv;
|
|
|
|
PRThread *thred = PR_GetCurrentThread();
|
|
|
|
|
|
|
|
PR_ASSERT(cvar != NULL);
|
|
|
|
/* We'd better be locked */
|
|
|
|
PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(cvar->lock->mutex));
|
|
|
|
PR_ASSERT(PR_TRUE == cvar->lock->locked);
|
|
|
|
/* and it better be by us */
|
|
|
|
PR_ASSERT(pthread_equal(cvar->lock->owner, pthread_self()));
|
|
|
|
|
2020-03-12 10:40:28 -07:00
|
|
|
if (_PT_THREAD_INTERRUPTED(thred)) {
|
|
|
|
goto aborted;
|
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The thread waiting is used for PR_Interrupt
|
|
|
|
*/
|
|
|
|
thred->waiting = cvar; /* this is where we're waiting */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have pending notifies, post them now.
|
|
|
|
*
|
|
|
|
* This is not optimal. We're going to post these notifies
|
|
|
|
* while we're holding the lock. That means on MP systems
|
|
|
|
* that they are going to collide for the lock that we will
|
|
|
|
* hold until we actually wait.
|
|
|
|
*/
|
2020-03-12 10:40:28 -07:00
|
|
|
if (0 != cvar->lock->notified.length) {
|
2019-03-11 03:26:37 -07:00
|
|
|
pt_PostNotifies(cvar->lock, PR_FALSE);
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We're surrendering the lock, so clear out the locked field.
|
|
|
|
*/
|
|
|
|
cvar->lock->locked = PR_FALSE;
|
|
|
|
|
2020-03-12 10:40:28 -07:00
|
|
|
if (timeout == PR_INTERVAL_NO_TIMEOUT) {
|
2019-03-11 03:26:37 -07:00
|
|
|
rv = pthread_cond_wait(&cvar->cv, &cvar->lock->mutex);
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
|
|
|
else {
|
2019-03-11 03:26:37 -07:00
|
|
|
rv = pt_TimedWait(&cvar->cv, &cvar->lock->mutex, timeout);
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
/* We just got the lock back - this better be empty */
|
|
|
|
PR_ASSERT(PR_FALSE == cvar->lock->locked);
|
|
|
|
cvar->lock->locked = PR_TRUE;
|
|
|
|
cvar->lock->owner = pthread_self();
|
|
|
|
|
|
|
|
PR_ASSERT(0 == cvar->lock->notified.length);
|
|
|
|
thred->waiting = NULL; /* and now we're not */
|
2020-03-12 10:40:28 -07:00
|
|
|
if (_PT_THREAD_INTERRUPTED(thred)) {
|
|
|
|
goto aborted;
|
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
if (rv != 0)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(rv);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
return PR_SUCCESS;
|
|
|
|
|
|
|
|
aborted:
|
|
|
|
PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
|
|
|
|
thred->state &= ~PT_THREAD_ABORTED;
|
|
|
|
return PR_FAILURE;
|
|
|
|
} /* PR_WaitCondVar */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_NotifyCondVar(PRCondVar *cvar)
|
|
|
|
{
|
2020-03-12 10:40:28 -07:00
|
|
|
PR_ASSERT(cvar != NULL);
|
2019-03-11 03:26:37 -07:00
|
|
|
pt_PostNotifyToCvar(cvar, PR_FALSE);
|
|
|
|
return PR_SUCCESS;
|
|
|
|
} /* PR_NotifyCondVar */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_NotifyAllCondVar(PRCondVar *cvar)
|
|
|
|
{
|
|
|
|
PR_ASSERT(cvar != NULL);
|
|
|
|
pt_PostNotifyToCvar(cvar, PR_TRUE);
|
|
|
|
return PR_SUCCESS;
|
|
|
|
} /* PR_NotifyAllCondVar */
|
|
|
|
|
|
|
|
/**************************************************************/
|
|
|
|
/**************************************************************/
|
|
|
|
/***************************MONITORS***************************/
|
|
|
|
/**************************************************************/
|
|
|
|
/**************************************************************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Notifies just get posted to the monitor. The actual notification is done
|
|
|
|
* when the monitor is fully exited so that MP systems don't contend for a
|
|
|
|
* monitor that they can't enter.
|
|
|
|
*/
|
|
|
|
static void pt_PostNotifyToMonitor(PRMonitor *mon, PRBool broadcast)
|
|
|
|
{
|
|
|
|
PR_ASSERT(NULL != mon);
|
|
|
|
PR_ASSERT_CURRENT_THREAD_IN_MONITOR(mon);
|
|
|
|
|
|
|
|
/* mon->notifyTimes is protected by the monitor, so we don't need to
|
|
|
|
* acquire mon->lock.
|
|
|
|
*/
|
2020-03-12 10:40:28 -07:00
|
|
|
if (broadcast) {
|
2019-03-11 03:26:37 -07:00
|
|
|
mon->notifyTimes = -1;
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
|
|
|
else if (-1 != mon->notifyTimes) {
|
2019-03-11 03:26:37 -07:00
|
|
|
mon->notifyTimes += 1;
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
} /* pt_PostNotifyToMonitor */
|
|
|
|
|
|
|
|
static void pt_PostNotifiesFromMonitor(pthread_cond_t *cv, PRIntn times)
|
|
|
|
{
|
|
|
|
PRIntn rv;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Time to actually notify any waits that were affected while the monitor
|
|
|
|
* was entered.
|
|
|
|
*/
|
|
|
|
PR_ASSERT(NULL != cv);
|
|
|
|
PR_ASSERT(0 != times);
|
|
|
|
if (-1 == times)
|
|
|
|
{
|
|
|
|
rv = pthread_cond_broadcast(cv);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
while (times-- > 0)
|
|
|
|
{
|
|
|
|
rv = pthread_cond_signal(cv);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} /* pt_PostNotifiesFromMonitor */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRMonitor*) PR_NewMonitor(void)
|
|
|
|
{
|
|
|
|
PRMonitor *mon;
|
|
|
|
int rv;
|
|
|
|
|
2020-03-12 10:40:28 -07:00
|
|
|
if (!_pr_initialized) {
|
|
|
|
_PR_ImplicitInitialization();
|
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
mon = PR_NEWZAP(PRMonitor);
|
|
|
|
if (mon == NULL)
|
|
|
|
{
|
|
|
|
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = _PT_PTHREAD_MUTEX_INIT(mon->lock, _pt_mattr);
|
|
|
|
PR_ASSERT(0 == rv);
|
2020-03-12 10:40:28 -07:00
|
|
|
if (0 != rv) {
|
2019-03-11 03:26:37 -07:00
|
|
|
goto error1;
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
_PT_PTHREAD_INVALIDATE_THR_HANDLE(mon->owner);
|
|
|
|
|
|
|
|
rv = _PT_PTHREAD_COND_INIT(mon->entryCV, _pt_cvar_attr);
|
|
|
|
PR_ASSERT(0 == rv);
|
2020-03-12 10:40:28 -07:00
|
|
|
if (0 != rv) {
|
2019-03-11 03:26:37 -07:00
|
|
|
goto error2;
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
rv = _PT_PTHREAD_COND_INIT(mon->waitCV, _pt_cvar_attr);
|
|
|
|
PR_ASSERT(0 == rv);
|
2020-03-12 10:40:28 -07:00
|
|
|
if (0 != rv) {
|
2019-03-11 03:26:37 -07:00
|
|
|
goto error3;
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
mon->notifyTimes = 0;
|
|
|
|
mon->entryCount = 0;
|
|
|
|
mon->refCount = 1;
|
|
|
|
mon->name = NULL;
|
|
|
|
return mon;
|
|
|
|
|
|
|
|
error3:
|
|
|
|
pthread_cond_destroy(&mon->entryCV);
|
|
|
|
error2:
|
|
|
|
pthread_mutex_destroy(&mon->lock);
|
|
|
|
error1:
|
|
|
|
PR_Free(mon);
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(rv);
|
|
|
|
return NULL;
|
|
|
|
} /* PR_NewMonitor */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRMonitor*) PR_NewNamedMonitor(const char* name)
|
|
|
|
{
|
|
|
|
PRMonitor* mon = PR_NewMonitor();
|
2020-03-12 10:40:28 -07:00
|
|
|
if (mon) {
|
2019-03-11 03:26:37 -07:00
|
|
|
mon->name = name;
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
return mon;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(void) PR_DestroyMonitor(PRMonitor *mon)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
|
|
|
|
PR_ASSERT(mon != NULL);
|
|
|
|
if (PR_ATOMIC_DECREMENT(&mon->refCount) == 0)
|
|
|
|
{
|
|
|
|
rv = pthread_cond_destroy(&mon->waitCV); PR_ASSERT(0 == rv);
|
|
|
|
rv = pthread_cond_destroy(&mon->entryCV); PR_ASSERT(0 == rv);
|
|
|
|
rv = pthread_mutex_destroy(&mon->lock); PR_ASSERT(0 == rv);
|
|
|
|
#if defined(DEBUG)
|
|
|
|
memset(mon, 0xaf, sizeof(PRMonitor));
|
|
|
|
#endif
|
|
|
|
PR_Free(mon);
|
|
|
|
}
|
|
|
|
} /* PR_DestroyMonitor */
|
|
|
|
|
2020-03-12 10:40:28 -07:00
|
|
|
/* The GC uses this; it is quite arguably a bad interface. I'm just
|
2019-03-11 03:26:37 -07:00
|
|
|
* duplicating it for now - XXXMB
|
|
|
|
*/
|
|
|
|
PR_IMPLEMENT(PRIntn) PR_GetMonitorEntryCount(PRMonitor *mon)
|
|
|
|
{
|
|
|
|
pthread_t self = pthread_self();
|
|
|
|
PRIntn rv;
|
|
|
|
PRIntn count = 0;
|
|
|
|
|
|
|
|
rv = pthread_mutex_lock(&mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
2020-03-12 10:40:28 -07:00
|
|
|
if (pthread_equal(mon->owner, self)) {
|
2019-03-11 03:26:37 -07:00
|
|
|
count = mon->entryCount;
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
rv = pthread_mutex_unlock(&mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(void) PR_AssertCurrentThreadInMonitor(PRMonitor *mon)
|
|
|
|
{
|
|
|
|
#if defined(DEBUG) || defined(FORCE_PR_ASSERT)
|
|
|
|
PRIntn rv;
|
|
|
|
|
|
|
|
rv = pthread_mutex_lock(&mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
PR_ASSERT(mon->entryCount != 0 &&
|
|
|
|
pthread_equal(mon->owner, pthread_self()));
|
|
|
|
rv = pthread_mutex_unlock(&mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(void) PR_EnterMonitor(PRMonitor *mon)
|
|
|
|
{
|
|
|
|
pthread_t self = pthread_self();
|
|
|
|
PRIntn rv;
|
|
|
|
|
|
|
|
PR_ASSERT(mon != NULL);
|
|
|
|
rv = pthread_mutex_lock(&mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
if (mon->entryCount != 0)
|
|
|
|
{
|
2020-03-12 10:40:28 -07:00
|
|
|
if (pthread_equal(mon->owner, self)) {
|
2019-03-11 03:26:37 -07:00
|
|
|
goto done;
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
while (mon->entryCount != 0)
|
|
|
|
{
|
|
|
|
rv = pthread_cond_wait(&mon->entryCV, &mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* and now I have the monitor */
|
|
|
|
PR_ASSERT(0 == mon->notifyTimes);
|
|
|
|
PR_ASSERT(_PT_PTHREAD_THR_HANDLE_IS_INVALID(mon->owner));
|
|
|
|
_PT_PTHREAD_COPY_THR_HANDLE(self, mon->owner);
|
|
|
|
|
|
|
|
done:
|
|
|
|
mon->entryCount += 1;
|
|
|
|
rv = pthread_mutex_unlock(&mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
} /* PR_EnterMonitor */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_ExitMonitor(PRMonitor *mon)
|
|
|
|
{
|
|
|
|
pthread_t self = pthread_self();
|
|
|
|
PRIntn rv;
|
|
|
|
PRBool notifyEntryWaiter = PR_FALSE;
|
|
|
|
PRIntn notifyTimes = 0;
|
|
|
|
|
|
|
|
PR_ASSERT(mon != NULL);
|
|
|
|
rv = pthread_mutex_lock(&mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
/* the entries should be > 0 and we'd better be the owner */
|
|
|
|
PR_ASSERT(mon->entryCount > 0);
|
|
|
|
PR_ASSERT(pthread_equal(mon->owner, self));
|
|
|
|
if (mon->entryCount == 0 || !pthread_equal(mon->owner, self))
|
|
|
|
{
|
|
|
|
rv = pthread_mutex_unlock(&mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
mon->entryCount -= 1; /* reduce by one */
|
|
|
|
if (mon->entryCount == 0)
|
|
|
|
{
|
|
|
|
/* and if it transitioned to zero - notify an entry waiter */
|
|
|
|
/* make the owner unknown */
|
|
|
|
_PT_PTHREAD_INVALIDATE_THR_HANDLE(mon->owner);
|
|
|
|
notifyEntryWaiter = PR_TRUE;
|
|
|
|
notifyTimes = mon->notifyTimes;
|
|
|
|
mon->notifyTimes = 0;
|
|
|
|
/* We will access the members of 'mon' after unlocking mon->lock.
|
|
|
|
* Add a reference. */
|
|
|
|
PR_ATOMIC_INCREMENT(&mon->refCount);
|
|
|
|
}
|
|
|
|
rv = pthread_mutex_unlock(&mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
if (notifyEntryWaiter)
|
|
|
|
{
|
2020-03-12 10:40:28 -07:00
|
|
|
if (notifyTimes) {
|
2019-03-11 03:26:37 -07:00
|
|
|
pt_PostNotifiesFromMonitor(&mon->waitCV, notifyTimes);
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
rv = pthread_cond_signal(&mon->entryCV);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
/* We are done accessing the members of 'mon'. Release the
|
|
|
|
* reference. */
|
|
|
|
PR_DestroyMonitor(mon);
|
|
|
|
}
|
|
|
|
return PR_SUCCESS;
|
|
|
|
} /* PR_ExitMonitor */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_Wait(PRMonitor *mon, PRIntervalTime timeout)
|
|
|
|
{
|
|
|
|
PRStatus rv;
|
|
|
|
PRUint32 saved_entries;
|
|
|
|
pthread_t saved_owner;
|
|
|
|
|
|
|
|
PR_ASSERT(mon != NULL);
|
|
|
|
rv = pthread_mutex_lock(&mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
/* the entries better be positive */
|
|
|
|
PR_ASSERT(mon->entryCount > 0);
|
|
|
|
/* and it better be owned by us */
|
|
|
|
PR_ASSERT(pthread_equal(mon->owner, pthread_self()));
|
|
|
|
|
|
|
|
/* tuck these away 'till later */
|
2020-03-12 10:40:28 -07:00
|
|
|
saved_entries = mon->entryCount;
|
2019-03-11 03:26:37 -07:00
|
|
|
mon->entryCount = 0;
|
|
|
|
_PT_PTHREAD_COPY_THR_HANDLE(mon->owner, saved_owner);
|
|
|
|
_PT_PTHREAD_INVALIDATE_THR_HANDLE(mon->owner);
|
|
|
|
/*
|
|
|
|
* If we have pending notifies, post them now.
|
|
|
|
*
|
|
|
|
* This is not optimal. We're going to post these notifies
|
|
|
|
* while we're holding the lock. That means on MP systems
|
|
|
|
* that they are going to collide for the lock that we will
|
|
|
|
* hold until we actually wait.
|
|
|
|
*/
|
|
|
|
if (0 != mon->notifyTimes)
|
|
|
|
{
|
|
|
|
pt_PostNotifiesFromMonitor(&mon->waitCV, mon->notifyTimes);
|
|
|
|
mon->notifyTimes = 0;
|
|
|
|
}
|
|
|
|
rv = pthread_cond_signal(&mon->entryCV);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
|
2020-03-12 10:40:28 -07:00
|
|
|
if (timeout == PR_INTERVAL_NO_TIMEOUT) {
|
2019-03-11 03:26:37 -07:00
|
|
|
rv = pthread_cond_wait(&mon->waitCV, &mon->lock);
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
|
|
|
else {
|
2019-03-11 03:26:37 -07:00
|
|
|
rv = pt_TimedWait(&mon->waitCV, &mon->lock, timeout);
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
|
|
|
|
while (mon->entryCount != 0)
|
|
|
|
{
|
|
|
|
rv = pthread_cond_wait(&mon->entryCV, &mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
}
|
|
|
|
PR_ASSERT(0 == mon->notifyTimes);
|
|
|
|
/* reinstate the interesting information */
|
|
|
|
mon->entryCount = saved_entries;
|
|
|
|
_PT_PTHREAD_COPY_THR_HANDLE(saved_owner, mon->owner);
|
|
|
|
|
|
|
|
rv = pthread_mutex_unlock(&mon->lock);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
return rv;
|
|
|
|
} /* PR_Wait */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_Notify(PRMonitor *mon)
|
|
|
|
{
|
|
|
|
pt_PostNotifyToMonitor(mon, PR_FALSE);
|
|
|
|
return PR_SUCCESS;
|
|
|
|
} /* PR_Notify */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_NotifyAll(PRMonitor *mon)
|
|
|
|
{
|
|
|
|
pt_PostNotifyToMonitor(mon, PR_TRUE);
|
|
|
|
return PR_SUCCESS;
|
|
|
|
} /* PR_NotifyAll */
|
|
|
|
|
|
|
|
/**************************************************************/
|
|
|
|
/**************************************************************/
|
|
|
|
/**************************SEMAPHORES**************************/
|
|
|
|
/**************************************************************/
|
|
|
|
/**************************************************************/
|
|
|
|
PR_IMPLEMENT(void) PR_PostSem(PRSemaphore *semaphore)
|
|
|
|
{
|
|
|
|
static PRBool unwarned = PR_TRUE;
|
|
|
|
if (unwarned) unwarned = _PR_Obsolete(
|
2020-03-12 10:40:28 -07:00
|
|
|
"PR_PostSem", "locks & condition variables");
|
|
|
|
PR_Lock(semaphore->cvar->lock);
|
|
|
|
PR_NotifyCondVar(semaphore->cvar);
|
|
|
|
semaphore->count += 1;
|
|
|
|
PR_Unlock(semaphore->cvar->lock);
|
2019-03-11 03:26:37 -07:00
|
|
|
} /* PR_PostSem */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_WaitSem(PRSemaphore *semaphore)
|
|
|
|
{
|
2020-03-12 10:40:28 -07:00
|
|
|
PRStatus status = PR_SUCCESS;
|
2019-03-11 03:26:37 -07:00
|
|
|
static PRBool unwarned = PR_TRUE;
|
|
|
|
if (unwarned) unwarned = _PR_Obsolete(
|
2020-03-12 10:40:28 -07:00
|
|
|
"PR_WaitSem", "locks & condition variables");
|
|
|
|
PR_Lock(semaphore->cvar->lock);
|
|
|
|
while ((semaphore->count == 0) && (PR_SUCCESS == status)) {
|
|
|
|
status = PR_WaitCondVar(semaphore->cvar, PR_INTERVAL_NO_TIMEOUT);
|
|
|
|
}
|
|
|
|
if (PR_SUCCESS == status) {
|
|
|
|
semaphore->count -= 1;
|
|
|
|
}
|
|
|
|
PR_Unlock(semaphore->cvar->lock);
|
|
|
|
return status;
|
2019-03-11 03:26:37 -07:00
|
|
|
} /* PR_WaitSem */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(void) PR_DestroySem(PRSemaphore *semaphore)
|
|
|
|
{
|
|
|
|
static PRBool unwarned = PR_TRUE;
|
|
|
|
if (unwarned) unwarned = _PR_Obsolete(
|
2020-03-12 10:40:28 -07:00
|
|
|
"PR_DestroySem", "locks & condition variables");
|
2019-03-11 03:26:37 -07:00
|
|
|
PR_DestroyLock(semaphore->cvar->lock);
|
|
|
|
PR_DestroyCondVar(semaphore->cvar);
|
|
|
|
PR_Free(semaphore);
|
|
|
|
} /* PR_DestroySem */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRSemaphore*) PR_NewSem(PRUintn value)
|
|
|
|
{
|
|
|
|
PRSemaphore *semaphore;
|
|
|
|
static PRBool unwarned = PR_TRUE;
|
2020-03-12 10:40:28 -07:00
|
|
|
if (!_pr_initialized) {
|
|
|
|
_PR_ImplicitInitialization();
|
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
if (unwarned) unwarned = _PR_Obsolete(
|
2020-03-12 10:40:28 -07:00
|
|
|
"PR_NewSem", "locks & condition variables");
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
semaphore = PR_NEWZAP(PRSemaphore);
|
|
|
|
if (NULL != semaphore)
|
|
|
|
{
|
|
|
|
PRLock *lock = PR_NewLock();
|
|
|
|
if (NULL != lock)
|
|
|
|
{
|
|
|
|
semaphore->cvar = PR_NewCondVar(lock);
|
|
|
|
if (NULL != semaphore->cvar)
|
|
|
|
{
|
|
|
|
semaphore->count = value;
|
|
|
|
return semaphore;
|
|
|
|
}
|
|
|
|
PR_DestroyLock(lock);
|
|
|
|
}
|
|
|
|
PR_Free(semaphore);
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Define the interprocess named semaphore functions.
|
|
|
|
* There are three implementations:
|
|
|
|
* 1. POSIX semaphore based;
|
|
|
|
* 2. System V semaphore based;
|
|
|
|
* 3. unsupported (fails with PR_NOT_IMPLEMENTED_ERROR).
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef _PR_HAVE_POSIX_SEMAPHORES
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRSem *) PR_OpenSemaphore(
|
|
|
|
const char *name,
|
|
|
|
PRIntn flags,
|
|
|
|
PRIntn mode,
|
|
|
|
PRUintn value)
|
|
|
|
{
|
|
|
|
PRSem *sem;
|
|
|
|
char osname[PR_IPC_NAME_SIZE];
|
|
|
|
|
|
|
|
if (_PR_MakeNativeIPCName(name, osname, sizeof(osname), _PRIPCSem)
|
|
|
|
== PR_FAILURE)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
sem = PR_NEW(PRSem);
|
|
|
|
if (NULL == sem)
|
|
|
|
{
|
|
|
|
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & PR_SEM_CREATE)
|
|
|
|
{
|
|
|
|
int oflag = O_CREAT;
|
|
|
|
|
2020-03-12 10:40:28 -07:00
|
|
|
if (flags & PR_SEM_EXCL) {
|
|
|
|
oflag |= O_EXCL;
|
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
sem->sem = sem_open(osname, oflag, mode, value);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
#ifdef HPUX
|
|
|
|
/* Pass 0 as the mode and value arguments to work around a bug. */
|
|
|
|
sem->sem = sem_open(osname, 0, 0, 0);
|
|
|
|
#else
|
|
|
|
sem->sem = sem_open(osname, 0);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
if ((sem_t *) -1 == sem->sem)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
PR_Free(sem);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return sem;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_WaitSemaphore(PRSem *sem)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
rv = sem_wait(sem->sem);
|
|
|
|
if (0 != rv)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
return PR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_PostSemaphore(PRSem *sem)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
rv = sem_post(sem->sem);
|
|
|
|
if (0 != rv)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
return PR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_CloseSemaphore(PRSem *sem)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
rv = sem_close(sem->sem);
|
|
|
|
if (0 != rv)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
PR_Free(sem);
|
|
|
|
return PR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_DeleteSemaphore(const char *name)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
char osname[PR_IPC_NAME_SIZE];
|
|
|
|
|
|
|
|
if (_PR_MakeNativeIPCName(name, osname, sizeof(osname), _PRIPCSem)
|
|
|
|
== PR_FAILURE)
|
|
|
|
{
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
rv = sem_unlink(osname);
|
|
|
|
if (0 != rv)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
return PR_SUCCESS;
|
|
|
|
}
|
2020-03-12 10:40:28 -07:00
|
|
|
|
2019-03-11 03:26:37 -07:00
|
|
|
#elif defined(_PR_HAVE_SYSV_SEMAPHORES)
|
|
|
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/sem.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
* From the semctl(2) man page in glibc 2.0
|
|
|
|
*/
|
|
|
|
#if (defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)) \
|
|
|
|
|| (defined(FREEBSD) && __FreeBSD_version < 1200059) \
|
|
|
|
|| defined(OPENBSD) || defined(BSDI) \
|
2020-03-12 10:40:28 -07:00
|
|
|
|| defined(DARWIN)
|
2019-03-11 03:26:37 -07:00
|
|
|
/* union semun is defined by including <sys/sem.h> */
|
|
|
|
#else
|
|
|
|
/* according to X/OPEN we have to define it ourselves */
|
|
|
|
union semun {
|
|
|
|
int val;
|
|
|
|
struct semid_ds *buf;
|
|
|
|
unsigned short *array;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 'a' (97) is the final closing price of NSCP stock.
|
|
|
|
*/
|
|
|
|
#define NSPR_IPC_KEY_ID 'a' /* the id argument for ftok() */
|
|
|
|
|
|
|
|
#define NSPR_SEM_MODE 0666
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRSem *) PR_OpenSemaphore(
|
|
|
|
const char *name,
|
|
|
|
PRIntn flags,
|
|
|
|
PRIntn mode,
|
|
|
|
PRUintn value)
|
|
|
|
{
|
|
|
|
PRSem *sem;
|
|
|
|
key_t key;
|
|
|
|
union semun arg;
|
|
|
|
struct sembuf sop;
|
|
|
|
struct semid_ds seminfo;
|
|
|
|
#define MAX_TRIES 60
|
|
|
|
PRIntn i;
|
|
|
|
char osname[PR_IPC_NAME_SIZE];
|
|
|
|
|
|
|
|
if (_PR_MakeNativeIPCName(name, osname, sizeof(osname), _PRIPCSem)
|
|
|
|
== PR_FAILURE)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure the file exists before calling ftok. */
|
|
|
|
if (flags & PR_SEM_CREATE)
|
|
|
|
{
|
|
|
|
int osfd = open(osname, O_RDWR|O_CREAT, mode);
|
|
|
|
if (-1 == osfd)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_OPEN_ERROR(errno);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (close(osfd) == -1)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_CLOSE_ERROR(errno);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
key = ftok(osname, NSPR_IPC_KEY_ID);
|
|
|
|
if ((key_t)-1 == key)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
sem = PR_NEW(PRSem);
|
|
|
|
if (NULL == sem)
|
|
|
|
{
|
|
|
|
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & PR_SEM_CREATE)
|
|
|
|
{
|
|
|
|
sem->semid = semget(key, 1, mode|IPC_CREAT|IPC_EXCL);
|
|
|
|
if (sem->semid >= 0)
|
|
|
|
{
|
|
|
|
/* creator of a semaphore is responsible for initializing it */
|
|
|
|
arg.val = 0;
|
|
|
|
if (semctl(sem->semid, 0, SETVAL, arg) == -1)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
PR_Free(sem);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* call semop to set sem_otime to nonzero */
|
|
|
|
sop.sem_num = 0;
|
|
|
|
sop.sem_op = value;
|
|
|
|
sop.sem_flg = 0;
|
|
|
|
if (semop(sem->semid, &sop, 1) == -1)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
PR_Free(sem);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return sem;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (errno != EEXIST || flags & PR_SEM_EXCL)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
PR_Free(sem);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
sem->semid = semget(key, 1, NSPR_SEM_MODE);
|
|
|
|
if (sem->semid == -1)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
PR_Free(sem);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
for (i = 0; i < MAX_TRIES; i++)
|
|
|
|
{
|
|
|
|
arg.buf = &seminfo;
|
|
|
|
semctl(sem->semid, 0, IPC_STAT, arg);
|
2020-03-12 10:40:28 -07:00
|
|
|
if (seminfo.sem_otime != 0) {
|
|
|
|
break;
|
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
sleep(1);
|
|
|
|
}
|
|
|
|
if (i == MAX_TRIES)
|
|
|
|
{
|
|
|
|
PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
|
|
|
|
PR_Free(sem);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return sem;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_WaitSemaphore(PRSem *sem)
|
|
|
|
{
|
|
|
|
struct sembuf sop;
|
|
|
|
|
|
|
|
sop.sem_num = 0;
|
|
|
|
sop.sem_op = -1;
|
|
|
|
sop.sem_flg = 0;
|
|
|
|
if (semop(sem->semid, &sop, 1) == -1)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
return PR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_PostSemaphore(PRSem *sem)
|
|
|
|
{
|
|
|
|
struct sembuf sop;
|
|
|
|
|
|
|
|
sop.sem_num = 0;
|
|
|
|
sop.sem_op = 1;
|
|
|
|
sop.sem_flg = 0;
|
|
|
|
if (semop(sem->semid, &sop, 1) == -1)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
return PR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_CloseSemaphore(PRSem *sem)
|
|
|
|
{
|
|
|
|
PR_Free(sem);
|
|
|
|
return PR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_DeleteSemaphore(const char *name)
|
|
|
|
{
|
|
|
|
key_t key;
|
|
|
|
int semid;
|
|
|
|
/* On some systems (e.g., glibc 2.0) semctl requires a fourth argument */
|
|
|
|
union semun unused;
|
|
|
|
char osname[PR_IPC_NAME_SIZE];
|
|
|
|
|
|
|
|
if (_PR_MakeNativeIPCName(name, osname, sizeof(osname), _PRIPCSem)
|
|
|
|
== PR_FAILURE)
|
|
|
|
{
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
key = ftok(osname, NSPR_IPC_KEY_ID);
|
|
|
|
if ((key_t) -1 == key)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
if (unlink(osname) == -1)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_UNLINK_ERROR(errno);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
semid = semget(key, 1, NSPR_SEM_MODE);
|
|
|
|
if (-1 == semid)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
unused.val = 0;
|
|
|
|
if (semctl(semid, 0, IPC_RMID, unused) == -1)
|
2020-03-12 10:40:28 -07:00
|
|
|
{
|
2019-03-11 03:26:37 -07:00
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(errno);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
return PR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* neither POSIX nor System V semaphores are available */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRSem *) PR_OpenSemaphore(
|
|
|
|
const char *name,
|
|
|
|
PRIntn flags,
|
|
|
|
PRIntn mode,
|
|
|
|
PRUintn value)
|
|
|
|
{
|
|
|
|
PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_WaitSemaphore(PRSem *sem)
|
|
|
|
{
|
|
|
|
PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_PostSemaphore(PRSem *sem)
|
|
|
|
{
|
|
|
|
PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_CloseSemaphore(PRSem *sem)
|
|
|
|
{
|
|
|
|
PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PR_DeleteSemaphore(const char *name)
|
|
|
|
{
|
|
|
|
PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* end of interprocess named semaphore functions */
|
|
|
|
|
|
|
|
/**************************************************************/
|
|
|
|
/**************************************************************/
|
|
|
|
/******************ROUTINES FOR DCE EMULATION******************/
|
|
|
|
/**************************************************************/
|
|
|
|
/**************************************************************/
|
|
|
|
|
|
|
|
#include "prpdce.h"
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PRP_TryLock(PRLock *lock)
|
|
|
|
{
|
|
|
|
PRIntn rv = pthread_mutex_trylock(&lock->mutex);
|
|
|
|
if (rv == 0)
|
|
|
|
{
|
|
|
|
PR_ASSERT(PR_FALSE == lock->locked);
|
|
|
|
lock->locked = PR_TRUE;
|
|
|
|
lock->owner = pthread_self();
|
|
|
|
}
|
|
|
|
/* XXX set error code? */
|
|
|
|
return (0 == rv) ? PR_SUCCESS : PR_FAILURE;
|
|
|
|
} /* PRP_TryLock */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRCondVar*) PRP_NewNakedCondVar(void)
|
|
|
|
{
|
|
|
|
PRCondVar *cv;
|
|
|
|
|
2020-03-12 10:40:28 -07:00
|
|
|
if (!_pr_initialized) {
|
|
|
|
_PR_ImplicitInitialization();
|
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
|
|
|
|
cv = PR_NEW(PRCondVar);
|
|
|
|
if (cv != NULL)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
rv = _PT_PTHREAD_COND_INIT(cv->cv, _pt_cvar_attr);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
if (0 == rv)
|
|
|
|
{
|
|
|
|
cv->lock = _PR_NAKED_CV_LOCK;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
PR_DELETE(cv);
|
|
|
|
cv = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return cv;
|
|
|
|
} /* PRP_NewNakedCondVar */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(void) PRP_DestroyNakedCondVar(PRCondVar *cvar)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
rv = pthread_cond_destroy(&cvar->cv); PR_ASSERT(0 == rv);
|
|
|
|
#if defined(DEBUG)
|
2020-03-12 10:40:28 -07:00
|
|
|
memset(cvar, 0xaf, sizeof(PRCondVar));
|
2019-03-11 03:26:37 -07:00
|
|
|
#endif
|
|
|
|
PR_Free(cvar);
|
|
|
|
} /* PRP_DestroyNakedCondVar */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PRP_NakedWait(
|
|
|
|
PRCondVar *cvar, PRLock *ml, PRIntervalTime timeout)
|
|
|
|
{
|
|
|
|
PRIntn rv;
|
|
|
|
PR_ASSERT(cvar != NULL);
|
|
|
|
/* XXX do we really want to assert this in a naked wait? */
|
|
|
|
PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(ml->mutex));
|
2020-03-12 10:40:28 -07:00
|
|
|
if (timeout == PR_INTERVAL_NO_TIMEOUT) {
|
2019-03-11 03:26:37 -07:00
|
|
|
rv = pthread_cond_wait(&cvar->cv, &ml->mutex);
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
|
|
|
else {
|
2019-03-11 03:26:37 -07:00
|
|
|
rv = pt_TimedWait(&cvar->cv, &ml->mutex, timeout);
|
2020-03-12 10:40:28 -07:00
|
|
|
}
|
2019-03-11 03:26:37 -07:00
|
|
|
if (rv != 0)
|
|
|
|
{
|
|
|
|
_PR_MD_MAP_DEFAULT_ERROR(rv);
|
|
|
|
return PR_FAILURE;
|
|
|
|
}
|
|
|
|
return PR_SUCCESS;
|
|
|
|
} /* PRP_NakedWait */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PRP_NakedNotify(PRCondVar *cvar)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
PR_ASSERT(cvar != NULL);
|
|
|
|
rv = pthread_cond_signal(&cvar->cv);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
return PR_SUCCESS;
|
|
|
|
} /* PRP_NakedNotify */
|
|
|
|
|
|
|
|
PR_IMPLEMENT(PRStatus) PRP_NakedBroadcast(PRCondVar *cvar)
|
|
|
|
{
|
|
|
|
int rv;
|
|
|
|
PR_ASSERT(cvar != NULL);
|
|
|
|
rv = pthread_cond_broadcast(&cvar->cv);
|
|
|
|
PR_ASSERT(0 == rv);
|
|
|
|
return PR_SUCCESS;
|
|
|
|
} /* PRP_NakedBroadcast */
|
|
|
|
|
|
|
|
#endif /* defined(_PR_PTHREADS) */
|
|
|
|
|
|
|
|
/* ptsynch.c */
|