tor-browser

prtrace.c (21720B)

---

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

 /* Get the filename for the logfile from the environment */
 logFileName = PR_GetEnvSecure("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 */