/* 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(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);

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