3106 lines
108 KiB
C
3106 lines
108 KiB
C
|
/*******************************************************************************
|
||
|
|
* Trace Recorder Library for Tracealyzer v4.1.5
|
||
|
|
* Percepio AB, www.percepio.com
|
||
|
|
*
|
||
|
|
* trcSnapshotRecorder.c
|
||
|
|
*
|
||
|
|
* The generic core of the trace recorder's snapshot mode.
|
||
|
|
*
|
||
|
|
* Terms of Use
|
||
|
|
* This file is part of the trace recorder library (RECORDER), which is the
|
||
|
|
* intellectual property of Percepio AB (PERCEPIO) and provided under a
|
||
|
|
* license as follows.
|
||
|
|
* The RECORDER may be used free of charge for the purpose of recording data
|
||
|
|
* intended for analysis in PERCEPIO products. It may not be used or modified
|
||
|
|
* for other purposes without explicit permission from PERCEPIO.
|
||
|
|
* You may distribute the RECORDER in its original source code form, assuming
|
||
|
|
* this text (terms of use, disclaimer, copyright notice) is unchanged. You are
|
||
|
|
* allowed to distribute the RECORDER with minor modifications intended for
|
||
|
|
* configuration or porting of the RECORDER, e.g., to allow using it on a
|
||
|
|
* specific processor, processor family or with a specific communication
|
||
|
|
* interface. Any such modifications should be documented directly below
|
||
|
|
* this comment block.
|
||
|
|
*
|
||
|
|
* Disclaimer
|
||
|
|
* The RECORDER is being delivered to you AS IS and PERCEPIO makes no warranty
|
||
|
|
* as to its use or performance. PERCEPIO does not and cannot warrant the
|
||
|
|
* performance or results you may obtain by using the RECORDER or documentation.
|
||
|
|
* PERCEPIO make no warranties, express or implied, as to noninfringement of
|
||
|
|
* third party rights, merchantability, or fitness for any particular purpose.
|
||
|
|
* In no event will PERCEPIO, its technology partners, or distributors be liable
|
||
|
|
* to you for any consequential, incidental or special damages, including any
|
||
|
|
* lost profits or lost savings, even if a representative of PERCEPIO has been
|
||
|
|
* advised of the possibility of such damages, or for any claim by any third
|
||
|
|
* party. Some jurisdictions do not allow the exclusion or limitation of
|
||
|
|
* incidental, consequential or special damages, or the exclusion of implied
|
||
|
|
* warranties or limitations on how long an implied warranty may last, so the
|
||
|
|
* above limitations may not apply to you.
|
||
|
|
*
|
||
|
|
* Tabs are used for indent in this file (1 tab = 4 spaces)
|
||
|
|
*
|
||
|
|
* Copyright Percepio AB, 2018.
|
||
|
|
* www.percepio.com
|
||
|
|
******************************************************************************/
|
||
|
|
|
||
|
|
#include "trcRecorder.h"
|
||
|
|
|
||
|
|
#if (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT)
|
||
|
|
|
||
|
|
#if (TRC_USE_TRACEALYZER_RECORDER == 1)
|
||
|
|
|
||
|
|
#include <string.h>
|
||
|
|
#include <stdarg.h>
|
||
|
|
#include <stdint.h>
|
||
|
|
|
||
|
|
#if ((TRC_HWTC_TYPE == TRC_CUSTOM_TIMER_INCR) || (TRC_HWTC_TYPE == TRC_CUSTOM_TIMER_DECR))
|
||
|
|
#error "CUSTOM timestamping mode is not (yet) supported in snapshot mode!"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* DO NOT CHANGE */
|
||
|
|
#define TRACE_MINOR_VERSION 5
|
||
|
|
#if (TRC_CFG_INCLUDE_ISR_TRACING == 1)
|
||
|
|
static traceHandle isrstack[TRC_CFG_MAX_ISR_NESTING];
|
||
|
|
int32_t isPendingContextSwitch = 0;
|
||
|
|
#endif /* (TRC_CFG_INCLUDE_ISR_TRACING == 1) */
|
||
|
|
|
||
|
|
#if !defined TRC_CFG_INCLUDE_READY_EVENTS || TRC_CFG_INCLUDE_READY_EVENTS == 1
|
||
|
|
static int readyEventsEnabled = 1;
|
||
|
|
#endif /*!defined TRC_CFG_INCLUDE_READY_EVENTS || TRC_CFG_INCLUDE_READY_EVENTS == 1*/
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* uiTraceTickCount
|
||
|
|
*
|
||
|
|
* This variable is should be updated by the Kernel tick interrupt. This does
|
||
|
|
* not need to be modified when developing a new timer port. It is preferred to
|
||
|
|
* keep any timer port changes in the HWTC macro definitions, which typically
|
||
|
|
* give sufficient flexibility.
|
||
|
|
******************************************************************************/
|
||
|
|
uint32_t uiTraceTickCount = 0;
|
||
|
|
|
||
|
|
uint32_t trace_disable_timestamp = 0;
|
||
|
|
|
||
|
|
static uint32_t last_timestamp = 0;
|
||
|
|
|
||
|
|
/* Flag that shows if inside a critical section of the recorder */
|
||
|
|
volatile int recorder_busy = 0;
|
||
|
|
|
||
|
|
/* Holds the value set by vTraceSetFrequency */
|
||
|
|
uint32_t timestampFrequency = 0;
|
||
|
|
|
||
|
|
/* The last error message of the recorder. NULL if no error message. */
|
||
|
|
const char* traceErrorMessage = NULL;
|
||
|
|
|
||
|
|
int8_t nISRactive = 0;
|
||
|
|
|
||
|
|
traceHandle handle_of_last_logged_task = 0;
|
||
|
|
|
||
|
|
/* Called when the recorder is stopped, set by vTraceSetStopHook. */
|
||
|
|
TRACE_STOP_HOOK vTraceStopHookPtr = (TRACE_STOP_HOOK)0;
|
||
|
|
|
||
|
|
uint16_t CurrentFilterMask = 0xFFFF;
|
||
|
|
|
||
|
|
uint16_t CurrentFilterGroup = FilterGroup0;
|
||
|
|
|
||
|
|
extern int8_t nISRactive;
|
||
|
|
|
||
|
|
extern traceHandle handle_of_last_logged_task;
|
||
|
|
|
||
|
|
/*************** Private Functions *******************************************/
|
||
|
|
static void prvStrncpy(char* dst, const char* src, uint32_t maxLength);
|
||
|
|
static uint8_t prvTraceGetObjectState(uint8_t objectclass, traceHandle id);
|
||
|
|
static void prvTraceGetChecksum(const char *pname, uint8_t* pcrc, uint8_t* plength);
|
||
|
|
static void* prvTraceNextFreeEventBufferSlot(void);
|
||
|
|
static uint16_t prvTraceGetDTS(uint16_t param_maxDTS);
|
||
|
|
static traceString prvTraceOpenSymbol(const char* name, traceString userEventChannel);
|
||
|
|
static void prvTraceUpdateCounters(void);
|
||
|
|
|
||
|
|
void vTraceStoreMemMangEvent(uint32_t ecode, uint32_t address, int32_t signed_size);
|
||
|
|
|
||
|
|
#if (TRC_CFG_SNAPSHOT_MODE == TRC_SNAPSHOT_MODE_RING_BUFFER)
|
||
|
|
static void prvCheckDataToBeOverwrittenForMultiEntryEvents(uint8_t nEntries);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
static traceString prvTraceCreateSymbolTableEntry(const char* name,
|
||
|
|
uint8_t crc6,
|
||
|
|
uint8_t len,
|
||
|
|
traceString channel);
|
||
|
|
|
||
|
|
static traceString prvTraceLookupSymbolTableEntry(const char* name,
|
||
|
|
uint8_t crc6,
|
||
|
|
uint8_t len,
|
||
|
|
traceString channel);
|
||
|
|
|
||
|
|
|
||
|
|
#if (TRC_CFG_INCLUDE_ISR_TRACING == 0)
|
||
|
|
/* ISR tracing is turned off */
|
||
|
|
void prvTraceIncreaseISRActive(void);
|
||
|
|
void prvTraceDecreaseISRActive(void);
|
||
|
|
#endif /*(TRC_CFG_INCLUDE_ISR_TRACING == 0)*/
|
||
|
|
|
||
|
|
#if (TRC_CFG_USE_16BIT_OBJECT_HANDLES == 1)
|
||
|
|
static uint8_t prvTraceGet8BitHandle(traceHandle handle);
|
||
|
|
#else
|
||
|
|
#define prvTraceGet8BitHandle(x) ((uint8_t)x)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
#if (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1) && (TRC_CFG_SCHEDULING_ONLY == 0)
|
||
|
|
static uint32_t heapMemUsage = 0;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if (TRC_CFG_SCHEDULING_ONLY == 0)
|
||
|
|
static uint32_t prvTraceGetParam(uint32_t, uint32_t);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceInitTraceData
|
||
|
|
*
|
||
|
|
* Allocates and initializes the recorder data structure, based on the constants
|
||
|
|
* in trcConfig.h. This allows for allocating the data on the heap, instead of
|
||
|
|
* using a static declaration.
|
||
|
|
******************************************************************************/
|
||
|
|
static void prvTraceInitTraceData(void);
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTracePortGetTimeStamp
|
||
|
|
*
|
||
|
|
* Returns the current time based on the HWTC macros which provide a hardware
|
||
|
|
* isolation layer towards the hardware timer/counter.
|
||
|
|
*
|
||
|
|
* The HWTC macros and prvTracePortGetTimeStamp is the main porting issue
|
||
|
|
* or the trace recorder library. Typically you should not need to change
|
||
|
|
* the code of prvTracePortGetTimeStamp if using the HWTC macros.
|
||
|
|
*
|
||
|
|
******************************************************************************/
|
||
|
|
void prvTracePortGetTimeStamp(uint32_t *puiTimestamp);
|
||
|
|
|
||
|
|
static void prvTraceTaskInstanceFinish(int8_t direct);
|
||
|
|
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1))
|
||
|
|
static void vTracePrintF_Helper(traceString eventLabel, const char* formatStr, va_list vl);
|
||
|
|
|
||
|
|
#if (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1)
|
||
|
|
static void vTraceUBData_Helper(traceUBChannel channelPair, va_list vl);
|
||
|
|
static void prvTraceUBHelper1(traceUBChannel channel, traceString eventLabel, traceString formatLabel, va_list vl);
|
||
|
|
static void prvTraceUBHelper2(traceUBChannel channel, uint32_t* data, uint32_t noOfSlots);
|
||
|
|
#endif /*(TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1)*/
|
||
|
|
#endif /* ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1)) */
|
||
|
|
|
||
|
|
/********* Public Functions **************************************************/
|
||
|
|
|
||
|
|
uint16_t uiIndexOfObject(traceHandle objecthandle, uint8_t objectclass);
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceError
|
||
|
|
*
|
||
|
|
* Called by various parts in the recorder. Stops the recorder and stores a
|
||
|
|
* pointer to an error message, which is printed by the monitor task.
|
||
|
|
******************************************************************************/
|
||
|
|
void prvTraceError(const char* msg);
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* vTraceEnable(int startOption) - snapshot mode
|
||
|
|
*
|
||
|
|
* Initializes and optionally starts the trace, depending on the start option.
|
||
|
|
* To use the trace recorder, the startup must call vTraceEnable before any RTOS
|
||
|
|
* calls are made (including "create" calls). Three start options are provided:
|
||
|
|
*
|
||
|
|
* TRC_START: Starts the tracing directly. In snapshot mode this allows for
|
||
|
|
* starting the trace at any point in your code, assuming vTraceEnable(TRC_INIT)
|
||
|
|
* has been called in the startup.
|
||
|
|
* Can also be used for streaming without Tracealyzer control, e.g. to a local
|
||
|
|
* flash file system (assuming such a "stream port", see trcStreamingPort.h).
|
||
|
|
*
|
||
|
|
* TRC_INIT: Initializes the trace recorder, but does not start the tracing.
|
||
|
|
* In snapshot mode, this must be followed by a vTraceEnable(TRC_START) sometime
|
||
|
|
* later.
|
||
|
|
*
|
||
|
|
* Usage examples, in snapshot mode:
|
||
|
|
*
|
||
|
|
* Snapshot trace, from startup:
|
||
|
|
* <board init>
|
||
|
|
* vTraceEnable(TRC_START);
|
||
|
|
* <RTOS init>
|
||
|
|
*
|
||
|
|
* Snapshot trace, from a later point:
|
||
|
|
* <board init>
|
||
|
|
* vTraceEnable(TRC_INIT);
|
||
|
|
* <RTOS init>
|
||
|
|
* ...
|
||
|
|
* vTraceEnable(TRC_START); // e.g., in task context, at some relevant event
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* Note: See other implementation of vTraceEnable in trcStreamingRecorder.c
|
||
|
|
******************************************************************************/
|
||
|
|
void vTraceEnable(int startOption)
|
||
|
|
{
|
||
|
|
prvTraceInitTraceData();
|
||
|
|
|
||
|
|
if (startOption == TRC_START)
|
||
|
|
{
|
||
|
|
vTraceStart();
|
||
|
|
}
|
||
|
|
else if (startOption == TRC_START_AWAIT_HOST)
|
||
|
|
{
|
||
|
|
prvTraceError("vTraceEnable(TRC_START_AWAIT_HOST) not allowed in Snapshot mode");
|
||
|
|
}
|
||
|
|
else if (startOption != TRC_INIT)
|
||
|
|
{
|
||
|
|
prvTraceError("Unexpected argument to vTraceEnable (snapshot mode)");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* vTraceSetRecorderDataBuffer
|
||
|
|
*
|
||
|
|
* If custom allocation is used, this function must be called so the recorder
|
||
|
|
* library knows where to save the trace data.
|
||
|
|
******************************************************************************/
|
||
|
|
#if (TRC_CFG_RECORDER_BUFFER_ALLOCATION == TRC_RECORDER_BUFFER_ALLOCATION_CUSTOM)
|
||
|
|
void vTraceSetRecorderDataBuffer(void* pRecorderData)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(pRecorderData != NULL, "vTraceSetRecorderDataBuffer, pRecorderData == NULL", TRC_UNUSED);
|
||
|
|
RecorderDataPtr = pRecorderData;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* vTraceSetStopHook
|
||
|
|
*
|
||
|
|
* Sets a function to be called when the recorder is stopped. This can be used
|
||
|
|
* to save the trace to a file system, if available. This is only implemented
|
||
|
|
* for snapshot mode.
|
||
|
|
******************************************************************************/
|
||
|
|
void vTraceSetStopHook(TRACE_STOP_HOOK stopHookFunction)
|
||
|
|
{
|
||
|
|
vTraceStopHookPtr = stopHookFunction;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* vTraceClear
|
||
|
|
*
|
||
|
|
* Resets the recorder. Only necessary if a restart is desired - this is not
|
||
|
|
* needed in the startup initialization.
|
||
|
|
******************************************************************************/
|
||
|
|
void vTraceClear(void)
|
||
|
|
{
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
RecorderDataPtr->absTimeLastEventSecond = 0;
|
||
|
|
RecorderDataPtr->absTimeLastEvent = 0;
|
||
|
|
RecorderDataPtr->nextFreeIndex = 0;
|
||
|
|
RecorderDataPtr->numEvents = 0;
|
||
|
|
RecorderDataPtr->bufferIsFull = 0;
|
||
|
|
traceErrorMessage = NULL;
|
||
|
|
RecorderDataPtr->internalErrorOccured = 0;
|
||
|
|
(void)memset(RecorderDataPtr->eventData, 0, RecorderDataPtr->maxEvents * 4);
|
||
|
|
handle_of_last_logged_task = 0;
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* uiTraceStart
|
||
|
|
*
|
||
|
|
* Starts the recorder. The recorder will not be started if an error has been
|
||
|
|
* indicated using prvTraceError, e.g. if any of the Nx constants in trcConfig.h
|
||
|
|
* has a too small value (TRC_CFG_NTASK, TRC_CFG_NQUEUE, etc).
|
||
|
|
*
|
||
|
|
* Returns 1 if the recorder was started successfully.
|
||
|
|
* Returns 0 if the recorder start was prevented due to a previous internal
|
||
|
|
* error. In that case, check xTraceGetLastError to get the error message.
|
||
|
|
* Any error message is also presented when opening a trace file.
|
||
|
|
*
|
||
|
|
* This function is obsolete, but has been saved for backwards compatibility.
|
||
|
|
* We recommend using vTraceEnable instead.
|
||
|
|
******************************************************************************/
|
||
|
|
uint32_t uiTraceStart(void)
|
||
|
|
{
|
||
|
|
traceHandle handle;
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
handle = 0;
|
||
|
|
|
||
|
|
if (RecorderDataPtr == NULL)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(RecorderDataPtr != NULL, "Recorder not initialized. Use vTraceEnable() instead!", 0);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (RecorderDataPtr->recorderActive == 1)
|
||
|
|
return 1; /* Already running */
|
||
|
|
|
||
|
|
if (traceErrorMessage == NULL)
|
||
|
|
{
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
RecorderDataPtr->recorderActive = 1;
|
||
|
|
|
||
|
|
handle = TRACE_GET_TASK_NUMBER(TRACE_GET_CURRENT_TASK());
|
||
|
|
if (handle == 0)
|
||
|
|
{
|
||
|
|
/* This occurs if the scheduler is not yet started.
|
||
|
|
This creates a dummy "(startup)" task entry internally in the
|
||
|
|
recorder */
|
||
|
|
handle = prvTraceGetObjectHandle(TRACE_CLASS_TASK);
|
||
|
|
prvTraceSetObjectName(TRACE_CLASS_TASK, handle, "(startup)");
|
||
|
|
|
||
|
|
prvTraceSetPriorityProperty(TRACE_CLASS_TASK, handle, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
prvTraceStoreTaskswitch(handle); /* Register the currently running task */
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
|
||
|
|
return RecorderDataPtr->recorderActive;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* vTraceStart
|
||
|
|
*
|
||
|
|
* Starts the recorder. The recorder will not be started if an error has been
|
||
|
|
* indicated using prvTraceError, e.g. if any of the Nx constants in trcConfig.h
|
||
|
|
* has a too small value (TRC_CFG_NTASK, TRC_CFG_NQUEUE, etc).
|
||
|
|
*
|
||
|
|
* This function is obsolete, but has been saved for backwards compatibility.
|
||
|
|
* We recommend using vTraceEnable instead.
|
||
|
|
******************************************************************************/
|
||
|
|
void vTraceStart(void)
|
||
|
|
{
|
||
|
|
(void)uiTraceStart();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* vTraceStop
|
||
|
|
*
|
||
|
|
* Stops the recorder. The recording can be resumed by calling vTraceStart.
|
||
|
|
* This does not reset the recorder. Use vTraceClear if that is desired.
|
||
|
|
******************************************************************************/
|
||
|
|
void vTraceStop(void)
|
||
|
|
{
|
||
|
|
if (RecorderDataPtr != NULL)
|
||
|
|
{
|
||
|
|
RecorderDataPtr->recorderActive = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (vTraceStopHookPtr != (TRACE_STOP_HOOK)0)
|
||
|
|
{
|
||
|
|
(*vTraceStopHookPtr)(); /* An application call-back function. */
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* xTraceIsRecordingEnabled
|
||
|
|
* Returns true (1) if the recorder is enabled (i.e. is recording), otherwise 0.
|
||
|
|
******************************************************************************/
|
||
|
|
int xTraceIsRecordingEnabled(void)
|
||
|
|
{
|
||
|
|
if (RecorderDataPtr != NULL)
|
||
|
|
{
|
||
|
|
return (int)RecorderDataPtr->recorderActive;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* xTraceGetLastError
|
||
|
|
*
|
||
|
|
* Gives the last error message, if any. NULL if no error message is stored.
|
||
|
|
* Any error message is also presented when opening a trace file.
|
||
|
|
******************************************************************************/
|
||
|
|
const char* xTraceGetLastError(void)
|
||
|
|
{
|
||
|
|
return traceErrorMessage;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* vTraceClearError
|
||
|
|
*
|
||
|
|
* Removes any previous error message generated by recorder calling prvTraceError.
|
||
|
|
* By calling this function, it may be possible to start/restart the trace
|
||
|
|
* despite errors in the recorder, but there is no guarantee that the trace
|
||
|
|
* recorder will work correctly in that case, depending on the type of error.
|
||
|
|
******************************************************************************/
|
||
|
|
void vTraceClearError(void)
|
||
|
|
{
|
||
|
|
traceErrorMessage = NULL;
|
||
|
|
if (RecorderDataPtr != NULL)
|
||
|
|
{
|
||
|
|
RecorderDataPtr->internalErrorOccured = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* xTraceGetTraceBuffer
|
||
|
|
*
|
||
|
|
* Returns a pointer to the recorder data structure. Use this together with
|
||
|
|
* uiTraceGetTraceBufferSize if you wish to implement an own store/upload
|
||
|
|
* solution, e.g., in case a debugger connection is not available for uploading
|
||
|
|
* the data.
|
||
|
|
******************************************************************************/
|
||
|
|
void* xTraceGetTraceBuffer(void)
|
||
|
|
{
|
||
|
|
return RecorderDataPtr;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* uiTraceGetTraceBufferSize
|
||
|
|
*
|
||
|
|
* Gets the size of the recorder data structure. For use together with
|
||
|
|
* vTraceGetTraceBuffer if you wish to implement an own store/upload solution,
|
||
|
|
* e.g., in case a debugger connection is not available for uploading the data.
|
||
|
|
******************************************************************************/
|
||
|
|
uint32_t uiTraceGetTraceBufferSize(void)
|
||
|
|
{
|
||
|
|
return sizeof(RecorderDataType);
|
||
|
|
}
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* prvTraceTaskInstanceFinish
|
||
|
|
*
|
||
|
|
* Private common function for the vTraceTaskInstanceFinishXXX functions.
|
||
|
|
*****************************************************************************/
|
||
|
|
static void prvTraceTaskInstanceFinish(int8_t direct)
|
||
|
|
{
|
||
|
|
TaskInstanceStatusEvent* tis;
|
||
|
|
uint8_t dts45;
|
||
|
|
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
if (RecorderDataPtr->recorderActive && handle_of_last_logged_task)
|
||
|
|
{
|
||
|
|
dts45 = (uint8_t)prvTraceGetDTS(0xFF);
|
||
|
|
tis = (TaskInstanceStatusEvent*) prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (tis != NULL)
|
||
|
|
{
|
||
|
|
if (direct == 0)
|
||
|
|
tis->type = TASK_INSTANCE_FINISHED_NEXT_KSE;
|
||
|
|
else
|
||
|
|
tis->type = TASK_INSTANCE_FINISHED_DIRECT;
|
||
|
|
|
||
|
|
tis->dts = dts45;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* vTraceInstanceFinishedNext(void)
|
||
|
|
*
|
||
|
|
* Marks the current task instance as finished on the next kernel call.
|
||
|
|
*
|
||
|
|
* If that kernel call is blocking, the instance ends after the blocking event
|
||
|
|
* and the corresponding return event is then the start of the next instance.
|
||
|
|
* If the kernel call is not blocking, the viewer instead splits the current
|
||
|
|
* fragment right before the kernel call, which makes this call the first event
|
||
|
|
* of the next instance.
|
||
|
|
*
|
||
|
|
* See also TRC_CFG_USE_IMPLICIT_IFE_RULES in trcConfig.h
|
||
|
|
*
|
||
|
|
* Example:
|
||
|
|
*
|
||
|
|
* while(1)
|
||
|
|
* {
|
||
|
|
* xQueueReceive(CommandQueue, &command, timeoutDuration);
|
||
|
|
* processCommand(command);
|
||
|
|
* vTraceInstanceFinishedNext();
|
||
|
|
* }
|
||
|
|
*****************************************************************************/
|
||
|
|
void vTraceInstanceFinishedNext(void)
|
||
|
|
{
|
||
|
|
prvTraceTaskInstanceFinish(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* vTraceInstanceFinishedNow(void)
|
||
|
|
*
|
||
|
|
* Marks the current task instance as finished at this very instant.
|
||
|
|
* This makes the viewer to splits the current fragment at this point and begin
|
||
|
|
* a new actor instance.
|
||
|
|
*
|
||
|
|
* See also TRC_CFG_USE_IMPLICIT_IFE_RULES in trcConfig.h
|
||
|
|
*
|
||
|
|
* Example:
|
||
|
|
*
|
||
|
|
* This example will generate two instances for each loop iteration.
|
||
|
|
* The first instance ends at vTraceInstanceFinishedNow(), while the second
|
||
|
|
* instance ends at the next xQueueReceive call.
|
||
|
|
*
|
||
|
|
* while (1)
|
||
|
|
* {
|
||
|
|
* xQueueReceive(CommandQueue, &command, timeoutDuration);
|
||
|
|
* ProcessCommand(command);
|
||
|
|
* vTraceInstanceFinishedNow();
|
||
|
|
* DoSometingElse();
|
||
|
|
* vTraceInstanceFinishedNext();
|
||
|
|
* }
|
||
|
|
*****************************************************************************/
|
||
|
|
void vTraceInstanceFinishedNow(void)
|
||
|
|
{
|
||
|
|
prvTraceTaskInstanceFinish(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* Interrupt recording functions
|
||
|
|
******************************************************************************/
|
||
|
|
|
||
|
|
#if (TRC_CFG_INCLUDE_ISR_TRACING == 1)
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* xTraceSetISRProperties
|
||
|
|
*
|
||
|
|
* Stores a name and priority level for an Interrupt Service Routine, to allow
|
||
|
|
* for better visualization. Returns a traceHandle used by vTraceStoreISRBegin.
|
||
|
|
*
|
||
|
|
* Example:
|
||
|
|
* #define PRIO_ISR_TIMER1 3 // the hardware priority of the interrupt
|
||
|
|
* ...
|
||
|
|
* traceHandle Timer1Handle = xTraceSetISRProperties("ISRTimer1", PRIO_ISR_TIMER1);
|
||
|
|
* ...
|
||
|
|
* void ISR_handler()
|
||
|
|
* {
|
||
|
|
* vTraceStoreISRBegin(Timer1Handle);
|
||
|
|
* ...
|
||
|
|
* vTraceStoreISREnd(0);
|
||
|
|
* }
|
||
|
|
******************************************************************************/
|
||
|
|
traceHandle xTraceSetISRProperties(const char* name, uint8_t priority)
|
||
|
|
{
|
||
|
|
static traceHandle handle = 0;
|
||
|
|
TRACE_ASSERT(RecorderDataPtr != NULL, "Recorder not initialized, call vTraceEnable() first!", (traceHandle)0);
|
||
|
|
TRACE_ASSERT(handle <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[TRACE_CLASS_ISR], "xTraceSetISRProperties: Invalid value for handle", 0);
|
||
|
|
TRACE_ASSERT(name != NULL, "xTraceSetISRProperties: name == NULL", 0);
|
||
|
|
|
||
|
|
handle++;
|
||
|
|
|
||
|
|
prvTraceSetObjectName(TRACE_CLASS_ISR, handle, name);
|
||
|
|
prvTraceSetPriorityProperty(TRACE_CLASS_ISR, handle, priority);
|
||
|
|
|
||
|
|
return handle;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* vTraceStoreISRBegin
|
||
|
|
*
|
||
|
|
* Registers the beginning of an Interrupt Service Routine, using a traceHandle
|
||
|
|
* provided by xTraceSetISRProperties.
|
||
|
|
*
|
||
|
|
* Example:
|
||
|
|
* #define PRIO_ISR_TIMER1 3 // the hardware priority of the interrupt
|
||
|
|
* ...
|
||
|
|
* traceHandle Timer1Handle = xTraceSetISRProperties("ISRTimer1", PRIO_ISR_TIMER1);
|
||
|
|
* ...
|
||
|
|
* void ISR_handler()
|
||
|
|
* {
|
||
|
|
* vTraceStoreISRBegin(Timer1Handle);
|
||
|
|
* ...
|
||
|
|
* vTraceStoreISREnd(0);
|
||
|
|
* }
|
||
|
|
******************************************************************************/
|
||
|
|
void vTraceStoreISRBegin(traceHandle handle)
|
||
|
|
{
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
if (recorder_busy)
|
||
|
|
{
|
||
|
|
/*************************************************************************
|
||
|
|
* This occurs if an ISR calls a trace function, preempting a previous
|
||
|
|
* trace call that is being processed in a different ISR or task.
|
||
|
|
* If this occurs, there is probably a problem in the definition of the
|
||
|
|
* recorder's internal critical sections (TRACE_ENTER_CRITICAL_SECTION and
|
||
|
|
* TRACE_EXIT_CRITICAL_SECTION). They must disable the RTOS tick interrupt
|
||
|
|
* and any other ISRs that calls the trace recorder directly or via
|
||
|
|
* traced kernel functions. The ARM port disables all interrupts using the
|
||
|
|
* PRIMASK register to avoid this issue.
|
||
|
|
*************************************************************************/
|
||
|
|
prvTraceError("vTraceStoreISRBegin - recorder busy! See code comment.");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
|
||
|
|
if (RecorderDataPtr->recorderActive && handle_of_last_logged_task)
|
||
|
|
{
|
||
|
|
uint16_t dts4;
|
||
|
|
|
||
|
|
TRACE_ASSERT(handle != 0, "vTraceStoreISRBegin: Invalid ISR handle (NULL)", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(handle <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[TRACE_CLASS_ISR], "vTraceStoreISRBegin: Invalid ISR handle (> NISR)", TRC_UNUSED);
|
||
|
|
|
||
|
|
dts4 = (uint16_t)prvTraceGetDTS(0xFFFF);
|
||
|
|
|
||
|
|
if (RecorderDataPtr->recorderActive) /* Need to repeat this check! */
|
||
|
|
{
|
||
|
|
if (nISRactive < TRC_CFG_MAX_ISR_NESTING)
|
||
|
|
{
|
||
|
|
TSEvent* ts;
|
||
|
|
uint8_t hnd8 = prvTraceGet8BitHandle(handle);
|
||
|
|
isrstack[nISRactive] = handle;
|
||
|
|
nISRactive++;
|
||
|
|
ts = (TSEvent*)prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (ts != NULL)
|
||
|
|
{
|
||
|
|
ts->type = TS_ISR_BEGIN;
|
||
|
|
ts->dts = dts4;
|
||
|
|
ts->objHandle = hnd8;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* This should not occur unless something is very wrong */
|
||
|
|
prvTraceError("Too many nested interrupts!");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* vTraceStoreISREnd
|
||
|
|
*
|
||
|
|
* Registers the end of an Interrupt Service Routine.
|
||
|
|
*
|
||
|
|
* The parameter pendingISR indicates if the interrupt has requested a
|
||
|
|
* task-switch (= 1), e.g., by signaling a semaphore. Otherwise (= 0) the
|
||
|
|
* interrupt is assumed to return to the previous context.
|
||
|
|
*
|
||
|
|
* Example:
|
||
|
|
* #define PRIO_OF_ISR_TIMER1 3 // the hardware priority of the interrupt
|
||
|
|
* traceHandle traceHandleIsrTimer1 = 0; // The ID set by the recorder
|
||
|
|
* ...
|
||
|
|
* traceHandleIsrTimer1 = xTraceSetISRProperties("ISRTimer1", PRIO_OF_ISR_TIMER1);
|
||
|
|
* ...
|
||
|
|
* void ISR_handler()
|
||
|
|
* {
|
||
|
|
* vTraceStoreISRBegin(traceHandleIsrTimer1);
|
||
|
|
* ...
|
||
|
|
* vTraceStoreISREnd(0);
|
||
|
|
* }
|
||
|
|
******************************************************************************/
|
||
|
|
void vTraceStoreISREnd(int pendingISR)
|
||
|
|
{
|
||
|
|
TSEvent* ts;
|
||
|
|
uint16_t dts5;
|
||
|
|
uint8_t hnd8 = 0, type = 0;
|
||
|
|
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
if (! RecorderDataPtr->recorderActive || ! handle_of_last_logged_task)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (recorder_busy)
|
||
|
|
{
|
||
|
|
/*************************************************************************
|
||
|
|
* This occurs if an ISR calls a trace function, preempting a previous
|
||
|
|
* trace call that is being processed in a different ISR or task.
|
||
|
|
* If this occurs, there is probably a problem in the definition of the
|
||
|
|
* recorder's internal critical sections (TRACE_ENTER_CRITICAL_SECTION and
|
||
|
|
* TRACE_EXIT_CRITICAL_SECTION). They must disable the RTOS tick interrupt
|
||
|
|
* and any other ISRs that calls the trace recorder directly or via
|
||
|
|
* traced kernel functions. The ARM port disables all interrupts using the
|
||
|
|
* PRIMASK register to avoid this issue.
|
||
|
|
*************************************************************************/
|
||
|
|
prvTraceError("vTraceStoreISREnd - recorder busy! See code comment.");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (nISRactive == 0)
|
||
|
|
{
|
||
|
|
prvTraceError("Unmatched call to vTraceStoreISREnd (nISRactive == 0, expected > 0)");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
isPendingContextSwitch |= pendingISR; /* Is there a pending context switch right now? */
|
||
|
|
nISRactive--;
|
||
|
|
if (nISRactive > 0)
|
||
|
|
{
|
||
|
|
/* Return to another ISR */
|
||
|
|
type = TS_ISR_RESUME;
|
||
|
|
hnd8 = prvTraceGet8BitHandle(isrstack[nISRactive - 1]); /* isrstack[nISRactive] is the handle of the ISR we're currently exiting. isrstack[nISRactive - 1] is the handle of the ISR that was executing previously. */
|
||
|
|
}
|
||
|
|
else if ((isPendingContextSwitch == 0) || (prvTraceIsSchedulerSuspended()))
|
||
|
|
{
|
||
|
|
/* Return to interrupted task, if no context switch will occur in between. */
|
||
|
|
type = TS_TASK_RESUME;
|
||
|
|
hnd8 = prvTraceGet8BitHandle(handle_of_last_logged_task);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (type != 0)
|
||
|
|
{
|
||
|
|
dts5 = (uint16_t)prvTraceGetDTS(0xFFFF);
|
||
|
|
ts = (TSEvent*)prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (ts != NULL)
|
||
|
|
{
|
||
|
|
ts->type = type;
|
||
|
|
ts->objHandle = hnd8;
|
||
|
|
ts->dts = dts5;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
/* ISR tracing is turned off */
|
||
|
|
void prvTraceIncreaseISRActive(void)
|
||
|
|
{
|
||
|
|
if (RecorderDataPtr->recorderActive && handle_of_last_logged_task)
|
||
|
|
nISRactive++;
|
||
|
|
}
|
||
|
|
|
||
|
|
void prvTraceDecreaseISRActive(void)
|
||
|
|
{
|
||
|
|
if (RecorderDataPtr->recorderActive && handle_of_last_logged_task)
|
||
|
|
nISRactive--;
|
||
|
|
}
|
||
|
|
#endif /* (TRC_CFG_INCLUDE_ISR_TRACING == 1)*/
|
||
|
|
|
||
|
|
|
||
|
|
/********************************************************************************/
|
||
|
|
/* User Event functions */
|
||
|
|
/********************************************************************************/
|
||
|
|
|
||
|
|
#define MAX_ARG_SIZE (4+32)
|
||
|
|
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1))
|
||
|
|
static uint8_t writeInt8(void * buffer, uint8_t i, uint8_t value)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(buffer != NULL, "writeInt8: buffer == NULL", 0);
|
||
|
|
|
||
|
|
if (i >= MAX_ARG_SIZE)
|
||
|
|
{
|
||
|
|
return 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
((uint8_t*)buffer)[i] = value;
|
||
|
|
|
||
|
|
if (i + 1 > MAX_ARG_SIZE)
|
||
|
|
{
|
||
|
|
return 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ((uint8_t) (i + 1));
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1))
|
||
|
|
static uint8_t writeInt16(void * buffer, uint8_t i, uint16_t value)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(buffer != NULL, "writeInt16: buffer == NULL", 0);
|
||
|
|
|
||
|
|
/* Align to multiple of 2 */
|
||
|
|
while ((i % 2) != 0)
|
||
|
|
{
|
||
|
|
if (i >= MAX_ARG_SIZE)
|
||
|
|
{
|
||
|
|
return 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
((uint8_t*)buffer)[i] = 0;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i + 2 > MAX_ARG_SIZE)
|
||
|
|
{
|
||
|
|
return 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
((uint16_t*)buffer)[i/2] = value;
|
||
|
|
|
||
|
|
return ((uint8_t) (i + 2));
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1))
|
||
|
|
static uint8_t writeInt32(void * buffer, uint8_t i, uint32_t value)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(buffer != NULL, "writeInt32: buffer == NULL", 0);
|
||
|
|
|
||
|
|
/* A 32 bit value should begin at an even 4-byte address */
|
||
|
|
while ((i % 4) != 0)
|
||
|
|
{
|
||
|
|
if (i >= MAX_ARG_SIZE)
|
||
|
|
{
|
||
|
|
return 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
((uint8_t*)buffer)[i] = 0;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i + 4 > MAX_ARG_SIZE)
|
||
|
|
{
|
||
|
|
return 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
((uint32_t*)buffer)[i/4] = value;
|
||
|
|
|
||
|
|
return ((uint8_t) (i + 4));
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1) && (TRC_CFG_INCLUDE_FLOAT_SUPPORT))
|
||
|
|
static uint8_t writeFloat(void * buffer, uint8_t i, float value)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(buffer != NULL, "writeFloat: buffer == NULL", 0);
|
||
|
|
|
||
|
|
/* A 32 bit value should begin at an even 4-byte address */
|
||
|
|
while ((i % 4) != 0)
|
||
|
|
{
|
||
|
|
if (i >= MAX_ARG_SIZE)
|
||
|
|
{
|
||
|
|
return 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
((uint8_t*)buffer)[i] = 0;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i + 4 > MAX_ARG_SIZE)
|
||
|
|
{
|
||
|
|
return 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
((float*)buffer)[i/4] = value;
|
||
|
|
|
||
|
|
return i + 4;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1) && (TRC_CFG_INCLUDE_FLOAT_SUPPORT))
|
||
|
|
static uint8_t writeDouble(void * buffer, uint8_t i, double value)
|
||
|
|
{
|
||
|
|
uint32_t * dest;
|
||
|
|
uint32_t * src = (uint32_t*)&value;
|
||
|
|
|
||
|
|
TRACE_ASSERT(buffer != NULL, "writeDouble: buffer == NULL", 0);
|
||
|
|
|
||
|
|
/* The double is written as two 32 bit values, and should begin at an even
|
||
|
|
4-byte address (to avoid having to align with 8 byte) */
|
||
|
|
while (i % 4 != 0)
|
||
|
|
{
|
||
|
|
if (i >= MAX_ARG_SIZE)
|
||
|
|
{
|
||
|
|
return 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
((uint8_t*)buffer)[i] = 0;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i + 8 > MAX_ARG_SIZE)
|
||
|
|
{
|
||
|
|
return 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
dest = &(((uint32_t *)buffer)[i/4]);
|
||
|
|
|
||
|
|
dest[0] = src[0];
|
||
|
|
dest[1] = src[1];
|
||
|
|
|
||
|
|
return i + 8;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceUserEventFormat
|
||
|
|
*
|
||
|
|
* Parses the format string and stores the arguments in the buffer.
|
||
|
|
******************************************************************************/
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1))
|
||
|
|
static uint8_t prvTraceUserEventFormat(const char* formatStr, va_list vl, uint8_t* buffer, uint8_t byteOffset)
|
||
|
|
{
|
||
|
|
uint16_t formatStrIndex = 0;
|
||
|
|
uint8_t argCounter = 0;
|
||
|
|
uint8_t i = byteOffset;
|
||
|
|
|
||
|
|
while (formatStr[formatStrIndex] != '\0')
|
||
|
|
{
|
||
|
|
if (formatStr[formatStrIndex] == '%')
|
||
|
|
{
|
||
|
|
argCounter++;
|
||
|
|
|
||
|
|
if (argCounter > 15)
|
||
|
|
{
|
||
|
|
prvTraceError("vTracePrintF - Too many arguments, max 15 allowed!");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
formatStrIndex++;
|
||
|
|
|
||
|
|
while ((formatStr[formatStrIndex] >= '0' && formatStr[formatStrIndex] <= '9') || formatStr[formatStrIndex] == '#' || formatStr[formatStrIndex] == '.')
|
||
|
|
formatStrIndex++;
|
||
|
|
|
||
|
|
if (formatStr[formatStrIndex] != '\0')
|
||
|
|
{
|
||
|
|
switch (formatStr[formatStrIndex])
|
||
|
|
{
|
||
|
|
case 'd': i = writeInt32( buffer,
|
||
|
|
i,
|
||
|
|
(uint32_t)va_arg(vl, uint32_t));
|
||
|
|
break;
|
||
|
|
case 'x':
|
||
|
|
case 'X':
|
||
|
|
case 'u': i = writeInt32( buffer,
|
||
|
|
i,
|
||
|
|
(uint32_t)va_arg(vl, uint32_t));
|
||
|
|
break;
|
||
|
|
case 's': i = writeInt16( buffer,
|
||
|
|
i,
|
||
|
|
xTraceRegisterString((char*)va_arg(vl, char*)));
|
||
|
|
break;
|
||
|
|
|
||
|
|
#if (TRC_CFG_INCLUDE_FLOAT_SUPPORT)
|
||
|
|
/* Yes, "double" as type also in the float
|
||
|
|
case. This since "float" is promoted into "double"
|
||
|
|
by the va_arg stuff. */
|
||
|
|
case 'f': i = writeFloat( buffer,
|
||
|
|
i,
|
||
|
|
(float)va_arg(vl, double));
|
||
|
|
break;
|
||
|
|
#else
|
||
|
|
/* No support for floats, but attempt to store a float user event
|
||
|
|
avoid a possible crash due to float reference. Instead store the
|
||
|
|
data on uint_32 format (will not be displayed anyway). This is just
|
||
|
|
to keep va_arg and i consistent. */
|
||
|
|
|
||
|
|
case 'f': i = writeInt32( buffer,
|
||
|
|
i,
|
||
|
|
(uint32_t)va_arg(vl, double));
|
||
|
|
break;
|
||
|
|
#endif
|
||
|
|
case 'l':
|
||
|
|
formatStrIndex++;
|
||
|
|
switch (formatStr[formatStrIndex])
|
||
|
|
{
|
||
|
|
#if (TRC_CFG_INCLUDE_FLOAT_SUPPORT)
|
||
|
|
case 'f': i = writeDouble(buffer,
|
||
|
|
i,
|
||
|
|
(double)va_arg(vl, double));
|
||
|
|
break;
|
||
|
|
#else
|
||
|
|
/* No support for floats, but attempt to store a float user event
|
||
|
|
avoid a possible crash due to float reference. Instead store the
|
||
|
|
data on uint_32 format (will not be displayed anyway). This is just
|
||
|
|
to keep va_arg and i consistent. */
|
||
|
|
case 'f': i = writeInt32( buffer, /* In this case, the value will not be shown anyway */
|
||
|
|
i,
|
||
|
|
(uint32_t)va_arg(vl, double));
|
||
|
|
|
||
|
|
i = writeInt32( buffer, /* Do it twice, to write in total 8 bytes */
|
||
|
|
i,
|
||
|
|
(uint32_t)va_arg(vl, double));
|
||
|
|
break;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 'h':
|
||
|
|
formatStrIndex++;
|
||
|
|
switch (formatStr[formatStrIndex])
|
||
|
|
{
|
||
|
|
case 'd': i = writeInt16( buffer,
|
||
|
|
i,
|
||
|
|
(uint16_t)va_arg(vl, uint32_t));
|
||
|
|
break;
|
||
|
|
case 'u': i = writeInt16( buffer,
|
||
|
|
i,
|
||
|
|
(uint16_t)va_arg(vl, uint32_t));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 'b':
|
||
|
|
formatStrIndex++;
|
||
|
|
switch (formatStr[formatStrIndex])
|
||
|
|
{
|
||
|
|
case 'd': i = writeInt8( buffer,
|
||
|
|
i,
|
||
|
|
(uint8_t)va_arg(vl, uint32_t));
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 'u': i = writeInt8( buffer,
|
||
|
|
i,
|
||
|
|
(uint8_t)va_arg(vl, uint32_t));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
formatStrIndex++;
|
||
|
|
if (i == 255)
|
||
|
|
{
|
||
|
|
prvTraceError("vTracePrintF - Too large arguments, max 32 byte allowed!");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return (uint8_t)(i+3)/4;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceClearChannelBuffer
|
||
|
|
*
|
||
|
|
* Clears a number of items in the channel buffer, starting from nextSlotToWrite.
|
||
|
|
******************************************************************************/
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1) && (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1))
|
||
|
|
static void prvTraceClearChannelBuffer(uint32_t count)
|
||
|
|
{
|
||
|
|
uint32_t slots;
|
||
|
|
|
||
|
|
TRACE_ASSERT((TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE) >= count,
|
||
|
|
"prvTraceClearChannelBuffer: TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE is too small to handle this event.", TRC_UNUSED);
|
||
|
|
|
||
|
|
/* Check if we're close to the end of the buffer */
|
||
|
|
if (RecorderDataPtr->userEventBuffer.nextSlotToWrite + count > (TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE))
|
||
|
|
{
|
||
|
|
slots = (TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE) - RecorderDataPtr->userEventBuffer.nextSlotToWrite; /* Number of slots before end of buffer */
|
||
|
|
(void)memset(&RecorderDataPtr->userEventBuffer.channelBuffer[RecorderDataPtr->userEventBuffer.nextSlotToWrite], 0, slots);
|
||
|
|
(void)memset(&RecorderDataPtr->userEventBuffer.channelBuffer[0], 0, (count - slots));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
(void)memset(&RecorderDataPtr->userEventBuffer.channelBuffer[RecorderDataPtr->userEventBuffer.nextSlotToWrite], 0, count);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceCopyToDataBuffer
|
||
|
|
*
|
||
|
|
* Copies a number of items to the data buffer, starting from nextSlotToWrite.
|
||
|
|
******************************************************************************/
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1) && (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1))
|
||
|
|
static void prvTraceCopyToDataBuffer(uint32_t* data, uint32_t count)
|
||
|
|
{
|
||
|
|
uint32_t slots;
|
||
|
|
|
||
|
|
TRACE_ASSERT(data != NULL,
|
||
|
|
"prvTraceCopyToDataBuffer: data == NULL.", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(count <= (TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE),
|
||
|
|
"prvTraceCopyToDataBuffer: TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE is too small to handle this event.", TRC_UNUSED);
|
||
|
|
/* Check if we're close to the end of the buffer */
|
||
|
|
if (RecorderDataPtr->userEventBuffer.nextSlotToWrite + count > (TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE))
|
||
|
|
{
|
||
|
|
slots = (TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE) - RecorderDataPtr->userEventBuffer.nextSlotToWrite; /* Number of slots before end of buffer */
|
||
|
|
(void)memcpy(&RecorderDataPtr->userEventBuffer.dataBuffer[RecorderDataPtr->userEventBuffer.nextSlotToWrite * 4], data, slots * 4);
|
||
|
|
(void)memcpy(&RecorderDataPtr->userEventBuffer.dataBuffer[0], data + slots, (count - slots) * 4);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
(void)memcpy(&RecorderDataPtr->userEventBuffer.dataBuffer[RecorderDataPtr->userEventBuffer.nextSlotToWrite * 4], data, count * 4);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceUBHelper1
|
||
|
|
*
|
||
|
|
* Calls on prvTraceUserEventFormat() to do the actual formatting, then goes on
|
||
|
|
* to the next helper function.
|
||
|
|
******************************************************************************/
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1) && (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1))
|
||
|
|
static void prvTraceUBHelper1(traceUBChannel channel, traceString eventLabel, traceString formatLabel, va_list vl)
|
||
|
|
{
|
||
|
|
uint32_t data[(3 + MAX_ARG_SIZE) / 4];
|
||
|
|
uint8_t byteOffset = 4; /* Need room for timestamp */
|
||
|
|
uint8_t noOfSlots;
|
||
|
|
|
||
|
|
if (channel == 0)
|
||
|
|
{
|
||
|
|
/* We are dealing with an unknown channel format pair */
|
||
|
|
byteOffset = (uint8_t)(byteOffset + 4); /* Also need room for channel and format */
|
||
|
|
((uint16_t*)data)[2] = eventLabel;
|
||
|
|
((uint16_t*)data)[3] = formatLabel;
|
||
|
|
}
|
||
|
|
|
||
|
|
noOfSlots = prvTraceUserEventFormat((char*)&(RecorderDataPtr->SymbolTable.symbytes[formatLabel+4]), vl, (uint8_t*)data, byteOffset);
|
||
|
|
|
||
|
|
prvTraceUBHelper2(channel, data, noOfSlots);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceUBHelper2
|
||
|
|
*
|
||
|
|
* This function simply copies the data buffer to the actual user event buffer.
|
||
|
|
******************************************************************************/
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1) && (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1))
|
||
|
|
static void prvTraceUBHelper2(traceUBChannel channel, uint32_t* data, uint32_t noOfSlots)
|
||
|
|
{
|
||
|
|
static uint32_t old_timestamp = 0;
|
||
|
|
uint32_t old_nextSlotToWrite = 0;
|
||
|
|
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
TRACE_ASSERT((TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE) >= noOfSlots, "prvTraceUBHelper2: TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE is too small to handle this event.", TRC_UNUSED);
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
/* Store the timestamp */
|
||
|
|
prvTracePortGetTimeStamp(data);
|
||
|
|
|
||
|
|
if (*data < old_timestamp)
|
||
|
|
{
|
||
|
|
RecorderDataPtr->userEventBuffer.wraparoundCounter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
old_timestamp = *data;
|
||
|
|
|
||
|
|
/* Start by erasing any information in the channel buffer */
|
||
|
|
prvTraceClearChannelBuffer(noOfSlots);
|
||
|
|
|
||
|
|
prvTraceCopyToDataBuffer(data, noOfSlots); /* Will wrap around the data if necessary */
|
||
|
|
|
||
|
|
old_nextSlotToWrite = RecorderDataPtr->userEventBuffer.nextSlotToWrite; /* Save the index that we want to write the channel data at when we're done */
|
||
|
|
RecorderDataPtr->userEventBuffer.nextSlotToWrite = (RecorderDataPtr->userEventBuffer.nextSlotToWrite + noOfSlots) % (TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE); /* Make sure we never end up outside the buffer */
|
||
|
|
|
||
|
|
/* Write to the channel buffer to indicate that this user event is ready to be used */
|
||
|
|
if (channel != 0)
|
||
|
|
{
|
||
|
|
RecorderDataPtr->userEventBuffer.channelBuffer[old_nextSlotToWrite] = channel;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* 0xFF indicates that this is not a normal channel id */
|
||
|
|
RecorderDataPtr->userEventBuffer.channelBuffer[old_nextSlotToWrite] = (traceUBChannel)0xFF;
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* xTraceRegisterUBChannel
|
||
|
|
*
|
||
|
|
* Registers a channel for Separated User Events, i.e., those stored in the
|
||
|
|
* separate user event buffer.
|
||
|
|
*
|
||
|
|
* Note: Only available if TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER is enabled in
|
||
|
|
* trcSnapshotConfig.h
|
||
|
|
******************************************************************************/
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1) && (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1))
|
||
|
|
traceUBChannel xTraceRegisterUBChannel(traceString channel, traceString formatStr)
|
||
|
|
{
|
||
|
|
uint8_t i;
|
||
|
|
traceUBChannel retVal = 0;
|
||
|
|
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
TRACE_ASSERT(formatStr != 0, "xTraceRegisterChannelFormat: formatStr == 0", (traceUBChannel)0);
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
for (i = 1; i <= (TRC_CFG_UB_CHANNELS); i++) /* Size of the channels buffer is TRC_CFG_UB_CHANNELS + 1. Index 0 is unused. */
|
||
|
|
{
|
||
|
|
if(RecorderDataPtr->userEventBuffer.channels[i].name == 0 && RecorderDataPtr->userEventBuffer.channels[i].defaultFormat == 0)
|
||
|
|
{
|
||
|
|
/* Found empty slot */
|
||
|
|
RecorderDataPtr->userEventBuffer.channels[i].name = channel;
|
||
|
|
RecorderDataPtr->userEventBuffer.channels[i].defaultFormat = formatStr;
|
||
|
|
retVal = (traceUBChannel)i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (RecorderDataPtr->userEventBuffer.channels[i].name == channel && RecorderDataPtr->userEventBuffer.channels[i].defaultFormat == formatStr)
|
||
|
|
{
|
||
|
|
/* Found a match */
|
||
|
|
retVal = (traceUBChannel)i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
|
||
|
|
return retVal;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* vTraceUBData
|
||
|
|
*
|
||
|
|
* Slightly faster version of vTracePrintF() due to no lookups.
|
||
|
|
*
|
||
|
|
* Note: This is only available if TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER is
|
||
|
|
* enabled in trcSnapshotConfig.h
|
||
|
|
******************************************************************************/
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1) && (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1))
|
||
|
|
void vTraceUBData(traceUBChannel channelPair, ...)
|
||
|
|
{
|
||
|
|
va_list vl;
|
||
|
|
|
||
|
|
TRACE_ASSERT(channelPair != 0, "vTraceUBData: Not a valid traceUBChannel!", TRC_UNUSED);
|
||
|
|
|
||
|
|
va_start(vl, channelPair);
|
||
|
|
vTraceUBData_Helper(channelPair, vl);
|
||
|
|
va_end(vl);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* Extracts the channel name and format string from the traceUBChannel, then calls prvTraceUBHelper1. */
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1) && (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1))
|
||
|
|
void vTraceUBData_Helper(traceUBChannel channelPair, va_list vl)
|
||
|
|
{
|
||
|
|
traceString channel;
|
||
|
|
traceString formatStr;
|
||
|
|
|
||
|
|
TRACE_ASSERT(channelPair != 0, "vTraceUBData_Helper: channelPair == 0", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(channelPair <= (TRC_CFG_UB_CHANNELS), "vTraceUBData_Helper: ", TRC_UNUSED);
|
||
|
|
|
||
|
|
channel = RecorderDataPtr->userEventBuffer.channels[channelPair].name;
|
||
|
|
formatStr = RecorderDataPtr->userEventBuffer.channels[channelPair].defaultFormat;
|
||
|
|
|
||
|
|
prvTraceUBHelper1(channelPair, channel, formatStr, vl);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* vTraceUBEvent
|
||
|
|
*
|
||
|
|
* Slightly faster version of ... due to no lookups.
|
||
|
|
******************************************************************************/
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1) && (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1))
|
||
|
|
void vTraceUBEvent(traceUBChannel channelPair)
|
||
|
|
{
|
||
|
|
uint32_t data[(3 + MAX_ARG_SIZE) / 4];
|
||
|
|
|
||
|
|
TRACE_ASSERT(channelPair != 0, "vTraceUBEvent: channelPair == 0", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(channelPair <= (TRC_CFG_UB_CHANNELS), "vTraceUBEvent: ", TRC_UNUSED);
|
||
|
|
|
||
|
|
prvTraceUBHelper2(channelPair, data, 1); /* Only need one slot for timestamp */
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* vTracePrintF
|
||
|
|
*
|
||
|
|
* Generates User Event with formatted text and data, similar to a "printf".
|
||
|
|
* It is very fast compared to a normal "printf" since this function only
|
||
|
|
* stores the arguments. The actual formatting is done
|
||
|
|
* on the host PC when the trace is displayed in the viewer tool.
|
||
|
|
*
|
||
|
|
* User Event labels are created using xTraceRegisterString.
|
||
|
|
* Example:
|
||
|
|
*
|
||
|
|
* traceString adc_uechannel = xTraceRegisterString("ADC User Events");
|
||
|
|
* ...
|
||
|
|
* vTracePrintF(adc_uechannel,
|
||
|
|
* "ADC channel %d: %lf volts",
|
||
|
|
* ch, (double)adc_reading/(double)scale);
|
||
|
|
*
|
||
|
|
* This can be combined into one line, if desired, but this is slower:
|
||
|
|
*
|
||
|
|
* vTracePrintF(xTraceRegisterString("ADC User Events"),
|
||
|
|
* "ADC channel %d: %lf volts",
|
||
|
|
* ch, (double)adc_reading/(double)scale);
|
||
|
|
*
|
||
|
|
* Calling xTraceRegisterString multiple times will not create duplicate entries, but
|
||
|
|
* it is of course faster to just do it once, and then keep the handle for later
|
||
|
|
* use. If you don't have any data arguments, only a text label/string, it is
|
||
|
|
* better to use vTracePrint - it is faster.
|
||
|
|
*
|
||
|
|
* Format specifiers supported:
|
||
|
|
* %d - 32 bit signed integer
|
||
|
|
* %u - 32 bit unsigned integer
|
||
|
|
* %f - 32 bit float
|
||
|
|
* %s - string (is copied to the recorder symbol table)
|
||
|
|
* %hd - 16 bit signed integer
|
||
|
|
* %hu - 16 bit unsigned integer
|
||
|
|
* %bd - 8 bit signed integer
|
||
|
|
* %bu - 8 bit unsigned integer
|
||
|
|
* %lf - double-precision float (Note! See below...)
|
||
|
|
*
|
||
|
|
* Up to 15 data arguments are allowed, with a total size of maximum 32 byte.
|
||
|
|
* In case this is exceeded, the user event is changed into an error message.
|
||
|
|
*
|
||
|
|
* The data is stored in trace buffer, and is packed to allow storing multiple
|
||
|
|
* smaller data entries in the same 4-byte record, e.g., four 8-bit values.
|
||
|
|
* A string requires two bytes, as the symbol table is limited to 64K. Storing
|
||
|
|
* a double (%lf) uses two records, so this is quite costly. Use float (%f)
|
||
|
|
* unless the higher precision is really necessary.
|
||
|
|
*
|
||
|
|
* Note that the double-precision float (%lf) assumes a 64 bit double
|
||
|
|
* representation. This does not seem to be the case on e.g. PIC24 and PIC32.
|
||
|
|
* Before using a %lf argument on a 16-bit MCU, please verify that
|
||
|
|
* "sizeof(double)" actually gives 8 as expected. If not, use %f instead.
|
||
|
|
******************************************************************************/
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1))
|
||
|
|
void vTracePrintF(traceString eventLabel, const char* formatStr, ...)
|
||
|
|
{
|
||
|
|
va_list vl;
|
||
|
|
|
||
|
|
va_start(vl, formatStr);
|
||
|
|
vTracePrintF_Helper(eventLabel, formatStr, vl);
|
||
|
|
va_end(vl);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1))
|
||
|
|
void vTracePrintF_Helper(traceString eventLabel, const char* formatStr, va_list vl)
|
||
|
|
{
|
||
|
|
#if (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 0)
|
||
|
|
uint32_t noOfSlots;
|
||
|
|
UserEvent* ue1;
|
||
|
|
uint32_t tempDataBuffer[(3 + MAX_ARG_SIZE) / 4];
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
TRACE_ASSERT(formatStr != NULL, "vTracePrintF_Helper: formatStr == NULL", TRC_UNUSED);
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
|
||
|
|
if (RecorderDataPtr->recorderActive && handle_of_last_logged_task)
|
||
|
|
{
|
||
|
|
/* First, write the "primary" user event entry in the local buffer, but
|
||
|
|
let the event type be "EVENT_BEING_WRITTEN" for now...*/
|
||
|
|
|
||
|
|
ue1 = (UserEvent*)(&tempDataBuffer[0]);
|
||
|
|
|
||
|
|
ue1->type = EVENT_BEING_WRITTEN; /* Update this as the last step */
|
||
|
|
|
||
|
|
noOfSlots = prvTraceUserEventFormat(formatStr, vl, (uint8_t*)tempDataBuffer, 4);
|
||
|
|
|
||
|
|
/* Store the format string, with a reference to the channel symbol */
|
||
|
|
ue1->payload = prvTraceOpenSymbol(formatStr, eventLabel);
|
||
|
|
|
||
|
|
ue1->dts = (uint8_t)prvTraceGetDTS(0xFF);
|
||
|
|
|
||
|
|
/* prvTraceGetDTS might stop the recorder in some cases... */
|
||
|
|
if (RecorderDataPtr->recorderActive)
|
||
|
|
{
|
||
|
|
|
||
|
|
/* If the data does not fit in the remaining main buffer, wrap around to
|
||
|
|
0 if allowed, otherwise stop the recorder and quit). */
|
||
|
|
if (RecorderDataPtr->nextFreeIndex + noOfSlots > RecorderDataPtr->maxEvents)
|
||
|
|
{
|
||
|
|
#if (TRC_CFG_SNAPSHOT_MODE == TRC_SNAPSHOT_MODE_RING_BUFFER)
|
||
|
|
(void)memset(& RecorderDataPtr->eventData[RecorderDataPtr->nextFreeIndex * 4],
|
||
|
|
0,
|
||
|
|
(RecorderDataPtr->maxEvents - RecorderDataPtr->nextFreeIndex)*4);
|
||
|
|
RecorderDataPtr->nextFreeIndex = 0;
|
||
|
|
RecorderDataPtr->bufferIsFull = 1;
|
||
|
|
#else
|
||
|
|
|
||
|
|
/* Stop recorder, since the event data will not fit in the
|
||
|
|
buffer and not circular buffer in this case... */
|
||
|
|
vTraceStop();
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Check if recorder has been stopped (i.e., vTraceStop above) */
|
||
|
|
if (RecorderDataPtr->recorderActive)
|
||
|
|
{
|
||
|
|
/* Check that the buffer to be overwritten does not contain any user
|
||
|
|
events that would be partially overwritten. If so, they must be "killed"
|
||
|
|
by replacing the user event and following data with NULL events (i.e.,
|
||
|
|
using a memset to zero).*/
|
||
|
|
#if (TRC_CFG_SNAPSHOT_MODE == TRC_SNAPSHOT_MODE_RING_BUFFER)
|
||
|
|
prvCheckDataToBeOverwrittenForMultiEntryEvents((uint8_t)noOfSlots);
|
||
|
|
#endif
|
||
|
|
/* Copy the local buffer to the main buffer */
|
||
|
|
(void)memcpy(& RecorderDataPtr->eventData[RecorderDataPtr->nextFreeIndex * 4],
|
||
|
|
tempDataBuffer,
|
||
|
|
noOfSlots * 4);
|
||
|
|
|
||
|
|
/* Update the event type, i.e., number of data entries following the
|
||
|
|
main USER_EVENT entry (Note: important that this is after the memcpy,
|
||
|
|
but within the critical section!)*/
|
||
|
|
RecorderDataPtr->eventData[RecorderDataPtr->nextFreeIndex * 4] =
|
||
|
|
(uint8_t) ( USER_EVENT + noOfSlots - 1 );
|
||
|
|
|
||
|
|
/* Update the main buffer event index (already checked that it fits in
|
||
|
|
the buffer, so no need to check for wrapping)*/
|
||
|
|
|
||
|
|
RecorderDataPtr->nextFreeIndex += noOfSlots;
|
||
|
|
RecorderDataPtr->numEvents += noOfSlots;
|
||
|
|
|
||
|
|
if (RecorderDataPtr->nextFreeIndex >= (TRC_CFG_EVENT_BUFFER_SIZE))
|
||
|
|
{
|
||
|
|
#if (TRC_CFG_SNAPSHOT_MODE == TRC_SNAPSHOT_MODE_RING_BUFFER)
|
||
|
|
/* We have reached the end, but this is a ring buffer. Start from the beginning again. */
|
||
|
|
RecorderDataPtr->bufferIsFull = 1;
|
||
|
|
RecorderDataPtr->nextFreeIndex = 0;
|
||
|
|
#else
|
||
|
|
/* We have reached the end so we stop. */
|
||
|
|
vTraceStop();
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#if (TRC_CFG_SNAPSHOT_MODE == TRC_SNAPSHOT_MODE_RING_BUFFER)
|
||
|
|
/* Make sure the next entry is cleared correctly */
|
||
|
|
prvCheckDataToBeOverwrittenForMultiEntryEvents(1);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
|
||
|
|
#elif (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1)
|
||
|
|
/* Use the separate user event buffer */
|
||
|
|
traceString formatLabel;
|
||
|
|
traceUBChannel channel;
|
||
|
|
|
||
|
|
if (RecorderDataPtr->recorderActive && handle_of_last_logged_task)
|
||
|
|
{
|
||
|
|
formatLabel = xTraceRegisterString(formatStr);
|
||
|
|
|
||
|
|
channel = xTraceRegisterUBChannel(eventLabel, formatLabel);
|
||
|
|
|
||
|
|
prvTraceUBHelper1(channel, eventLabel, formatLabel, vl);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* vTracePrint
|
||
|
|
*
|
||
|
|
* Basic user event
|
||
|
|
*
|
||
|
|
* Generates a User Event with a text label. The label is created/looked up
|
||
|
|
* in the symbol table using xTraceRegisterString.
|
||
|
|
******************************************************************************/
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1))
|
||
|
|
void vTracePrint(traceString chn, const char* str)
|
||
|
|
{
|
||
|
|
#if (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 0)
|
||
|
|
UserEvent* ue;
|
||
|
|
uint8_t dts1;
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
if (RecorderDataPtr->recorderActive && handle_of_last_logged_task)
|
||
|
|
{
|
||
|
|
dts1 = (uint8_t)prvTraceGetDTS(0xFF);
|
||
|
|
ue = (UserEvent*) prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (ue != NULL)
|
||
|
|
{
|
||
|
|
ue->dts = dts1;
|
||
|
|
ue->type = USER_EVENT;
|
||
|
|
ue->payload = prvTraceOpenSymbol(str, chn);
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
|
||
|
|
#elif (TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER == 1)
|
||
|
|
traceUBChannel channel;
|
||
|
|
uint32_t noOfSlots = 1;
|
||
|
|
uint32_t tempDataBuffer[(3 + MAX_ARG_SIZE) / 4];
|
||
|
|
if (RecorderDataPtr->recorderActive && handle_of_last_logged_task)
|
||
|
|
{
|
||
|
|
traceString trcStr = prvTraceOpenSymbol(str, chn);
|
||
|
|
channel = xTraceRegisterUBChannel(chn, trcStr);
|
||
|
|
|
||
|
|
if (channel == 0)
|
||
|
|
{
|
||
|
|
/* We are dealing with an unknown channel format pair */
|
||
|
|
noOfSlots++; /* Also need room for channel and format */
|
||
|
|
((uint16_t*)tempDataBuffer)[2] = chn;
|
||
|
|
((uint16_t*)tempDataBuffer)[3] = trcStr;
|
||
|
|
}
|
||
|
|
|
||
|
|
prvTraceUBHelper2(channel, tempDataBuffer, noOfSlots);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* xTraceRegisterString
|
||
|
|
*
|
||
|
|
* Register strings in the recorder, e.g. for names of user event channels.
|
||
|
|
*
|
||
|
|
* Example:
|
||
|
|
* myEventHandle = xTraceRegisterString("MyUserEvent");
|
||
|
|
* ...
|
||
|
|
* vTracePrintF(myEventHandle, "My value is: %d", myValue);
|
||
|
|
******************************************************************************/
|
||
|
|
#if ((TRC_CFG_SCHEDULING_ONLY == 0) && (TRC_CFG_INCLUDE_USER_EVENTS == 1))
|
||
|
|
traceString xTraceRegisterString(const char* label)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(label != NULL, "xTraceRegisterString: label == NULL", (traceString)0);
|
||
|
|
TRACE_ASSERT(RecorderDataPtr != NULL, "Recorder not initialized, call vTraceEnable() first!", (traceHandle)0);
|
||
|
|
return prvTraceOpenSymbol(label, 0);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
#if ((!defined TRC_CFG_INCLUDE_READY_EVENTS) || (TRC_CFG_INCLUDE_READY_EVENTS == 1))
|
||
|
|
|
||
|
|
void prvTraceSetReadyEventsEnabled(int status)
|
||
|
|
{
|
||
|
|
readyEventsEnabled = status;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceStoreTaskReady
|
||
|
|
*
|
||
|
|
* This function stores a ready state for the task handle sent in as parameter.
|
||
|
|
******************************************************************************/
|
||
|
|
void prvTraceStoreTaskReady(traceHandle handle)
|
||
|
|
{
|
||
|
|
uint16_t dts3;
|
||
|
|
TREvent* tr;
|
||
|
|
uint8_t hnd8;
|
||
|
|
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
if (handle == 0)
|
||
|
|
{
|
||
|
|
/* On FreeRTOS v7.3.0, this occurs when creating tasks due to a bad
|
||
|
|
placement of the trace macro. In that case, the events are ignored. */
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (! readyEventsEnabled)
|
||
|
|
{
|
||
|
|
/* When creating tasks, ready events are also created. If creating
|
||
|
|
a "hidden" (not traced) task, we must therefore disable recording
|
||
|
|
of ready events to avoid an undesired ready event... */
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
TRACE_ASSERT(handle <= (TRC_CFG_NTASK), "prvTraceStoreTaskReady: Invalid value for handle", TRC_UNUSED);
|
||
|
|
|
||
|
|
if (recorder_busy)
|
||
|
|
{
|
||
|
|
/*************************************************************************
|
||
|
|
* This occurs if an ISR calls a trace function, preempting a previous
|
||
|
|
* trace call that is being processed in a different ISR or task.
|
||
|
|
* If this occurs, there is probably a problem in the definition of the
|
||
|
|
* recorder's internal critical sections (TRACE_ENTER_CRITICAL_SECTION and
|
||
|
|
* TRACE_EXIT_CRITICAL_SECTION). They must disable the RTOS tick interrupt
|
||
|
|
* and any other ISRs that calls the trace recorder directly or via
|
||
|
|
* traced kernel functions. The ARM port disables all interrupts using the
|
||
|
|
* PRIMASK register to avoid this issue.
|
||
|
|
*************************************************************************/
|
||
|
|
prvTraceError("Recorder busy - high priority ISR using syscall? (1)");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
if (RecorderDataPtr->recorderActive) /* Need to repeat this check! */
|
||
|
|
{
|
||
|
|
dts3 = (uint16_t)prvTraceGetDTS(0xFFFF);
|
||
|
|
hnd8 = prvTraceGet8BitHandle(handle);
|
||
|
|
tr = (TREvent*)prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (tr != NULL)
|
||
|
|
{
|
||
|
|
tr->type = DIV_TASK_READY;
|
||
|
|
tr->dts = dts3;
|
||
|
|
tr->objHandle = hnd8;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceStoreLowPower
|
||
|
|
*
|
||
|
|
* This function stores a low power state.
|
||
|
|
******************************************************************************/
|
||
|
|
void prvTraceStoreLowPower(uint32_t flag)
|
||
|
|
{
|
||
|
|
uint16_t dts;
|
||
|
|
LPEvent* lp;
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
TRACE_ASSERT(flag <= 1, "prvTraceStoreLowPower: Invalid flag value", TRC_UNUSED);
|
||
|
|
|
||
|
|
if (recorder_busy)
|
||
|
|
{
|
||
|
|
/*************************************************************************
|
||
|
|
* This occurs if an ISR calls a trace function, preempting a previous
|
||
|
|
* trace call that is being processed in a different ISR or task.
|
||
|
|
* If this occurs, there is probably a problem in the definition of the
|
||
|
|
* recorder's internal critical sections (TRACE_ENTER_CRITICAL_SECTION and
|
||
|
|
* TRACE_EXIT_CRITICAL_SECTION). They must disable the RTOS tick interrupt
|
||
|
|
* and any other ISRs that calls the trace recorder directly or via
|
||
|
|
* traced kernel functions. The ARM port disables all interrupts using the
|
||
|
|
* PRIMASK register to avoid this issue.
|
||
|
|
*************************************************************************/
|
||
|
|
prvTraceError("Recorder busy - high priority ISR using syscall? (1)");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
if (RecorderDataPtr->recorderActive)
|
||
|
|
{
|
||
|
|
dts = (uint16_t)prvTraceGetDTS(0xFFFF);
|
||
|
|
lp = (LPEvent*)prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (lp != NULL)
|
||
|
|
{
|
||
|
|
lp->type = (uint8_t) (LOW_POWER_BEGIN + ( uint8_t ) flag); /* BEGIN or END depending on flag */
|
||
|
|
lp->dts = dts;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* vTraceStoreMemMangEvent
|
||
|
|
*
|
||
|
|
* This function stores malloc and free events. Each call requires two records,
|
||
|
|
* for size and address respectively. The event code parameter (ecode) is applied
|
||
|
|
* to the first record (size) and the following address record gets event
|
||
|
|
* code "ecode + 1", so make sure this is respected in the event code table.
|
||
|
|
* Note: On "free" calls, the signed_size parameter should be negative.
|
||
|
|
******************************************************************************/
|
||
|
|
#if (TRC_CFG_INCLUDE_MEMMANG_EVENTS == 1)
|
||
|
|
#if (TRC_CFG_SCHEDULING_ONLY == 0)
|
||
|
|
void vTraceStoreMemMangEvent(uint32_t ecode, uint32_t address, int32_t signed_size)
|
||
|
|
{
|
||
|
|
uint8_t dts1;
|
||
|
|
MemEventSize * ms;
|
||
|
|
MemEventAddr * ma;
|
||
|
|
uint16_t size_low;
|
||
|
|
uint16_t addr_low;
|
||
|
|
uint8_t addr_high;
|
||
|
|
uint32_t size;
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
if (RecorderDataPtr == NULL)
|
||
|
|
{
|
||
|
|
/* Occurs in vTraceInitTraceData, if using dynamic allocation. */
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (signed_size < 0)
|
||
|
|
size = (uint32_t)(- signed_size);
|
||
|
|
else
|
||
|
|
size = (uint32_t)(signed_size);
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
|
||
|
|
heapMemUsage = heapMemUsage + (uint32_t)signed_size;
|
||
|
|
|
||
|
|
if (RecorderDataPtr->recorderActive)
|
||
|
|
{
|
||
|
|
dts1 = (uint8_t)prvTraceGetDTS(0xFF);
|
||
|
|
size_low = (uint16_t)prvTraceGetParam(0xFFFF, size);
|
||
|
|
ms = (MemEventSize *)prvTraceNextFreeEventBufferSlot();
|
||
|
|
|
||
|
|
if (ms != NULL)
|
||
|
|
{
|
||
|
|
ms->dts = dts1;
|
||
|
|
ms->type = NULL_EVENT; /* Updated when all events are written */
|
||
|
|
ms->size = size_low;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
|
||
|
|
/* Storing a second record with address (signals "failed" if null) */
|
||
|
|
#if (TRC_CFG_HEAP_SIZE_BELOW_16M)
|
||
|
|
/* If the heap address range is within 16 MB, i.e., the upper 8 bits
|
||
|
|
of addresses are constant, this optimization avoids storing an extra
|
||
|
|
event record by ignoring the upper 8 bit of the address */
|
||
|
|
addr_low = address & 0xFFFF;
|
||
|
|
addr_high = (address >> 16) & 0xFF;
|
||
|
|
#else
|
||
|
|
/* The whole 32 bit address is stored using a second event record
|
||
|
|
for the upper 16 bit */
|
||
|
|
addr_low = (uint16_t)prvTraceGetParam(0xFFFF, address);
|
||
|
|
addr_high = 0;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
ma = (MemEventAddr *) prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (ma != NULL)
|
||
|
|
{
|
||
|
|
ma->addr_low = addr_low;
|
||
|
|
ma->addr_high = addr_high;
|
||
|
|
ma->type = (uint8_t) (ecode + 1); /* Note this! */
|
||
|
|
ms->type = (uint8_t) ecode;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
RecorderDataPtr->heapMemUsage = heapMemUsage;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
#endif /* TRC_CFG_SCHEDULING_ONLY */
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceStoreKernelCall
|
||
|
|
*
|
||
|
|
* This is the main integration point for storing kernel calls, and
|
||
|
|
* is called by the hooks in trcKernelHooks.h (see trcKernelPort.h for event codes).
|
||
|
|
******************************************************************************/
|
||
|
|
#if (TRC_CFG_SCHEDULING_ONLY == 0)
|
||
|
|
void prvTraceStoreKernelCall(uint32_t ecode, traceObjectClass objectClass, uint32_t objectNumber)
|
||
|
|
{
|
||
|
|
KernelCall * kse;
|
||
|
|
uint16_t dts1;
|
||
|
|
uint8_t hnd8;
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
TRACE_ASSERT(ecode < 0xFF, "prvTraceStoreKernelCall: ecode >= 0xFF", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(objectClass < TRACE_NCLASSES, "prvTraceStoreKernelCall: objectClass >= TRACE_NCLASSES", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(objectNumber <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectClass], "prvTraceStoreKernelCall: Invalid value for objectNumber", TRC_UNUSED);
|
||
|
|
|
||
|
|
if (recorder_busy)
|
||
|
|
{
|
||
|
|
/*************************************************************************
|
||
|
|
* This occurs if an ISR calls a trace function, preempting a previous
|
||
|
|
* trace call that is being processed in a different ISR or task.
|
||
|
|
* If this occurs, there is probably a problem in the definition of the
|
||
|
|
* recorder's internal critical sections (TRACE_ENTER_CRITICAL_SECTION and
|
||
|
|
* TRACE_EXIT_CRITICAL_SECTION). They must disable the RTOS tick interrupt
|
||
|
|
* and any other ISRs that calls the trace recorder directly or via
|
||
|
|
* traced kernel functions. The ARM port disables all interrupts using the
|
||
|
|
* PRIMASK register to avoid this issue.
|
||
|
|
*************************************************************************/
|
||
|
|
prvTraceError("Recorder busy - high priority ISR using syscall? (2)");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (handle_of_last_logged_task == 0)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
if (RecorderDataPtr->recorderActive)
|
||
|
|
{
|
||
|
|
dts1 = (uint16_t)prvTraceGetDTS(0xFFFF);
|
||
|
|
hnd8 = prvTraceGet8BitHandle((traceHandle)objectNumber);
|
||
|
|
kse = (KernelCall*) prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (kse != NULL)
|
||
|
|
{
|
||
|
|
kse->dts = dts1;
|
||
|
|
kse->type = (uint8_t)ecode;
|
||
|
|
kse->objHandle = hnd8;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
#endif /* TRC_CFG_SCHEDULING_ONLY */
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceStoreKernelCallWithParam
|
||
|
|
*
|
||
|
|
* Used for storing kernel calls with a handle and a numeric parameter. If the
|
||
|
|
* numeric parameter does not fit in one byte, and extra XPS event is inserted
|
||
|
|
* before the kernel call event containing the three upper bytes.
|
||
|
|
******************************************************************************/
|
||
|
|
#if (TRC_CFG_SCHEDULING_ONLY == 0)
|
||
|
|
void prvTraceStoreKernelCallWithParam(uint32_t evtcode,
|
||
|
|
traceObjectClass objectClass,
|
||
|
|
uint32_t objectNumber,
|
||
|
|
uint32_t param)
|
||
|
|
{
|
||
|
|
KernelCallWithParamAndHandle * kse;
|
||
|
|
uint8_t dts2;
|
||
|
|
uint8_t hnd8;
|
||
|
|
uint8_t p8;
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
TRACE_ASSERT(evtcode < 0xFF, "prvTraceStoreKernelCallWithParam: evtcode >= 0xFF", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(objectClass < TRACE_NCLASSES, "prvTraceStoreKernelCallWithParam: objectClass >= TRACE_NCLASSES", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(objectNumber <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectClass], "prvTraceStoreKernelCallWithParam: Invalid value for objectNumber", TRC_UNUSED);
|
||
|
|
|
||
|
|
if (recorder_busy)
|
||
|
|
{
|
||
|
|
/*************************************************************************
|
||
|
|
* This occurs if an ISR calls a trace function, preempting a previous
|
||
|
|
* trace call that is being processed in a different ISR or task.
|
||
|
|
* If this occurs, there is probably a problem in the definition of the
|
||
|
|
* recorder's internal critical sections (TRACE_ENTER_CRITICAL_SECTION and
|
||
|
|
* TRACE_EXIT_CRITICAL_SECTION). They must disable the RTOS tick interrupt
|
||
|
|
* and any other ISRs that calls the trace recorder directly or via
|
||
|
|
* traced kernel functions. The ARM port disables all interrupts using the
|
||
|
|
* PRIMASK register to avoid this issue.
|
||
|
|
*************************************************************************/
|
||
|
|
prvTraceError("Recorder busy - high priority ISR using syscall? (3)");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
if (RecorderDataPtr->recorderActive && handle_of_last_logged_task)
|
||
|
|
{
|
||
|
|
dts2 = (uint8_t)prvTraceGetDTS(0xFF);
|
||
|
|
p8 = (uint8_t) prvTraceGetParam(0xFF, param);
|
||
|
|
hnd8 = prvTraceGet8BitHandle((traceHandle)objectNumber);
|
||
|
|
kse = (KernelCallWithParamAndHandle*) prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (kse != NULL)
|
||
|
|
{
|
||
|
|
kse->dts = dts2;
|
||
|
|
kse->type = (uint8_t)evtcode;
|
||
|
|
kse->objHandle = hnd8;
|
||
|
|
kse->param = p8;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
#endif /* TRC_CFG_SCHEDULING_ONLY */
|
||
|
|
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceGetParam
|
||
|
|
*
|
||
|
|
* Used for storing extra bytes for kernel calls with numeric parameters.
|
||
|
|
*
|
||
|
|
* May only be called within a critical section!
|
||
|
|
******************************************************************************/
|
||
|
|
#if (TRC_CFG_SCHEDULING_ONLY == 0)
|
||
|
|
static uint32_t prvTraceGetParam(uint32_t param_max, uint32_t param)
|
||
|
|
{
|
||
|
|
XPSEvent* xps;
|
||
|
|
|
||
|
|
TRACE_ASSERT(param_max == 0xFF || param_max == 0xFFFF,
|
||
|
|
"prvTraceGetParam: Invalid value for param_max", param);
|
||
|
|
|
||
|
|
if (param <= param_max)
|
||
|
|
{
|
||
|
|
return param;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
xps = (XPSEvent*) prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (xps != NULL)
|
||
|
|
{
|
||
|
|
xps->type = DIV_XPS;
|
||
|
|
xps->xps_8 = (uint8_t)((param & (0xFF00 & ~param_max)) >> 8);
|
||
|
|
xps->xps_16 = (uint16_t)((param & (0xFFFF0000 & ~param_max)) >> 16);
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
|
||
|
|
return param & param_max;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceStoreKernelCallWithNumericParamOnly
|
||
|
|
*
|
||
|
|
* Used for storing kernel calls with numeric parameters only. This is
|
||
|
|
* only used for traceTASK_DELAY and traceDELAY_UNTIL at the moment.
|
||
|
|
******************************************************************************/
|
||
|
|
#if (TRC_CFG_SCHEDULING_ONLY == 0)
|
||
|
|
void prvTraceStoreKernelCallWithNumericParamOnly(uint32_t evtcode, uint32_t param)
|
||
|
|
{
|
||
|
|
KernelCallWithParam16 * kse;
|
||
|
|
uint8_t dts6;
|
||
|
|
uint16_t restParam;
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
restParam = 0;
|
||
|
|
|
||
|
|
TRACE_ASSERT(evtcode < 0xFF, "prvTraceStoreKernelCallWithNumericParamOnly: Invalid value for evtcode", TRC_UNUSED);
|
||
|
|
|
||
|
|
if (recorder_busy)
|
||
|
|
{
|
||
|
|
/*************************************************************************
|
||
|
|
* This occurs if an ISR calls a trace function, preempting a previous
|
||
|
|
* trace call that is being processed in a different ISR or task.
|
||
|
|
* If this occurs, there is probably a problem in the definition of the
|
||
|
|
* recorder's internal critical sections (TRACE_ENTER_CRITICAL_SECTION and
|
||
|
|
* TRACE_EXIT_CRITICAL_SECTION). They must disable the RTOS tick interrupt
|
||
|
|
* and any other ISRs that calls the trace recorder directly or via
|
||
|
|
* traced kernel functions. The ARM port disables all interrupts using the
|
||
|
|
* PRIMASK register to avoid this issue.
|
||
|
|
*************************************************************************/
|
||
|
|
prvTraceError("Recorder busy - high priority ISR using syscall? (4)");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
if (RecorderDataPtr->recorderActive && handle_of_last_logged_task)
|
||
|
|
{
|
||
|
|
dts6 = (uint8_t)prvTraceGetDTS(0xFF);
|
||
|
|
restParam = (uint16_t)prvTraceGetParam(0xFFFF, param);
|
||
|
|
kse = (KernelCallWithParam16*) prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (kse != NULL)
|
||
|
|
{
|
||
|
|
kse->dts = dts6;
|
||
|
|
kse->type = (uint8_t)evtcode;
|
||
|
|
kse->param = restParam;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
}
|
||
|
|
#endif /* TRC_CFG_SCHEDULING_ONLY */
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceStoreTaskswitch
|
||
|
|
* Called by the scheduler from the SWITCHED_OUT hook, and by uiTraceStart.
|
||
|
|
* At this point interrupts are assumed to be disabled!
|
||
|
|
******************************************************************************/
|
||
|
|
void prvTraceStoreTaskswitch(traceHandle task_handle)
|
||
|
|
{
|
||
|
|
uint16_t dts3;
|
||
|
|
TSEvent* ts;
|
||
|
|
uint8_t hnd8;
|
||
|
|
#if (TRC_CFG_INCLUDE_ISR_TRACING == 1)
|
||
|
|
extern int32_t isPendingContextSwitch;
|
||
|
|
#endif
|
||
|
|
trcSR_ALLOC_CRITICAL_SECTION_ON_CORTEX_M_ONLY();
|
||
|
|
|
||
|
|
TRACE_ASSERT(task_handle <= (TRC_CFG_NTASK),
|
||
|
|
"prvTraceStoreTaskswitch: Invalid value for task_handle", TRC_UNUSED);
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN_ON_CORTEX_M_ONLY();
|
||
|
|
|
||
|
|
if ((task_handle != handle_of_last_logged_task) && (RecorderDataPtr->recorderActive))
|
||
|
|
{
|
||
|
|
#if (TRC_CFG_INCLUDE_ISR_TRACING == 1)
|
||
|
|
isPendingContextSwitch = 0;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
dts3 = (uint16_t)prvTraceGetDTS(0xFFFF);
|
||
|
|
handle_of_last_logged_task = task_handle;
|
||
|
|
hnd8 = prvTraceGet8BitHandle(handle_of_last_logged_task);
|
||
|
|
ts = (TSEvent*)prvTraceNextFreeEventBufferSlot();
|
||
|
|
|
||
|
|
if (ts != NULL)
|
||
|
|
{
|
||
|
|
if (prvTraceGetObjectState(TRACE_CLASS_TASK,
|
||
|
|
handle_of_last_logged_task) == TASK_STATE_INSTANCE_ACTIVE)
|
||
|
|
{
|
||
|
|
ts->type = TS_TASK_RESUME;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ts->type = TS_TASK_BEGIN;
|
||
|
|
}
|
||
|
|
|
||
|
|
ts->dts = dts3;
|
||
|
|
ts->objHandle = hnd8;
|
||
|
|
|
||
|
|
prvTraceSetObjectState(TRACE_CLASS_TASK,
|
||
|
|
handle_of_last_logged_task,
|
||
|
|
TASK_STATE_INSTANCE_ACTIVE);
|
||
|
|
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_END_ON_CORTEX_M_ONLY();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceStoreObjectNameOnCloseEvent
|
||
|
|
*
|
||
|
|
* Updates the symbol table with the name of this object from the dynamic
|
||
|
|
* objects table and stores a "close" event, holding the mapping between handle
|
||
|
|
* and name (a symbol table handle). The stored name-handle mapping is thus the
|
||
|
|
* "old" one, valid up until this point.
|
||
|
|
******************************************************************************/
|
||
|
|
void prvTraceStoreObjectNameOnCloseEvent(uint8_t evtcode, traceHandle handle,
|
||
|
|
traceObjectClass objectclass)
|
||
|
|
{
|
||
|
|
ObjCloseNameEvent * ce;
|
||
|
|
const char * name;
|
||
|
|
traceString idx;
|
||
|
|
|
||
|
|
TRACE_ASSERT(objectclass < TRACE_NCLASSES,
|
||
|
|
"prvTraceStoreObjectNameOnCloseEvent: objectclass >= TRACE_NCLASSES", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(handle <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectclass],
|
||
|
|
"prvTraceStoreObjectNameOnCloseEvent: Invalid value for handle", TRC_UNUSED);
|
||
|
|
|
||
|
|
if (RecorderDataPtr->recorderActive)
|
||
|
|
{
|
||
|
|
uint8_t hnd8 = prvTraceGet8BitHandle(handle);
|
||
|
|
name = TRACE_PROPERTY_NAME_GET(objectclass, handle);
|
||
|
|
idx = prvTraceOpenSymbol(name, 0);
|
||
|
|
|
||
|
|
// Interrupt disable not necessary, already done in trcHooks.h macro
|
||
|
|
ce = (ObjCloseNameEvent*) prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (ce != NULL)
|
||
|
|
{
|
||
|
|
ce->type = (uint8_t) evtcode;
|
||
|
|
ce->objHandle = hnd8;
|
||
|
|
ce->symbolIndex = idx;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void prvTraceStoreObjectPropertiesOnCloseEvent(uint8_t evtcode, traceHandle handle,
|
||
|
|
traceObjectClass objectclass)
|
||
|
|
{
|
||
|
|
ObjClosePropEvent * pe;
|
||
|
|
|
||
|
|
TRACE_ASSERT(objectclass < TRACE_NCLASSES,
|
||
|
|
"prvTraceStoreObjectPropertiesOnCloseEvent: objectclass >= TRACE_NCLASSES", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(handle <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectclass],
|
||
|
|
"prvTraceStoreObjectPropertiesOnCloseEvent: Invalid value for handle", TRC_UNUSED);
|
||
|
|
|
||
|
|
if (RecorderDataPtr->recorderActive)
|
||
|
|
{
|
||
|
|
// Interrupt disable not necessary, already done in trcHooks.h macro
|
||
|
|
pe = (ObjClosePropEvent*) prvTraceNextFreeEventBufferSlot();
|
||
|
|
if (pe != NULL)
|
||
|
|
{
|
||
|
|
if (objectclass == TRACE_CLASS_TASK)
|
||
|
|
{
|
||
|
|
pe->arg1 = TRACE_PROPERTY_ACTOR_PRIORITY(objectclass, handle);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pe->arg1 = TRACE_PROPERTY_OBJECT_STATE(objectclass, handle);
|
||
|
|
}
|
||
|
|
pe->type = evtcode;
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void prvTraceSetPriorityProperty(uint8_t objectclass, traceHandle id, uint8_t value)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(objectclass < TRACE_NCLASSES,
|
||
|
|
"prvTraceSetPriorityProperty: objectclass >= TRACE_NCLASSES", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(id <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectclass],
|
||
|
|
"prvTraceSetPriorityProperty: Invalid value for id", TRC_UNUSED);
|
||
|
|
|
||
|
|
TRACE_PROPERTY_ACTOR_PRIORITY(objectclass, id) = value;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8_t prvTraceGetPriorityProperty(uint8_t objectclass, traceHandle id)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(objectclass < TRACE_NCLASSES,
|
||
|
|
"prvTraceGetPriorityProperty: objectclass >= TRACE_NCLASSES", 0);
|
||
|
|
TRACE_ASSERT(id <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectclass],
|
||
|
|
"prvTraceGetPriorityProperty: Invalid value for id", 0);
|
||
|
|
|
||
|
|
return TRACE_PROPERTY_ACTOR_PRIORITY(objectclass, id);
|
||
|
|
}
|
||
|
|
|
||
|
|
void prvTraceSetObjectState(uint8_t objectclass, traceHandle id, uint8_t value)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(objectclass < TRACE_NCLASSES,
|
||
|
|
"prvTraceSetObjectState: objectclass >= TRACE_NCLASSES", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(id <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectclass],
|
||
|
|
"prvTraceSetObjectState: Invalid value for id", TRC_UNUSED);
|
||
|
|
|
||
|
|
TRACE_PROPERTY_OBJECT_STATE(objectclass, id) = value;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8_t prvTraceGetObjectState(uint8_t objectclass, traceHandle id)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(objectclass < TRACE_NCLASSES,
|
||
|
|
"prvTraceGetObjectState: objectclass >= TRACE_NCLASSES", 0);
|
||
|
|
TRACE_ASSERT(id <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectclass],
|
||
|
|
"prvTraceGetObjectState: Invalid value for id", 0);
|
||
|
|
|
||
|
|
return TRACE_PROPERTY_OBJECT_STATE(objectclass, id);
|
||
|
|
}
|
||
|
|
|
||
|
|
void prvTraceSetTaskInstanceFinished(traceHandle handle)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(handle <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[TRACE_CLASS_TASK],
|
||
|
|
"prvTraceSetTaskInstanceFinished: Invalid value for handle", TRC_UNUSED);
|
||
|
|
|
||
|
|
#if (TRC_CFG_USE_IMPLICIT_IFE_RULES == 1)
|
||
|
|
TRACE_PROPERTY_OBJECT_STATE(TRACE_CLASS_TASK, handle) = 0;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* Static data initializations
|
||
|
|
******************************************************************************/
|
||
|
|
|
||
|
|
/* A set of stacks that keeps track of available object handles for each class.
|
||
|
|
The stacks are empty initially, meaning that allocation of new handles will be
|
||
|
|
based on a counter (for each object class). Any delete operation will
|
||
|
|
return the handle to the corresponding stack, for reuse on the next allocate.*/
|
||
|
|
objectHandleStackType objectHandleStacks = { { 0 }, { 0 }, { 0 }, { 0 }, { 0 } };
|
||
|
|
|
||
|
|
/* Initial TRC_HWTC_COUNT value, for detecting if the time-stamping source is
|
||
|
|
enabled. If using the OS periodic timer for time-stamping, this might not
|
||
|
|
have been configured on the earliest events during the startup. */
|
||
|
|
uint32_t init_hwtc_count;
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* RecorderData
|
||
|
|
*
|
||
|
|
* The main data structure in snapshot mode, when using the default static memory
|
||
|
|
* allocation (TRC_RECORDER_BUFFER_ALLOCATION_STATIC). The recorder uses a pointer
|
||
|
|
* RecorderDataPtr to access the data, to also allow for dynamic or custom data
|
||
|
|
* allocation (see TRC_CFG_RECORDER_BUFFER_ALLOCATION).
|
||
|
|
******************************************************************************/
|
||
|
|
#if (TRC_CFG_RECORDER_BUFFER_ALLOCATION == TRC_RECORDER_BUFFER_ALLOCATION_STATIC)
|
||
|
|
RecorderDataType RecorderData;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* RecorderDataPtr
|
||
|
|
*
|
||
|
|
* Pointer to the main data structure, when in snapshot mode.
|
||
|
|
******************************************************************************/
|
||
|
|
RecorderDataType* RecorderDataPtr = NULL;
|
||
|
|
|
||
|
|
/* This version of the function dynamically allocates the trace data */
|
||
|
|
void prvTraceInitTraceData()
|
||
|
|
{
|
||
|
|
|
||
|
|
if (RecorderDataPtr == NULL)
|
||
|
|
{
|
||
|
|
#if (TRC_CFG_RECORDER_BUFFER_ALLOCATION == TRC_RECORDER_BUFFER_ALLOCATION_STATIC)
|
||
|
|
RecorderDataPtr = &RecorderData;
|
||
|
|
#elif (TRC_CFG_RECORDER_BUFFER_ALLOCATION == TRC_RECORDER_BUFFER_ALLOCATION_DYNAMIC)
|
||
|
|
RecorderDataPtr = (RecorderDataType*)TRACE_MALLOC(sizeof(RecorderDataType));
|
||
|
|
if (! RecorderDataPtr)
|
||
|
|
{
|
||
|
|
prvTraceError("Failed allocating recorder buffer!");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
#elif (TRC_CFG_RECORDER_BUFFER_ALLOCATION == TRC_RECORDER_BUFFER_ALLOCATION_CUSTOM)
|
||
|
|
if (! RecorderDataPtr)
|
||
|
|
{
|
||
|
|
prvTraceError("Recorder data pointer not set! Use vTraceSetRecorderDataBuffer().");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (RecorderDataPtr->startmarker0 == 1)
|
||
|
|
{
|
||
|
|
/* Already initialized */
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
init_hwtc_count = TRC_HWTC_COUNT;
|
||
|
|
|
||
|
|
(void)memset(RecorderDataPtr, 0, sizeof(RecorderDataType));
|
||
|
|
|
||
|
|
RecorderDataPtr->version = TRACE_KERNEL_VERSION;
|
||
|
|
RecorderDataPtr->minor_version = TRACE_MINOR_VERSION;
|
||
|
|
RecorderDataPtr->irq_priority_order = TRC_IRQ_PRIORITY_ORDER;
|
||
|
|
RecorderDataPtr->filesize = sizeof(RecorderDataType);
|
||
|
|
RecorderDataPtr->maxEvents = (TRC_CFG_EVENT_BUFFER_SIZE);
|
||
|
|
RecorderDataPtr->debugMarker0 = (int32_t) 0xF0F0F0F0;
|
||
|
|
RecorderDataPtr->isUsing16bitHandles = TRC_CFG_USE_16BIT_OBJECT_HANDLES;
|
||
|
|
RecorderDataPtr->isrTailchainingThreshold = TRC_CFG_ISR_TAILCHAINING_THRESHOLD;
|
||
|
|
|
||
|
|
/* This function is kernel specific */
|
||
|
|
vTraceInitObjectPropertyTable();
|
||
|
|
|
||
|
|
RecorderDataPtr->debugMarker1 = (int32_t)0xF1F1F1F1;
|
||
|
|
RecorderDataPtr->SymbolTable.symTableSize = (TRC_CFG_SYMBOL_TABLE_SIZE);
|
||
|
|
RecorderDataPtr->SymbolTable.nextFreeSymbolIndex = 1;
|
||
|
|
#if (TRC_CFG_INCLUDE_FLOAT_SUPPORT == 1)
|
||
|
|
RecorderDataPtr->exampleFloatEncoding = 1.0f; /* otherwise already zero */
|
||
|
|
#endif
|
||
|
|
RecorderDataPtr->debugMarker2 = (int32_t)0xF2F2F2F2;
|
||
|
|
prvStrncpy(RecorderDataPtr->systemInfo, "Trace Recorder Demo", 80);
|
||
|
|
RecorderDataPtr->debugMarker3 = (int32_t)0xF3F3F3F3;
|
||
|
|
RecorderDataPtr->endmarker0 = 0x0A;
|
||
|
|
RecorderDataPtr->endmarker1 = 0x0B;
|
||
|
|
RecorderDataPtr->endmarker2 = 0x0C;
|
||
|
|
RecorderDataPtr->endmarker3 = 0x0D;
|
||
|
|
RecorderDataPtr->endmarker4 = 0x71;
|
||
|
|
RecorderDataPtr->endmarker5 = 0x72;
|
||
|
|
RecorderDataPtr->endmarker6 = 0x73;
|
||
|
|
RecorderDataPtr->endmarker7 = 0x74;
|
||
|
|
RecorderDataPtr->endmarker8 = 0xF1;
|
||
|
|
RecorderDataPtr->endmarker9 = 0xF2;
|
||
|
|
RecorderDataPtr->endmarker10 = 0xF3;
|
||
|
|
RecorderDataPtr->endmarker11 = 0xF4;
|
||
|
|
|
||
|
|
#if TRC_CFG_USE_SEPARATE_USER_EVENT_BUFFER
|
||
|
|
RecorderDataPtr->userEventBuffer.bufferID = 1;
|
||
|
|
RecorderDataPtr->userEventBuffer.version = 0;
|
||
|
|
RecorderDataPtr->userEventBuffer.numberOfSlots = (TRC_CFG_SEPARATE_USER_EVENT_BUFFER_SIZE);
|
||
|
|
RecorderDataPtr->userEventBuffer.numberOfChannels = (TRC_CFG_UB_CHANNELS) + 1;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* Kernel specific initialization of the objectHandleStacks variable */
|
||
|
|
vTraceInitObjectHandleStack();
|
||
|
|
|
||
|
|
|
||
|
|
/* Finally, the 12-byte "start markers" are initialized, allowing for
|
||
|
|
Tracealyzer to find the trace data in a larger RAM dump.
|
||
|
|
|
||
|
|
The start and end markers must be unique, but without proper precautions there
|
||
|
|
might be a risk of accidental duplicates of the start/end markers, e.g., due to
|
||
|
|
compiler optimizations.
|
||
|
|
|
||
|
|
The below initialization of the start marker is therefore made in reverse order
|
||
|
|
and the fields are volatile to ensure this assignment order. This to avoid any
|
||
|
|
chance of accidental duplicates of this elsewhere in memory.
|
||
|
|
|
||
|
|
Moreover, the fields are set byte-by-byte to avoid endian issues.*/
|
||
|
|
|
||
|
|
RecorderDataPtr->startmarker11 = 0xF4;
|
||
|
|
RecorderDataPtr->startmarker10 = 0xF3;
|
||
|
|
RecorderDataPtr->startmarker9 = 0xF2;
|
||
|
|
RecorderDataPtr->startmarker8 = 0xF1;
|
||
|
|
RecorderDataPtr->startmarker7 = 0x74;
|
||
|
|
RecorderDataPtr->startmarker6 = 0x73;
|
||
|
|
RecorderDataPtr->startmarker5 = 0x72;
|
||
|
|
RecorderDataPtr->startmarker4 = 0x71;
|
||
|
|
RecorderDataPtr->startmarker3 = 0x04;
|
||
|
|
RecorderDataPtr->startmarker2 = 0x03;
|
||
|
|
RecorderDataPtr->startmarker1 = 0x02;
|
||
|
|
RecorderDataPtr->startmarker0 = 0x01;
|
||
|
|
|
||
|
|
if (traceErrorMessage != NULL)
|
||
|
|
{
|
||
|
|
// An error was detected before vTraceEnable was called, make sure this is stored in the trace data.
|
||
|
|
prvStrncpy(RecorderDataPtr->systemInfo, traceErrorMessage, 80);
|
||
|
|
RecorderDataPtr->internalErrorOccured = 1;
|
||
|
|
vTraceStop();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#ifdef TRC_PORT_SPECIFIC_INIT
|
||
|
|
TRC_PORT_SPECIFIC_INIT();
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void* prvTraceNextFreeEventBufferSlot(void)
|
||
|
|
{
|
||
|
|
if (! RecorderDataPtr->recorderActive)
|
||
|
|
{
|
||
|
|
/* If an XTS or XPS event prior to the main event has filled the buffer
|
||
|
|
before saving the main event, and store mode is "stop when full". */
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (RecorderDataPtr->nextFreeIndex >= (TRC_CFG_EVENT_BUFFER_SIZE))
|
||
|
|
{
|
||
|
|
prvTraceError("Attempt to index outside event buffer!");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
return (void*)(&RecorderDataPtr->eventData[RecorderDataPtr->nextFreeIndex*4]);
|
||
|
|
}
|
||
|
|
|
||
|
|
uint16_t uiIndexOfObject(traceHandle objecthandle, uint8_t objectclass)
|
||
|
|
{
|
||
|
|
TRACE_ASSERT(objectclass < TRACE_NCLASSES,
|
||
|
|
"uiIndexOfObject: Invalid value for objectclass", 0);
|
||
|
|
TRACE_ASSERT(objecthandle > 0 && objecthandle <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectclass],
|
||
|
|
"uiIndexOfObject: Invalid value for objecthandle", 0);
|
||
|
|
|
||
|
|
if ((objectclass < TRACE_NCLASSES) && (objecthandle > 0) &&
|
||
|
|
(objecthandle <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectclass]))
|
||
|
|
{
|
||
|
|
return (uint16_t)(RecorderDataPtr->ObjectPropertyTable.StartIndexOfClass[objectclass] +
|
||
|
|
(RecorderDataPtr->ObjectPropertyTable.TotalPropertyBytesPerClass[objectclass] * (objecthandle-1)));
|
||
|
|
}
|
||
|
|
|
||
|
|
prvTraceError("Object table lookup with invalid object handle or object class!");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
traceHandle prvTraceGetObjectHandle(traceObjectClass objectclass)
|
||
|
|
{
|
||
|
|
traceHandle handle;
|
||
|
|
static int indexOfHandle;
|
||
|
|
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
TRACE_ASSERT(RecorderDataPtr != NULL, "Recorder not initialized, call vTraceEnable() first!", (traceHandle)0);
|
||
|
|
|
||
|
|
TRACE_ASSERT(objectclass < TRACE_NCLASSES,
|
||
|
|
"prvTraceGetObjectHandle: Invalid value for objectclass", (traceHandle)0);
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
indexOfHandle = objectHandleStacks.indexOfNextAvailableHandle[objectclass];
|
||
|
|
if (objectHandleStacks.objectHandles[indexOfHandle] == 0)
|
||
|
|
{
|
||
|
|
/* Zero is used to indicate a never before used handle, i.e.,
|
||
|
|
new slots in the handle stack. The handle slot needs to
|
||
|
|
be initialized here (starts at 1). */
|
||
|
|
objectHandleStacks.objectHandles[indexOfHandle] =
|
||
|
|
(traceHandle)(1 + indexOfHandle -
|
||
|
|
objectHandleStacks.lowestIndexOfClass[objectclass]);
|
||
|
|
}
|
||
|
|
|
||
|
|
handle = objectHandleStacks.objectHandles[indexOfHandle];
|
||
|
|
|
||
|
|
if (objectHandleStacks.indexOfNextAvailableHandle[objectclass]
|
||
|
|
> objectHandleStacks.highestIndexOfClass[objectclass])
|
||
|
|
{
|
||
|
|
prvTraceError(pszTraceGetErrorNotEnoughHandles(objectclass));
|
||
|
|
handle = 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
int hndCount;
|
||
|
|
objectHandleStacks.indexOfNextAvailableHandle[objectclass]++;
|
||
|
|
|
||
|
|
hndCount = objectHandleStacks.indexOfNextAvailableHandle[objectclass] -
|
||
|
|
objectHandleStacks.lowestIndexOfClass[objectclass];
|
||
|
|
|
||
|
|
if (hndCount >
|
||
|
|
objectHandleStacks.handleCountWaterMarksOfClass[objectclass])
|
||
|
|
{
|
||
|
|
objectHandleStacks.handleCountWaterMarksOfClass[objectclass] =
|
||
|
|
(traceHandle)hndCount;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
|
||
|
|
return handle;
|
||
|
|
}
|
||
|
|
|
||
|
|
void prvTraceFreeObjectHandle(traceObjectClass objectclass, traceHandle handle)
|
||
|
|
{
|
||
|
|
int indexOfHandle;
|
||
|
|
|
||
|
|
TRACE_ASSERT(objectclass < TRACE_NCLASSES,
|
||
|
|
"prvTraceFreeObjectHandle: Invalid value for objectclass", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(handle > 0 && handle <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectclass],
|
||
|
|
"prvTraceFreeObjectHandle: Invalid value for handle", TRC_UNUSED);
|
||
|
|
|
||
|
|
/* Check that there is room to push the handle on the stack */
|
||
|
|
if ((objectHandleStacks.indexOfNextAvailableHandle[objectclass] - 1) <
|
||
|
|
objectHandleStacks.lowestIndexOfClass[objectclass])
|
||
|
|
{
|
||
|
|
/* Error */
|
||
|
|
prvTraceError("Attempt to free more handles than allocated!");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
objectHandleStacks.indexOfNextAvailableHandle[objectclass]--;
|
||
|
|
indexOfHandle = objectHandleStacks.indexOfNextAvailableHandle[objectclass];
|
||
|
|
objectHandleStacks.objectHandles[indexOfHandle] = handle;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvMarkObjectAsUsed
|
||
|
|
*
|
||
|
|
* Sets an "is used flag" on object creation, using the first byte of the name
|
||
|
|
* field. This allows for counting the number of used Object Table slots, even
|
||
|
|
* if no names have been set.
|
||
|
|
******************************************************************************/
|
||
|
|
void prvMarkObjectAsUsed(traceObjectClass objectclass, traceHandle handle)
|
||
|
|
{
|
||
|
|
uint16_t idx = uiIndexOfObject(handle, objectclass);
|
||
|
|
RecorderDataPtr->ObjectPropertyTable.objbytes[idx] = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvStrncpy
|
||
|
|
*
|
||
|
|
* Private string copy function, to improve portability between compilers.
|
||
|
|
******************************************************************************/
|
||
|
|
static void prvStrncpy(char* dst, const char* src, uint32_t maxLength)
|
||
|
|
{
|
||
|
|
uint32_t i;
|
||
|
|
for (i = 0; i < maxLength; i++)
|
||
|
|
{
|
||
|
|
dst[i] = src[i];
|
||
|
|
if (src[i] == 0)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceSetObjectName
|
||
|
|
*
|
||
|
|
* Registers the names of queues, semaphores and other kernel objects in the
|
||
|
|
* recorder's Object Property Table, at the given handle and object class.
|
||
|
|
******************************************************************************/
|
||
|
|
void prvTraceSetObjectName(traceObjectClass objectclass,
|
||
|
|
traceHandle handle,
|
||
|
|
const char* name)
|
||
|
|
{
|
||
|
|
static uint16_t idx;
|
||
|
|
|
||
|
|
TRACE_ASSERT(name != NULL, "prvTraceSetObjectName: name == NULL", TRC_UNUSED);
|
||
|
|
|
||
|
|
if (objectclass >= TRACE_NCLASSES)
|
||
|
|
{
|
||
|
|
prvTraceError("Illegal object class in prvTraceSetObjectName");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (handle == 0)
|
||
|
|
{
|
||
|
|
prvTraceError("Illegal handle (0) in prvTraceSetObjectName.");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (handle > RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[objectclass])
|
||
|
|
{
|
||
|
|
/* ERROR */
|
||
|
|
prvTraceError(pszTraceGetErrorNotEnoughHandles(objectclass));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
idx = uiIndexOfObject(handle, objectclass);
|
||
|
|
|
||
|
|
if (traceErrorMessage == NULL)
|
||
|
|
{
|
||
|
|
prvStrncpy((char*)&(RecorderDataPtr->ObjectPropertyTable.objbytes[idx]),
|
||
|
|
name,
|
||
|
|
RecorderDataPtr->ObjectPropertyTable.NameLengthPerClass[ objectclass ]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
traceString prvTraceOpenSymbol(const char* name, traceString userEventChannel)
|
||
|
|
{
|
||
|
|
uint16_t result;
|
||
|
|
uint8_t len;
|
||
|
|
uint8_t crc;
|
||
|
|
TRACE_ALLOC_CRITICAL_SECTION();
|
||
|
|
|
||
|
|
len = 0;
|
||
|
|
crc = 0;
|
||
|
|
|
||
|
|
TRACE_ASSERT(name != NULL, "prvTraceOpenSymbol: name == NULL", (traceString)0);
|
||
|
|
|
||
|
|
prvTraceGetChecksum(name, &crc, &len);
|
||
|
|
|
||
|
|
trcCRITICAL_SECTION_BEGIN();
|
||
|
|
result = prvTraceLookupSymbolTableEntry(name, crc, len, userEventChannel);
|
||
|
|
if (!result)
|
||
|
|
{
|
||
|
|
result = prvTraceCreateSymbolTableEntry(name, crc, len, userEventChannel);
|
||
|
|
}
|
||
|
|
trcCRITICAL_SECTION_END();
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* vTraceSetFrequency
|
||
|
|
*
|
||
|
|
* Registers the clock rate of the time source for the event timestamping.
|
||
|
|
* This is normally not required, but if the default value (TRC_HWTC_FREQ_HZ)
|
||
|
|
* should be incorrect for your setup, you can override it using this function.
|
||
|
|
*
|
||
|
|
* Must be called prior to vTraceEnable, and the time source is assumed to
|
||
|
|
* have a fixed clock frequency after the startup.
|
||
|
|
*
|
||
|
|
* Note that, in snapshot mode, the value is divided by the TRC_HWTC_DIVISOR.
|
||
|
|
* This is a software "prescaler" that is also applied on the timestamps.
|
||
|
|
*****************************************************************************/
|
||
|
|
void vTraceSetFrequency(uint32_t frequency)
|
||
|
|
{
|
||
|
|
timestampFrequency = frequency;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* Supporting functions
|
||
|
|
******************************************************************************/
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceError
|
||
|
|
*
|
||
|
|
* Called by various parts in the recorder. Stops the recorder and stores a
|
||
|
|
* pointer to an error message, which is printed by the monitor task.
|
||
|
|
* If you are not using the monitor task, you may use xTraceGetLastError()
|
||
|
|
* from your application to check if the recorder is OK.
|
||
|
|
*
|
||
|
|
* Note: If a recorder error is registered before vTraceStart is called, the
|
||
|
|
* trace start will be aborted. This can occur if any of the Nxxxx constants
|
||
|
|
* (e.g., TRC_CFG_NTASK) in trcConfig.h is too small.
|
||
|
|
******************************************************************************/
|
||
|
|
void prvTraceError(const char* msg)
|
||
|
|
{
|
||
|
|
/* Stop the recorder */
|
||
|
|
if (RecorderDataPtr != NULL)
|
||
|
|
{
|
||
|
|
vTraceStop();
|
||
|
|
}
|
||
|
|
|
||
|
|
/* If first error only... */
|
||
|
|
if (traceErrorMessage == NULL)
|
||
|
|
{
|
||
|
|
traceErrorMessage = (char*)(intptr_t) msg;
|
||
|
|
if (RecorderDataPtr != NULL)
|
||
|
|
{
|
||
|
|
prvStrncpy(RecorderDataPtr->systemInfo, traceErrorMessage, 80);
|
||
|
|
RecorderDataPtr->internalErrorOccured = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void vTraceSetFilterMask(uint16_t filterMask)
|
||
|
|
{
|
||
|
|
CurrentFilterMask = filterMask;
|
||
|
|
}
|
||
|
|
|
||
|
|
void vTraceSetFilterGroup(uint16_t filterGroup)
|
||
|
|
{
|
||
|
|
CurrentFilterGroup = filterGroup;
|
||
|
|
}
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* prvCheckDataToBeOverwrittenForMultiEntryEvents
|
||
|
|
*
|
||
|
|
* This checks if the next event to be overwritten is a multi-entry user event,
|
||
|
|
* i.e., a USER_EVENT followed by data entries.
|
||
|
|
* Such data entries do not have an event code at byte 0, as other events.
|
||
|
|
* All 4 bytes are user data, so the first byte of such data events must
|
||
|
|
* not be interpreted as type field. The number of data entries following
|
||
|
|
* a USER_EVENT is given in the event code of the USER_EVENT.
|
||
|
|
* Therefore, when overwriting a USER_EVENT (when using in ring-buffer mode)
|
||
|
|
* any data entries following must be replaced with NULL events (code 0).
|
||
|
|
*
|
||
|
|
* This is assumed to execute within a critical section...
|
||
|
|
*****************************************************************************/
|
||
|
|
|
||
|
|
#if (TRC_CFG_SNAPSHOT_MODE == TRC_SNAPSHOT_MODE_RING_BUFFER)
|
||
|
|
void prvCheckDataToBeOverwrittenForMultiEntryEvents(uint8_t nofEntriesToCheck)
|
||
|
|
{
|
||
|
|
/* Generic "int" type is desired - should be 16 bit variable on 16 bit HW */
|
||
|
|
unsigned int i = 0;
|
||
|
|
unsigned int e = 0;
|
||
|
|
|
||
|
|
TRACE_ASSERT(nofEntriesToCheck != 0,
|
||
|
|
"prvCheckDataToBeOverwrittenForMultiEntryEvents: nofEntriesToCheck == 0", TRC_UNUSED);
|
||
|
|
|
||
|
|
while (i < nofEntriesToCheck)
|
||
|
|
{
|
||
|
|
e = RecorderDataPtr->nextFreeIndex + i;
|
||
|
|
if ((RecorderDataPtr->eventData[e*4] > USER_EVENT) &&
|
||
|
|
(RecorderDataPtr->eventData[e*4] < USER_EVENT + 16))
|
||
|
|
{
|
||
|
|
uint8_t nDataEvents = (uint8_t)(RecorderDataPtr->eventData[e*4] - USER_EVENT);
|
||
|
|
if ((e + nDataEvents) < RecorderDataPtr->maxEvents)
|
||
|
|
{
|
||
|
|
(void)memset(& RecorderDataPtr->eventData[e*4], 0, (size_t) (4 + 4 * nDataEvents));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (RecorderDataPtr->eventData[e*4] == DIV_XPS)
|
||
|
|
{
|
||
|
|
if ((e + 1) < RecorderDataPtr->maxEvents)
|
||
|
|
{
|
||
|
|
/* Clear 8 bytes */
|
||
|
|
(void)memset(& RecorderDataPtr->eventData[e*4], 0, 4 + 4);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* Clear 8 bytes, 4 first and 4 last */
|
||
|
|
(void)memset(& RecorderDataPtr->eventData[0], 0, 4);
|
||
|
|
(void)memset(& RecorderDataPtr->eventData[e*4], 0, 4);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceUpdateCounters
|
||
|
|
*
|
||
|
|
* Updates the index of the event buffer.
|
||
|
|
******************************************************************************/
|
||
|
|
void prvTraceUpdateCounters(void)
|
||
|
|
{
|
||
|
|
if (RecorderDataPtr->recorderActive == 0)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
RecorderDataPtr->numEvents++;
|
||
|
|
|
||
|
|
RecorderDataPtr->nextFreeIndex++;
|
||
|
|
|
||
|
|
if (RecorderDataPtr->nextFreeIndex >= (TRC_CFG_EVENT_BUFFER_SIZE))
|
||
|
|
{
|
||
|
|
#if (TRC_CFG_SNAPSHOT_MODE == TRC_SNAPSHOT_MODE_RING_BUFFER)
|
||
|
|
RecorderDataPtr->bufferIsFull = 1;
|
||
|
|
RecorderDataPtr->nextFreeIndex = 0;
|
||
|
|
#else
|
||
|
|
vTraceStop();
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
#if (TRC_CFG_SNAPSHOT_MODE == TRC_SNAPSHOT_MODE_RING_BUFFER)
|
||
|
|
prvCheckDataToBeOverwrittenForMultiEntryEvents(1);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* prvTraceGetDTS
|
||
|
|
*
|
||
|
|
* Returns a differential timestamp (DTS), i.e., the time since
|
||
|
|
* last event, and creates an XTS event if the DTS does not fit in the
|
||
|
|
* number of bits given. The XTS event holds the MSB bytes of the DTS.
|
||
|
|
*
|
||
|
|
* The parameter param_maxDTS should be 0xFF for 8-bit dts or 0xFFFF for
|
||
|
|
* events with 16-bit dts fields.
|
||
|
|
*****************************************************************************/
|
||
|
|
uint16_t prvTraceGetDTS(uint16_t param_maxDTS)
|
||
|
|
{
|
||
|
|
static uint32_t old_timestamp = 0;
|
||
|
|
XTSEvent* xts = 0;
|
||
|
|
uint32_t dts = 0;
|
||
|
|
uint32_t timestamp = 0;
|
||
|
|
|
||
|
|
TRACE_ASSERT(param_maxDTS == 0xFF || param_maxDTS == 0xFFFF, "prvTraceGetDTS: Invalid value for param_maxDTS", 0);
|
||
|
|
|
||
|
|
|
||
|
|
if (RecorderDataPtr->frequency == 0)
|
||
|
|
{
|
||
|
|
if (timestampFrequency != 0)
|
||
|
|
{
|
||
|
|
/* If to override default TRC_HWTC_FREQ_HZ value with value set by vTraceSetFrequency */
|
||
|
|
RecorderDataPtr->frequency = timestampFrequency / (TRC_HWTC_DIVISOR);
|
||
|
|
}
|
||
|
|
else if (init_hwtc_count != (TRC_HWTC_COUNT))
|
||
|
|
{
|
||
|
|
/* If using default value and timer has been started.
|
||
|
|
Note: If the default frequency value set here would be incorrect, e.g.,
|
||
|
|
if the timer has actually not been configured yet, override this
|
||
|
|
with vTraceSetFrequency.
|
||
|
|
*/
|
||
|
|
RecorderDataPtr->frequency = (TRC_HWTC_FREQ_HZ) / (TRC_HWTC_DIVISOR);
|
||
|
|
}
|
||
|
|
/* If no override (vTraceSetFrequency) and timer inactive -> no action */
|
||
|
|
}
|
||
|
|
|
||
|
|
/**************************************************************************
|
||
|
|
* The below statements read the timestamp from the timer port module.
|
||
|
|
* If necessary, whole seconds are extracted using division while the rest
|
||
|
|
* comes from the modulo operation.
|
||
|
|
**************************************************************************/
|
||
|
|
|
||
|
|
prvTracePortGetTimeStamp(×tamp);
|
||
|
|
|
||
|
|
/***************************************************************************
|
||
|
|
* Since dts is unsigned the result will be correct even if timestamp has
|
||
|
|
* wrapped around.
|
||
|
|
***************************************************************************/
|
||
|
|
dts = timestamp - old_timestamp;
|
||
|
|
old_timestamp = timestamp;
|
||
|
|
|
||
|
|
if (RecorderDataPtr->frequency > 0)
|
||
|
|
{
|
||
|
|
/* Check if dts > 1 second */
|
||
|
|
if (dts > RecorderDataPtr->frequency)
|
||
|
|
{
|
||
|
|
/* More than 1 second has passed */
|
||
|
|
RecorderDataPtr->absTimeLastEventSecond += dts / RecorderDataPtr->frequency;
|
||
|
|
/* The part that is not an entire second is added to absTimeLastEvent */
|
||
|
|
RecorderDataPtr->absTimeLastEvent += dts % RecorderDataPtr->frequency;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
RecorderDataPtr->absTimeLastEvent += dts;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Check if absTimeLastEvent >= 1 second */
|
||
|
|
if (RecorderDataPtr->absTimeLastEvent >= RecorderDataPtr->frequency)
|
||
|
|
{
|
||
|
|
/* RecorderDataPtr->absTimeLastEvent is more than or equal to 1 second, but always less than 2 seconds */
|
||
|
|
RecorderDataPtr->absTimeLastEventSecond++;
|
||
|
|
RecorderDataPtr->absTimeLastEvent -= RecorderDataPtr->frequency;
|
||
|
|
/* RecorderDataPtr->absTimeLastEvent is now less than 1 second */
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* Special case if the recorder has not yet started (frequency may be uninitialized, i.e., zero) */
|
||
|
|
RecorderDataPtr->absTimeLastEvent = timestamp;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* If the dts (time since last event) does not fit in event->dts (only 8 or 16 bits) */
|
||
|
|
if (dts > param_maxDTS)
|
||
|
|
{
|
||
|
|
/* Create an XTS event (eXtended TimeStamp) containing the higher dts bits*/
|
||
|
|
xts = (XTSEvent*) prvTraceNextFreeEventBufferSlot();
|
||
|
|
|
||
|
|
if (xts != NULL)
|
||
|
|
{
|
||
|
|
if (param_maxDTS == 0xFFFF)
|
||
|
|
{
|
||
|
|
xts->type = XTS16;
|
||
|
|
xts->xts_16 = (uint16_t)((dts / 0x10000) & 0xFFFF);
|
||
|
|
xts->xts_8 = 0;
|
||
|
|
}
|
||
|
|
else if (param_maxDTS == 0xFF)
|
||
|
|
{
|
||
|
|
xts->type = XTS8;
|
||
|
|
xts->xts_16 = (uint16_t)((dts / 0x100) & 0xFFFF);
|
||
|
|
xts->xts_8 = (uint8_t)((dts / 0x1000000) & 0xFF);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
prvTraceError("Bad param_maxDTS in prvTraceGetDTS");
|
||
|
|
}
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return (uint16_t)dts & param_maxDTS;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceLookupSymbolTableEntry
|
||
|
|
*
|
||
|
|
* Find an entry in the symbol table, return 0 if not present.
|
||
|
|
*
|
||
|
|
* The strings are stored in a byte pool, with four bytes of "meta-data" for
|
||
|
|
* every string.
|
||
|
|
* byte 0-1: index of next entry with same checksum (for fast lookup).
|
||
|
|
* byte 2-3: reference to a symbol table entry, a label for vTracePrintF
|
||
|
|
* format strings only (the handle of the destination channel).
|
||
|
|
* byte 4..(4 + length): the string (object name or user event label), with
|
||
|
|
* zero-termination
|
||
|
|
******************************************************************************/
|
||
|
|
traceString prvTraceLookupSymbolTableEntry(const char* name,
|
||
|
|
uint8_t crc6,
|
||
|
|
uint8_t len,
|
||
|
|
traceString chn)
|
||
|
|
{
|
||
|
|
uint16_t i = RecorderDataPtr->SymbolTable.latestEntryOfChecksum[ crc6 ];
|
||
|
|
|
||
|
|
TRACE_ASSERT(name != NULL, "prvTraceLookupSymbolTableEntry: name == NULL", (traceString)0);
|
||
|
|
TRACE_ASSERT(len != 0, "prvTraceLookupSymbolTableEntry: len == 0", (traceString)0);
|
||
|
|
|
||
|
|
while (i != 0)
|
||
|
|
{
|
||
|
|
if (RecorderDataPtr->SymbolTable.symbytes[i + 2] == (chn & 0x00FF))
|
||
|
|
{
|
||
|
|
if (RecorderDataPtr->SymbolTable.symbytes[i + 3] == (chn / 0x100))
|
||
|
|
{
|
||
|
|
if (RecorderDataPtr->SymbolTable.symbytes[i + 4 + len] == '\0')
|
||
|
|
{
|
||
|
|
if (strncmp((char*)(& RecorderDataPtr->SymbolTable.symbytes[i + 4]), name, len) == 0)
|
||
|
|
{
|
||
|
|
break; /* found */
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
i = (uint16_t)(RecorderDataPtr->SymbolTable.symbytes[i] + (RecorderDataPtr->SymbolTable.symbytes[i + 1] * 0x100));
|
||
|
|
}
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceCreateSymbolTableEntry
|
||
|
|
*
|
||
|
|
* Creates an entry in the symbol table, independent if it exists already.
|
||
|
|
*
|
||
|
|
* The strings are stored in a byte pool, with four bytes of "meta-data" for
|
||
|
|
* every string.
|
||
|
|
* byte 0-1: index of next entry with same checksum (for fast lookup).
|
||
|
|
* byte 2-3: reference to a symbol table entry, a label for vTracePrintF
|
||
|
|
* format strings only (the handle of the destination channel).
|
||
|
|
* byte 4..(4 + length): the string (object name or user event label), with
|
||
|
|
* zero-termination
|
||
|
|
******************************************************************************/
|
||
|
|
uint16_t prvTraceCreateSymbolTableEntry(const char* name,
|
||
|
|
uint8_t crc6,
|
||
|
|
uint8_t len,
|
||
|
|
traceString channel)
|
||
|
|
{
|
||
|
|
uint16_t ret = 0;
|
||
|
|
|
||
|
|
TRACE_ASSERT(name != NULL, "prvTraceCreateSymbolTableEntry: name == NULL", 0);
|
||
|
|
TRACE_ASSERT(len != 0, "prvTraceCreateSymbolTableEntry: len == 0", 0);
|
||
|
|
|
||
|
|
if (RecorderDataPtr->SymbolTable.nextFreeSymbolIndex + len + 4 >= (TRC_CFG_SYMBOL_TABLE_SIZE))
|
||
|
|
{
|
||
|
|
prvTraceError("Symbol table full. Increase TRC_CFG_SYMBOL_TABLE_SIZE in trcConfig.h");
|
||
|
|
ret = 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
|
||
|
|
RecorderDataPtr->SymbolTable.symbytes
|
||
|
|
[ RecorderDataPtr->SymbolTable.nextFreeSymbolIndex] =
|
||
|
|
(uint8_t)(RecorderDataPtr->SymbolTable.latestEntryOfChecksum[ crc6 ] & 0x00FF);
|
||
|
|
|
||
|
|
RecorderDataPtr->SymbolTable.symbytes
|
||
|
|
[ RecorderDataPtr->SymbolTable.nextFreeSymbolIndex + 1] =
|
||
|
|
(uint8_t)(RecorderDataPtr->SymbolTable.latestEntryOfChecksum[ crc6 ] / 0x100);
|
||
|
|
|
||
|
|
RecorderDataPtr->SymbolTable.symbytes
|
||
|
|
[ RecorderDataPtr->SymbolTable.nextFreeSymbolIndex + 2] =
|
||
|
|
(uint8_t)(channel & 0x00FF);
|
||
|
|
|
||
|
|
RecorderDataPtr->SymbolTable.symbytes
|
||
|
|
[ RecorderDataPtr->SymbolTable.nextFreeSymbolIndex + 3] =
|
||
|
|
(uint8_t)(channel / 0x100);
|
||
|
|
|
||
|
|
/* set name (bytes 4...4+len-1) */
|
||
|
|
prvStrncpy((char*)&(RecorderDataPtr->SymbolTable.symbytes
|
||
|
|
[ RecorderDataPtr->SymbolTable.nextFreeSymbolIndex + 4]), name, len);
|
||
|
|
|
||
|
|
/* Set zero termination (at offset 4+len) */
|
||
|
|
RecorderDataPtr->SymbolTable.symbytes
|
||
|
|
[RecorderDataPtr->SymbolTable.nextFreeSymbolIndex + 4 + len] = '\0';
|
||
|
|
|
||
|
|
/* store index of entry (for return value, and as head of LL[crc6]) */
|
||
|
|
RecorderDataPtr->SymbolTable.latestEntryOfChecksum
|
||
|
|
[ crc6 ] = (uint16_t)RecorderDataPtr->SymbolTable.nextFreeSymbolIndex;
|
||
|
|
|
||
|
|
RecorderDataPtr->SymbolTable.nextFreeSymbolIndex += (uint32_t) (len + 5);
|
||
|
|
|
||
|
|
ret = (uint16_t)(RecorderDataPtr->SymbolTable.nextFreeSymbolIndex - (uint8_t)(len + 5));
|
||
|
|
}
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* prvTraceGetChecksum
|
||
|
|
*
|
||
|
|
* Calculates a simple 6-bit checksum from a string, used to index the string
|
||
|
|
* for fast symbol table lookup.
|
||
|
|
******************************************************************************/
|
||
|
|
void prvTraceGetChecksum(const char *pname, uint8_t* pcrc, uint8_t* plength)
|
||
|
|
{
|
||
|
|
unsigned char c;
|
||
|
|
int length = 1; /* Should be 1 to account for '\0' */
|
||
|
|
int crc = 0;
|
||
|
|
|
||
|
|
TRACE_ASSERT(pname != NULL, "prvTraceGetChecksum: pname == NULL", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(pcrc != NULL, "prvTraceGetChecksum: pcrc == NULL", TRC_UNUSED);
|
||
|
|
TRACE_ASSERT(plength != NULL, "prvTraceGetChecksum: plength == NULL", TRC_UNUSED);
|
||
|
|
|
||
|
|
if (pname != (const char *) 0)
|
||
|
|
{
|
||
|
|
for (; (c = (unsigned char) *pname++) != '\0';)
|
||
|
|
{
|
||
|
|
crc += c;
|
||
|
|
length++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
*pcrc = (uint8_t)(crc & 0x3F);
|
||
|
|
*plength = (uint8_t)length;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if (TRC_CFG_USE_16BIT_OBJECT_HANDLES == 1)
|
||
|
|
|
||
|
|
static void prvTraceStoreXID(traceHandle handle);
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* prvTraceStoreXID
|
||
|
|
*
|
||
|
|
* Stores an XID (eXtended IDentifier) event.
|
||
|
|
* This is used if an object/task handle is larger than 255.
|
||
|
|
* The parameter "handle" is the full (16 bit) handle, assumed to be 256 or
|
||
|
|
* larger. Handles below 256 should not use this function.
|
||
|
|
*
|
||
|
|
* NOTE: this function MUST be called from within a critical section.
|
||
|
|
*****************************************************************************/
|
||
|
|
static void prvTraceStoreXID(traceHandle handle)
|
||
|
|
{
|
||
|
|
XPSEvent* xid;
|
||
|
|
|
||
|
|
TRACE_ASSERT(handle >= 256, "prvTraceStoreXID: Handle < 256", TRC_UNUSED);
|
||
|
|
|
||
|
|
xid = (XPSEvent*)prvTraceNextFreeEventBufferSlot();
|
||
|
|
|
||
|
|
if (xid != NULL)
|
||
|
|
{
|
||
|
|
xid->type = XID;
|
||
|
|
|
||
|
|
/* This function is (only) used when traceHandle is 16 bit... */
|
||
|
|
xid->xps_16 = handle;
|
||
|
|
|
||
|
|
prvTraceUpdateCounters();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint8_t prvTraceGet8BitHandle(traceHandle handle)
|
||
|
|
{
|
||
|
|
if (handle > 255)
|
||
|
|
{
|
||
|
|
prvTraceStoreXID(handle);
|
||
|
|
/* The full handle (16 bit) is stored in the XID event.
|
||
|
|
This code (255) is used instead of zero (which is an error code).*/
|
||
|
|
return 255;
|
||
|
|
}
|
||
|
|
return (uint8_t)(handle & 0xFF);
|
||
|
|
}
|
||
|
|
#endif /*(TRC_CFG_USE_16BIT_OBJECT_HANDLES == 1)*/
|
||
|
|
|
||
|
|
|
||
|
|
/* If using DWT timestamping (default on ARM Cortex-M3, M4 and M7), make sure the DWT unit is initialized. */
|
||
|
|
#ifndef TRC_CFG_ARM_CM_USE_SYSTICK
|
||
|
|
#if ((TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_ARM_Cortex_M) && (defined (__CORTEX_M) && (__CORTEX_M >= 0x03)))
|
||
|
|
void prvTraceInitCortexM()
|
||
|
|
{
|
||
|
|
/* Ensure that the DWT registers are unlocked and can be modified. */
|
||
|
|
TRC_REG_ITM_LOCKACCESS = TRC_ITM_LOCKACCESS_UNLOCK;
|
||
|
|
|
||
|
|
/* Make sure DWT is enabled, if supported */
|
||
|
|
TRC_REG_DEMCR |= TRC_DEMCR_TRCENA;
|
||
|
|
|
||
|
|
do{
|
||
|
|
/* Verify that DWT is supported */
|
||
|
|
if (TRC_REG_DEMCR == 0)
|
||
|
|
{
|
||
|
|
/* This function is called on Cortex-M3, M4 and M7 devices to initialize
|
||
|
|
the DWT unit, assumed present. The DWT cycle counter is used for timestamping.
|
||
|
|
|
||
|
|
If the below error is produced, the DWT unit does not seem to be available.
|
||
|
|
|
||
|
|
In that case, define the macro TRC_CFG_ARM_CM_USE_SYSTICK in your build
|
||
|
|
to use SysTick timestamping instead, or define your own timestamping by
|
||
|
|
setting TRC_CFG_HARDWARE_PORT to TRC_HARDWARE_PORT_APPLICATION_DEFINED
|
||
|
|
and make the necessary definitions, as explained in trcHardwarePort.h.*/
|
||
|
|
|
||
|
|
prvTraceError("DWT unit not available, see code comment.");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Verify that DWT_CYCCNT is supported */
|
||
|
|
if (TRC_REG_DWT_CTRL & TRC_DWT_CTRL_NOCYCCNT)
|
||
|
|
{
|
||
|
|
/* This function is called on Cortex-M3, M4 and M7 devices to initialize
|
||
|
|
the DWT unit, assumed present. The DWT cycle counter is used for timestamping.
|
||
|
|
|
||
|
|
If the below error is produced, the cycle counter does not seem to be available.
|
||
|
|
|
||
|
|
In that case, define the macro TRC_CFG_ARM_CM_USE_SYSTICK in your build
|
||
|
|
to use SysTick timestamping instead, or define your own timestamping by
|
||
|
|
setting TRC_CFG_HARDWARE_PORT to TRC_HARDWARE_PORT_APPLICATION_DEFINED
|
||
|
|
and make the necessary definitions, as explained in trcHardwarePort.h.*/
|
||
|
|
|
||
|
|
prvTraceError("DWT_CYCCNT not available, see code comment.");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Reset the cycle counter */
|
||
|
|
TRC_REG_DWT_CYCCNT = 0;
|
||
|
|
|
||
|
|
/* Enable the cycle counter */
|
||
|
|
TRC_REG_DWT_CTRL |= TRC_DWT_CTRL_CYCCNTENA;
|
||
|
|
|
||
|
|
}while(0); /* breaks above jump here */
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/******************************************************************************
|
||
|
|
* prvTracePortGetTimeStamp
|
||
|
|
*
|
||
|
|
* Returns the current time based on the HWTC macros which provide a hardware
|
||
|
|
* isolation layer towards the hardware timer/counter.
|
||
|
|
*
|
||
|
|
* The HWTC macros and prvTracePortGetTimeStamp is the main porting issue
|
||
|
|
* or the trace recorder library. Typically you should not need to change
|
||
|
|
* the code of prvTracePortGetTimeStamp if using the HWTC macros.
|
||
|
|
*
|
||
|
|
******************************************************************************/
|
||
|
|
void prvTracePortGetTimeStamp(uint32_t *pTimestamp)
|
||
|
|
{
|
||
|
|
static uint32_t last_hwtc_count = 0;
|
||
|
|
uint32_t hwtc_count = 0;
|
||
|
|
|
||
|
|
#if TRC_HWTC_TYPE == TRC_OS_TIMER_INCR || TRC_HWTC_TYPE == TRC_OS_TIMER_DECR
|
||
|
|
/* systick based timer */
|
||
|
|
static uint32_t last_traceTickCount = 0;
|
||
|
|
uint32_t traceTickCount = 0;
|
||
|
|
#else /*TRC_HWTC_TYPE == TRC_OS_TIMER_INCR || TRC_HWTC_TYPE == TRC_OS_TIMER_DECR*/
|
||
|
|
/* Free running timer */
|
||
|
|
static uint32_t last_hwtc_rest = 0;
|
||
|
|
uint32_t diff = 0;
|
||
|
|
uint32_t diff_scaled = 0;
|
||
|
|
#endif /*TRC_HWTC_TYPE == TRC_OS_TIMER_INCR || TRC_HWTC_TYPE == TRC_OS_TIMER_DECR*/
|
||
|
|
|
||
|
|
if (trace_disable_timestamp == 1)
|
||
|
|
{
|
||
|
|
if (pTimestamp)
|
||
|
|
*pTimestamp = last_timestamp;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Retrieve TRC_HWTC_COUNT only once since the same value should be used all throughout this function. */
|
||
|
|
#if (TRC_HWTC_TYPE == TRC_OS_TIMER_INCR || TRC_HWTC_TYPE == TRC_FREE_RUNNING_32BIT_INCR)
|
||
|
|
/* Get the increasing tick count */
|
||
|
|
hwtc_count = (TRC_HWTC_COUNT);
|
||
|
|
#elif (TRC_HWTC_TYPE == TRC_OS_TIMER_DECR || TRC_HWTC_TYPE == TRC_FREE_RUNNING_32BIT_DECR)
|
||
|
|
/* Convert decreasing tick count into increasing tick count */
|
||
|
|
hwtc_count = (TRC_HWTC_PERIOD) - (TRC_HWTC_COUNT);
|
||
|
|
#else
|
||
|
|
#error "TRC_HWTC_TYPE has unexpected value"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if (TRC_CFG_HARDWARE_PORT == TRC_HARDWARE_PORT_Win32)
|
||
|
|
/* The Win32 port uses ulGetRunTimeCounterValue for timestamping, which in turn
|
||
|
|
uses QueryPerformanceCounter. That function is not always reliable when used over
|
||
|
|
multiple threads. We must therefore handle rare cases where the timestamp is less
|
||
|
|
than the previous. In practice, this should "never" roll over since the
|
||
|
|
performance counter is 64 bit wide. */
|
||
|
|
|
||
|
|
if (last_hwtc_count > hwtc_count)
|
||
|
|
{
|
||
|
|
hwtc_count = last_hwtc_count;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if (TRC_HWTC_TYPE == TRC_OS_TIMER_INCR || TRC_HWTC_TYPE == TRC_OS_TIMER_DECR)
|
||
|
|
/* Timestamping is based on a timer that wraps at TRC_HWTC_PERIOD */
|
||
|
|
if (last_traceTickCount - uiTraceTickCount - 1 < 0x80000000)
|
||
|
|
{
|
||
|
|
/* This means last_traceTickCount is higher than uiTraceTickCount,
|
||
|
|
so we have previously compensated for a missed tick.
|
||
|
|
Therefore we use the last stored value because that is more accurate. */
|
||
|
|
traceTickCount = last_traceTickCount;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* Business as usual */
|
||
|
|
traceTickCount = uiTraceTickCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Check for overflow. May occur if the update of uiTraceTickCount has been
|
||
|
|
delayed due to disabled interrupts. */
|
||
|
|
if (traceTickCount == last_traceTickCount && hwtc_count < last_hwtc_count)
|
||
|
|
{
|
||
|
|
/* A trace tick has occurred but not been executed by the kernel, so we compensate manually. */
|
||
|
|
traceTickCount++;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Check if the return address is OK, then we perform the calculation. */
|
||
|
|
if (pTimestamp)
|
||
|
|
{
|
||
|
|
/* Get timestamp from trace ticks. Scale down the period to avoid unwanted overflows. */
|
||
|
|
last_timestamp = traceTickCount * ((TRC_HWTC_PERIOD) / (TRC_HWTC_DIVISOR));
|
||
|
|
/* Increase timestamp by (hwtc_count + "lost hardware ticks from scaling down period") / TRC_HWTC_DIVISOR. */
|
||
|
|
last_timestamp += (hwtc_count + traceTickCount * ((TRC_HWTC_PERIOD) % (TRC_HWTC_DIVISOR))) / (TRC_HWTC_DIVISOR);
|
||
|
|
}
|
||
|
|
/* Store the previous value */
|
||
|
|
last_traceTickCount = traceTickCount;
|
||
|
|
|
||
|
|
#else /*(TRC_HWTC_TYPE == TRC_OS_TIMER_INCR || TRC_HWTC_TYPE == TRC_OS_TIMER_DECR)*/
|
||
|
|
|
||
|
|
/* Timestamping is based on a free running timer */
|
||
|
|
/* This part handles free running clocks that can be scaled down to avoid too large DTS values.
|
||
|
|
Without this, the scaled timestamp will incorrectly wrap at (2^32 / TRC_HWTC_DIVISOR) ticks.
|
||
|
|
The scaled timestamp returned from this function is supposed to go from 0 -> 2^32, which in real time would represent (0 -> 2^32 * TRC_HWTC_DIVISOR) ticks. */
|
||
|
|
|
||
|
|
/* First we see how long time has passed since the last timestamp call, and we also add the ticks that was lost when we scaled down the last time. */
|
||
|
|
diff = (hwtc_count - last_hwtc_count) + last_hwtc_rest;
|
||
|
|
|
||
|
|
/* Scale down the diff */
|
||
|
|
diff_scaled = diff / (TRC_HWTC_DIVISOR);
|
||
|
|
|
||
|
|
/* Find out how many ticks were lost when scaling down, so we can add them the next time */
|
||
|
|
last_hwtc_rest = diff % (TRC_HWTC_DIVISOR);
|
||
|
|
|
||
|
|
/* We increase the scaled timestamp by the scaled amount */
|
||
|
|
last_timestamp += diff_scaled;
|
||
|
|
#endif /*(TRC_HWTC_TYPE == TRC_OS_TIMER_INCR || TRC_HWTC_TYPE == TRC_OS_TIMER_DECR)*/
|
||
|
|
|
||
|
|
/* Is anyone interested in the results? */
|
||
|
|
if (pTimestamp)
|
||
|
|
*pTimestamp = last_timestamp;
|
||
|
|
|
||
|
|
/* Store the previous value */
|
||
|
|
last_hwtc_count = hwtc_count;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif /*(TRC_USE_TRACEALYZER_RECORDER == 1)*/
|
||
|
|
|
||
|
|
#endif /*(TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_SNAPSHOT)*/
|