/******************************************************************************* | |
* Trace Recorder Library for Tracealyzer v3.1.2 | |
* 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, 2017. | |
* 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; | |
uint8_t inExcludedTask = 0; | |
extern uint8_t inExcludedTask; | |
extern int8_t nISRactive; | |
extern traceHandle handle_of_last_logged_task; | |
/* Called when the recorder is stopped, set by vTraceSetStopHook. */ | |
TRACE_STOP_HOOK vTraceStopHookPtr = (TRACE_STOP_HOOK)0; | |
/*************** 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); | |
#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) | |
/* Current heap usage. Always updated. */ | |
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. | |
******************************************************************************/ | |
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) | |
{ | |
prvTraceError("RecorderDataPtr is NULL. Call vTraceInitTraceData() before starting trace."); | |
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) | |
{ | |
RecorderDataPtr->recorderActive = 0; | |
if (vTraceStopHookPtr != (TRACE_STOP_HOOK)0) | |
{ | |
(*vTraceStopHookPtr)(); /* An application call-back function. */ | |
} | |
} | |
/******************************************************************************* | |
* 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 && (! inExcludedTask || nISRactive) && 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(); | |
* } | |
* | |
* Note: This is only supported in Tracealyzer tools v2.7 or later | |
* | |
*****************************************************************************/ | |
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(); | |
* } | |
* | |
* Note: This is only supported in Tracealyzer tools v2.7 or later | |
* | |
*****************************************************************************/ | |
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; | |
handle++; | |
TRACE_ASSERT(handle <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[TRACE_CLASS_ISR], "xTraceSetISRProperties: Invalid value for handle", 0); | |
TRACE_ASSERT(name != NULL, "xTraceSetISRProperties: name == NULL", 0); | |
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 <= RecorderDataPtr->ObjectPropertyTable.NumberOfObjectsPerClass[TRACE_CLASS_ISR], "vTraceStoreISRBegin: Invalid value for handle", 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 | |
* trcConfig.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 && (! inExcludedTask || nISRactive) && 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 && (! inExcludedTask || nISRactive) && 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 && (! inExcludedTask || nISRactive) && 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 && (! inExcludedTask || nISRactive) && 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); | |
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! */ | |
{ | |
if (!TRACE_GET_TASK_FLAG_ISEXCLUDED(handle)) | |
{ | |
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) | |
{ | |
/* If it is an ISR or NOT an excluded task, this kernel call will be stored in the trace */ | |
if (nISRactive || !inExcludedTask) | |
{ | |
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) | |
{ | |
/* If it is an ISR or NOT an excluded task, this kernel call will be stored in the trace */ | |
if (nISRactive || !inExcludedTask) | |
{ | |
/* Check if the referenced object or the event code is excluded */ | |
if (!uiTraceIsObjectExcluded(objectClass, (traceHandle)objectNumber) && !TRACE_GET_EVENT_CODE_FLAG_ISEXCLUDED(ecode)) | |
{ | |
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 && (! inExcludedTask || nISRactive)) | |
{ | |
/* Check if the referenced object or the event code is excluded */ | |
if (!uiTraceIsObjectExcluded(objectClass, (traceHandle)objectNumber) && | |
!TRACE_GET_EVENT_CODE_FLAG_ISEXCLUDED(evtcode)) | |
{ | |
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 | |
&& (! inExcludedTask || nISRactive)) | |
{ | |
/* Check if the event code is excluded */ | |
if (!TRACE_GET_EVENT_CODE_FLAG_ISEXCLUDED(evtcode)) | |
{ | |
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; | |
int8_t skipEvent; | |
uint8_t hnd8; | |
#if (TRC_CFG_INCLUDE_ISR_TRACING == 1) | |
extern int32_t isPendingContextSwitch; | |
#endif | |
trcSR_ALLOC_CRITICAL_SECTION_ON_CORTEX_M_ONLY(); | |
skipEvent = 0; | |
TRACE_ASSERT(task_handle <= TRC_CFG_NTASK, | |
"prvTraceStoreTaskswitch: Invalid value for task_handle", TRC_UNUSED); | |
/* Skip the event if the task has been excluded, using vTraceExcludeTask */ | |
if (TRACE_GET_TASK_FLAG_ISEXCLUDED(task_handle)) | |
{ | |
skipEvent = 1; | |
inExcludedTask = 1; | |
} | |
else | |
{ | |
inExcludedTask = 0; | |
} | |
trcCRITICAL_SECTION_BEGIN_ON_CORTEX_M_ONLY(); | |
/* Skip the event if the same task is scheduled */ | |
if (task_handle == handle_of_last_logged_task) | |
{ | |
skipEvent = 1; | |
} | |
if (!RecorderDataPtr->recorderActive) | |
{ | |
skipEvent = 1; | |
} | |
/* If this event should be logged, log it! */ | |
if (skipEvent == 0) | |
{ | |
#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. | |
******************************************************************************/ | |
#if (TRC_CFG_INCLUDE_OBJECT_DELETE == 1) | |
void prvTraceStoreObjectNameOnCloseEvent(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) (EVENTGROUP_OBJCLOSE_NAME + objectclass); | |
ce->objHandle = hnd8; | |
ce->symbolIndex = idx; | |
prvTraceUpdateCounters(); | |
} | |
} | |
} | |
void prvTraceStoreObjectPropertiesOnCloseEvent(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 = (uint8_t) (EVENTGROUP_OBJCLOSE_PROP + objectclass); | |
prvTraceUpdateCounters(); | |
} | |
} | |
} | |
#endif | |
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 | |
******************************************************************************/ | |
/* Tasks and kernel objects can be explicitly excluded from the trace to reduce | |
buffer usage. This structure handles the exclude flags for all objects and tasks. | |
Note that slot 0 is not used, since not a valid handle. */ | |
uint8_t trcExcludedObjects[(TRACE_KERNEL_OBJECT_COUNT + TRACE_NCLASSES) / 8 + 1] = { 0 }; | |
/* Specific events can also be excluded, i.e., by the event code. This can be | |
used to exclude kernel calls that don't refer to a kernel object, like a delay. | |
This structure handle the exclude flags for all event codes */ | |
uint8_t trcExcludedEventCodes[NEventCodes / 8 + 1] = { 0 }; | |
/* 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; | |
#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_ASSERT(objectclass < TRACE_NCLASSES, | |
"prvTraceGetObjectHandle: Invalid value for objectclass", (traceHandle)0); | |
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; | |
} | |
TRACE_CLEAR_OBJECT_FLAG_ISEXCLUDED(objectclass, handle); | |
} | |
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 */ | |
vTraceStop(); | |
/* If first error only... */ | |
if (traceErrorMessage == NULL) | |
{ | |
traceErrorMessage = (char*)(intptr_t) msg; | |
if (RecorderDataPtr != NULL) | |
{ | |
prvStrncpy(RecorderDataPtr->systemInfo, traceErrorMessage, 80); | |
RecorderDataPtr->internalErrorOccured = 1; | |
} | |
} | |
} | |
/****************************************************************************** | |
* 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)*/ |