Update to NSPR 4.10.4.

nspr/pr/src/pthreads/ptthread.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:            ptthread.c
 ** Descritpion:        Implemenation for threds using pthreds
 ** Exports:            ptthread.h
 */
@@ skipping 104 matching lines @@
         ts->stackBottom = ts->allocBase - ts->stackSize;
 #endif
     }
 }
 
 static void *_pt_root(void *arg)
 {
     PRIntn rv;
     PRThread *thred = (PRThread*)arg;
     PRBool detached = (thred->state & PT_THREAD_DETACHED) ? PR_TRUE : PR_FALSE;
+    pthread_t id = pthread_self();
 #ifdef _PR_NICE_PRIORITY_SCHEDULING
     pid_t tid;
 #endif
 
-    /*
-     * Both the parent thread and this new thread set thred->id.
-     * The new thread must ensure that thred->id is set before
-     * it executes its startFunc.  The parent thread must ensure
-     * that thred->id is set before PR_CreateThread() returns.
-     * Both threads set thred->id without holding a lock.  Since
-     * they are writing the same value, this unprotected double
-     * write should be safe.
-     */
-    thred->id = pthread_self();
-
 #ifdef _PR_NICE_PRIORITY_SCHEDULING
     /*
      * We need to know the kernel thread ID of each thread in order to
      * set its nice value hence we do it here instead of at creation time.
      */
     tid = gettid();
     errno = 0;
     rv = getpriority(PRIO_PROCESS, 0);
 
     /* If we cannot read the main thread's nice value don't try to change the
      * new thread's nice value. */
     if (errno == 0) {
         setpriority(PRIO_PROCESS, tid,
                     pt_RelativePriority(rv, thred->priority));
     }
-
-    PR_Lock(pt_book.ml);
-    thred->tid = tid;
-    PR_NotifyAllCondVar(pt_book.cv);
-    PR_Unlock(pt_book.ml);
 #endif
 
     /*
     ** DCE Threads can't detach during creation, so do it late.
     ** I would like to do it only here, but that doesn't seem
     ** to work.
     */
 #if defined(_PR_DCETHREADS)
     if (detached)
     {
         /* pthread_detach() modifies its argument, so we must pass a copy */
-        pthread_t self = thred->id;
+        pthread_t self = id;
         rv = pthread_detach(&self);
         PR_ASSERT(0 == rv);
     }
 #endif /* defined(_PR_DCETHREADS) */
 
     /* Set up the thread stack information */
     _PR_InitializeStack(thred->stack);
 
     /*
      * Set within the current thread the pointer to our object.
      * This object will be deleted when the thread termintates,
      * whether in a join or detached (see _PR_InitThreads()).
      */
     rv = pthread_setspecific(pt_book.key, thred);
     PR_ASSERT(0 == rv);
 
     /* make the thread visible to the rest of the runtime */
     PR_Lock(pt_book.ml);
+    /*
+     * Both the parent thread and this new thread set thred->id.
+     * The new thread must ensure that thred->id is set before
+     * it executes its startFunc.  The parent thread must ensure
+     * that thred->id is set before PR_CreateThread() returns.
+     * Both threads set thred->id while holding pt_book.ml and
+     * use thred->idSet to ensure thred->id is written only once.
+     */
+    if (!thred->idSet)
+    {
+        thred->id = id;
+        thred->idSet = PR_TRUE;
+    }
+    else
+    {
+        PR_ASSERT(pthread_equal(thred->id, id));
+    }
+
+#ifdef _PR_NICE_PRIORITY_SCHEDULING
+    thred->tid = tid;
+    PR_NotifyAllCondVar(pt_book.cv);
+#endif
 
     /* If this is a GCABLE thread, set its state appropriately */
     if (thred->suspend & PT_THREAD_SETGCABLE)
             thred->state |= PT_THREAD_GCABLE;
     thred->suspend = 0;
 
     thred->prev = pt_book.last;
     if (pt_book.last)
         pt_book.last->next = thred;
     else
         pt_book.first = thred;
     thred->next = NULL;
     pt_book.last = thred;
     PR_Unlock(pt_book.ml);
 
     thred->startFunc(thred->arg);  /* make visible to the client */
 
     /* unhook the thread from the runtime */
     PR_Lock(pt_book.ml);
     /*
      * At this moment, PR_CreateThread() may not have set thred->id yet.
      * It is safe for a detached thread to free thred only after
-     * PR_CreateThread() has set thred->id.
+     * PR_CreateThread() has accessed thred->id and thred->idSet.
      */
     if (detached)
     {
         while (!thred->okToDelete)
             PR_WaitCondVar(pt_book.cv, PR_INTERVAL_NO_TIMEOUT);
     }
 
     if (thred->state & PT_THREAD_SYSTEM)
         pt_book.system -= 1;
     else if (--pt_book.user == pt_book.this_many)
@@ skipping 43 matching lines @@
     if (!_pr_initialized) return NULL;
 
     /* PR_NEWZAP must not call PR_GetCurrentThread() */
     thred = PR_NEWZAP(PRThread);
     if (NULL != thred)
     {
         int rv;
 
         thred->priority = PR_PRIORITY_NORMAL;
         thred->id = pthread_self();
+        thred->idSet = PR_TRUE;
 #ifdef _PR_NICE_PRIORITY_SCHEDULING
         thred->tid = gettid();
 #endif
         rv = pthread_setspecific(pt_book.key, thred);
         PR_ASSERT(0 == rv);
 
         thred->state = PT_THREAD_GLOBAL | PT_THREAD_FOREIGN;
         PR_Lock(pt_book.ml);
 
         /* then put it into the list */
@@ skipping 200 matching lines @@
                 PR_NotifyAllCondVar(pt_book.cv);
             PR_Unlock(pt_book.ml);
 
             PR_Free(thred->stack);
             PR_Free(thred);  /* all that work ... poof! */
             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, oserr);
             thred = NULL;  /* and for what? */
             goto done;
         }
 
+        PR_Lock(pt_book.ml);
         /*
          * Both the parent thread and this new thread set thred->id.
          * The parent thread must ensure that thred->id is set before
          * PR_CreateThread() returns.  (See comments in _pt_root().)
          */
-        thred->id = id;
+        if (!thred->idSet)
+        {
+            thred->id = id;
+            thred->idSet = PR_TRUE;
+        }
+        else
+        {
+            PR_ASSERT(pthread_equal(thred->id, id));
+        }
 
         /*
-         * If the new thread is detached, tell it that PR_CreateThread()
-         * has set thred->id so it's ok to delete thred.
+         * If the new thread is detached, tell it that PR_CreateThread() has
+         * accessed thred->id and thred->idSet so it's ok to delete thred.
          */
         if (PR_UNJOINABLE_THREAD == state)
         {
-            PR_Lock(pt_book.ml);
             thred->okToDelete = PR_TRUE;
             PR_NotifyAllCondVar(pt_book.cv);
-            PR_Unlock(pt_book.ml);
         }
+        PR_Unlock(pt_book.ml);
     }
 
 done:
     rv = _PT_PTHREAD_ATTR_DESTROY(&tattr);
     PR_ASSERT(0 == rv);
 
     return thred;
 }  /* _PR_CreateThread */
 
 PR_IMPLEMENT(PRThread*) PR_CreateThread(
@@ skipping 409 matching lines @@
     pt_book.ml = PR_NewLock();
     PR_ASSERT(NULL != pt_book.ml);
     pt_book.cv = PR_NewCondVar(pt_book.ml);
     PR_ASSERT(NULL != pt_book.cv);
     thred = PR_NEWZAP(PRThread);
     PR_ASSERT(NULL != thred);
     thred->arg = NULL;
     thred->startFunc = NULL;
     thred->priority = priority;
     thred->id = pthread_self();
+    thred->idSet = PR_TRUE;
 #ifdef _PR_NICE_PRIORITY_SCHEDULING
     thred->tid = gettid();
 #endif
 
     thred->state = (PT_THREAD_DETACHED | PT_THREAD_PRIMORD);
     if (PR_SYSTEM_THREAD == type)
     {
         thred->state |= PT_THREAD_SYSTEM;
         pt_book.system += 1;
             pt_book.this_many = 0;
@@ skipping 835 matching lines @@
 PR_IMPLEMENT(const char *) PR_GetThreadName(const PRThread *thread)
 {
     if (!thread)
         return NULL;
     return thread->name;
 }
 
 #endif  /* defined(_PR_PTHREADS) || defined(_PR_DCETHREADS) */
 
 /* ptthread.c */