Update to NSS 3.12.7 and NSPR 4.8.6....

nss/mozilla/nsprpub/pr/src/pthreads/ptsynch.c

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
@@ skipping 130 matching lines @@
             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_AtomicDecrement(&cv->notify_pending))
+            if (0 > PR_ATOMIC_DECREMENT(&cv->notify_pending))
             {
                 pt_debug.delayed_cv_deletes += 1;
                 PR_DestroyCondVar(cv);
             }
 #else  /* defined(DEBUG) */
-            if (0 > PR_AtomicDecrement(&cv->notify_pending))
+            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)
@@ skipping 21 matching lines @@
     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_DELETE(lock);
+    PR_Free(lock);
 }  /* PR_DestroyLock */
 
 PR_IMPLEMENT(void) PR_Lock(PRLock *lock)
 {
     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);
@@ skipping 121 matching lines @@
         /* 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_AtomicIncrement(&cvar->notify_pending);
+    (void)PR_ATOMIC_INCREMENT(&cvar->notify_pending);
     notified->cv[index].times = (broadcast) ? -1 : 1;
     notified->cv[index].cv = cvar;
     notified->length += 1;
 
 finished:
     PR_ASSERT(PR_TRUE == cvar->lock->locked);
     PR_ASSERT(pthread_equal(cvar->lock->owner, pthread_self()));
 }  /* 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);
         cv->lock = lock;
         cv->notify_pending = 0;
 #if defined(DEBUG)
         pt_debug.cvars_created += 1;
 #endif
     }
     return cv;
 }  /* PR_NewCondVar */
 
 PR_IMPLEMENT(void) PR_DestroyCondVar(PRCondVar *cvar)
 {
-    if (0 > PR_AtomicDecrement(&cvar->notify_pending))
+    if (0 > PR_ATOMIC_DECREMENT(&cvar->notify_pending))
     {
         PRIntn rv = pthread_cond_destroy(&cvar->cv); PR_ASSERT(0 == rv);
 #if defined(DEBUG)
         memset(cvar, 0xaf, sizeof(PRCondVar));
         pt_debug.cvars_destroyed += 1;
 #endif
-        PR_DELETE(cvar);
+        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 */
@@ skipping 68 matching lines @@
 /**************************************************************/
 /**************************************************************/
 /***************************MONITORS***************************/
 /**************************************************************/
 /**************************************************************/
 
 PR_IMPLEMENT(PRMonitor*) PR_NewMonitor(void)
 {
     PRMonitor *mon;
     PRCondVar *cvar;
+    int rv;
 
     if (!_pr_initialized) _PR_ImplicitInitialization();
 
     cvar = PR_NEWZAP(PRCondVar);
     if (NULL == cvar)
     {
         PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
         return NULL;
     }
     mon = PR_NEWZAP(PRMonitor);
-    if (mon != NULL)
+    if (mon == NULL)
     {
-        int rv;
-        rv = _PT_PTHREAD_MUTEX_INIT(mon->lock.mutex, _pt_mattr); 
-        PR_ASSERT(0 == rv);
+        PR_Free(cvar);
+        PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
+        return NULL;
+    }
 
-        _PT_PTHREAD_INVALIDATE_THR_HANDLE(mon->owner);
+    rv = _PT_PTHREAD_MUTEX_INIT(mon->lock.mutex, _pt_mattr); 
+    PR_ASSERT(0 == rv);
+    if (0 != rv)
+    {
+        PR_Free(mon);
+        PR_Free(cvar);
+        PR_SetError(PR_OPERATION_NOT_SUPPORTED_ERROR, 0);
+        return NULL;
+    }
 
-        mon->cvar = cvar;
-        rv = _PT_PTHREAD_COND_INIT(mon->cvar->cv, _pt_cvar_attr); 
-        PR_ASSERT(0 == rv);
-        mon->entryCount = 0;
-        mon->cvar->lock = &mon->lock;
-        if (0 != rv)
-        {
-            PR_DELETE(mon);
-            PR_DELETE(cvar);
-            mon = NULL;
-        }
+    _PT_PTHREAD_INVALIDATE_THR_HANDLE(mon->owner);
+
+    mon->cvar = cvar;
+    rv = _PT_PTHREAD_COND_INIT(mon->cvar->cv, _pt_cvar_attr); 
+    PR_ASSERT(0 == rv);
+    mon->entryCount = 0;
+    mon->cvar->lock = &mon->lock;
+    if (0 != rv)
+    {
+        pthread_mutex_destroy(&mon->lock.mutex);
+        PR_Free(mon);
+        PR_Free(cvar);
+        PR_SetError(PR_OPERATION_NOT_SUPPORTED_ERROR, 0);
+        return NULL;
     }
     return mon;
 }  /* 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);
     PR_DestroyCondVar(mon->cvar);
     rv = pthread_mutex_destroy(&mon->lock.mutex); PR_ASSERT(0 == rv);
 #if defined(DEBUG)
         memset(mon, 0xaf, sizeof(PRMonitor));
 #endif
-    PR_DELETE(mon);    
+    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();
     if (pthread_equal(mon->owner, self))
@@ skipping 140 matching lines @@
         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_DELETE(semaphore);
+    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_DELETE(semaphore);
+        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).
@@ skipping 36 matching lines @@
 #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_DELETE(sem);
+        PR_Free(sem);
         return NULL;
     }
     return sem;
 }
 
 PR_IMPLEMENT(PRStatus) PR_WaitSemaphore(PRSem *sem)
 {
     int rv;
     rv = sem_wait(sem->sem);
     if (0 != rv)
@@ skipping 18 matching lines @@
 
 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_DELETE(sem);
+    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)
@@ skipping 90 matching lines @@
     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_DELETE(sem);
+                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_DELETE(sem);
+                PR_Free(sem);
                 return NULL;
             }
             return sem;
         }
 
         if (errno != EEXIST || flags & PR_SEM_EXCL)
         {
             _PR_MD_MAP_DEFAULT_ERROR(errno);
-            PR_DELETE(sem);
+            PR_Free(sem);
             return NULL;
         }
     }
 
     sem->semid = semget(key, 1, NSPR_SEM_MODE);
     if (sem->semid == -1)
     {
         _PR_MD_MAP_DEFAULT_ERROR(errno);
-        PR_DELETE(sem);
+        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_DELETE(sem);
+        PR_Free(sem);
         return NULL;
     }
     return sem;
 }
 
 PR_IMPLEMENT(PRStatus) PR_WaitSemaphore(PRSem *sem)
 {
     struct sembuf sop;
 
     sop.sem_num = 0;
@@ skipping 17 matching lines @@
     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_DELETE(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];
@@ skipping 105 matching lines @@
     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_DELETE(cvar);
+    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)
@@ skipping 22 matching lines @@
     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 */