Quelle  ptsynch.c   Sprache: C

/* -*- 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;
  rv = _PT_PTHREAD_MUTEXATTR_INIT(&_pt_mattr);
  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) */
      if (0 > PR_ATOMIC_DECREMENT(&cv->notify_pending)) {
        PR_DestroyCondVar(cv);
      }
#  endif /* defined(DEBUG) */
    }
    prev = notified;
    notified = notified->link;
    if (&post != prev) {
      PR_DELETE(prev);
    }
  } while (NULL != notified);
} /* pt_PostNotifies */

PR_IMPLEMENT(PRLock*) PR_NewLock(void) {
  PRIntn rv;
  PRLock* lock;

  if (!_pr_initialized) {
    _PR_ImplicitInitialization();
  }

  lock = PR_NEWZAP(PRLock);
  if (lock != NULL) {
    rv = _PT_PTHREAD_MUTEX_INIT(lock->mutex, _pt_mattr);
    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
   * the correctness of PR_AssertCurrentThreadOwnsLock(), but
   * 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));

  if (!lock->locked || !pthread_equal(lock->owner, self)) {
    return PR_FAILURE;
  }

  lock->locked = PR_FALSE;
  if (0 == lock->notified.length) /* shortcut */
  {
    rv = pthread_mutex_unlock(&lock->mutex);
    PR_ASSERT(0 == rv);
  } else {
    pt_PostNotifies(lock, PR_TRUE);
  }

#  if defined(DEBUG)
  pt_debug.locks_released += 1;
#  endif
  return PR_SUCCESS;
} /* PR_Unlock */

PR_IMPLEMENT(void) PR_AssertCurrentThreadOwnsLock(PRLock* lock) {
  /* Nb: the order of the |locked| and |owner==me| checks is not critical
   * to the correctness of PR_AssertCurrentThreadOwnsLock(), but
   * 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) {
        if (broadcast) {
          notified->cv[index].times = -1;
        } else if (-1 != notified->cv[index].times) {
          notified->cv[index].times += 1;
        }
        return; /* we're finished */
      }
    }
    /* if not full, enter new CV in this array */
    if (notified->length < PT_CV_NOTIFIED_LENGTH) {
      break;
    }

    /* if there's no link, create an empty array and link it */
    if (NULL == notified->link) {
      notified->link = PR_NEWZAP(_PT_Notified);
    }
    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()));

  if (_PT_THREAD_INTERRUPTED(thred)) {
    goto aborted;
  }

  /*
   * 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.
   */
  if (0 != cvar->lock->notified.length) {
    pt_PostNotifies(cvar->lock, PR_FALSE);
  }

  /*
   * We're surrendering the lock, so clear out the locked field.
   */
  cvar->lock->locked = PR_FALSE;

  if (timeout == PR_INTERVAL_NO_TIMEOUT) {
    rv = pthread_cond_wait(&cvar->cv, &cvar->lock->mutex);
  } else {
    rv = pt_TimedWait(&cvar->cv, &cvar->lock->mutex, timeout);
  }

  /* 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 */
  if (_PT_THREAD_INTERRUPTED(thred)) {
    goto aborted;
  }
  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) {
  PR_ASSERT(cvar != NULL);
  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.
   */
  if (broadcast) {
    mon->notifyTimes = -1;
  } else if (-1 != mon->notifyTimes) {
    mon->notifyTimes += 1;
  }
} /* 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;

  if (!_pr_initialized) {
    _PR_ImplicitInitialization();
  }

  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);
  if (0 != rv) {
    goto error1;
  }

  _PT_PTHREAD_INVALIDATE_THR_HANDLE(mon->owner);

  rv = _PT_PTHREAD_COND_INIT(mon->entryCV, _pt_cvar_attr);
  PR_ASSERT(0 == rv);
  if (0 != rv) {
    goto error2;
  }

  rv = _PT_PTHREAD_COND_INIT(mon->waitCV, _pt_cvar_attr);
  PR_ASSERT(0 == rv);
  if (0 != rv) {
    goto error3;
  }

  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();
  if (mon) {
    mon->name = name;
  }
  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 */

/* The GC uses this; it is quite arguably a bad interface.  I'm just
 * 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);
  if (pthread_equal(mon->owner, self)) {
    count = mon->entryCount;
  }
  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) {
    if (pthread_equal(mon->owner, self)) {
      goto done;
    }
    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) {
    if (notifyTimes) {
      pt_PostNotifiesFromMonitor(&mon->waitCV, notifyTimes);
    }
    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 */
  saved_entries = mon->entryCount;
  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);

  if (timeout == PR_INTERVAL_NO_TIMEOUT) {
    rv = pthread_cond_wait(&mon->waitCV, &mon->lock);
  } else {
    rv = pt_TimedWait(&mon->waitCV, &mon->lock, timeout);
  }
  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("PR_PostSem", "locks & condition variables");
  PR_Lock(semaphore->cvar->lock);
  PR_NotifyCondVar(semaphore->cvar);
  semaphore->count += 1;
  PR_Unlock(semaphore->cvar->lock);
} /* PR_PostSem */

PR_IMPLEMENT(PRStatus) PR_WaitSem(PRSemaphore* semaphore) {
  PRStatus status = PR_SUCCESS;
  static PRBool unwarned = PR_TRUE;
  if (unwarned)
    unwarned = _PR_Obsolete("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;
} /* PR_WaitSem */

PR_IMPLEMENT(void) PR_DestroySem(PRSemaphore* semaphore) {
  static PRBool unwarned = PR_TRUE;
  if (unwarned)
    unwarned = _PR_Obsolete("PR_DestroySem", "locks & condition variables");
  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;
  if (!_pr_initialized) {
    _PR_ImplicitInitialization();
  }

  if (unwarned)
    unwarned = _PR_Obsolete("PR_NewSem", "locks & condition variables");

  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;

    if (flags & PR_SEM_EXCL) {
      oflag |= O_EXCL;
    }
    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;
}

#  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(DARWIN)
/* 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);
    if (seminfo.sem_otime != 0) {
      break;
    }
    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) {
    _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;

  if (!_pr_initialized) {
    _PR_ImplicitInitialization();
  }

  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)
  memset(cvar, 0xaf, sizeof(PRCondVar));
#  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));
  if (timeout == PR_INTERVAL_NO_TIMEOUT) {
    rv = pthread_cond_wait(&cvar->cv, &ml->mutex);
  } else {
    rv = pt_TimedWait(&cvar->cv, &ml->mutex, timeout);
  }
  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 */