nss-3.41/nss/lib/util/nssrwlk.c - manifest_repos/nss - Git at Google

 /* 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/. */

 #include "nssrwlk.h"
 #include "nspr.h"

 PR_BEGIN_EXTERN_C

 /*
  * Reader-writer lock
  */
 struct nssRWLockStr {
     PZLock *rw_lock;
     char *rw_name;               /* lock name                    */
     PRUint32 rw_rank;            /* rank of the lock             */
     PRInt32 rw_writer_locks;     /* ==  0, if unlocked           */
     PRInt32 rw_reader_locks;     /* ==  0, if unlocked           */
                                  /* > 0  , # of read locks       */
     PRUint32 rw_waiting_readers; /* number of waiting readers    */
     PRUint32 rw_waiting_writers; /* number of waiting writers    */
     PZCondVar *rw_reader_waitq;  /* cvar for readers             */
     PZCondVar *rw_writer_waitq;  /* cvar for writers             */
     PRThread *rw_owner;          /* lock owner for write-lock    */
                                  /* Non-null if write lock held. */
 };

 PR_END_EXTERN_C

 #include <string.h>

 #ifdef DEBUG_RANK_ORDER
 #define NSS_RWLOCK_RANK_ORDER_DEBUG /* enable deadlock detection using \
                                        rank-order for locks            \
                                     */
 #endif

 #ifdef NSS_RWLOCK_RANK_ORDER_DEBUG

 static PRUintn nss_thread_rwlock_initialized;
 static PRUintn nss_thread_rwlock; /* TPD key for lock stack */
 static PRUintn nss_thread_rwlock_alloc_failed;

 #define _NSS_RWLOCK_RANK_ORDER_LIMIT 10

 typedef struct thread_rwlock_stack {
     PRInt32 trs_index;                                  /* top of stack */
     NSSRWLock *trs_stack[_NSS_RWLOCK_RANK_ORDER_LIMIT]; /* stack of lock
                                                                pointers */
 } thread_rwlock_stack;

 /* forward static declarations. */
 static PRUint32 nssRWLock_GetThreadRank(PRThread *me);
 static void nssRWLock_SetThreadRank(PRThread *me, NSSRWLock *rwlock);
 static void nssRWLock_UnsetThreadRank(PRThread *me, NSSRWLock *rwlock);
 static void nssRWLock_ReleaseLockStack(void *lock_stack);

 #endif

 #define UNTIL(x) while (!(x))

 /*
  * Reader/Writer Locks
  */

 /*
  * NSSRWLock_New
  *      Create a reader-writer lock, with the given lock rank and lock name
  *
  */

 NSSRWLock *
 NSSRWLock_New(PRUint32 lock_rank, const char *lock_name)
 {
     NSSRWLock *rwlock;

     rwlock = PR_NEWZAP(NSSRWLock);
     if (rwlock == NULL)
         return NULL;

     rwlock->rw_lock = PZ_NewLock(nssILockRWLock);
     if (rwlock->rw_lock == NULL) {
         goto loser;
     }
     rwlock->rw_reader_waitq = PZ_NewCondVar(rwlock->rw_lock);
     if (rwlock->rw_reader_waitq == NULL) {
         goto loser;
     }
     rwlock->rw_writer_waitq = PZ_NewCondVar(rwlock->rw_lock);
     if (rwlock->rw_writer_waitq == NULL) {
         goto loser;
     }
     if (lock_name != NULL) {
         rwlock->rw_name = (char *)PR_Malloc((PRUint32)strlen(lock_name) + 1);
         if (rwlock->rw_name == NULL) {
             goto loser;
         }
         strcpy(rwlock->rw_name, lock_name);
     } else {
         rwlock->rw_name = NULL;
     }
     rwlock->rw_rank = lock_rank;
     rwlock->rw_waiting_readers = 0;
     rwlock->rw_waiting_writers = 0;
     rwlock->rw_reader_locks = 0;
     rwlock->rw_writer_locks = 0;

     return rwlock;

 loser:
     NSSRWLock_Destroy(rwlock);
     return (NULL);
 }

 /*
 ** Destroy the given RWLock "lock".
 */
 void
 NSSRWLock_Destroy(NSSRWLock *rwlock)
 {
     PR_ASSERT(rwlock != NULL);
     PR_ASSERT(rwlock->rw_waiting_readers == 0);
     PR_ASSERT(rwlock->rw_writer_locks == 0);
     PR_ASSERT(rwlock->rw_reader_locks == 0);

     /* XXX Shouldn't we lock the PZLock before destroying this?? */

     if (rwlock->rw_name)
         PR_Free(rwlock->rw_name);
     if (rwlock->rw_reader_waitq)
         PZ_DestroyCondVar(rwlock->rw_reader_waitq);
     if (rwlock->rw_writer_waitq)
         PZ_DestroyCondVar(rwlock->rw_writer_waitq);
     if (rwlock->rw_lock)
         PZ_DestroyLock(rwlock->rw_lock);
     PR_DELETE(rwlock);
 }

 /*
 ** Read-lock the RWLock.
 */
 void
 NSSRWLock_LockRead(NSSRWLock *rwlock)
 {
     PRThread *me = PR_GetCurrentThread();

     PZ_Lock(rwlock->rw_lock);
 #ifdef NSS_RWLOCK_RANK_ORDER_DEBUG

     /*
      * assert that rank ordering is not violated; the rank of 'rwlock' should
      * be equal to or greater than the highest rank of all the locks held by
      * the thread.
      */
     PR_ASSERT((rwlock->rw_rank == NSS_RWLOCK_RANK_NONE) ||
               (rwlock->rw_rank >= nssRWLock_GetThreadRank(me)));
 #endif
     /*
      * wait if write-locked or if a writer is waiting; preference for writers
      */
     UNTIL((rwlock->rw_owner == me) ||    /* I own it, or        */
           ((rwlock->rw_owner == NULL) && /* no-one owns it, and */
            (rwlock->rw_waiting_writers == 0)))
     { /* no-one is waiting to own */

         rwlock->rw_waiting_readers++;
         PZ_WaitCondVar(rwlock->rw_reader_waitq, PR_INTERVAL_NO_TIMEOUT);
         rwlock->rw_waiting_readers--;
     }
     rwlock->rw_reader_locks++; /* Increment read-lock count */

     PZ_Unlock(rwlock->rw_lock);

 #ifdef NSS_RWLOCK_RANK_ORDER_DEBUG
     nssRWLock_SetThreadRank(me, rwlock); /* update thread's lock rank */
 #endif
 }

 /* Unlock a Read lock held on this RW lock.
 */
 void
 NSSRWLock_UnlockRead(NSSRWLock *rwlock)
 {
     PZ_Lock(rwlock->rw_lock);

     PR_ASSERT(rwlock->rw_reader_locks > 0); /* lock must be read locked */

     if ((rwlock->rw_reader_locks > 0) &&    /* caller isn't screwey */
         (--rwlock->rw_reader_locks == 0) && /* not read locked any more */
         (rwlock->rw_owner == NULL) &&       /* not write locked */
         (rwlock->rw_waiting_writers > 0)) { /* someone's waiting. */

         PZ_NotifyCondVar(rwlock->rw_writer_waitq); /* wake him up. */
     }

     PZ_Unlock(rwlock->rw_lock);

 #ifdef NSS_RWLOCK_RANK_ORDER_DEBUG
     /*
      * update thread's lock rank
      */
     nssRWLock_UnsetThreadRank(me, rwlock);
 #endif
     return;
 }

 /*
 ** Write-lock the RWLock.
 */
 void
 NSSRWLock_LockWrite(NSSRWLock *rwlock)
 {
     PRThread *me = PR_GetCurrentThread();

     PZ_Lock(rwlock->rw_lock);
 #ifdef NSS_RWLOCK_RANK_ORDER_DEBUG
     /*
      * assert that rank ordering is not violated; the rank of 'rwlock' should
      * be equal to or greater than the highest rank of all the locks held by
      * the thread.
      */
     PR_ASSERT((rwlock->rw_rank == NSS_RWLOCK_RANK_NONE) ||
               (rwlock->rw_rank >= nssRWLock_GetThreadRank(me)));
 #endif
     /*
      * wait if read locked or write locked.
      */
     PR_ASSERT(rwlock->rw_reader_locks >= 0);
     PR_ASSERT(me != NULL);

     UNTIL((rwlock->rw_owner == me) ||    /* I own write lock, or */
           ((rwlock->rw_owner == NULL) && /* no writer   and */
            (rwlock->rw_reader_locks == 0)))
     { /* no readers, either. */

         rwlock->rw_waiting_writers++;
         PZ_WaitCondVar(rwlock->rw_writer_waitq, PR_INTERVAL_NO_TIMEOUT);
         rwlock->rw_waiting_writers--;
         PR_ASSERT(rwlock->rw_reader_locks >= 0);
     }

     PR_ASSERT(rwlock->rw_reader_locks == 0);
     /*
      * apply write lock
      */
     rwlock->rw_owner = me;
     rwlock->rw_writer_locks++; /* Increment write-lock count */

     PZ_Unlock(rwlock->rw_lock);

 #ifdef NSS_RWLOCK_RANK_ORDER_DEBUG
     /*
      * update thread's lock rank
      */
     nssRWLock_SetThreadRank(me, rwlock);
 #endif
 }

 /* Unlock a Read lock held on this RW lock.
 */
 void
 NSSRWLock_UnlockWrite(NSSRWLock *rwlock)
 {
     PRThread *me = PR_GetCurrentThread();

     PZ_Lock(rwlock->rw_lock);
     PR_ASSERT(rwlock->rw_owner == me);      /* lock must be write-locked by me.  */
     PR_ASSERT(rwlock->rw_writer_locks > 0); /* lock must be write locked */

     if (rwlock->rw_owner == me &&         /* I own it, and            */
         rwlock->rw_writer_locks > 0 &&    /* I own it, and            */
         --rwlock->rw_writer_locks == 0) { /* I'm all done with it     */

         rwlock->rw_owner = NULL; /* I don't own it any more. */

         /* Give preference to waiting writers. */
         if (rwlock->rw_waiting_writers > 0) {
             if (rwlock->rw_reader_locks == 0)
                 PZ_NotifyCondVar(rwlock->rw_writer_waitq);
         } else if (rwlock->rw_waiting_readers > 0) {
             PZ_NotifyAllCondVar(rwlock->rw_reader_waitq);
         }
     }
     PZ_Unlock(rwlock->rw_lock);

 #ifdef NSS_RWLOCK_RANK_ORDER_DEBUG
     /*
      * update thread's lock rank
      */
     nssRWLock_UnsetThreadRank(me, rwlock);
 #endif
     return;
 }

 /* This is primarily for debugging, i.e. for inclusion in ASSERT calls. */
 PRBool
 NSSRWLock_HaveWriteLock(NSSRWLock *rwlock)
 {
     PRBool ownWriteLock;
     PRThread *me = PR_GetCurrentThread();

 /* This lock call isn't really necessary.
     ** If this thread is the owner, that fact cannot change during this call,
     ** because this thread is in this call.
     ** If this thread is NOT the owner, the owner could change, but it
     ** could not become this thread.
     */
 #if UNNECESSARY
     PZ_Lock(rwlock->rw_lock);
 #endif
     ownWriteLock = (PRBool)(me == rwlock->rw_owner);
 #if UNNECESSARY
     PZ_Unlock(rwlock->rw_lock);
 #endif
     return ownWriteLock;
 }

 #ifdef NSS_RWLOCK_RANK_ORDER_DEBUG

 /*
  * nssRWLock_SetThreadRank
  *      Set a thread's lock rank, which is the highest of the ranks of all
  *      the locks held by the thread. Pointers to the locks are added to a
  *      per-thread list, which is anchored off a thread-private data key.
  */

 static void
 nssRWLock_SetThreadRank(PRThread *me, NSSRWLock *rwlock)
 {
     thread_rwlock_stack *lock_stack;
     PRStatus rv;

     /*
      * allocated thread-private-data for rwlock list, if not already allocated
      */
     if (!nss_thread_rwlock_initialized) {
         /*
          * allocate tpd, only if not failed already
          */
         if (!nss_thread_rwlock_alloc_failed) {
             if (PR_NewThreadPrivateIndex(&nss_thread_rwlock,
                                          nssRWLock_ReleaseLockStack) == PR_FAILURE) {
                 nss_thread_rwlock_alloc_failed = 1;
                 return;
             }
         } else
             return;
     }
     /*
      * allocate a lock stack
      */
     if ((lock_stack = PR_GetThreadPrivate(nss_thread_rwlock)) == NULL) {
         lock_stack = (thread_rwlock_stack *)
             PR_CALLOC(1 * sizeof(thread_rwlock_stack));
         if (lock_stack) {
             rv = PR_SetThreadPrivate(nss_thread_rwlock, lock_stack);
             if (rv == PR_FAILURE) {
                 PR_DELETE(lock_stack);
                 nss_thread_rwlock_alloc_failed = 1;
                 return;
             }
         } else {
             nss_thread_rwlock_alloc_failed = 1;
             return;
         }
     }
     /*
      * add rwlock to lock stack, if limit is not exceeded
      */
     if (lock_stack) {
         if (lock_stack->trs_index < _NSS_RWLOCK_RANK_ORDER_LIMIT)
             lock_stack->trs_stack[lock_stack->trs_index++] = rwlock;
     }
     nss_thread_rwlock_initialized = 1;
 }

 static void
 nssRWLock_ReleaseLockStack(void *lock_stack)
 {
     PR_ASSERT(lock_stack);
     PR_DELETE(lock_stack);
 }

 /*
  * nssRWLock_GetThreadRank
  *
  *      return thread's lock rank. If thread-private-data for the lock
  *      stack is not allocated, return NSS_RWLOCK_RANK_NONE.
  */

 static PRUint32
 nssRWLock_GetThreadRank(PRThread *me)
 {
     thread_rwlock_stack *lock_stack;

     if (nss_thread_rwlock_initialized) {
         if ((lock_stack = PR_GetThreadPrivate(nss_thread_rwlock)) == NULL)
             return (NSS_RWLOCK_RANK_NONE);
         else
             return (lock_stack->trs_stack[lock_stack->trs_index - 1]->rw_rank);

     } else
         return (NSS_RWLOCK_RANK_NONE);
 }

 /*
  * nssRWLock_UnsetThreadRank
  *
  *      remove the rwlock from the lock stack. Since locks may not be
  *      unlocked in a FIFO order, the entire lock stack is searched.
  */

 static void
 nssRWLock_UnsetThreadRank(PRThread *me, NSSRWLock *rwlock)
 {
     thread_rwlock_stack *lock_stack;
     int new_index = 0, index, done = 0;

     if (!nss_thread_rwlock_initialized)
         return;

     lock_stack = PR_GetThreadPrivate(nss_thread_rwlock);

     PR_ASSERT(lock_stack != NULL);

     index = lock_stack->trs_index - 1;
     while (index-- >= 0) {
         if ((lock_stack->trs_stack[index] == rwlock) && !done) {
             /*
              * reset the slot for rwlock
              */
             lock_stack->trs_stack[index] = NULL;
             done = 1;
         }
         /*
          * search for the lowest-numbered empty slot, above which there are
          * no non-empty slots
          */
         if ((lock_stack->trs_stack[index] != NULL) && !new_index)
             new_index = index + 1;
         if (done && new_index)
             break;
     }
     /*
      * set top of stack to highest numbered empty slot
      */
     lock_stack->trs_index = new_index;
 }

 #endif /* NSS_RWLOCK_RANK_ORDER_DEBUG */
	/* 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/. */

	#include "nssrwlk.h"
	#include "nspr.h"

	PR_BEGIN_EXTERN_C

	/*
	* Reader-writer lock
	*/
	struct nssRWLockStr {
	PZLock *rw_lock;
	char rw_name; / lock name */
	PRUint32 rw_rank; /* rank of the lock */
	PRInt32 rw_writer_locks; /* == 0, if unlocked */
	PRInt32 rw_reader_locks; /* == 0, if unlocked */
	/* > 0 , # of read locks */
	PRUint32 rw_waiting_readers; /* number of waiting readers */
	PRUint32 rw_waiting_writers; /* number of waiting writers */
	PZCondVar rw_reader_waitq; / cvar for readers */
	PZCondVar rw_writer_waitq; / cvar for writers */
	PRThread rw_owner; / lock owner for write-lock */
	/* Non-null if write lock held. */
	};

	PR_END_EXTERN_C

	#include <string.h>

	#ifdef DEBUG_RANK_ORDER
	#define NSS_RWLOCK_RANK_ORDER_DEBUG /* enable deadlock detection using \
	rank-order for locks \
	*/
	#endif

	#ifdef NSS_RWLOCK_RANK_ORDER_DEBUG

	static PRUintn nss_thread_rwlock_initialized;
	static PRUintn nss_thread_rwlock; /* TPD key for lock stack */
	static PRUintn nss_thread_rwlock_alloc_failed;

	#define _NSS_RWLOCK_RANK_ORDER_LIMIT 10

	typedef struct thread_rwlock_stack {
	PRInt32 trs_index; /* top of stack */
	NSSRWLock trs_stack[_NSS_RWLOCK_RANK_ORDER_LIMIT]; / stack of lock
	pointers */
	} thread_rwlock_stack;

	/* forward static declarations. */
	static PRUint32 nssRWLock_GetThreadRank(PRThread *me);
	static void nssRWLock_SetThreadRank(PRThread me, NSSRWLock rwlock);
	static void nssRWLock_UnsetThreadRank(PRThread me, NSSRWLock rwlock);
	static void nssRWLock_ReleaseLockStack(void *lock_stack);

	#endif

	#define UNTIL(x) while (!(x))

	/*
	* Reader/Writer Locks
	*/

	/*
	* NSSRWLock_New
	* Create a reader-writer lock, with the given lock rank and lock name
	*
	*/

	NSSRWLock *
	NSSRWLock_New(PRUint32 lock_rank, const char *lock_name)
	{
	NSSRWLock *rwlock;

	rwlock = PR_NEWZAP(NSSRWLock);
	if (rwlock == NULL)
	return NULL;

	rwlock->rw_lock = PZ_NewLock(nssILockRWLock);
	if (rwlock->rw_lock == NULL) {
	goto loser;
	}
	rwlock->rw_reader_waitq = PZ_NewCondVar(rwlock->rw_lock);
	if (rwlock->rw_reader_waitq == NULL) {
	goto loser;
	}
	rwlock->rw_writer_waitq = PZ_NewCondVar(rwlock->rw_lock);
	if (rwlock->rw_writer_waitq == NULL) {
	goto loser;
	}
	if (lock_name != NULL) {
	rwlock->rw_name = (char *)PR_Malloc((PRUint32)strlen(lock_name) + 1);
	if (rwlock->rw_name == NULL) {
	goto loser;
	}
	strcpy(rwlock->rw_name, lock_name);
	} else {
	rwlock->rw_name = NULL;
	}
	rwlock->rw_rank = lock_rank;
	rwlock->rw_waiting_readers = 0;
	rwlock->rw_waiting_writers = 0;
	rwlock->rw_reader_locks = 0;
	rwlock->rw_writer_locks = 0;

	return rwlock;

	loser:
	NSSRWLock_Destroy(rwlock);
	return (NULL);
	}

	/*
	** Destroy the given RWLock "lock".
	*/
	void
	NSSRWLock_Destroy(NSSRWLock *rwlock)
	{
	PR_ASSERT(rwlock != NULL);
	PR_ASSERT(rwlock->rw_waiting_readers == 0);
	PR_ASSERT(rwlock->rw_writer_locks == 0);
	PR_ASSERT(rwlock->rw_reader_locks == 0);

	/* XXX Shouldn't we lock the PZLock before destroying this?? */

	if (rwlock->rw_name)
	PR_Free(rwlock->rw_name);
	if (rwlock->rw_reader_waitq)
	PZ_DestroyCondVar(rwlock->rw_reader_waitq);
	if (rwlock->rw_writer_waitq)
	PZ_DestroyCondVar(rwlock->rw_writer_waitq);
	if (rwlock->rw_lock)
	PZ_DestroyLock(rwlock->rw_lock);
	PR_DELETE(rwlock);
	}

	/*
	** Read-lock the RWLock.
	*/
	void
	NSSRWLock_LockRead(NSSRWLock *rwlock)
	{
	PRThread *me = PR_GetCurrentThread();

	PZ_Lock(rwlock->rw_lock);
	#ifdef NSS_RWLOCK_RANK_ORDER_DEBUG

	/*
	* assert that rank ordering is not violated; the rank of 'rwlock' should
	* be equal to or greater than the highest rank of all the locks held by
	* the thread.
	*/
	PR_ASSERT((rwlock->rw_rank == NSS_RWLOCK_RANK_NONE) \|\|
	(rwlock->rw_rank >= nssRWLock_GetThreadRank(me)));
	#endif
	/*
	* wait if write-locked or if a writer is waiting; preference for writers
	*/
	UNTIL((rwlock->rw_owner == me) \|\| /* I own it, or */
	((rwlock->rw_owner == NULL) && /* no-one owns it, and */
	(rwlock->rw_waiting_writers == 0)))
	{ /* no-one is waiting to own */

	rwlock->rw_waiting_readers++;
	PZ_WaitCondVar(rwlock->rw_reader_waitq, PR_INTERVAL_NO_TIMEOUT);
	rwlock->rw_waiting_readers--;
	}
	rwlock->rw_reader_locks++; /* Increment read-lock count */

	PZ_Unlock(rwlock->rw_lock);

	#ifdef NSS_RWLOCK_RANK_ORDER_DEBUG
	nssRWLock_SetThreadRank(me, rwlock); /* update thread's lock rank */
	#endif
	}

	/* Unlock a Read lock held on this RW lock.
	*/
	void
	NSSRWLock_UnlockRead(NSSRWLock *rwlock)
	{
	PZ_Lock(rwlock->rw_lock);

	PR_ASSERT(rwlock->rw_reader_locks > 0); /* lock must be read locked */

	if ((rwlock->rw_reader_locks > 0) && /* caller isn't screwey */
	(--rwlock->rw_reader_locks == 0) && /* not read locked any more */
	(rwlock->rw_owner == NULL) && /* not write locked */
	(rwlock->rw_waiting_writers > 0)) { /* someone's waiting. */

	PZ_NotifyCondVar(rwlock->rw_writer_waitq); /* wake him up. */
	}

	PZ_Unlock(rwlock->rw_lock);

	#ifdef NSS_RWLOCK_RANK_ORDER_DEBUG
	/*
	* update thread's lock rank
	*/
	nssRWLock_UnsetThreadRank(me, rwlock);
	#endif
	return;
	}

	/*
	** Write-lock the RWLock.
	*/
	void
	NSSRWLock_LockWrite(NSSRWLock *rwlock)
	{
	PRThread *me = PR_GetCurrentThread();

	PZ_Lock(rwlock->rw_lock);
	#ifdef NSS_RWLOCK_RANK_ORDER_DEBUG
	/*
	* assert that rank ordering is not violated; the rank of 'rwlock' should
	* be equal to or greater than the highest rank of all the locks held by
	* the thread.
	*/
	PR_ASSERT((rwlock->rw_rank == NSS_RWLOCK_RANK_NONE) \|\|
	(rwlock->rw_rank >= nssRWLock_GetThreadRank(me)));
	#endif
	/*
	* wait if read locked or write locked.
	*/
	PR_ASSERT(rwlock->rw_reader_locks >= 0);
	PR_ASSERT(me != NULL);

	UNTIL((rwlock->rw_owner == me) \|\| /* I own write lock, or */
	((rwlock->rw_owner == NULL) && /* no writer and */
	(rwlock->rw_reader_locks == 0)))
	{ /* no readers, either. */

	rwlock->rw_waiting_writers++;
	PZ_WaitCondVar(rwlock->rw_writer_waitq, PR_INTERVAL_NO_TIMEOUT);
	rwlock->rw_waiting_writers--;
	PR_ASSERT(rwlock->rw_reader_locks >= 0);
	}

	PR_ASSERT(rwlock->rw_reader_locks == 0);
	/*
	* apply write lock
	*/
	rwlock->rw_owner = me;
	rwlock->rw_writer_locks++; /* Increment write-lock count */

	PZ_Unlock(rwlock->rw_lock);

	#ifdef NSS_RWLOCK_RANK_ORDER_DEBUG
	/*
	* update thread's lock rank
	*/
	nssRWLock_SetThreadRank(me, rwlock);
	#endif
	}

	/* Unlock a Read lock held on this RW lock.
	*/
	void
	NSSRWLock_UnlockWrite(NSSRWLock *rwlock)
	{
	PRThread *me = PR_GetCurrentThread();

	PZ_Lock(rwlock->rw_lock);
	PR_ASSERT(rwlock->rw_owner == me); /* lock must be write-locked by me. */
	PR_ASSERT(rwlock->rw_writer_locks > 0); /* lock must be write locked */

	if (rwlock->rw_owner == me && /* I own it, and */
	rwlock->rw_writer_locks > 0 && /* I own it, and */
	--rwlock->rw_writer_locks == 0) { /* I'm all done with it */

	rwlock->rw_owner = NULL; /* I don't own it any more. */

	/* Give preference to waiting writers. */
	if (rwlock->rw_waiting_writers > 0) {
	if (rwlock->rw_reader_locks == 0)
	PZ_NotifyCondVar(rwlock->rw_writer_waitq);
	} else if (rwlock->rw_waiting_readers > 0) {
	PZ_NotifyAllCondVar(rwlock->rw_reader_waitq);
	}
	}
	PZ_Unlock(rwlock->rw_lock);

	#ifdef NSS_RWLOCK_RANK_ORDER_DEBUG
	/*
	* update thread's lock rank
	*/
	nssRWLock_UnsetThreadRank(me, rwlock);
	#endif
	return;
	}

	/* This is primarily for debugging, i.e. for inclusion in ASSERT calls. */
	PRBool
	NSSRWLock_HaveWriteLock(NSSRWLock *rwlock)
	{
	PRBool ownWriteLock;
	PRThread *me = PR_GetCurrentThread();

	/* This lock call isn't really necessary.
	** If this thread is the owner, that fact cannot change during this call,
	** because this thread is in this call.
	** If this thread is NOT the owner, the owner could change, but it
	** could not become this thread.
	*/
	#if UNNECESSARY
	PZ_Lock(rwlock->rw_lock);
	#endif
	ownWriteLock = (PRBool)(me == rwlock->rw_owner);
	#if UNNECESSARY
	PZ_Unlock(rwlock->rw_lock);
	#endif
	return ownWriteLock;
	}

	#ifdef NSS_RWLOCK_RANK_ORDER_DEBUG

	/*
	* nssRWLock_SetThreadRank
	* Set a thread's lock rank, which is the highest of the ranks of all
	* the locks held by the thread. Pointers to the locks are added to a
	* per-thread list, which is anchored off a thread-private data key.
	*/

	static void
	nssRWLock_SetThreadRank(PRThread me, NSSRWLock rwlock)
	{
	thread_rwlock_stack *lock_stack;
	PRStatus rv;

	/*
	* allocated thread-private-data for rwlock list, if not already allocated
	*/
	if (!nss_thread_rwlock_initialized) {
	/*
	* allocate tpd, only if not failed already
	*/
	if (!nss_thread_rwlock_alloc_failed) {
	if (PR_NewThreadPrivateIndex(&nss_thread_rwlock,
	nssRWLock_ReleaseLockStack) == PR_FAILURE) {
	nss_thread_rwlock_alloc_failed = 1;
	return;
	}
	} else
	return;
	}
	/*
	* allocate a lock stack
	*/
	if ((lock_stack = PR_GetThreadPrivate(nss_thread_rwlock)) == NULL) {
	lock_stack = (thread_rwlock_stack *)
	PR_CALLOC(1 * sizeof(thread_rwlock_stack));
	if (lock_stack) {
	rv = PR_SetThreadPrivate(nss_thread_rwlock, lock_stack);
	if (rv == PR_FAILURE) {
	PR_DELETE(lock_stack);
	nss_thread_rwlock_alloc_failed = 1;
	return;
	}
	} else {
	nss_thread_rwlock_alloc_failed = 1;
	return;
	}
	}
	/*
	* add rwlock to lock stack, if limit is not exceeded
	*/
	if (lock_stack) {
	if (lock_stack->trs_index < _NSS_RWLOCK_RANK_ORDER_LIMIT)
	lock_stack->trs_stack[lock_stack->trs_index++] = rwlock;
	}
	nss_thread_rwlock_initialized = 1;
	}

	static void
	nssRWLock_ReleaseLockStack(void *lock_stack)
	{
	PR_ASSERT(lock_stack);
	PR_DELETE(lock_stack);
	}

	/*
	* nssRWLock_GetThreadRank
	*
	* return thread's lock rank. If thread-private-data for the lock
	* stack is not allocated, return NSS_RWLOCK_RANK_NONE.
	*/

	static PRUint32
	nssRWLock_GetThreadRank(PRThread *me)
	{
	thread_rwlock_stack *lock_stack;

	if (nss_thread_rwlock_initialized) {
	if ((lock_stack = PR_GetThreadPrivate(nss_thread_rwlock)) == NULL)
	return (NSS_RWLOCK_RANK_NONE);
	else
	return (lock_stack->trs_stack[lock_stack->trs_index - 1]->rw_rank);

	} else
	return (NSS_RWLOCK_RANK_NONE);
	}

	/*
	* nssRWLock_UnsetThreadRank
	*
	* remove the rwlock from the lock stack. Since locks may not be
	* unlocked in a FIFO order, the entire lock stack is searched.
	*/

	static void
	nssRWLock_UnsetThreadRank(PRThread me, NSSRWLock rwlock)
	{
	thread_rwlock_stack *lock_stack;
	int new_index = 0, index, done = 0;

	if (!nss_thread_rwlock_initialized)
	return;

	lock_stack = PR_GetThreadPrivate(nss_thread_rwlock);

	PR_ASSERT(lock_stack != NULL);

	index = lock_stack->trs_index - 1;
	while (index-- >= 0) {
	if ((lock_stack->trs_stack[index] == rwlock) && !done) {
	/*
	* reset the slot for rwlock
	*/
	lock_stack->trs_stack[index] = NULL;
	done = 1;
	}
	/*
	* search for the lowest-numbered empty slot, above which there are
	* no non-empty slots
	*/
	if ((lock_stack->trs_stack[index] != NULL) && !new_index)
	new_index = index + 1;
	if (done && new_index)
	break;
	}
	/*
	* set top of stack to highest numbered empty slot
	*/
	lock_stack->trs_index = new_index;
	}

	#endif /* NSS_RWLOCK_RANK_ORDER_DEBUG */