nss/lib/util/nssilock.c - chromium/deps/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/. */

 /*
  * nssilock.c - NSS lock instrumentation wrapper functions
  *
  * NOTE - These are not public interfaces
  *
  * Implementation Notes:
  * I've tried to make the instrumentation relatively non-intrusive.
  * To do this, I have used a single PR_LOG() call in each
  * instrumented function. There's room for improvement.
  *
  *
  */

 #include "prinit.h"
 #include "prerror.h"
 #include "prlock.h"
 #include "prmem.h"
 #include "prenv.h"
 #include "prcvar.h"
 #include "prio.h"

 #if defined(NEED_NSS_ILOCK)
 #include "prlog.h"
 #include "nssilock.h"

 /*
 ** Declare the instrumented PZLock
 */
 struct pzlock_s {
     PRLock *lock;  /* the PZLock to be instrumented */
     PRIntervalTime time; /* timestamp when the lock was aquired */
     nssILockType ltype;
 };

 /*
 ** Declare the instrumented PZMonitor
 */
 struct pzmonitor_s {
     PRMonitor *mon;   /* the PZMonitor to be instrumented */
     PRIntervalTime time; /* timestamp when the monitor was aquired */
     nssILockType ltype;
 };

 /*
 ** Declare the instrumented PZCondVar
 */
 struct pzcondvar_s  {
     PRCondVar   *cvar;  /* the PZCondVar to be instrumented */
     nssILockType ltype;
 };


 /*
 ** Define a CallOnce type to ensure serialized self-initialization
 */
 static PRCallOnceType coNssILock;     /* CallOnce type */
 static PRIntn  nssILockInitialized;   /* initialization done when 1 */
 static PRLogModuleInfo *nssILog;      /* Log instrumentation to this handle */


 #define NUM_TT_ENTRIES 6000000
 static PRInt32  traceIndex = -1;      /* index into trace table */
 static struct pzTrace_s *tt;          /* pointer to trace table */
 static PRInt32  ttBufSize = (NUM_TT_ENTRIES * sizeof(struct pzTrace_s ));
 static PRCondVar *ttCVar;
 static PRLock    *ttLock;
 static PRFileDesc *ttfd;              /* trace table file */

 /*
 ** Vtrace() -- Trace events, write events to external media
 **
 ** Vtrace() records traced events in an in-memory trace table
 ** when the trace table fills, Vtrace writes the entire table
 ** to a file.
 **
 ** data can be lost!
 **
 */
 static void Vtrace(
     nssILockOp      op,
     nssILockType    ltype,
     PRIntervalTime  callTime,
     PRIntervalTime  heldTime,
     void            *lock,
     PRIntn          line,
     char            *file
 )  {
     PRInt32 idx;
     struct pzTrace_s *tp;

 RetryTrace:
     idx = PR_ATOMIC_INCREMENT( &traceIndex );
     while( NUM_TT_ENTRIES <= idx || op == FlushTT ) {
         if( NUM_TT_ENTRIES == idx  || op == FlushTT )  {
             int writeSize = idx * sizeof(struct pzTrace_s);
             PR_Lock(ttLock);
             PR_Write( ttfd, tt, writeSize );
             traceIndex = -1;
             PR_NotifyAllCondVar( ttCVar );
             PR_Unlock(ttLock);
             goto RetryTrace;
         } else {
             PR_Lock(ttLock);
             while( NUM_TT_ENTRIES < idx )
                 PR_WaitCondVar(ttCVar, PR_INTERVAL_NO_WAIT);
             PR_Unlock(ttLock);
             goto RetryTrace;
         }
     } /* end while() */

     /* create the trace entry */
     tp = tt + idx;
     tp->threadID = PR_GetThreadID(PR_GetCurrentThread());
     tp->op = op;
     tp->ltype = ltype;
     tp->callTime = callTime;
     tp->heldTime = heldTime;
     tp->lock = lock;
     tp ->line = line;
     strcpy(tp->file, file );
     return;
 } /* --- end Vtrace() --- */

 /*
 ** pz_TraceFlush() -- Force trace table write to file
 **
 */
 extern void pz_TraceFlush( void )
 {
     Vtrace( FlushTT, nssILockSelfServ, 0, 0, NULL, 0, "" );
     return;
 } /* --- end pz_TraceFlush() --- */

 /*
 ** nssILockInit() -- Initialization for nssilock
 **
 ** This function is called from the CallOnce mechanism.
 */
 static PRStatus
     nssILockInit( void )
 {
     int i;
     nssILockInitialized = 1;

     /* new log module */
     nssILog = PR_NewLogModule("nssilock");
     if ( NULL == nssILog )  {
         return(PR_FAILURE);
     }

     tt = PR_Calloc( NUM_TT_ENTRIES, sizeof(struct pzTrace_s));
     if (NULL == tt ) {
         fprintf(stderr, "nssilock: can't allocate trace table\n");
         exit(1);
     }

     ttfd = PR_Open( "xxxTTLog", PR_CREATE_FILE | PR_WRONLY, 0666 );
     if ( NULL == ttfd )  {
         fprintf( stderr, "Oh Drat! Can't open 'xxxTTLog'\n");
         exit(1);
     }

     ttLock = PR_NewLock();
     ttCVar = PR_NewCondVar(ttLock);

     return(PR_SUCCESS);
 } /* --- end nssILockInit() --- */

 extern PZLock * pz_NewLock(
     nssILockType ltype,
     char *file,
     PRIntn line )
 {
     PRStatus rc;
     PZLock  *lock;

     /* Self Initialize the nssILock feature */
     if (!nssILockInitialized)  {
         rc = PR_CallOnce( &coNssILock, nssILockInit );
         if ( PR_FAILURE == rc ) {
             PR_SetError( PR_UNKNOWN_ERROR, 0 );
             return( NULL );
         }
     }

     lock = PR_NEWZAP( PZLock );
     if ( NULL != lock )  {
         lock->ltype = ltype;
         lock->lock = PR_NewLock();
         if ( NULL == lock->lock )  {
             PR_DELETE( lock );
             PORT_SetError(SEC_ERROR_NO_MEMORY);
         }
     } else {
             PORT_SetError(SEC_ERROR_NO_MEMORY);
     }

     Vtrace( NewLock, ltype, 0, 0, lock, line, file );
     return(lock);
 } /* --- end pz_NewLock() --- */

 extern void
     pz_Lock(
         PZLock *lock,
         char *file,
         PRIntn line
     )
 {
     PRIntervalTime callTime;

     callTime = PR_IntervalNow();
     PR_Lock( lock->lock );
     lock->time = PR_IntervalNow();
     callTime = lock->time - callTime;

     Vtrace( Lock, lock->ltype, callTime, 0, lock, line, file );
     return;
 } /* --- end  pz_Lock() --- */

 extern PRStatus
     pz_Unlock(
         PZLock *lock,
         char *file,
         PRIntn line
     )
 {
     PRStatus rc;
     PRIntervalTime callTime, now, heldTime;

     callTime = PR_IntervalNow();
     rc = PR_Unlock( lock->lock );
     now = PR_IntervalNow();
     callTime = now - callTime;
     heldTime = now - lock->time;
     Vtrace( Unlock, lock->ltype, callTime, heldTime, lock, line, file );
     return( rc );
 } /* --- end  pz_Unlock() --- */

 extern void
     pz_DestroyLock(
         PZLock *lock,
         char *file,
         PRIntn line
     )
 {
     Vtrace( DestroyLock, lock->ltype, 0, 0, lock, line, file );
     PR_DestroyLock( lock->lock );
     PR_DELETE( lock );
     return;
 } /* --- end  pz_DestroyLock() --- */


 extern PZCondVar *
     pz_NewCondVar(
         PZLock *lock,
         char *file,
         PRIntn line
     )
 {
     PZCondVar *cvar;

     cvar = PR_NEWZAP( PZCondVar );
     if ( NULL == cvar ) {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
     } else {
         cvar->ltype = lock->ltype;
         cvar->cvar = PR_NewCondVar( lock->lock );
         if ( NULL == cvar->cvar )  {
             PR_DELETE( cvar );
             PORT_SetError(SEC_ERROR_NO_MEMORY);
         }

     }
     Vtrace( NewCondVar, lock->ltype, 0, 0, cvar, line, file );
     return( cvar );
 } /* --- end  pz_NewCondVar() --- */

 extern void
     pz_DestroyCondVar(
         PZCondVar *cvar,
         char *file,
         PRIntn line
     )
 {
     Vtrace( DestroyCondVar, cvar->ltype, 0, 0, cvar, line, file );
     PR_DestroyCondVar( cvar->cvar );
     PR_DELETE( cvar );
 } /* --- end  pz_DestroyCondVar() --- */

 extern PRStatus
     pz_WaitCondVar(
         PZCondVar *cvar,
         PRIntervalTime timeout,
         char *file,
         PRIntn line
     )
 {
     PRStatus    rc;
     PRIntervalTime callTime;

     callTime = PR_IntervalNow();
     rc = PR_WaitCondVar( cvar->cvar, timeout );
     callTime = PR_IntervalNow() - callTime;

     Vtrace( WaitCondVar, cvar->ltype, callTime, 0, cvar, line, file );
     return(rc);
 } /* --- end  pz_WaitCondVar() --- */

 extern PRStatus
     pz_NotifyCondVar(
         PZCondVar *cvar,
         char *file,
         PRIntn line
     )
 {
     PRStatus    rc;

     rc = PR_NotifyCondVar( cvar->cvar );

     Vtrace( NotifyCondVar, cvar->ltype, 0, 0, cvar, line, file );
     return(rc);
 } /* --- end  pz_NotifyCondVar() --- */

 extern PRStatus
     pz_NotifyAllCondVar(
         PZCondVar *cvar,
         char *file,
         PRIntn line
     )
 {
     PRStatus    rc;

     rc = PR_NotifyAllCondVar( cvar->cvar );

     Vtrace( NotifyAllCondVar, cvar->ltype, 0, 0, cvar, line, file );
     return(rc);
 } /* --- end  pz_NotifyAllCondVar() --- */

 extern PZMonitor *
     pz_NewMonitor(
         nssILockType ltype,
         char *file,
         PRIntn line
     )
 {
     PRStatus rc;
     PZMonitor   *mon;

     /* Self Initialize the nssILock feature */
     if (!nssILockInitialized)  {
         rc = PR_CallOnce( &coNssILock, nssILockInit );
         if ( PR_FAILURE == rc ) {
             PR_SetError( PR_UNKNOWN_ERROR, 0 );
             return( NULL );
         }
     }

     mon = PR_NEWZAP( PZMonitor );
     if ( NULL != mon )  {
         mon->ltype = ltype;
         mon->mon = PR_NewMonitor();
         if ( NULL == mon->mon )  {
             PR_DELETE( mon );
             PORT_SetError(SEC_ERROR_NO_MEMORY);
         }
     } else {
         PORT_SetError(SEC_ERROR_NO_MEMORY);
     }

     Vtrace( NewMonitor, ltype, 0, 0, mon, line, file );
     return(mon);
 } /* --- end  pz_NewMonitor() --- */

 extern void
     pz_DestroyMonitor(
         PZMonitor *mon,
         char *file,
         PRIntn line
     )
 {
     Vtrace( DestroyMonitor, mon->ltype, 0, 0, mon, line, file );
     PR_DestroyMonitor( mon->mon );
     PR_DELETE( mon );
     return;
 } /* --- end  pz_DestroyMonitor() --- */

 extern void
     pz_EnterMonitor(
         PZMonitor *mon,
         char *file,
         PRIntn line
     )
 {
     PRIntervalTime callTime, now;

     callTime = PR_IntervalNow();
     PR_EnterMonitor( mon->mon );
     now = PR_IntervalNow();
     callTime = now - callTime;
     if ( PR_GetMonitorEntryCount(mon->mon) == 1 )  {
         mon->time = now;
     }
     Vtrace( EnterMonitor, mon->ltype, callTime, 0, mon, line, file );
     return;
 } /* --- end  pz_EnterMonitor() --- */

 extern PRStatus
     pz_ExitMonitor(
         PZMonitor *mon,
         char *file,
         PRIntn line
     )
 {
     PRStatus rc;
     PRIntervalTime callTime, now, heldTime;
     PRIntn  mec = PR_GetMonitorEntryCount( mon->mon );

     heldTime = (PRIntervalTime)-1;
     callTime = PR_IntervalNow();
     rc = PR_ExitMonitor( mon->mon );
     now = PR_IntervalNow();
     callTime = now - callTime;
     if ( mec == 1 )
         heldTime = now - mon->time;
     Vtrace( ExitMonitor, mon->ltype, callTime, heldTime, mon, line, file );
     return( rc );
 } /* --- end  pz_ExitMonitor() --- */

 extern PRIntn
     pz_GetMonitorEntryCount(
         PZMonitor *mon,
         char *file,
         PRIntn line
     )
 {
     return( PR_GetMonitorEntryCount(mon->mon));
 } /* --- end pz_GetMonitorEntryCount() --- */


 extern PRStatus
     pz_Wait(
         PZMonitor *mon,
         PRIntervalTime ticks,
         char *file,
         PRIntn line
     )
 {
     PRStatus rc;
     PRIntervalTime callTime;

     callTime = PR_IntervalNow();
     rc = PR_Wait( mon->mon, ticks );
     callTime = PR_IntervalNow() - callTime;
     Vtrace( Wait, mon->ltype, callTime, 0, mon, line, file );
     return( rc );
 } /* --- end  pz_Wait() --- */

 extern PRStatus
     pz_Notify(
         PZMonitor *mon,
         char *file,
         PRIntn line
     )
 {
     PRStatus rc;
     PRIntervalTime callTime;

     callTime = PR_IntervalNow();
     rc = PR_Notify( mon->mon );
     callTime = PR_IntervalNow() - callTime;
     Vtrace( Notify, mon->ltype, callTime, 0, mon, line, file );
     return( rc );
 } /* --- end  pz_Notify() --- */

 extern PRStatus
     pz_NotifyAll(
         PZMonitor *mon,
         char *file,
         PRIntn line
     )
 {
     PRStatus rc;
     PRIntervalTime callTime;

     callTime = PR_IntervalNow();
     rc = PR_NotifyAll( mon->mon );
     callTime = PR_IntervalNow() - callTime;
     Vtrace( NotifyAll, mon->ltype, callTime, 0, mon, line, file );
     return( rc );
 } /* --- end  pz_NotifyAll() --- */

 #endif /* NEED_NSS_ILOCK */
 /* --- end nssilock.c --------------------------------- */
	/* 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/. */

	/*
	* nssilock.c - NSS lock instrumentation wrapper functions
	*
	* NOTE - These are not public interfaces
	*
	* Implementation Notes:
	* I've tried to make the instrumentation relatively non-intrusive.
	* To do this, I have used a single PR_LOG() call in each
	* instrumented function. There's room for improvement.
	*
	*
	*/

	#include "prinit.h"
	#include "prerror.h"
	#include "prlock.h"
	#include "prmem.h"
	#include "prenv.h"
	#include "prcvar.h"
	#include "prio.h"

	#if defined(NEED_NSS_ILOCK)
	#include "prlog.h"
	#include "nssilock.h"

	/*
	** Declare the instrumented PZLock
	*/
	struct pzlock_s {
	PRLock lock; / the PZLock to be instrumented */
	PRIntervalTime time; /* timestamp when the lock was aquired */
	nssILockType ltype;
	};

	/*
	** Declare the instrumented PZMonitor
	*/
	struct pzmonitor_s {
	PRMonitor mon; / the PZMonitor to be instrumented */
	PRIntervalTime time; /* timestamp when the monitor was aquired */
	nssILockType ltype;
	};

	/*
	** Declare the instrumented PZCondVar
	*/
	struct pzcondvar_s {
	PRCondVar cvar; / the PZCondVar to be instrumented */
	nssILockType ltype;
	};


	/*
	** Define a CallOnce type to ensure serialized self-initialization
	*/
	static PRCallOnceType coNssILock; /* CallOnce type */
	static PRIntn nssILockInitialized; /* initialization done when 1 */
	static PRLogModuleInfo nssILog; / Log instrumentation to this handle */


	#define NUM_TT_ENTRIES 6000000
	static PRInt32 traceIndex = -1; /* index into trace table */
	static struct pzTrace_s tt; / pointer to trace table */
	static PRInt32 ttBufSize = (NUM_TT_ENTRIES * sizeof(struct pzTrace_s ));
	static PRCondVar *ttCVar;
	static PRLock *ttLock;
	static PRFileDesc ttfd; / trace table file */

	/*
	** Vtrace() -- Trace events, write events to external media
	**
	** Vtrace() records traced events in an in-memory trace table
	** when the trace table fills, Vtrace writes the entire table
	** to a file.
	**
	** data can be lost!
	**
	*/
	static void Vtrace(
	nssILockOp op,
	nssILockType ltype,
	PRIntervalTime callTime,
	PRIntervalTime heldTime,
	void *lock,
	PRIntn line,
	char *file
	) {
	PRInt32 idx;
	struct pzTrace_s *tp;

	RetryTrace:
	idx = PR_ATOMIC_INCREMENT( &traceIndex );
	while( NUM_TT_ENTRIES <= idx \|\| op == FlushTT ) {
	if( NUM_TT_ENTRIES == idx \|\| op == FlushTT ) {
	int writeSize = idx * sizeof(struct pzTrace_s);
	PR_Lock(ttLock);
	PR_Write( ttfd, tt, writeSize );
	traceIndex = -1;
	PR_NotifyAllCondVar( ttCVar );
	PR_Unlock(ttLock);
	goto RetryTrace;
	} else {
	PR_Lock(ttLock);
	while( NUM_TT_ENTRIES < idx )
	PR_WaitCondVar(ttCVar, PR_INTERVAL_NO_WAIT);
	PR_Unlock(ttLock);
	goto RetryTrace;
	}
	} /* end while() */

	/* create the trace entry */
	tp = tt + idx;
	tp->threadID = PR_GetThreadID(PR_GetCurrentThread());
	tp->op = op;
	tp->ltype = ltype;
	tp->callTime = callTime;
	tp->heldTime = heldTime;
	tp->lock = lock;
	tp ->line = line;
	strcpy(tp->file, file );
	return;
	} /* --- end Vtrace() --- */

	/*
	** pz_TraceFlush() -- Force trace table write to file
	**
	*/
	extern void pz_TraceFlush( void )
	{
	Vtrace( FlushTT, nssILockSelfServ, 0, 0, NULL, 0, "" );
	return;
	} /* --- end pz_TraceFlush() --- */

	/*
	** nssILockInit() -- Initialization for nssilock
	**
	** This function is called from the CallOnce mechanism.
	*/
	static PRStatus
	nssILockInit( void )
	{
	int i;
	nssILockInitialized = 1;

	/* new log module */
	nssILog = PR_NewLogModule("nssilock");
	if ( NULL == nssILog ) {
	return(PR_FAILURE);
	}

	tt = PR_Calloc( NUM_TT_ENTRIES, sizeof(struct pzTrace_s));
	if (NULL == tt ) {
	fprintf(stderr, "nssilock: can't allocate trace table\n");
	exit(1);
	}

	ttfd = PR_Open( "xxxTTLog", PR_CREATE_FILE \| PR_WRONLY, 0666 );
	if ( NULL == ttfd ) {
	fprintf( stderr, "Oh Drat! Can't open 'xxxTTLog'\n");
	exit(1);
	}

	ttLock = PR_NewLock();
	ttCVar = PR_NewCondVar(ttLock);

	return(PR_SUCCESS);
	} /* --- end nssILockInit() --- */

	extern PZLock * pz_NewLock(
	nssILockType ltype,
	char *file,
	PRIntn line )
	{
	PRStatus rc;
	PZLock *lock;

	/* Self Initialize the nssILock feature */
	if (!nssILockInitialized) {
	rc = PR_CallOnce( &coNssILock, nssILockInit );
	if ( PR_FAILURE == rc ) {
	PR_SetError( PR_UNKNOWN_ERROR, 0 );
	return( NULL );
	}
	}

	lock = PR_NEWZAP( PZLock );
	if ( NULL != lock ) {
	lock->ltype = ltype;
	lock->lock = PR_NewLock();
	if ( NULL == lock->lock ) {
	PR_DELETE( lock );
	PORT_SetError(SEC_ERROR_NO_MEMORY);
	}
	} else {
	PORT_SetError(SEC_ERROR_NO_MEMORY);
	}

	Vtrace( NewLock, ltype, 0, 0, lock, line, file );
	return(lock);
	} /* --- end pz_NewLock() --- */

	extern void
	pz_Lock(
	PZLock *lock,
	char *file,
	PRIntn line
	)
	{
	PRIntervalTime callTime;

	callTime = PR_IntervalNow();
	PR_Lock( lock->lock );
	lock->time = PR_IntervalNow();
	callTime = lock->time - callTime;

	Vtrace( Lock, lock->ltype, callTime, 0, lock, line, file );
	return;
	} /* --- end pz_Lock() --- */

	extern PRStatus
	pz_Unlock(
	PZLock *lock,
	char *file,
	PRIntn line
	)
	{
	PRStatus rc;
	PRIntervalTime callTime, now, heldTime;

	callTime = PR_IntervalNow();
	rc = PR_Unlock( lock->lock );
	now = PR_IntervalNow();
	callTime = now - callTime;
	heldTime = now - lock->time;
	Vtrace( Unlock, lock->ltype, callTime, heldTime, lock, line, file );
	return( rc );
	} /* --- end pz_Unlock() --- */

	extern void
	pz_DestroyLock(
	PZLock *lock,
	char *file,
	PRIntn line
	)
	{
	Vtrace( DestroyLock, lock->ltype, 0, 0, lock, line, file );
	PR_DestroyLock( lock->lock );
	PR_DELETE( lock );
	return;
	} /* --- end pz_DestroyLock() --- */



	extern PZCondVar *
	pz_NewCondVar(
	PZLock *lock,
	char *file,
	PRIntn line
	)
	{
	PZCondVar *cvar;

	cvar = PR_NEWZAP( PZCondVar );
	if ( NULL == cvar ) {
	PORT_SetError(SEC_ERROR_NO_MEMORY);
	} else {
	cvar->ltype = lock->ltype;
	cvar->cvar = PR_NewCondVar( lock->lock );
	if ( NULL == cvar->cvar ) {
	PR_DELETE( cvar );
	PORT_SetError(SEC_ERROR_NO_MEMORY);
	}

	}
	Vtrace( NewCondVar, lock->ltype, 0, 0, cvar, line, file );
	return( cvar );
	} /* --- end pz_NewCondVar() --- */

	extern void
	pz_DestroyCondVar(
	PZCondVar *cvar,
	char *file,
	PRIntn line
	)
	{
	Vtrace( DestroyCondVar, cvar->ltype, 0, 0, cvar, line, file );
	PR_DestroyCondVar( cvar->cvar );
	PR_DELETE( cvar );
	} /* --- end pz_DestroyCondVar() --- */

	extern PRStatus
	pz_WaitCondVar(
	PZCondVar *cvar,
	PRIntervalTime timeout,
	char *file,
	PRIntn line
	)
	{
	PRStatus rc;
	PRIntervalTime callTime;

	callTime = PR_IntervalNow();
	rc = PR_WaitCondVar( cvar->cvar, timeout );
	callTime = PR_IntervalNow() - callTime;

	Vtrace( WaitCondVar, cvar->ltype, callTime, 0, cvar, line, file );
	return(rc);
	} /* --- end pz_WaitCondVar() --- */

	extern PRStatus
	pz_NotifyCondVar(
	PZCondVar *cvar,
	char *file,
	PRIntn line
	)
	{
	PRStatus rc;

	rc = PR_NotifyCondVar( cvar->cvar );

	Vtrace( NotifyCondVar, cvar->ltype, 0, 0, cvar, line, file );
	return(rc);
	} /* --- end pz_NotifyCondVar() --- */

	extern PRStatus
	pz_NotifyAllCondVar(
	PZCondVar *cvar,
	char *file,
	PRIntn line
	)
	{
	PRStatus rc;

	rc = PR_NotifyAllCondVar( cvar->cvar );

	Vtrace( NotifyAllCondVar, cvar->ltype, 0, 0, cvar, line, file );
	return(rc);
	} /* --- end pz_NotifyAllCondVar() --- */

	extern PZMonitor *
	pz_NewMonitor(
	nssILockType ltype,
	char *file,
	PRIntn line
	)
	{
	PRStatus rc;
	PZMonitor *mon;

	/* Self Initialize the nssILock feature */
	if (!nssILockInitialized) {
	rc = PR_CallOnce( &coNssILock, nssILockInit );
	if ( PR_FAILURE == rc ) {
	PR_SetError( PR_UNKNOWN_ERROR, 0 );
	return( NULL );
	}
	}

	mon = PR_NEWZAP( PZMonitor );
	if ( NULL != mon ) {
	mon->ltype = ltype;
	mon->mon = PR_NewMonitor();
	if ( NULL == mon->mon ) {
	PR_DELETE( mon );
	PORT_SetError(SEC_ERROR_NO_MEMORY);
	}
	} else {
	PORT_SetError(SEC_ERROR_NO_MEMORY);
	}

	Vtrace( NewMonitor, ltype, 0, 0, mon, line, file );
	return(mon);
	} /* --- end pz_NewMonitor() --- */

	extern void
	pz_DestroyMonitor(
	PZMonitor *mon,
	char *file,
	PRIntn line
	)
	{
	Vtrace( DestroyMonitor, mon->ltype, 0, 0, mon, line, file );
	PR_DestroyMonitor( mon->mon );
	PR_DELETE( mon );
	return;
	} /* --- end pz_DestroyMonitor() --- */

	extern void
	pz_EnterMonitor(
	PZMonitor *mon,
	char *file,
	PRIntn line
	)
	{
	PRIntervalTime callTime, now;

	callTime = PR_IntervalNow();
	PR_EnterMonitor( mon->mon );
	now = PR_IntervalNow();
	callTime = now - callTime;
	if ( PR_GetMonitorEntryCount(mon->mon) == 1 ) {
	mon->time = now;
	}
	Vtrace( EnterMonitor, mon->ltype, callTime, 0, mon, line, file );
	return;
	} /* --- end pz_EnterMonitor() --- */

	extern PRStatus
	pz_ExitMonitor(
	PZMonitor *mon,
	char *file,
	PRIntn line
	)
	{
	PRStatus rc;
	PRIntervalTime callTime, now, heldTime;
	PRIntn mec = PR_GetMonitorEntryCount( mon->mon );

	heldTime = (PRIntervalTime)-1;
	callTime = PR_IntervalNow();
	rc = PR_ExitMonitor( mon->mon );
	now = PR_IntervalNow();
	callTime = now - callTime;
	if ( mec == 1 )
	heldTime = now - mon->time;
	Vtrace( ExitMonitor, mon->ltype, callTime, heldTime, mon, line, file );
	return( rc );
	} /* --- end pz_ExitMonitor() --- */

	extern PRIntn
	pz_GetMonitorEntryCount(
	PZMonitor *mon,
	char *file,
	PRIntn line
	)
	{
	return( PR_GetMonitorEntryCount(mon->mon));
	} /* --- end pz_GetMonitorEntryCount() --- */


	extern PRStatus
	pz_Wait(
	PZMonitor *mon,
	PRIntervalTime ticks,
	char *file,
	PRIntn line
	)
	{
	PRStatus rc;
	PRIntervalTime callTime;

	callTime = PR_IntervalNow();
	rc = PR_Wait( mon->mon, ticks );
	callTime = PR_IntervalNow() - callTime;
	Vtrace( Wait, mon->ltype, callTime, 0, mon, line, file );
	return( rc );
	} /* --- end pz_Wait() --- */

	extern PRStatus
	pz_Notify(
	PZMonitor *mon,
	char *file,
	PRIntn line
	)
	{
	PRStatus rc;
	PRIntervalTime callTime;

	callTime = PR_IntervalNow();
	rc = PR_Notify( mon->mon );
	callTime = PR_IntervalNow() - callTime;
	Vtrace( Notify, mon->ltype, callTime, 0, mon, line, file );
	return( rc );
	} /* --- end pz_Notify() --- */

	extern PRStatus
	pz_NotifyAll(
	PZMonitor *mon,
	char *file,
	PRIntn line
	)
	{
	PRStatus rc;
	PRIntervalTime callTime;

	callTime = PR_IntervalNow();
	rc = PR_NotifyAll( mon->mon );
	callTime = PR_IntervalNow() - callTime;
	Vtrace( NotifyAll, mon->ltype, callTime, 0, mon, line, file );
	return( rc );
	} /* --- end pz_NotifyAll() --- */

	#endif /* NEED_NSS_ILOCK */
	/* --- end nssilock.c --------------------------------- */