path: root/lib/util/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 --------------------------------- */