firefox-dev 11.0+build1-0ubuntu4 / usr / include / firefox / nssilock.h

/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is the Netscape security libraries.
 *
 * The Initial Developer of the Original Code is
 * Netscape Communications Corporation.
 * Portions created by the Initial Developer are Copyright (C) 1994-2000
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/*
** nssilock.h - Instrumented locking functions for NSS
**
** Description:
**    nssilock provides instrumentation for locks and monitors in
**    the NSS libraries. The instrumentation, when enabled, causes
**    each call to the instrumented function to record data about
**    the call to an external file. The external file
**    subsequently used to extract performance data and other
**    statistical information about the operation of locks used in
**    the nss library.
**     
**    To enable compilation with instrumentation, build NSS with 
**    the compile time switch NEED_NSS_ILOCK defined.
**
**    say:  "gmake OS_CFLAGS+=-DNEED_NSS_ILOCK" at make time.
**
**    At runtime, to enable recording from nssilock, one or more
**    environment variables must be set. For each nssILockType to
**    be recorded, an environment variable of the form NSS_ILOCK_x
**    must be set to 1. For example:
**
**       set NSS_ILOCK_Cert=1
**
**    nssilock uses PRLOG is used to record to trace data. The
**    PRLogModule name associated with nssilock data is: "nssilock".
**    To enable recording of nssilock data you will need to set the
**    environment variable NSPR_LOG_MODULES to enable
**    recording for the nssilock log module. Similarly, you will
**    need to set the environment variable NSPR_LOG_FILE to specify
**    the filename to receive the recorded data. See prlog.h for usage.
**    Example:
**
**        export NSPR_LOG_MODULES=nssilock:6
**        export NSPR_LOG_FILE=xxxLogfile
**
** Operation:
**    nssilock wraps calls to NSPR's PZLock and PZMonitor functions
**    with similarly named functions: PZ_NewLock(), etc. When NSS is
**    built with lock instrumentation enabled, the PZ* functions are
**    compiled into NSS; when lock instrumentation is disabled,
**    calls to PZ* functions are directly mapped to PR* functions
**    and the instrumentation arguments to the PZ* functions are
**    compiled away.
**
**
** File Format:
**    The format of the external file is implementation
**    dependent. Where NSPR's PR_LOG() function is used, the file
**    contains data defined for PR_LOG() plus the data written by
**    the wrapped function. On some platforms and under some
**    circumstances, platform dependent logging or
**    instrumentation probes may be used. In any case, the
**    relevant data provided by the lock instrumentation is:
**    
**      lockType, func, address, duration, line, file [heldTime]
** 
**    where:
**    
**       lockType: a character representation of nssILockType for the
**       call. e.g. ... "cert"
**    
**       func: the function doing the tracing. e.g. "NewLock"
**    
**       address: address of the instrumented lock or monitor
**    
**       duration: is how long was spent in the instrumented function,
**       in PRIntervalTime "ticks".
**    
**       line: the line number within the calling function
**    
**       file: the file from which the call was made
**    
**       heldTime: how long the lock/monitor was held. field
**       present only for PZ_Unlock() and PZ_ExitMonitor().
**    
** Design Notes:
**    The design for lock instrumentation was influenced by the
**    need to gather performance data on NSS 3.x. It is intended
**    that the effort to modify NSS to use lock instrumentation
**    be minimized. Existing calls to locking functions need only
**    have their names changed to the instrumentation function
**    names.
**    
** Private NSS Interface:
**    nssilock.h defines a private interface for use by NSS.
**    nssilock.h is experimental in nature and is subject to
**    change or revocation without notice. ... Don't mess with
**    it.
**    
*/

/*
 * $Id:
 */

#ifndef _NSSILOCK_H_
#define _NSSILOCK_H_

#include "utilrename.h"
#include "prtypes.h"
#include "prmon.h"
#include "prlock.h"
#include "prcvar.h"

#include "nssilckt.h"

PR_BEGIN_EXTERN_C

#if defined(NEED_NSS_ILOCK)

#define PZ_NewLock(t) pz_NewLock((t),__FILE__,__LINE__)
extern PZLock * 
    pz_NewLock(
        nssILockType ltype,
        char *file,
        PRIntn  line
    );

#define PZ_Lock(k)  pz_Lock((k),__FILE__,__LINE__)
extern void
    pz_Lock(
        PZLock *lock,
        char *file,
        PRIntn line
    );

#define PZ_Unlock(k) pz_Unlock((k),__FILE__,__LINE__)
extern PRStatus
    pz_Unlock(
        PZLock *lock,
        char *file,
        PRIntn line
    );

#define PZ_DestroyLock(k) pz_DestroyLock((k),__FILE__,__LINE__)
extern void
    pz_DestroyLock(
        PZLock *lock,
        char *file,
        PRIntn line
    );


#define PZ_NewCondVar(l)        pz_NewCondVar((l),__FILE__,__LINE__)
extern PZCondVar *
    pz_NewCondVar(
        PZLock *lock,
        char *file,
        PRIntn line
    );

#define PZ_DestroyCondVar(v)    pz_DestroyCondVar((v),__FILE__,__LINE__)
extern void
    pz_DestroyCondVar(
        PZCondVar *cvar,
        char *file,
        PRIntn line
    );

#define PZ_WaitCondVar(v,t)       pz_WaitCondVar((v),(t),__FILE__,__LINE__)
extern PRStatus
    pz_WaitCondVar(
        PZCondVar *cvar,
        PRIntervalTime timeout,
        char *file,
        PRIntn line
    );

#define PZ_NotifyCondVar(v)     pz_NotifyCondVar((v),__FILE__,__LINE__)
extern PRStatus
    pz_NotifyCondVar(
        PZCondVar *cvar,
        char *file,
        PRIntn line
    );

#define PZ_NotifyAllCondVar(v)  pz_NotifyAllCondVar((v),__FILE__,__LINE__)
extern PRStatus
    pz_NotifyAllCondVar(
        PZCondVar *cvar,
        char *file,
        PRIntn line
    );


#define PZ_NewMonitor(t) pz_NewMonitor((t),__FILE__,__LINE__)
extern PZMonitor *
    pz_NewMonitor( 
        nssILockType ltype,
        char *file,
        PRIntn line
    );

#define PZ_DestroyMonitor(m) pz_DestroyMonitor((m),__FILE__,__LINE__)
extern void
    pz_DestroyMonitor(
        PZMonitor *mon,
        char *file,
        PRIntn line
    );

#define PZ_EnterMonitor(m) pz_EnterMonitor((m),__FILE__,__LINE__)
extern void
    pz_EnterMonitor(
        PZMonitor *mon,
        char *file,
        PRIntn line
    );


#define PZ_ExitMonitor(m) pz_ExitMonitor((m),__FILE__,__LINE__)
extern PRStatus
    pz_ExitMonitor(
        PZMonitor *mon,
        char *file,
        PRIntn line
    );

#define PZ_InMonitor(m)  (PZ_GetMonitorEntryCount(m) > 0 )
#define PZ_GetMonitorEntryCount(m) pz_GetMonitorEntryCount((m),__FILE__,__LINE__)
extern PRIntn
    pz_GetMonitorEntryCount(
        PZMonitor *mon,
        char *file,
        PRIntn line
    );

#define PZ_Wait(m,i) pz_Wait((m),((i)),__FILE__,__LINE__)
extern PRStatus
    pz_Wait(
        PZMonitor *mon,
        PRIntervalTime ticks,
        char *file,
        PRIntn line
    );

#define PZ_Notify(m) pz_Notify((m),__FILE__,__LINE__)
extern PRStatus
    pz_Notify(
        PZMonitor *mon,
        char *file,
        PRIntn line
    );

#define PZ_NotifyAll(m) pz_NotifyAll((m),__FILE__,__LINE__)
extern PRStatus
    pz_NotifyAll(
        PZMonitor *mon,
        char *file,
        PRIntn line
    );

#define PZ_TraceFlush() pz_TraceFlush()
extern void pz_TraceFlush( void );

#else /* NEED_NSS_ILOCK */

#define PZ_NewLock(t)           PR_NewLock()
#define PZ_DestroyLock(k)       PR_DestroyLock((k))
#define PZ_Lock(k)              PR_Lock((k))
#define PZ_Unlock(k)            PR_Unlock((k))

#define PZ_NewCondVar(l)        PR_NewCondVar((l))
#define PZ_DestroyCondVar(v)    PR_DestroyCondVar((v))
#define PZ_WaitCondVar(v,t)     PR_WaitCondVar((v),(t))
#define PZ_NotifyCondVar(v)     PR_NotifyCondVar((v))
#define PZ_NotifyAllCondVar(v)  PR_NotifyAllCondVar((v))

#define PZ_NewMonitor(t)        PR_NewMonitor()
#define PZ_DestroyMonitor(m)    PR_DestroyMonitor((m))
#define PZ_EnterMonitor(m)      PR_EnterMonitor((m))
#define PZ_ExitMonitor(m)       PR_ExitMonitor((m))
#define PZ_InMonitor(m)         PR_InMonitor((m))
#define PZ_Wait(m,t)            PR_Wait(((m)),((t)))
#define PZ_Notify(m)            PR_Notify((m))
#define PZ_NotifyAll(m)         PR_Notify((m))
#define PZ_TraceFlush()         /* nothing */

    
#endif /* NEED_NSS_ILOCK */

PR_END_EXTERN_C
#endif /* _NSSILOCK_H_ */