The Tor Browser: nsprpub/pr/src/misc/prtrace.c@6474c204b198 (annotated)

nsprpub/pr/src/misc/prtrace.c@6474c204b198 (annotated)

nsprpub/pr/src/misc/prtrace.c

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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/. */
 /*
 ** prtrace.c -- NSPR Trace Instrumentation
 **
 ** Implement the API defined in prtrace.h
 **
 **
 **
 */
 #include <string.h>
 #include "primpl.h"
 #define DEFAULT_TRACE_BUFSIZE ( 1024 * 1024 )
 #define DEFAULT_BUFFER_SEGMENTS    2
 /*
 ** Enumerate states in a RName structure
 */
 typedef enum TraceState
 {
     Running = 1,
     Suspended = 2
 } TraceState;
 /*
 ** Define QName structure
 */
 typedef struct QName
 {
     PRCList link;
     PRCList rNameList;
     char    name[PRTRACE_NAME_MAX+1];
 } QName;
 /*
 ** Define RName structure
 */
 typedef struct RName
 {
     PRCList link;
     PRLock  *lock;
     QName   *qName;
     TraceState state;
     char    name[PRTRACE_NAME_MAX+1];
     char    desc[PRTRACE_DESC_MAX+1];
 } RName;
 /*
 ** The Trace Facility database
 **
 */
 static PRLogModuleInfo *lm;
 static PRLock      *traceLock;      /* Facility Lock */
 static PRCList     qNameList;       /* anchor to all QName structures */
 static TraceState traceState = Running;
 /*
 ** in-memory trace buffer controls
 */
 static  PRTraceEntry    *tBuf;      /* pointer to buffer */
 static  PRInt32         bufSize;    /* size of buffer, in bytes, rounded up to sizeof(PRTraceEntry) */
 static  volatile PRInt32  next;     /* index to next PRTraceEntry */
 static  PRInt32         last;       /* index of highest numbered trace entry */
 /*
 ** Real-time buffer capture controls
 */
 static PRInt32 fetchLastSeen = 0;
 static PRBool  fetchLostData = PR_FALSE;
 /*
 ** Buffer write-to-file controls
 */
 static  PRLock      *logLock;               /* Sync lock */
 static  PRCondVar   *logCVar;               /* Sync Condidtion Variable */
 /*
 ** Inter-thread state communication.
 ** Controling thread writes to logOrder under protection of logCVar
 ** the logging thread reads logOrder and sets logState on Notify.
 **
 ** logSegments, logCount, logLostData must be read and written under
 ** protection of logLock, logCVar.
 **
 */
 static  enum LogState
 {
     LogNotRunning,  /* Initial state */
     LogReset,       /* Causes logger to re-calc controls */
     LogActive,      /* Logging in progress, set only by log thread */
     LogSuspend,     /* Suspend Logging */
     LogResume,      /* Resume Logging => LogActive */
     LogStop         /* Stop the log thread */
 }   logOrder, logState, localState;         /* controlling state variables */
 static  PRInt32     logSegments;            /* Number of buffer segments */
 static  PRInt32     logEntries;             /* number of Trace Entries in the buffer */
 static  PRInt32     logEntriesPerSegment;   /* number of PRTraceEntries per buffer segment */
 static  PRInt32     logSegSize;             /* size of buffer segment */
 static  PRInt32     logCount;               /* number of segments pending output */
 static  PRInt32     logLostData;            /* number of lost log buffer segments */
 /*
 ** end Trace Database
 **
 */
 /*
 ** _PR_InitializeTrace() -- Initialize the trace facility
 */
 static void NewTraceBuffer( PRInt32 size )
 {
     /*
     ** calculate the size of the buffer
     ** round down so that each segment has the same number of
     ** trace entries
     */
     logSegments = DEFAULT_BUFFER_SEGMENTS;
     logEntries = size / sizeof(PRTraceEntry);
     logEntriesPerSegment = logEntries / logSegments;
     logEntries = logSegments * logEntriesPerSegment;
     bufSize = logEntries * sizeof(PRTraceEntry);
     logSegSize = logEntriesPerSegment * sizeof(PRTraceEntry);
     PR_ASSERT( bufSize != 0);
     PR_LOG( lm, PR_LOG_ERROR,
         ("NewTraceBuffer: logSegments: %ld, logEntries: %ld, logEntriesPerSegment: %ld, logSegSize: %ld",
             logSegments, logEntries, logEntriesPerSegment, logSegSize ));
     tBuf = PR_Malloc( bufSize );
     if ( tBuf == NULL )
     {
         PR_LOG( lm, PR_LOG_ERROR,
             ("PRTrace: Failed to get trace buffer"));
         PR_ASSERT( 0 );
     }
     else
     {
         PR_LOG( lm, PR_LOG_NOTICE,
             ("PRTrace: Got trace buffer of size: %ld, at %p", bufSize, tBuf));
     }
     next = 0;
     last = logEntries -1;
     logCount = 0;
     logLostData = PR_TRUE; /* not really on first call */
     logOrder = LogReset;
 } /* end NewTraceBuffer() */
 /*
 ** _PR_InitializeTrace() -- Initialize the trace facility
 */
 static void _PR_InitializeTrace( void )
 {
     /* The lock pointer better be null on this call */
     PR_ASSERT( traceLock == NULL );
     traceLock = PR_NewLock();
     PR_ASSERT( traceLock != NULL );
     PR_Lock( traceLock );
     PR_INIT_CLIST( &qNameList );
     lm = PR_NewLogModule("trace");
     bufSize = DEFAULT_TRACE_BUFSIZE;
     NewTraceBuffer( bufSize );
     /* Initialize logging controls */
     logLock = PR_NewLock();
     logCVar = PR_NewCondVar( logLock );
     PR_Unlock( traceLock );
     return;
 } /* end _PR_InitializeTrace() */
 /*
 ** Create a Trace Handle
 */
 PR_IMPLEMENT(PRTraceHandle)
 	PR_CreateTrace(
     	const char *qName,          /* QName for this trace handle */
 	    const char *rName,          /* RName for this trace handle */
 	    const char *description     /* description for this trace handle */
 )
 {
     QName   *qnp;
     RName   *rnp;
     PRBool  matchQname = PR_FALSE;
     /* Self initialize, if necessary */
     if ( traceLock == NULL )
         _PR_InitializeTrace();
     /* Validate input arguments */
     PR_ASSERT( strlen(qName) <= PRTRACE_NAME_MAX );
     PR_ASSERT( strlen(rName) <= PRTRACE_NAME_MAX );
     PR_ASSERT( strlen(description) <= PRTRACE_DESC_MAX );
     PR_LOG( lm, PR_LOG_DEBUG,
             ("PRTRACE: CreateTrace: Qname: %s, RName: %s", qName, rName));
     /* Lock the Facility */
     PR_Lock( traceLock );
     /* Do we already have a matching QName? */
     if (!PR_CLIST_IS_EMPTY( &qNameList ))
     {
         qnp = (QName *) PR_LIST_HEAD( &qNameList );
         do {
             if ( strcmp(qnp->name, qName) == 0)
             {
                 matchQname = PR_TRUE;
                 break;
             }
             qnp = (QName *)PR_NEXT_LINK( &qnp->link );
         } while( qnp != (QName *)&qNameList );
     }
     /*
     ** If we did not find a matching QName,
     **    allocate one and initialize it.
     **    link it onto the qNameList.
     **
     */
     if ( matchQname != PR_TRUE )
     {
         qnp = PR_NEWZAP( QName );
         PR_ASSERT( qnp != NULL );
         PR_INIT_CLIST( &qnp->link );
         PR_INIT_CLIST( &qnp->rNameList );
         strcpy( qnp->name, qName );
         PR_APPEND_LINK( &qnp->link, &qNameList );
     }
     /* Do we already have a matching RName? */
     if (!PR_CLIST_IS_EMPTY( &qnp->rNameList ))
     {
         rnp = (RName *) PR_LIST_HEAD( &qnp->rNameList );
         do {
             /*
             ** No duplicate RNames are allowed within a QName
             **
             */
             PR_ASSERT( strcmp(rnp->name, rName));
             rnp = (RName *)PR_NEXT_LINK( &rnp->link );
         } while( rnp != (RName *)&qnp->rNameList );
     }
     /* Get a new RName structure; initialize its members */
     rnp = PR_NEWZAP( RName );
     PR_ASSERT( rnp != NULL );
     PR_INIT_CLIST( &rnp->link );
     strcpy( rnp->name, rName );
     strcpy( rnp->desc, description );
     rnp->lock = PR_NewLock();
     rnp->state = Running;
     if ( rnp->lock == NULL )
     {
         PR_ASSERT(0);
     }
     PR_APPEND_LINK( &rnp->link, &qnp->rNameList ); /* add RName to QName's rnList */
     rnp->qName = qnp;                       /* point the RName to the QName */
     /* Unlock the Facility */
     PR_Unlock( traceLock );
     PR_LOG( lm, PR_LOG_DEBUG, ("PRTrace: Create: QName: %s %p, RName: %s %p\n\t",
         qName, qnp, rName, rnp ));
     return((PRTraceHandle)rnp);
 } /* end  PR_CreateTrace() */
 /*
 **
 */
 PR_IMPLEMENT(void)
 	PR_DestroyTrace(
 		PRTraceHandle handle    /* Handle to be destroyed */
 )
 {
     RName   *rnp = (RName *)handle;
     QName   *qnp = rnp->qName;
     PR_LOG( lm, PR_LOG_DEBUG, ("PRTrace: Deleting: QName: %s, RName: %s",
         qnp->name, rnp->name));
     /* Lock the Facility */
     PR_Lock( traceLock );
     /*
     ** Remove RName from the list of RNames in QName
     ** and free RName
     */
     PR_LOG( lm, PR_LOG_DEBUG, ("PRTrace: Deleting RName: %s, %p",
         rnp->name, rnp));
     PR_REMOVE_LINK( &rnp->link );
     PR_Free( rnp->lock );
     PR_DELETE( rnp );
     /*
     ** If this is the last RName within QName
     **   remove QName from the qNameList and free it
     */
     if ( PR_CLIST_IS_EMPTY( &qnp->rNameList ) )
     {
         PR_LOG( lm, PR_LOG_DEBUG, ("PRTrace: Deleting unused QName: %s, %p",
             qnp->name, qnp));
         PR_REMOVE_LINK( &qnp->link );
         PR_DELETE( qnp );
     }
     /* Unlock the Facility */
     PR_Unlock( traceLock );
     return;
 } /* end PR_DestroyTrace()  */
 /*
 ** Create a TraceEntry in the trace buffer
 */
 PR_IMPLEMENT(void)
 	PR_Trace(
     	PRTraceHandle handle,       /* use this trace handle */
 	    PRUint32    userData0,      /* User supplied data word 0 */
 	    PRUint32    userData1,      /* User supplied data word 1 */
 	    PRUint32    userData2,      /* User supplied data word 2 */
 	    PRUint32    userData3,      /* User supplied data word 3 */
 	    PRUint32    userData4,      /* User supplied data word 4 */
 	    PRUint32    userData5,      /* User supplied data word 5 */
 	    PRUint32    userData6,      /* User supplied data word 6 */
 	    PRUint32    userData7       /* User supplied data word 7 */
 )
 {
     PRTraceEntry   *tep;
     PRInt32         mark;
     if ( (traceState == Suspended )
         || ( ((RName *)handle)->state == Suspended ))
         return;
     /*
     ** Get the next trace entry slot w/ minimum delay
     */
     PR_Lock( traceLock );
     tep = &tBuf[next++];
     if ( next > last )
         next = 0;
     if ( fetchLostData == PR_FALSE && next == fetchLastSeen )
         fetchLostData = PR_TRUE;
     mark = next;
     PR_Unlock( traceLock );
     /*
     ** We have a trace entry. Fill it in.
     */
     tep->thread = PR_GetCurrentThread();
     tep->handle = handle;
     tep->time   = PR_Now();
     tep->userData[0] = userData0;
     tep->userData[1] = userData1;
     tep->userData[2] = userData2;
     tep->userData[3] = userData3;
     tep->userData[4] = userData4;
     tep->userData[5] = userData5;
     tep->userData[6] = userData6;
     tep->userData[7] = userData7;
     /* When buffer segment is full, signal trace log thread to run */
     if (( mark % logEntriesPerSegment) == 0 )
     {
         PR_Lock( logLock );
         logCount++;
         PR_NotifyCondVar( logCVar );
         PR_Unlock( logLock );
         /*
         ** Gh0D! This is awful!
         ** Anyway, to minimize lost trace data segments,
         ** I inserted the PR_Sleep(0) to cause a context switch
         ** so that the log thread could run.
         ** I know, it perturbs the universe and may cause
         ** funny things to happen in the optimized builds.
         ** Take it out, lose data; leave it in risk Heisenberg.
         */
         /* PR_Sleep(0); */
     }
     return;
 } /* end PR_Trace() */
 /*
 **
 */
 PR_IMPLEMENT(void)
 	PR_SetTraceOption(
 	    PRTraceOption command,  /* One of the enumerated values */
 	    void *value             /* command value or NULL */
 )
 {
     RName * rnp;
     switch ( command )
     {
         case PRTraceBufSize :
             PR_Lock( traceLock );
             PR_Free( tBuf );
             bufSize = *(PRInt32 *)value;
             NewTraceBuffer( bufSize );
             PR_Unlock( traceLock );
             PR_LOG( lm, PR_LOG_DEBUG,
                 ("PRSetTraceOption: PRTraceBufSize: %ld", bufSize));
             break;
         case PRTraceEnable :
             rnp = *(RName **)value;
             rnp->state = Running;
             PR_LOG( lm, PR_LOG_DEBUG,
                 ("PRSetTraceOption: PRTraceEnable: %p", rnp));
             break;
         case PRTraceDisable :
             rnp = *(RName **)value;
             rnp->state = Suspended;
             PR_LOG( lm, PR_LOG_DEBUG,
                 ("PRSetTraceOption: PRTraceDisable: %p", rnp));
             break;
         case PRTraceSuspend :
             traceState = Suspended;
             PR_LOG( lm, PR_LOG_DEBUG,
                 ("PRSetTraceOption: PRTraceSuspend"));
             break;
         case PRTraceResume :
             traceState = Running;
             PR_LOG( lm, PR_LOG_DEBUG,
                 ("PRSetTraceOption: PRTraceResume"));
             break;
         case PRTraceSuspendRecording :
             PR_Lock( logLock );
             logOrder = LogSuspend;
             PR_NotifyCondVar( logCVar );
             PR_Unlock( logLock );
             PR_LOG( lm, PR_LOG_DEBUG,
                 ("PRSetTraceOption: PRTraceSuspendRecording"));
             break;
         case PRTraceResumeRecording :
             PR_LOG( lm, PR_LOG_DEBUG,
                 ("PRSetTraceOption: PRTraceResumeRecording"));
             if ( logState != LogSuspend )
                 break;
             PR_Lock( logLock );
             logOrder = LogResume;
             PR_NotifyCondVar( logCVar );
             PR_Unlock( logLock );
             break;
         case PRTraceStopRecording :
             PR_Lock( logLock );
             logOrder = LogStop;
             PR_NotifyCondVar( logCVar );
             PR_Unlock( logLock );
             PR_LOG( lm, PR_LOG_DEBUG,
                 ("PRSetTraceOption: PRTraceStopRecording"));
             break;
         case PRTraceLockHandles :
             PR_LOG( lm, PR_LOG_DEBUG,
                 ("PRSetTraceOption: PRTraceLockTraceHandles"));
             PR_Lock( traceLock );
             break;
         case PRTraceUnLockHandles :
             PR_LOG( lm, PR_LOG_DEBUG,
                 ("PRSetTraceOption: PRTraceUnLockHandles"));
             PR_Unlock( traceLock );
             break;
         default:
             PR_LOG( lm, PR_LOG_ERROR,
                 ("PRSetTraceOption: Invalid command %ld", command ));
             PR_ASSERT( 0 );
             break;
     } /* end switch() */
     return;
 } /* end  PR_SetTraceOption() */
 /*
 **
 */
 PR_IMPLEMENT(void)
 	PR_GetTraceOption(
     	PRTraceOption command,  /* One of the enumerated values */
 	    void *value             /* command value or NULL */
 )
 {
     switch ( command )
     {
         case PRTraceBufSize :
             *((PRInt32 *)value) = bufSize;
             PR_LOG( lm, PR_LOG_DEBUG,
                 ("PRGetTraceOption: PRTraceBufSize: %ld", bufSize ));
             break;
         default:
             PR_LOG( lm, PR_LOG_ERROR,
                 ("PRGetTraceOption: Invalid command %ld", command ));
             PR_ASSERT( 0 );
             break;
     } /* end switch() */
     return;
 } /* end PR_GetTraceOption() */
 /*
 **
 */
 PR_IMPLEMENT(PRTraceHandle)
 	PR_GetTraceHandleFromName(
     	const char *qName,      /* QName search argument */
         const char *rName       /* RName search argument */
 )
 {
     const char    *qn, *rn, *desc;
     PRTraceHandle     qh, rh = NULL;
     RName   *rnp = NULL;
     PR_LOG( lm, PR_LOG_DEBUG, ("PRTrace: GetTraceHandleFromName:\n\t"
         "QName: %s, RName: %s", qName, rName ));
     qh = PR_FindNextTraceQname( NULL );
     while (qh != NULL)
     {
         rh = PR_FindNextTraceRname( NULL, qh );
         while ( rh != NULL )
         {
             PR_GetTraceNameFromHandle( rh, &qn, &rn, &desc );
             if ( (strcmp( qName, qn ) == 0)
                 && (strcmp( rName, rn ) == 0 ))
             {
                 rnp = (RName *)rh;
                 goto foundIt;
             }
             rh = PR_FindNextTraceRname( rh, qh );
         }
         qh = PR_FindNextTraceQname( NULL );
     }
 foundIt:
     PR_LOG( lm, PR_LOG_DEBUG, ("PR_Counter: GetConterHandleFromName: %p", rnp ));
     return(rh);
 } /* end PR_GetTraceHandleFromName() */
 /*
 **
 */
 PR_IMPLEMENT(void)
 	PR_GetTraceNameFromHandle(
     	PRTraceHandle handle,       /* handle as search argument */
 	    const char **qName,         /* pointer to associated QName */
 	    const char **rName,         /* pointer to associated RName */
     	const char **description    /* pointer to associated description */
 )
 {
     RName   *rnp = (RName *)handle;
     QName   *qnp = rnp->qName;
     *qName = qnp->name;
     *rName = rnp->name;
     *description = rnp->desc;
     PR_LOG( lm, PR_LOG_DEBUG, ("PRTrace: GetConterNameFromHandle: "
         "QNp: %p, RNp: %p,\n\tQName: %s, RName: %s, Desc: %s",
         qnp, rnp, qnp->name, rnp->name, rnp->desc ));
     return;
 } /* end PR_GetTraceNameFromHandle() */
 /*
 **
 */
 PR_IMPLEMENT(PRTraceHandle)
 	PR_FindNextTraceQname(
         PRTraceHandle handle
 )
 {
     QName *qnp = (QName *)handle;
     if ( PR_CLIST_IS_EMPTY( &qNameList ))
             qnp = NULL;
     else if ( qnp == NULL )
         qnp = (QName *)PR_LIST_HEAD( &qNameList );
     else if ( PR_NEXT_LINK( &qnp->link ) ==  &qNameList )
         qnp = NULL;
     else
         qnp = (QName *)PR_NEXT_LINK( &qnp->link );
     PR_LOG( lm, PR_LOG_DEBUG, ("PRTrace: FindNextQname: Handle: %p, Returns: %p",
         handle, qnp ));
     return((PRTraceHandle)qnp);
 } /* end PR_FindNextTraceQname() */
 /*
 **
 */
 PR_IMPLEMENT(PRTraceHandle)
 	PR_FindNextTraceRname(
         PRTraceHandle rhandle,
         PRTraceHandle qhandle
 )
 {
     RName *rnp = (RName *)rhandle;
     QName *qnp = (QName *)qhandle;
     if ( PR_CLIST_IS_EMPTY( &qnp->rNameList ))
         rnp = NULL;
     else if ( rnp == NULL )
         rnp = (RName *)PR_LIST_HEAD( &qnp->rNameList );
     else if ( PR_NEXT_LINK( &rnp->link ) ==  &qnp->rNameList )
         rnp = NULL;
     else
         rnp = (RName *)PR_NEXT_LINK( &rnp->link );
     PR_LOG( lm, PR_LOG_DEBUG, ("PRTrace: FindNextRname: Rhandle: %p, QHandle: %p, Returns: %p",
         rhandle, qhandle, rnp ));
     return((PRTraceHandle)rnp);
 } /* end PR_FindNextTraceRname() */
 /*
 **
 */
 static PRFileDesc * InitializeRecording( void )
 {
     char    *logFileName;
     PRFileDesc  *logFile;
     /* Self initialize, if necessary */
     if ( traceLock == NULL )
         _PR_InitializeTrace();
     PR_LOG( lm, PR_LOG_DEBUG,
         ("PR_RecordTraceEntries: begins"));
     logLostData = 0; /* reset at entry */
     logState = LogReset;
 #ifdef XP_UNIX
     if ((getuid() != geteuid()) || (getgid() != getegid())) {
         return NULL;
     }
 #endif /* XP_UNIX */
     /* Get the filename for the logfile from the environment */
     logFileName = PR_GetEnv( "NSPR_TRACE_LOG" );
     if ( logFileName == NULL )
     {
         PR_LOG( lm, PR_LOG_ERROR,
             ("RecordTraceEntries: Environment variable not defined. Exiting"));
         return NULL;
     }
     /* Open the logfile */
     logFile = PR_Open( logFileName, PR_WRONLY | PR_CREATE_FILE, 0666 );
     if ( logFile == NULL )
     {
         PR_LOG( lm, PR_LOG_ERROR,
             ("RecordTraceEntries: Cannot open %s as trace log file. OS error: %ld",
 		logFileName, PR_GetOSError()));
         return NULL;
     }
     return logFile;
 } /* end InitializeRecording() */
 /*
 **
 */
 static void ProcessOrders( void )
 {
     switch ( logOrder )
     {
     case LogReset :
         logOrder = logState = localState;
         PR_LOG( lm, PR_LOG_DEBUG,
             ("RecordTraceEntries: LogReset"));
         break;
     case LogSuspend :
         localState = logOrder = logState = LogSuspend;
         PR_LOG( lm, PR_LOG_DEBUG,
             ("RecordTraceEntries: LogSuspend"));
         break;
     case LogResume :
         localState = logOrder = logState = LogActive;
         PR_LOG( lm, PR_LOG_DEBUG,
             ("RecordTraceEntries: LogResume"));
         break;
     case LogStop :
         logOrder = logState = LogStop;
         PR_LOG( lm, PR_LOG_DEBUG,
             ("RecordTraceEntries: LogStop"));
         break;
     default :
         PR_LOG( lm, PR_LOG_ERROR,
             ("RecordTraceEntries: Invalid logOrder: %ld", logOrder ));
         PR_ASSERT( 0 );
         break;
     } /* end switch() */
     return ;
 } /* end ProcessOrders() */
 /*
 **
 */
 static void WriteTraceSegment( PRFileDesc *logFile, void *buf, PRInt32 amount )
 {
     PRInt32 rc;
     PR_LOG( lm, PR_LOG_ERROR,
         ("WriteTraceSegment: Buffer: %p, Amount: %ld", buf, amount));
     rc = PR_Write( logFile, buf , amount );
     if ( rc == -1 )
         PR_LOG( lm, PR_LOG_ERROR,
             ("RecordTraceEntries: PR_Write() failed. Error: %ld", PR_GetError() ));
     else if ( rc != amount )
         PR_LOG( lm, PR_LOG_ERROR,
             ("RecordTraceEntries: PR_Write() Tried to write: %ld, Wrote: %ld", amount, rc));
     else
         PR_LOG( lm, PR_LOG_DEBUG,
             ("RecordTraceEntries: PR_Write(): Buffer: %p, bytes: %ld", buf, amount));
     return;
 } /* end WriteTraceSegment() */
 /*
 **
 */
 PR_IMPLEMENT(void)
 	PR_RecordTraceEntries(
         void
 )
 {
     PRFileDesc  *logFile;
     PRInt32     lostSegments;
     PRInt32     currentSegment = 0;
     void        *buf;
     PRBool      doWrite;
     logFile = InitializeRecording();
     if ( logFile == NULL )
     {
         PR_LOG( lm, PR_LOG_DEBUG,
             ("PR_RecordTraceEntries: Failed to initialize"));
         return;
     }
     /* Do this until told to stop */
     while ( logState != LogStop )
     {
         PR_Lock( logLock );
         while ( (logCount == 0) && ( logOrder == logState ) )
             PR_WaitCondVar( logCVar, PR_INTERVAL_NO_TIMEOUT );
         /* Handle state transitions */
         if ( logOrder != logState )
             ProcessOrders();
         /* recalculate local controls */
         if ( logCount )
         {
             lostSegments = logCount - logSegments;
             if ( lostSegments > 0 )
             {
                 logLostData += ( logCount - logSegments );
                 logCount = (logCount % logSegments);
                 currentSegment = logCount;
                 PR_LOG( lm, PR_LOG_DEBUG,
                     ("PR_RecordTraceEntries: LostData segments: %ld", logLostData));
             }
             else
             {
                 logCount--;
             }
             buf = tBuf + ( logEntriesPerSegment * currentSegment );
             if (++currentSegment >= logSegments )
                 currentSegment = 0;
             doWrite = PR_TRUE;
         }
         else
             doWrite = PR_FALSE;
         PR_Unlock( logLock );
         if ( doWrite == PR_TRUE )
         {
             if ( localState != LogSuspend )
                 WriteTraceSegment( logFile, buf, logSegSize );
             else
                 PR_LOG( lm, PR_LOG_DEBUG,
                     ("RecordTraceEntries: PR_Write(): is suspended" ));
         }
     } /* end while(logState...) */
     PR_Close( logFile );
     PR_LOG( lm, PR_LOG_DEBUG,
         ("RecordTraceEntries: exiting"));
     return;
 } /* end  PR_RecordTraceEntries() */
 /*
 **
 */
 PR_IMPLEMENT(PRIntn)
     PR_GetTraceEntries(
         PRTraceEntry    *buffer,    /* where to write output */
         PRInt32         count,      /* number to get */
         PRInt32         *found      /* number you got */
 )
 {
     PRInt32 rc;
     PRInt32 copied = 0;
     PR_Lock( traceLock );
     /*
     ** Depending on where the LastSeen and Next indices are,
     ** copy the trace buffer in one or two pieces.
     */
     PR_LOG( lm, PR_LOG_ERROR,
         ("PR_GetTraceEntries: Next: %ld, LastSeen: %ld", next, fetchLastSeen));
     if ( fetchLastSeen <= next )
     {
         while (( count-- > 0 ) && (fetchLastSeen < next ))
         {
             *(buffer + copied++) = *(tBuf + fetchLastSeen++);
         }
         PR_LOG( lm, PR_LOG_ERROR,
             ("PR_GetTraceEntries: Copied: %ld, LastSeen: %ld", copied, fetchLastSeen));
     }
     else /* copy in 2 parts */
     {
         while ( count-- > 0  && fetchLastSeen <= last )
         {
             *(buffer + copied++) = *(tBuf + fetchLastSeen++);
         }
         fetchLastSeen = 0;
         PR_LOG( lm, PR_LOG_ERROR,
             ("PR_GetTraceEntries: Copied: %ld, LastSeen: %ld", copied, fetchLastSeen));
         while ( count-- > 0  && fetchLastSeen < next )
         {
             *(buffer + copied++) = *(tBuf + fetchLastSeen++);
         }
         PR_LOG( lm, PR_LOG_ERROR,
             ("PR_GetTraceEntries: Copied: %ld, LastSeen: %ld", copied, fetchLastSeen));
     }
     *found = copied;
     rc = ( fetchLostData == PR_TRUE )? 1 : 0;
     fetchLostData = PR_FALSE;
     PR_Unlock( traceLock );
     return rc;
 } /* end PR_GetTraceEntries() */
 /* end prtrace.c */

The Tor Browser / annotate

nsprpub/pr/src/misc/prtrace.c@6474c204b198 (annotated)

nsprpub/pr/src/misc/prtrace.c