FreeRTOS-Kernel/FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace/trcTask.c

/*
 * Percepio Trace Recorder for Tracealyzer v4.6.0
 * Copyright 2021 Percepio AB
 * www.percepio.com
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * The implementation for tasks.
 */

#include <trcRecorder.h>

#if ( TRC_USE_TRACEALYZER_RECORDER == 1 )

    #if ( TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING )

/* Code used for "task address" when no task has started, to indicate "(startup)".
 * This value was used since NULL/0 was already reserved for the idle task. */
        #define TRACE_HANDLE_NO_TASK                 ( ( void * ) 2 )

        #define TRC_TASK_STATE_INDEX_PRIORITY        0
        #define TRC_TASK_STATE_INDEX_UNUSED_STACK    1

        TraceTaskInfo_t * pxTraceTaskInfo;

        traceResult xTraceTaskInitialize( TraceTaskInfoBuffer_t * pxBuffer )
        {
            uint32_t i;

            TRC_ASSERT_EQUAL_SIZE( TraceTaskInfoBuffer_t, TraceTaskInfo_t );

            /* This should never fail */
            TRC_ASSERT( pxBuffer != 0 );

            pxTraceTaskInfo = ( TraceTaskInfo_t * ) pxBuffer;

            for( i = 0; i < TRC_CFG_CORE_COUNT; i++ )
            {
                pxTraceTaskInfo->coreTasks[ i ] = TRACE_HANDLE_NO_TASK;
            }

            xTraceSetComponentInitialized( TRC_RECORDER_COMPONENT_TASK );

            return TRC_SUCCESS;
        }

        traceResult xTraceTaskUnregister( TraceTaskHandle_t xTaskHandle,
                                          TraceUnsignedBaseType_t uxPriority )
        {
            void * pvTask;

            /* This should never fail */
            TRC_ASSERT_ALWAYS_EVALUATE( xTraceEntryGetAddress( ( TraceEntryHandle_t ) xTaskHandle, &pvTask ) == TRC_SUCCESS );

            xTraceStackMonitorRemove( pvTask );

            return xTraceObjectUnregister( ( TraceObjectHandle_t ) xTaskHandle, PSF_EVENT_TASK_DELETE, uxPriority );
        }

        traceResult xTraceTaskSetPriority( TraceTaskHandle_t xTaskHandle,
                                           TraceUnsignedBaseType_t uxPriority )
        {
            TraceEventHandle_t xEventHandle = 0;
            void * pvTask;

            /* This should never fail */
            TRC_ASSERT_ALWAYS_EVALUATE( xTraceObjectSetState( ( TraceObjectHandle_t ) xTaskHandle, uxPriority ) == TRC_SUCCESS );

            /* This should never fail */
            TRC_ASSERT_ALWAYS_EVALUATE( xTraceEntryGetAddress( ( TraceEntryHandle_t ) xTaskHandle, &pvTask ) == TRC_SUCCESS );

            /* We need to check this */
            if( xTraceEventBegin( PSF_EVENT_TASK_PRIORITY, sizeof( void * ) + sizeof( uint32_t ), &xEventHandle ) == TRC_SUCCESS )
            {
                xTraceEventAddPointer( xEventHandle, pvTask );
                xTraceEventAdd32( xEventHandle, ( uint32_t ) uxPriority );
                xTraceEventEnd( xEventHandle );
            }

            return TRC_SUCCESS;
        }

        traceResult xTraceTaskSetPriorityWithoutHandle( void * pvTask,
                                                        TraceUnsignedBaseType_t uxPriority )
        {
            TraceEventHandle_t xEventHandle = 0;
            TraceEntryHandle_t xEntryHandle;

            if( xTraceEntryFind( pvTask, &xEntryHandle ) == TRC_FAIL )
            {
                return TRC_FAIL;
            }

            /* This should never fail */
            TRC_ASSERT_ALWAYS_EVALUATE( xTraceObjectSetState( ( TraceObjectHandle_t ) xEntryHandle, uxPriority ) == TRC_SUCCESS );

            /* We need to check this */
            if( xTraceEventBegin( PSF_EVENT_TASK_PRIORITY, sizeof( void * ) + sizeof( uint32_t ), &xEventHandle ) == TRC_SUCCESS )
            {
                xTraceEventAddPointer( xEventHandle, pvTask );
                xTraceEventAdd32( xEventHandle, ( uint32_t ) uxPriority );
                xTraceEventEnd( xEventHandle );
            }

            return TRC_SUCCESS;
        }

        traceResult xTraceTaskSwitch( void * pvTask,
                                      TraceUnsignedBaseType_t uxPriority )
        {
            traceResult xResult = TRC_FAIL;
            TraceEventHandle_t xEventHandle = 0;
            void * pvCurrent = 0;

            ( void ) pvTask;
            ( void ) uxPriority;

            TRACE_ALLOC_CRITICAL_SECTION();

            if( xTraceIsRecorderEnabled() == 0 )
            {
                return xResult;
            }

            TRACE_ENTER_CRITICAL_SECTION();

            xTraceStateSet( TRC_STATE_IN_TASKSWITCH );

            xTraceTaskGetCurrent( &pvCurrent );

            if( pvCurrent != pvTask )
            {
                xTraceTaskSetCurrent( pvTask );

                if( xTraceEventBegin( PSF_EVENT_TASK_ACTIVATE, sizeof( void * ) + sizeof( uint32_t ), &xEventHandle ) == TRC_SUCCESS )
                {
                    xTraceEventAddPointer( xEventHandle, pvTask );
                    xTraceEventAdd32( xEventHandle, ( uint32_t ) uxPriority );
                    xTraceEventEnd( xEventHandle );
                    xResult = TRC_SUCCESS;
                }
            }

            xTraceStateSet( TRC_STATE_IN_APPLICATION );

            TRACE_EXIT_CRITICAL_SECTION();

            return xResult;
        }

        #if ( TRC_CFG_INCLUDE_READY_EVENTS == 1 )
            traceResult xTraceTaskReady( void * pvTask )
            {
                traceResult xResult = TRC_FAIL;
                TraceEventHandle_t xEventHandle = 0;

                if( xTraceEventBegin( PSF_EVENT_TASK_READY, sizeof( void * ), &xEventHandle ) == TRC_SUCCESS )
                {
                    xTraceEventAddPointer( xEventHandle, pvTask );
                    xTraceEventEnd( xEventHandle );
                    xResult = TRC_SUCCESS;
                }

                return xResult;
            }
        #endif /* (TRC_CFG_INCLUDE_READY_EVENTS == 1) */

        traceResult xTraceTaskInstanceFinishedNow( void )
        {
            TraceEventHandle_t xEventHandle = 0;

            if( xTraceEventBegin( PSF_EVENT_IFE_DIRECT, 0, &xEventHandle ) == TRC_FAIL )
            {
                return TRC_FAIL;
            }

            xTraceEventEnd( xEventHandle );

            return TRC_SUCCESS;
        }

        traceResult xTraceTaskInstanceFinishedNext( void )
        {
            TraceEventHandle_t xEventHandle = 0;

            if( xTraceEventBegin( PSF_EVENT_IFE_NEXT, 0, &xEventHandle ) == TRC_FAIL )
            {
                return TRC_FAIL;
            }

            xTraceEventEnd( xEventHandle );

            return TRC_SUCCESS;
        }

    #endif /* (TRC_CFG_RECORDER_MODE == TRC_RECORDER_MODE_STREAMING) */

#endif /* (TRC_USE_TRACEALYZER_RECORDER == 1) */