| /* |
| * FreeRTOS Kernel <DEVELOPMENT BRANCH> |
| * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved. |
| * |
| * SPDX-License-Identifier: MIT |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy of |
| * this software and associated documentation files (the "Software"), to deal in |
| * the Software without restriction, including without limitation the rights to |
| * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of |
| * the Software, and to permit persons to whom the Software is furnished to do so, |
| * subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in all |
| * copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS |
| * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR |
| * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER |
| * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| * |
| * https://www.FreeRTOS.org |
| * https://github.com/FreeRTOS |
| * |
| */ |
| |
| /* Standard includes. */ |
| #include <stdlib.h> |
| #include <string.h> |
| |
| /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining |
| * all the API functions to use the MPU wrappers. That should only be done when |
| * task.h is included from an application file. */ |
| #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE |
| |
| /* FreeRTOS includes. */ |
| #include "FreeRTOS.h" |
| #include "task.h" |
| #include "timers.h" |
| #include "stack_macros.h" |
| |
| /* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified |
| * because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined |
| * for the header files above, but not in this file, in order to generate the |
| * correct privileged Vs unprivileged linkage and placement. */ |
| #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021. */ |
| |
| /* Set configUSE_STATS_FORMATTING_FUNCTIONS to 2 to include the stats formatting |
| * functions but without including stdio.h here. */ |
| #if ( configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) |
| |
| /* At the bottom of this file are two optional functions that can be used |
| * to generate human readable text from the raw data generated by the |
| * uxTaskGetSystemState() function. Note the formatting functions are provided |
| * for convenience only, and are NOT considered part of the kernel. */ |
| #include <stdio.h> |
| #endif /* configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) */ |
| |
| #if ( configUSE_PREEMPTION == 0 ) |
| |
| /* If the cooperative scheduler is being used then a yield should not be |
| * performed just because a higher priority task has been woken. */ |
| #define taskYIELD_TASK_CORE_IF_USING_PREEMPTION( pxTCB ) |
| #define taskYIELD_ANY_CORE_IF_USING_PREEMPTION( pxTCB ) |
| #else |
| |
| #if ( configNUMBER_OF_CORES == 1 ) |
| |
| /* This macro requests the running task pxTCB to yield. In single core |
| * scheduler, a running task always runs on core 0 and portYIELD_WITHIN_API() |
| * can be used to request the task running on core 0 to yield. Therefore, pxTCB |
| * is not used in this macro. */ |
| #define taskYIELD_TASK_CORE_IF_USING_PREEMPTION( pxTCB ) \ |
| do { \ |
| ( void ) ( pxTCB ); \ |
| portYIELD_WITHIN_API(); \ |
| } while( 0 ) |
| |
| #define taskYIELD_ANY_CORE_IF_USING_PREEMPTION( pxTCB ) \ |
| do { \ |
| if( pxCurrentTCB->uxPriority < ( pxTCB )->uxPriority ) \ |
| { \ |
| portYIELD_WITHIN_API(); \ |
| } \ |
| else \ |
| { \ |
| mtCOVERAGE_TEST_MARKER(); \ |
| } \ |
| } while( 0 ) |
| |
| #else /* if ( configNUMBER_OF_CORES == 1 ) */ |
| |
| /* Yield the core on which this task is running. */ |
| #define taskYIELD_TASK_CORE_IF_USING_PREEMPTION( pxTCB ) prvYieldCore( ( pxTCB )->xTaskRunState ) |
| |
| /* Yield for the task if a running task has priority lower than this task. */ |
| #define taskYIELD_ANY_CORE_IF_USING_PREEMPTION( pxTCB ) prvYieldForTask( pxTCB ) |
| |
| #endif /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| |
| #endif /* if ( configUSE_PREEMPTION == 0 ) */ |
| |
| /* Values that can be assigned to the ucNotifyState member of the TCB. */ |
| #define taskNOT_WAITING_NOTIFICATION ( ( uint8_t ) 0 ) /* Must be zero as it is the initialised value. */ |
| #define taskWAITING_NOTIFICATION ( ( uint8_t ) 1 ) |
| #define taskNOTIFICATION_RECEIVED ( ( uint8_t ) 2 ) |
| |
| /* |
| * The value used to fill the stack of a task when the task is created. This |
| * is used purely for checking the high water mark for tasks. |
| */ |
| #define tskSTACK_FILL_BYTE ( 0xa5U ) |
| |
| /* Bits used to record how a task's stack and TCB were allocated. */ |
| #define tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB ( ( uint8_t ) 0 ) |
| #define tskSTATICALLY_ALLOCATED_STACK_ONLY ( ( uint8_t ) 1 ) |
| #define tskSTATICALLY_ALLOCATED_STACK_AND_TCB ( ( uint8_t ) 2 ) |
| |
| /* If any of the following are set then task stacks are filled with a known |
| * value so the high water mark can be determined. If none of the following are |
| * set then don't fill the stack so there is no unnecessary dependency on memset. */ |
| #if ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) ) |
| #define tskSET_NEW_STACKS_TO_KNOWN_VALUE 1 |
| #else |
| #define tskSET_NEW_STACKS_TO_KNOWN_VALUE 0 |
| #endif |
| |
| /* |
| * Macros used by vListTask to indicate which state a task is in. |
| */ |
| #define tskRUNNING_CHAR ( 'X' ) |
| #define tskBLOCKED_CHAR ( 'B' ) |
| #define tskREADY_CHAR ( 'R' ) |
| #define tskDELETED_CHAR ( 'D' ) |
| #define tskSUSPENDED_CHAR ( 'S' ) |
| |
| /* |
| * Some kernel aware debuggers require the data the debugger needs access to to |
| * be global, rather than file scope. |
| */ |
| #ifdef portREMOVE_STATIC_QUALIFIER |
| #define static |
| #endif |
| |
| /* The name allocated to the Idle task. This can be overridden by defining |
| * configIDLE_TASK_NAME in FreeRTOSConfig.h. */ |
| #ifndef configIDLE_TASK_NAME |
| #define configIDLE_TASK_NAME "IDLE" |
| #endif |
| |
| #if ( configUSE_PORT_OPTIMISED_TASK_SELECTION == 0 ) |
| |
| /* If configUSE_PORT_OPTIMISED_TASK_SELECTION is 0 then task selection is |
| * performed in a generic way that is not optimised to any particular |
| * microcontroller architecture. */ |
| |
| /* uxTopReadyPriority holds the priority of the highest priority ready |
| * state task. */ |
| #define taskRECORD_READY_PRIORITY( uxPriority ) \ |
| do { \ |
| if( ( uxPriority ) > uxTopReadyPriority ) \ |
| { \ |
| uxTopReadyPriority = ( uxPriority ); \ |
| } \ |
| } while( 0 ) /* taskRECORD_READY_PRIORITY */ |
| |
| /*-----------------------------------------------------------*/ |
| |
| #if ( configNUMBER_OF_CORES == 1 ) |
| #define taskSELECT_HIGHEST_PRIORITY_TASK() \ |
| do { \ |
| UBaseType_t uxTopPriority = uxTopReadyPriority; \ |
| \ |
| /* Find the highest priority queue that contains ready tasks. */ \ |
| while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopPriority ] ) ) ) \ |
| { \ |
| configASSERT( uxTopPriority ); \ |
| --uxTopPriority; \ |
| } \ |
| \ |
| /* listGET_OWNER_OF_NEXT_ENTRY indexes through the list, so the tasks of \ |
| * the same priority get an equal share of the processor time. */ \ |
| listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) ); \ |
| uxTopReadyPriority = uxTopPriority; \ |
| } while( 0 ) /* taskSELECT_HIGHEST_PRIORITY_TASK */ |
| #else /* if ( configNUMBER_OF_CORES == 1 ) */ |
| |
| #define taskSELECT_HIGHEST_PRIORITY_TASK( xCoreID ) prvSelectHighestPriorityTask( xCoreID ) |
| |
| #endif /* if ( configNUMBER_OF_CORES == 1 ) */ |
| |
| /*-----------------------------------------------------------*/ |
| |
| /* Define away taskRESET_READY_PRIORITY() and portRESET_READY_PRIORITY() as |
| * they are only required when a port optimised method of task selection is |
| * being used. */ |
| #define taskRESET_READY_PRIORITY( uxPriority ) |
| #define portRESET_READY_PRIORITY( uxPriority, uxTopReadyPriority ) |
| |
| #else /* configUSE_PORT_OPTIMISED_TASK_SELECTION */ |
| |
| /* If configUSE_PORT_OPTIMISED_TASK_SELECTION is 1 then task selection is |
| * performed in a way that is tailored to the particular microcontroller |
| * architecture being used. */ |
| |
| /* A port optimised version is provided. Call the port defined macros. */ |
| #define taskRECORD_READY_PRIORITY( uxPriority ) portRECORD_READY_PRIORITY( ( uxPriority ), uxTopReadyPriority ) |
| |
| /*-----------------------------------------------------------*/ |
| |
| #define taskSELECT_HIGHEST_PRIORITY_TASK() \ |
| do { \ |
| UBaseType_t uxTopPriority; \ |
| \ |
| /* Find the highest priority list that contains ready tasks. */ \ |
| portGET_HIGHEST_PRIORITY( uxTopPriority, uxTopReadyPriority ); \ |
| configASSERT( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ uxTopPriority ] ) ) > 0 ); \ |
| listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) ); \ |
| } while( 0 ) |
| |
| /*-----------------------------------------------------------*/ |
| |
| /* A port optimised version is provided, call it only if the TCB being reset |
| * is being referenced from a ready list. If it is referenced from a delayed |
| * or suspended list then it won't be in a ready list. */ |
| #define taskRESET_READY_PRIORITY( uxPriority ) \ |
| do { \ |
| if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ ( uxPriority ) ] ) ) == ( UBaseType_t ) 0 ) \ |
| { \ |
| portRESET_READY_PRIORITY( ( uxPriority ), ( uxTopReadyPriority ) ); \ |
| } \ |
| } while( 0 ) |
| |
| #endif /* configUSE_PORT_OPTIMISED_TASK_SELECTION */ |
| |
| /*-----------------------------------------------------------*/ |
| |
| /* pxDelayedTaskList and pxOverflowDelayedTaskList are switched when the tick |
| * count overflows. */ |
| #define taskSWITCH_DELAYED_LISTS() \ |
| do { \ |
| List_t * pxTemp; \ |
| \ |
| /* The delayed tasks list should be empty when the lists are switched. */ \ |
| configASSERT( ( listLIST_IS_EMPTY( pxDelayedTaskList ) ) ); \ |
| \ |
| pxTemp = pxDelayedTaskList; \ |
| pxDelayedTaskList = pxOverflowDelayedTaskList; \ |
| pxOverflowDelayedTaskList = pxTemp; \ |
| xNumOfOverflows++; \ |
| prvResetNextTaskUnblockTime(); \ |
| } while( 0 ) |
| |
| /*-----------------------------------------------------------*/ |
| |
| /* |
| * Place the task represented by pxTCB into the appropriate ready list for |
| * the task. It is inserted at the end of the list. |
| */ |
| #define prvAddTaskToReadyList( pxTCB ) \ |
| do { \ |
| traceMOVED_TASK_TO_READY_STATE( pxTCB ); \ |
| taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority ); \ |
| listINSERT_END( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xStateListItem ) ); \ |
| tracePOST_MOVED_TASK_TO_READY_STATE( pxTCB ); \ |
| } while( 0 ) |
| /*-----------------------------------------------------------*/ |
| |
| /* |
| * Several functions take a TaskHandle_t parameter that can optionally be NULL, |
| * where NULL is used to indicate that the handle of the currently executing |
| * task should be used in place of the parameter. This macro simply checks to |
| * see if the parameter is NULL and returns a pointer to the appropriate TCB. |
| */ |
| #define prvGetTCBFromHandle( pxHandle ) ( ( ( pxHandle ) == NULL ) ? pxCurrentTCB : ( pxHandle ) ) |
| |
| /* The item value of the event list item is normally used to hold the priority |
| * of the task to which it belongs (coded to allow it to be held in reverse |
| * priority order). However, it is occasionally borrowed for other purposes. It |
| * is important its value is not updated due to a task priority change while it is |
| * being used for another purpose. The following bit definition is used to inform |
| * the scheduler that the value should not be changed - in which case it is the |
| * responsibility of whichever module is using the value to ensure it gets set back |
| * to its original value when it is released. */ |
| #if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS ) |
| #define taskEVENT_LIST_ITEM_VALUE_IN_USE 0x8000U |
| #elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_32_BITS ) |
| #define taskEVENT_LIST_ITEM_VALUE_IN_USE 0x80000000UL |
| #elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_64_BITS ) |
| #define taskEVENT_LIST_ITEM_VALUE_IN_USE 0x8000000000000000ULL |
| #endif |
| |
| /* Indicates that the task is not actively running on any core. */ |
| #define taskTASK_NOT_RUNNING ( ( BaseType_t ) ( -1 ) ) |
| |
| /* Indicates that the task is actively running but scheduled to yield. */ |
| #define taskTASK_SCHEDULED_TO_YIELD ( ( BaseType_t ) ( -2 ) ) |
| |
| /* Returns pdTRUE if the task is actively running and not scheduled to yield. */ |
| #if ( configNUMBER_OF_CORES == 1 ) |
| #define taskTASK_IS_RUNNING( pxTCB ) ( ( ( pxTCB ) == pxCurrentTCB ) ? ( pdTRUE ) : ( pdFALSE ) ) |
| #define taskTASK_IS_RUNNING_OR_SCHEDULED_TO_YIELD( pxTCB ) ( ( ( pxTCB ) == pxCurrentTCB ) ? ( pdTRUE ) : ( pdFALSE ) ) |
| #else |
| #define taskTASK_IS_RUNNING( pxTCB ) ( ( ( ( pxTCB )->xTaskRunState >= ( BaseType_t ) 0 ) && ( ( pxTCB )->xTaskRunState < ( BaseType_t ) configNUMBER_OF_CORES ) ) ? ( pdTRUE ) : ( pdFALSE ) ) |
| #define taskTASK_IS_RUNNING_OR_SCHEDULED_TO_YIELD( pxTCB ) ( ( ( pxTCB )->xTaskRunState != taskTASK_NOT_RUNNING ) ? ( pdTRUE ) : ( pdFALSE ) ) |
| #endif |
| |
| /* Indicates that the task is an Idle task. */ |
| #define taskATTRIBUTE_IS_IDLE ( UBaseType_t ) ( 1UL << 0UL ) |
| |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( portCRITICAL_NESTING_IN_TCB == 1 ) ) |
| #define portGET_CRITICAL_NESTING_COUNT() ( pxCurrentTCBs[ portGET_CORE_ID() ]->uxCriticalNesting ) |
| #define portSET_CRITICAL_NESTING_COUNT( x ) ( pxCurrentTCBs[ portGET_CORE_ID() ]->uxCriticalNesting = ( x ) ) |
| #define portINCREMENT_CRITICAL_NESTING_COUNT() ( pxCurrentTCBs[ portGET_CORE_ID() ]->uxCriticalNesting++ ) |
| #define portDECREMENT_CRITICAL_NESTING_COUNT() ( pxCurrentTCBs[ portGET_CORE_ID() ]->uxCriticalNesting-- ) |
| #endif /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( portCRITICAL_NESTING_IN_TCB == 1 ) ) */ |
| |
| /* Code below here allows infinite loop controlling, especially for the infinite loop |
| * in idle task function (for example when performing unit tests). */ |
| #ifndef INFINITE_LOOP |
| #define INFINITE_LOOP() 1 |
| #endif |
| |
| #define taskBITS_PER_BYTE ( ( size_t ) 8 ) |
| |
| /* |
| * Task control block. A task control block (TCB) is allocated for each task, |
| * and stores task state information, including a pointer to the task's context |
| * (the task's run time environment, including register values) |
| */ |
| typedef struct tskTaskControlBlock /* The old naming convention is used to prevent breaking kernel aware debuggers. */ |
| { |
| volatile StackType_t * pxTopOfStack; /**< Points to the location of the last item placed on the tasks stack. THIS MUST BE THE FIRST MEMBER OF THE TCB STRUCT. */ |
| |
| #if ( portUSING_MPU_WRAPPERS == 1 ) |
| xMPU_SETTINGS xMPUSettings; /**< The MPU settings are defined as part of the port layer. THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */ |
| #endif |
| |
| #if ( configUSE_CORE_AFFINITY == 1 ) && ( configNUMBER_OF_CORES > 1 ) |
| UBaseType_t uxCoreAffinityMask; /**< Used to link the task to certain cores. UBaseType_t must have greater than or equal to the number of bits as configNUMBER_OF_CORES. */ |
| #endif |
| |
| ListItem_t xStateListItem; /**< The list that the state list item of a task is reference from denotes the state of that task (Ready, Blocked, Suspended ). */ |
| ListItem_t xEventListItem; /**< Used to reference a task from an event list. */ |
| UBaseType_t uxPriority; /**< The priority of the task. 0 is the lowest priority. */ |
| StackType_t * pxStack; /**< Points to the start of the stack. */ |
| #if ( configNUMBER_OF_CORES > 1 ) |
| volatile BaseType_t xTaskRunState; /**< Used to identify the core the task is running on, if the task is running. Otherwise, identifies the task's state - not running or yielding. */ |
| UBaseType_t uxTaskAttributes; /**< Task's attributes - currently used to identify the idle tasks. */ |
| #endif |
| char pcTaskName[ configMAX_TASK_NAME_LEN ]; /**< Descriptive name given to the task when created. Facilitates debugging only. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ |
| |
| #if ( configUSE_TASK_PREEMPTION_DISABLE == 1 ) |
| BaseType_t xPreemptionDisable; /**< Used to prevent the task from being preempted. */ |
| #endif |
| |
| #if ( ( portSTACK_GROWTH > 0 ) || ( configRECORD_STACK_HIGH_ADDRESS == 1 ) ) |
| StackType_t * pxEndOfStack; /**< Points to the highest valid address for the stack. */ |
| #endif |
| |
| #if ( portCRITICAL_NESTING_IN_TCB == 1 ) |
| UBaseType_t uxCriticalNesting; /**< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */ |
| #endif |
| |
| #if ( configUSE_TRACE_FACILITY == 1 ) |
| UBaseType_t uxTCBNumber; /**< Stores a number that increments each time a TCB is created. It allows debuggers to determine when a task has been deleted and then recreated. */ |
| UBaseType_t uxTaskNumber; /**< Stores a number specifically for use by third party trace code. */ |
| #endif |
| |
| #if ( configUSE_MUTEXES == 1 ) |
| UBaseType_t uxBasePriority; /**< The priority last assigned to the task - used by the priority inheritance mechanism. */ |
| UBaseType_t uxMutexesHeld; |
| #endif |
| |
| #if ( configUSE_APPLICATION_TASK_TAG == 1 ) |
| TaskHookFunction_t pxTaskTag; |
| #endif |
| |
| #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 ) |
| void * pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ]; |
| #endif |
| |
| #if ( configGENERATE_RUN_TIME_STATS == 1 ) |
| configRUN_TIME_COUNTER_TYPE ulRunTimeCounter; /**< Stores the amount of time the task has spent in the Running state. */ |
| #endif |
| |
| #if ( configUSE_C_RUNTIME_TLS_SUPPORT == 1 ) |
| configTLS_BLOCK_TYPE xTLSBlock; /**< Memory block used as Thread Local Storage (TLS) Block for the task. */ |
| #endif |
| |
| #if ( configUSE_TASK_NOTIFICATIONS == 1 ) |
| volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ]; |
| volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ]; |
| #endif |
| |
| /* See the comments in FreeRTOS.h with the definition of |
| * tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE. */ |
| #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro has been consolidated for readability reasons. */ |
| uint8_t ucStaticallyAllocated; /**< Set to pdTRUE if the task is a statically allocated to ensure no attempt is made to free the memory. */ |
| #endif |
| |
| #if ( INCLUDE_xTaskAbortDelay == 1 ) |
| uint8_t ucDelayAborted; |
| #endif |
| |
| #if ( configUSE_POSIX_ERRNO == 1 ) |
| int iTaskErrno; |
| #endif |
| } tskTCB; |
| |
| /* The old tskTCB name is maintained above then typedefed to the new TCB_t name |
| * below to enable the use of older kernel aware debuggers. */ |
| typedef tskTCB TCB_t; |
| |
| /*lint -save -e956 A manual analysis and inspection has been used to determine |
| * which static variables must be declared volatile. */ |
| #if ( configNUMBER_OF_CORES == 1 ) |
| portDONT_DISCARD PRIVILEGED_DATA TCB_t * volatile pxCurrentTCB = NULL; |
| #else |
| /* MISRA Ref 8.4.1 [Declaration shall be visible] */ |
| /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-84 */ |
| /* coverity[misra_c_2012_rule_8_4_violation] */ |
| portDONT_DISCARD PRIVILEGED_DATA TCB_t * volatile pxCurrentTCBs[ configNUMBER_OF_CORES ]; |
| #define pxCurrentTCB xTaskGetCurrentTaskHandle() |
| #endif |
| |
| /* Lists for ready and blocked tasks. -------------------- |
| * xDelayedTaskList1 and xDelayedTaskList2 could be moved to function scope but |
| * doing so breaks some kernel aware debuggers and debuggers that rely on removing |
| * the static qualifier. */ |
| PRIVILEGED_DATA static List_t pxReadyTasksLists[ configMAX_PRIORITIES ]; /**< Prioritised ready tasks. */ |
| PRIVILEGED_DATA static List_t xDelayedTaskList1; /**< Delayed tasks. */ |
| PRIVILEGED_DATA static List_t xDelayedTaskList2; /**< Delayed tasks (two lists are used - one for delays that have overflowed the current tick count. */ |
| PRIVILEGED_DATA static List_t * volatile pxDelayedTaskList; /**< Points to the delayed task list currently being used. */ |
| PRIVILEGED_DATA static List_t * volatile pxOverflowDelayedTaskList; /**< Points to the delayed task list currently being used to hold tasks that have overflowed the current tick count. */ |
| PRIVILEGED_DATA static List_t xPendingReadyList; /**< Tasks that have been readied while the scheduler was suspended. They will be moved to the ready list when the scheduler is resumed. */ |
| |
| #if ( INCLUDE_vTaskDelete == 1 ) |
| |
| PRIVILEGED_DATA static List_t xTasksWaitingTermination; /**< Tasks that have been deleted - but their memory not yet freed. */ |
| PRIVILEGED_DATA static volatile UBaseType_t uxDeletedTasksWaitingCleanUp = ( UBaseType_t ) 0U; |
| |
| #endif |
| |
| #if ( INCLUDE_vTaskSuspend == 1 ) |
| |
| PRIVILEGED_DATA static List_t xSuspendedTaskList; /**< Tasks that are currently suspended. */ |
| |
| #endif |
| |
| /* Global POSIX errno. Its value is changed upon context switching to match |
| * the errno of the currently running task. */ |
| #if ( configUSE_POSIX_ERRNO == 1 ) |
| int FreeRTOS_errno = 0; |
| #endif |
| |
| /* Other file private variables. --------------------------------*/ |
| PRIVILEGED_DATA static volatile UBaseType_t uxCurrentNumberOfTasks = ( UBaseType_t ) 0U; |
| PRIVILEGED_DATA static volatile TickType_t xTickCount = ( TickType_t ) configINITIAL_TICK_COUNT; |
| PRIVILEGED_DATA static volatile UBaseType_t uxTopReadyPriority = tskIDLE_PRIORITY; |
| PRIVILEGED_DATA static volatile BaseType_t xSchedulerRunning = pdFALSE; |
| PRIVILEGED_DATA static volatile TickType_t xPendedTicks = ( TickType_t ) 0U; |
| PRIVILEGED_DATA static volatile BaseType_t xYieldPendings[ configNUMBER_OF_CORES ] = { pdFALSE }; |
| PRIVILEGED_DATA static volatile BaseType_t xNumOfOverflows = ( BaseType_t ) 0; |
| PRIVILEGED_DATA static UBaseType_t uxTaskNumber = ( UBaseType_t ) 0U; |
| PRIVILEGED_DATA static volatile TickType_t xNextTaskUnblockTime = ( TickType_t ) 0U; /* Initialised to portMAX_DELAY before the scheduler starts. */ |
| PRIVILEGED_DATA static TaskHandle_t xIdleTaskHandles[ configNUMBER_OF_CORES ]; /**< Holds the handles of the idle tasks. The idle tasks are created automatically when the scheduler is started. */ |
| |
| /* Improve support for OpenOCD. The kernel tracks Ready tasks via priority lists. |
| * For tracking the state of remote threads, OpenOCD uses uxTopUsedPriority |
| * to determine the number of priority lists to read back from the remote target. */ |
| const volatile UBaseType_t uxTopUsedPriority = configMAX_PRIORITIES - 1U; |
| |
| /* Context switches are held pending while the scheduler is suspended. Also, |
| * interrupts must not manipulate the xStateListItem of a TCB, or any of the |
| * lists the xStateListItem can be referenced from, if the scheduler is suspended. |
| * If an interrupt needs to unblock a task while the scheduler is suspended then it |
| * moves the task's event list item into the xPendingReadyList, ready for the |
| * kernel to move the task from the pending ready list into the real ready list |
| * when the scheduler is unsuspended. The pending ready list itself can only be |
| * accessed from a critical section. |
| * |
| * Updates to uxSchedulerSuspended must be protected by both the task lock and the ISR lock |
| * and must not be done from an ISR. Reads must be protected by either lock and may be done |
| * from either an ISR or a task. */ |
| PRIVILEGED_DATA static volatile UBaseType_t uxSchedulerSuspended = ( UBaseType_t ) 0U; |
| |
| #if ( configGENERATE_RUN_TIME_STATS == 1 ) |
| |
| /* Do not move these variables to function scope as doing so prevents the |
| * code working with debuggers that need to remove the static qualifier. */ |
| PRIVILEGED_DATA static configRUN_TIME_COUNTER_TYPE ulTaskSwitchedInTime[ configNUMBER_OF_CORES ] = { 0U }; /**< Holds the value of a timer/counter the last time a task was switched in. */ |
| PRIVILEGED_DATA static volatile configRUN_TIME_COUNTER_TYPE ulTotalRunTime[ configNUMBER_OF_CORES ] = { 0U }; /**< Holds the total amount of execution time as defined by the run time counter clock. */ |
| |
| #endif |
| |
| #if ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configNUMBER_OF_CORES > 1 ) |
| |
| /* Do not move these variables to function scope as doing so prevents the |
| * code working with debuggers that need to remove the static qualifier. */ |
| static StaticTask_t xIdleTCBBuffers[ configNUMBER_OF_CORES - 1 ]; |
| static StackType_t xIdleTaskStackBuffers[ configNUMBER_OF_CORES - 1 ][ configMINIMAL_STACK_SIZE ]; |
| |
| #endif /* #if ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configNUMBER_OF_CORES > 1 ) */ |
| |
| /*lint -restore */ |
| |
| /*-----------------------------------------------------------*/ |
| |
| /* File private functions. --------------------------------*/ |
| |
| /* |
| * Creates the idle tasks during scheduler start. |
| */ |
| static BaseType_t prvCreateIdleTasks( void ); |
| |
| #if ( configNUMBER_OF_CORES > 1 ) |
| |
| /* |
| * Checks to see if another task moved the current task out of the ready |
| * list while it was waiting to enter a critical section and yields, if so. |
| */ |
| static void prvCheckForRunStateChange( void ); |
| #endif /* #if ( configNUMBER_OF_CORES > 1 ) */ |
| |
| #if ( configNUMBER_OF_CORES > 1 ) |
| |
| /* |
| * Yields the given core. |
| */ |
| static void prvYieldCore( BaseType_t xCoreID ); |
| #endif /* #if ( configNUMBER_OF_CORES > 1 ) */ |
| |
| #if ( configNUMBER_OF_CORES > 1 ) |
| |
| /* |
| * Yields a core, or cores if multiple priorities are not allowed to run |
| * simultaneously, to allow the task pxTCB to run. |
| */ |
| static void prvYieldForTask( const TCB_t * pxTCB ); |
| #endif /* #if ( configNUMBER_OF_CORES > 1 ) */ |
| |
| #if ( configNUMBER_OF_CORES > 1 ) |
| |
| /* |
| * Selects the highest priority available task for the given core. |
| */ |
| static void prvSelectHighestPriorityTask( BaseType_t xCoreID ); |
| #endif /* #if ( configNUMBER_OF_CORES > 1 ) */ |
| |
| /** |
| * Utility task that simply returns pdTRUE if the task referenced by xTask is |
| * currently in the Suspended state, or pdFALSE if the task referenced by xTask |
| * is in any other state. |
| */ |
| #if ( INCLUDE_vTaskSuspend == 1 ) |
| |
| static BaseType_t prvTaskIsTaskSuspended( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION; |
| |
| #endif /* INCLUDE_vTaskSuspend */ |
| |
| /* |
| * Utility to ready all the lists used by the scheduler. This is called |
| * automatically upon the creation of the first task. |
| */ |
| static void prvInitialiseTaskLists( void ) PRIVILEGED_FUNCTION; |
| |
| /* |
| * The idle task, which as all tasks is implemented as a never ending loop. |
| * The idle task is automatically created and added to the ready lists upon |
| * creation of the first user task. |
| * |
| * In the FreeRTOS SMP, configNUMBER_OF_CORES - 1 minimal idle tasks are also |
| * created to ensure that each core has an idle task to run when no other |
| * task is available to run. |
| * |
| * The portTASK_FUNCTION_PROTO() macro is used to allow port/compiler specific |
| * language extensions. The equivalent prototype for these functions are: |
| * |
| * void prvIdleTask( void *pvParameters ); |
| * void prvMinimalIdleTask( void *pvParameters ); |
| * |
| */ |
| static portTASK_FUNCTION_PROTO( prvIdleTask, pvParameters ) PRIVILEGED_FUNCTION; |
| #if ( configNUMBER_OF_CORES > 1 ) |
| static portTASK_FUNCTION_PROTO( prvMinimalIdleTask, pvParameters ) PRIVILEGED_FUNCTION; |
| #endif |
| |
| /* |
| * Utility to free all memory allocated by the scheduler to hold a TCB, |
| * including the stack pointed to by the TCB. |
| * |
| * This does not free memory allocated by the task itself (i.e. memory |
| * allocated by calls to pvPortMalloc from within the tasks application code). |
| */ |
| #if ( INCLUDE_vTaskDelete == 1 ) |
| |
| static void prvDeleteTCB( TCB_t * pxTCB ) PRIVILEGED_FUNCTION; |
| |
| #endif |
| |
| /* |
| * Used only by the idle task. This checks to see if anything has been placed |
| * in the list of tasks waiting to be deleted. If so the task is cleaned up |
| * and its TCB deleted. |
| */ |
| static void prvCheckTasksWaitingTermination( void ) PRIVILEGED_FUNCTION; |
| |
| /* |
| * The currently executing task is entering the Blocked state. Add the task to |
| * either the current or the overflow delayed task list. |
| */ |
| static void prvAddCurrentTaskToDelayedList( TickType_t xTicksToWait, |
| const BaseType_t xCanBlockIndefinitely ) PRIVILEGED_FUNCTION; |
| |
| /* |
| * Fills an TaskStatus_t structure with information on each task that is |
| * referenced from the pxList list (which may be a ready list, a delayed list, |
| * a suspended list, etc.). |
| * |
| * THIS FUNCTION IS INTENDED FOR DEBUGGING ONLY, AND SHOULD NOT BE CALLED FROM |
| * NORMAL APPLICATION CODE. |
| */ |
| #if ( configUSE_TRACE_FACILITY == 1 ) |
| |
| static UBaseType_t prvListTasksWithinSingleList( TaskStatus_t * pxTaskStatusArray, |
| List_t * pxList, |
| eTaskState eState ) PRIVILEGED_FUNCTION; |
| |
| #endif |
| |
| /* |
| * Searches pxList for a task with name pcNameToQuery - returning a handle to |
| * the task if it is found, or NULL if the task is not found. |
| */ |
| #if ( INCLUDE_xTaskGetHandle == 1 ) |
| |
| static TCB_t * prvSearchForNameWithinSingleList( List_t * pxList, |
| const char pcNameToQuery[] ) PRIVILEGED_FUNCTION; |
| |
| #endif |
| |
| /* |
| * When a task is created, the stack of the task is filled with a known value. |
| * This function determines the 'high water mark' of the task stack by |
| * determining how much of the stack remains at the original preset value. |
| */ |
| #if ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) ) |
| |
| static configSTACK_DEPTH_TYPE prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte ) PRIVILEGED_FUNCTION; |
| |
| #endif |
| |
| /* |
| * Return the amount of time, in ticks, that will pass before the kernel will |
| * next move a task from the Blocked state to the Running state. |
| * |
| * This conditional compilation should use inequality to 0, not equality to 1. |
| * This is to ensure portSUPPRESS_TICKS_AND_SLEEP() can be called when user |
| * defined low power mode implementations require configUSE_TICKLESS_IDLE to be |
| * set to a value other than 1. |
| */ |
| #if ( configUSE_TICKLESS_IDLE != 0 ) |
| |
| static TickType_t prvGetExpectedIdleTime( void ) PRIVILEGED_FUNCTION; |
| |
| #endif |
| |
| /* |
| * Set xNextTaskUnblockTime to the time at which the next Blocked state task |
| * will exit the Blocked state. |
| */ |
| static void prvResetNextTaskUnblockTime( void ) PRIVILEGED_FUNCTION; |
| |
| #if ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) |
| |
| /* |
| * Helper function used to pad task names with spaces when printing out |
| * human readable tables of task information. |
| */ |
| static char * prvWriteNameToBuffer( char * pcBuffer, |
| const char * pcTaskName ) PRIVILEGED_FUNCTION; |
| |
| #endif |
| |
| /* |
| * Called after a Task_t structure has been allocated either statically or |
| * dynamically to fill in the structure's members. |
| */ |
| static void prvInitialiseNewTask( TaskFunction_t pxTaskCode, |
| const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ |
| const uint32_t ulStackDepth, |
| void * const pvParameters, |
| UBaseType_t uxPriority, |
| TaskHandle_t * const pxCreatedTask, |
| TCB_t * pxNewTCB, |
| const MemoryRegion_t * const xRegions ) PRIVILEGED_FUNCTION; |
| |
| /* |
| * Called after a new task has been created and initialised to place the task |
| * under the control of the scheduler. |
| */ |
| static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB ) PRIVILEGED_FUNCTION; |
| |
| /* |
| * freertos_tasks_c_additions_init() should only be called if the user definable |
| * macro FREERTOS_TASKS_C_ADDITIONS_INIT() is defined, as that is the only macro |
| * called by the function. |
| */ |
| #ifdef FREERTOS_TASKS_C_ADDITIONS_INIT |
| |
| static void freertos_tasks_c_additions_init( void ) PRIVILEGED_FUNCTION; |
| |
| #endif |
| |
| #if ( configUSE_MINIMAL_IDLE_HOOK == 1 ) |
| extern void vApplicationMinimalIdleHook( void ); |
| #endif /* #if ( configUSE_MINIMAL_IDLE_HOOK == 1 ) */ |
| |
| #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) ) |
| |
| /* |
| * Convert the snprintf return value to the number of characters |
| * written. The following are the possible cases: |
| * |
| * 1. The buffer supplied to snprintf is large enough to hold the |
| * generated string. The return value in this case is the number |
| * of characters actually written, not counting the terminating |
| * null character. |
| * 2. The buffer supplied to snprintf is NOT large enough to hold |
| * the generated string. The return value in this case is the |
| * number of characters that would have been written if the |
| * buffer had been sufficiently large, not counting the |
| * terminating null character. |
| * 3. Encoding error. The return value in this case is a negative |
| * number. |
| * |
| * From 1 and 2 above ==> Only when the return value is non-negative |
| * and less than the supplied buffer length, the string has been |
| * completely written. |
| */ |
| static size_t prvSnprintfReturnValueToCharsWritten( int iSnprintfReturnValue, |
| size_t n ); |
| |
| #endif /* #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) ) */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( configNUMBER_OF_CORES > 1 ) |
| static void prvCheckForRunStateChange( void ) |
| { |
| UBaseType_t uxPrevCriticalNesting; |
| const TCB_t * pxThisTCB; |
| |
| /* This must only be called from within a task. */ |
| portASSERT_IF_IN_ISR(); |
| |
| /* This function is always called with interrupts disabled |
| * so this is safe. */ |
| pxThisTCB = pxCurrentTCBs[ portGET_CORE_ID() ]; |
| |
| while( pxThisTCB->xTaskRunState == taskTASK_SCHEDULED_TO_YIELD ) |
| { |
| /* We are only here if we just entered a critical section |
| * or if we just suspended the scheduler, and another task |
| * has requested that we yield. |
| * |
| * This is slightly complicated since we need to save and restore |
| * the suspension and critical nesting counts, as well as release |
| * and reacquire the correct locks. And then, do it all over again |
| * if our state changed again during the reacquisition. */ |
| uxPrevCriticalNesting = portGET_CRITICAL_NESTING_COUNT(); |
| |
| if( uxPrevCriticalNesting > 0U ) |
| { |
| portSET_CRITICAL_NESTING_COUNT( 0U ); |
| portRELEASE_ISR_LOCK(); |
| } |
| else |
| { |
| /* The scheduler is suspended. uxSchedulerSuspended is updated |
| * only when the task is not requested to yield. */ |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| portRELEASE_TASK_LOCK(); |
| portMEMORY_BARRIER(); |
| configASSERT( pxThisTCB->xTaskRunState == taskTASK_SCHEDULED_TO_YIELD ); |
| |
| portENABLE_INTERRUPTS(); |
| |
| /* Enabling interrupts should cause this core to immediately |
| * service the pending interrupt and yield. If the run state is still |
| * yielding here then that is a problem. */ |
| configASSERT( pxThisTCB->xTaskRunState != taskTASK_SCHEDULED_TO_YIELD ); |
| |
| portDISABLE_INTERRUPTS(); |
| portGET_TASK_LOCK(); |
| portGET_ISR_LOCK(); |
| |
| portSET_CRITICAL_NESTING_COUNT( uxPrevCriticalNesting ); |
| |
| if( uxPrevCriticalNesting == 0U ) |
| { |
| portRELEASE_ISR_LOCK(); |
| } |
| } |
| } |
| #endif /* #if ( configNUMBER_OF_CORES > 1 ) */ |
| |
| /*-----------------------------------------------------------*/ |
| |
| #if ( configNUMBER_OF_CORES > 1 ) |
| static void prvYieldCore( BaseType_t xCoreID ) |
| { |
| /* This must be called from a critical section and xCoreID must be valid. */ |
| if( ( portCHECK_IF_IN_ISR() == pdTRUE ) && ( xCoreID == ( BaseType_t ) portGET_CORE_ID() ) ) |
| { |
| xYieldPendings[ xCoreID ] = pdTRUE; |
| } |
| else |
| { |
| if( pxCurrentTCBs[ xCoreID ]->xTaskRunState != taskTASK_SCHEDULED_TO_YIELD ) |
| { |
| if( xCoreID == ( BaseType_t ) portGET_CORE_ID() ) |
| { |
| xYieldPendings[ xCoreID ] = pdTRUE; |
| } |
| else |
| { |
| portYIELD_CORE( xCoreID ); |
| pxCurrentTCBs[ xCoreID ]->xTaskRunState = taskTASK_SCHEDULED_TO_YIELD; |
| } |
| } |
| } |
| } |
| #endif /* #if ( configNUMBER_OF_CORES > 1 ) */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( configNUMBER_OF_CORES > 1 ) |
| static void prvYieldForTask( const TCB_t * pxTCB ) |
| { |
| BaseType_t xLowestPriorityToPreempt; |
| BaseType_t xCurrentCoreTaskPriority; |
| BaseType_t xLowestPriorityCore = ( BaseType_t ) -1; |
| BaseType_t xCoreID; |
| |
| #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) |
| BaseType_t xYieldCount = 0; |
| #endif /* #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) */ |
| |
| /* This must be called from a critical section. */ |
| configASSERT( portGET_CRITICAL_NESTING_COUNT() > 0U ); |
| |
| #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) |
| |
| /* No task should yield for this one if it is a lower priority |
| * than priority level of currently ready tasks. */ |
| if( pxTCB->uxPriority >= uxTopReadyPriority ) |
| #else |
| /* Yield is not required for a task which is already running. */ |
| if( taskTASK_IS_RUNNING( pxTCB ) == pdFALSE ) |
| #endif |
| { |
| xLowestPriorityToPreempt = ( BaseType_t ) pxTCB->uxPriority; |
| |
| /* xLowestPriorityToPreempt will be decremented to -1 if the priority of pxTCB |
| * is 0. This is ok as we will give system idle tasks a priority of -1 below. */ |
| --xLowestPriorityToPreempt; |
| |
| for( xCoreID = ( BaseType_t ) 0; xCoreID < ( BaseType_t ) configNUMBER_OF_CORES; xCoreID++ ) |
| { |
| xCurrentCoreTaskPriority = ( BaseType_t ) pxCurrentTCBs[ xCoreID ]->uxPriority; |
| |
| /* System idle tasks are being assigned a priority of tskIDLE_PRIORITY - 1 here. */ |
| if( ( pxCurrentTCBs[ xCoreID ]->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) != 0U ) |
| { |
| xCurrentCoreTaskPriority = xCurrentCoreTaskPriority - 1; |
| } |
| |
| if( ( taskTASK_IS_RUNNING( pxCurrentTCBs[ xCoreID ] ) != pdFALSE ) && ( xYieldPendings[ xCoreID ] == pdFALSE ) ) |
| { |
| #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) |
| if( taskTASK_IS_RUNNING( pxTCB ) == pdFALSE ) |
| #endif |
| { |
| if( xCurrentCoreTaskPriority <= xLowestPriorityToPreempt ) |
| { |
| #if ( configUSE_CORE_AFFINITY == 1 ) |
| if( ( pxTCB->uxCoreAffinityMask & ( ( UBaseType_t ) 1U << ( UBaseType_t ) xCoreID ) ) != 0U ) |
| #endif |
| { |
| #if ( configUSE_TASK_PREEMPTION_DISABLE == 1 ) |
| if( pxCurrentTCBs[ xCoreID ]->xPreemptionDisable == pdFALSE ) |
| #endif |
| { |
| xLowestPriorityToPreempt = xCurrentCoreTaskPriority; |
| xLowestPriorityCore = xCoreID; |
| } |
| } |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| |
| #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) |
| { |
| /* Yield all currently running non-idle tasks with a priority lower than |
| * the task that needs to run. */ |
| if( ( xCurrentCoreTaskPriority > ( ( BaseType_t ) tskIDLE_PRIORITY - 1 ) ) && |
| ( xCurrentCoreTaskPriority < ( BaseType_t ) pxTCB->uxPriority ) ) |
| { |
| prvYieldCore( xCoreID ); |
| xYieldCount++; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| #endif /* #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) */ |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| |
| #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) |
| if( ( xYieldCount == 0 ) && ( xLowestPriorityCore >= 0 ) ) |
| #else /* #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) */ |
| if( xLowestPriorityCore >= 0 ) |
| #endif /* #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) */ |
| { |
| prvYieldCore( xLowestPriorityCore ); |
| } |
| |
| #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) |
| /* Verify that the calling core always yields to higher priority tasks. */ |
| if( ( ( pxCurrentTCBs[ portGET_CORE_ID() ]->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) == 0 ) && |
| ( pxTCB->uxPriority > pxCurrentTCBs[ portGET_CORE_ID() ]->uxPriority ) ) |
| { |
| configASSERT( ( xYieldPendings[ portGET_CORE_ID() ] == pdTRUE ) || |
| ( taskTASK_IS_RUNNING( pxCurrentTCBs[ portGET_CORE_ID() ] ) == pdFALSE ) ); |
| } |
| #endif |
| } |
| } |
| #endif /* #if ( configNUMBER_OF_CORES > 1 ) */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( configNUMBER_OF_CORES > 1 ) |
| static void prvSelectHighestPriorityTask( BaseType_t xCoreID ) |
| { |
| UBaseType_t uxCurrentPriority = uxTopReadyPriority; |
| BaseType_t xTaskScheduled = pdFALSE; |
| BaseType_t xDecrementTopPriority = pdTRUE; |
| |
| #if ( configUSE_CORE_AFFINITY == 1 ) |
| const TCB_t * pxPreviousTCB = NULL; |
| #endif |
| #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) |
| BaseType_t xPriorityDropped = pdFALSE; |
| #endif |
| |
| /* This function should be called when scheduler is running. */ |
| configASSERT( xSchedulerRunning == pdTRUE ); |
| |
| /* A new task is created and a running task with the same priority yields |
| * itself to run the new task. When a running task yields itself, it is still |
| * in the ready list. This running task will be selected before the new task |
| * since the new task is always added to the end of the ready list. |
| * The other problem is that the running task still in the same position of |
| * the ready list when it yields itself. It is possible that it will be selected |
| * earlier then other tasks which waits longer than this task. |
| * |
| * To fix these problems, the running task should be put to the end of the |
| * ready list before searching for the ready task in the ready list. */ |
| if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxCurrentTCBs[ xCoreID ]->uxPriority ] ), |
| &pxCurrentTCBs[ xCoreID ]->xStateListItem ) == pdTRUE ) |
| { |
| ( void ) uxListRemove( &pxCurrentTCBs[ xCoreID ]->xStateListItem ); |
| vListInsertEnd( &( pxReadyTasksLists[ pxCurrentTCBs[ xCoreID ]->uxPriority ] ), |
| &pxCurrentTCBs[ xCoreID ]->xStateListItem ); |
| } |
| |
| while( xTaskScheduled == pdFALSE ) |
| { |
| #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) |
| { |
| if( uxCurrentPriority < uxTopReadyPriority ) |
| { |
| /* We can't schedule any tasks, other than idle, that have a |
| * priority lower than the priority of a task currently running |
| * on another core. */ |
| uxCurrentPriority = tskIDLE_PRIORITY; |
| } |
| } |
| #endif |
| |
| if( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxCurrentPriority ] ) ) == pdFALSE ) |
| { |
| const List_t * const pxReadyList = &( pxReadyTasksLists[ uxCurrentPriority ] ); |
| const ListItem_t * pxEndMarker = listGET_END_MARKER( pxReadyList ); |
| ListItem_t * pxIterator; |
| |
| /* The ready task list for uxCurrentPriority is not empty, so uxTopReadyPriority |
| * must not be decremented any further. */ |
| xDecrementTopPriority = pdFALSE; |
| |
| for( pxIterator = listGET_HEAD_ENTRY( pxReadyList ); pxIterator != pxEndMarker; pxIterator = listGET_NEXT( pxIterator ) ) |
| { |
| TCB_t * pxTCB = ( TCB_t * ) listGET_LIST_ITEM_OWNER( pxIterator ); |
| |
| #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) |
| { |
| /* When falling back to the idle priority because only one priority |
| * level is allowed to run at a time, we should ONLY schedule the true |
| * idle tasks, not user tasks at the idle priority. */ |
| if( uxCurrentPriority < uxTopReadyPriority ) |
| { |
| if( ( pxTCB->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) == 0 ) |
| { |
| continue; |
| } |
| } |
| } |
| #endif /* #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) */ |
| |
| if( pxTCB->xTaskRunState == taskTASK_NOT_RUNNING ) |
| { |
| #if ( configUSE_CORE_AFFINITY == 1 ) |
| if( ( pxTCB->uxCoreAffinityMask & ( ( UBaseType_t ) 1U << ( UBaseType_t ) xCoreID ) ) != 0U ) |
| #endif |
| { |
| /* If the task is not being executed by any core swap it in. */ |
| pxCurrentTCBs[ xCoreID ]->xTaskRunState = taskTASK_NOT_RUNNING; |
| #if ( configUSE_CORE_AFFINITY == 1 ) |
| pxPreviousTCB = pxCurrentTCBs[ xCoreID ]; |
| #endif |
| pxTCB->xTaskRunState = xCoreID; |
| pxCurrentTCBs[ xCoreID ] = pxTCB; |
| xTaskScheduled = pdTRUE; |
| } |
| } |
| else if( pxTCB == pxCurrentTCBs[ xCoreID ] ) |
| { |
| configASSERT( ( pxTCB->xTaskRunState == xCoreID ) || ( pxTCB->xTaskRunState == taskTASK_SCHEDULED_TO_YIELD ) ); |
| |
| #if ( configUSE_CORE_AFFINITY == 1 ) |
| if( ( pxTCB->uxCoreAffinityMask & ( ( UBaseType_t ) 1U << ( UBaseType_t ) xCoreID ) ) != 0U ) |
| #endif |
| { |
| /* The task is already running on this core, mark it as scheduled. */ |
| pxTCB->xTaskRunState = xCoreID; |
| xTaskScheduled = pdTRUE; |
| } |
| } |
| else |
| { |
| /* This task is running on the core other than xCoreID. */ |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| if( xTaskScheduled != pdFALSE ) |
| { |
| /* A task has been selected to run on this core. */ |
| break; |
| } |
| } |
| } |
| else |
| { |
| if( xDecrementTopPriority != pdFALSE ) |
| { |
| uxTopReadyPriority--; |
| #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) |
| { |
| xPriorityDropped = pdTRUE; |
| } |
| #endif |
| } |
| } |
| |
| /* There are configNUMBER_OF_CORES Idle tasks created when scheduler started. |
| * The scheduler should be able to select a task to run when uxCurrentPriority |
| * is tskIDLE_PRIORITY. uxCurrentPriority is never decreased to value blow |
| * tskIDLE_PRIORITY. */ |
| if( uxCurrentPriority > tskIDLE_PRIORITY ) |
| { |
| uxCurrentPriority--; |
| } |
| else |
| { |
| /* This function is called when idle task is not created. Break the |
| * loop to prevent uxCurrentPriority overrun. */ |
| break; |
| } |
| } |
| |
| #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) |
| { |
| if( xTaskScheduled == pdTRUE ) |
| { |
| if( xPriorityDropped != pdFALSE ) |
| { |
| /* There may be several ready tasks that were being prevented from running because there was |
| * a higher priority task running. Now that the last of the higher priority tasks is no longer |
| * running, make sure all the other idle tasks yield. */ |
| BaseType_t x; |
| |
| for( x = ( BaseType_t ) 0; x < ( BaseType_t ) configNUMBER_OF_CORES; x++ ) |
| { |
| if( ( pxCurrentTCBs[ x ]->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) != 0 ) |
| { |
| prvYieldCore( x ); |
| } |
| } |
| } |
| } |
| } |
| #endif /* #if ( configRUN_MULTIPLE_PRIORITIES == 0 ) */ |
| |
| #if ( configUSE_CORE_AFFINITY == 1 ) |
| { |
| if( xTaskScheduled == pdTRUE ) |
| { |
| if( ( pxPreviousTCB != NULL ) && ( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxPreviousTCB->uxPriority ] ), &( pxPreviousTCB->xStateListItem ) ) != pdFALSE ) ) |
| { |
| /* A ready task was just evicted from this core. See if it can be |
| * scheduled on any other core. */ |
| UBaseType_t uxCoreMap = pxPreviousTCB->uxCoreAffinityMask; |
| BaseType_t xLowestPriority = ( BaseType_t ) pxPreviousTCB->uxPriority; |
| BaseType_t xLowestPriorityCore = -1; |
| BaseType_t x; |
| |
| if( ( pxPreviousTCB->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) != 0U ) |
| { |
| xLowestPriority = xLowestPriority - 1; |
| } |
| |
| if( ( uxCoreMap & ( ( UBaseType_t ) 1U << ( UBaseType_t ) xCoreID ) ) != 0U ) |
| { |
| /* The ready task that was removed from this core is not excluded from it. |
| * Only look at the intersection of the cores the removed task is allowed to run |
| * on with the cores that the new task is excluded from. It is possible that the |
| * new task was only placed onto this core because it is excluded from another. |
| * Check to see if the previous task could run on one of those cores. */ |
| uxCoreMap &= ~( pxCurrentTCBs[ xCoreID ]->uxCoreAffinityMask ); |
| } |
| else |
| { |
| /* The ready task that was removed from this core is excluded from it. */ |
| } |
| |
| uxCoreMap &= ( ( 1U << configNUMBER_OF_CORES ) - 1U ); |
| |
| for( x = ( ( BaseType_t ) configNUMBER_OF_CORES - 1 ); x >= ( BaseType_t ) 0; x-- ) |
| { |
| UBaseType_t uxCore = ( UBaseType_t ) x; |
| BaseType_t xTaskPriority; |
| |
| if( ( uxCoreMap & ( ( UBaseType_t ) 1U << uxCore ) ) != 0U ) |
| { |
| xTaskPriority = ( BaseType_t ) pxCurrentTCBs[ uxCore ]->uxPriority; |
| |
| if( ( pxCurrentTCBs[ uxCore ]->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) != 0U ) |
| { |
| xTaskPriority = xTaskPriority - ( BaseType_t ) 1; |
| } |
| |
| uxCoreMap &= ~( ( UBaseType_t ) 1U << uxCore ); |
| |
| if( ( xTaskPriority < xLowestPriority ) && |
| ( taskTASK_IS_RUNNING( pxCurrentTCBs[ uxCore ] ) != pdFALSE ) && |
| ( xYieldPendings[ uxCore ] == pdFALSE ) ) |
| { |
| #if ( configUSE_TASK_PREEMPTION_DISABLE == 1 ) |
| if( pxCurrentTCBs[ uxCore ]->xPreemptionDisable == pdFALSE ) |
| #endif |
| { |
| xLowestPriority = xTaskPriority; |
| xLowestPriorityCore = ( BaseType_t ) uxCore; |
| } |
| } |
| } |
| } |
| |
| if( xLowestPriorityCore >= 0 ) |
| { |
| prvYieldCore( xLowestPriorityCore ); |
| } |
| } |
| } |
| } |
| #endif /* #if ( configUSE_CORE_AFFINITY == 1 ) */ |
| } |
| |
| #endif /* ( configNUMBER_OF_CORES > 1 ) */ |
| |
| /*-----------------------------------------------------------*/ |
| |
| #if ( configSUPPORT_STATIC_ALLOCATION == 1 ) |
| |
| TaskHandle_t xTaskCreateStatic( TaskFunction_t pxTaskCode, |
| const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ |
| const uint32_t ulStackDepth, |
| void * const pvParameters, |
| UBaseType_t uxPriority, |
| StackType_t * const puxStackBuffer, |
| StaticTask_t * const pxTaskBuffer ) |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) |
| { |
| return xTaskCreateStaticAffinitySet( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer, tskNO_AFFINITY ); |
| } |
| |
| TaskHandle_t xTaskCreateStaticAffinitySet( TaskFunction_t pxTaskCode, |
| const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ |
| const uint32_t ulStackDepth, |
| void * const pvParameters, |
| UBaseType_t uxPriority, |
| StackType_t * const puxStackBuffer, |
| StaticTask_t * const pxTaskBuffer, |
| UBaseType_t uxCoreAffinityMask ) |
| #endif /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) */ |
| { |
| TCB_t * pxNewTCB; |
| TaskHandle_t xReturn; |
| |
| traceENTER_xTaskCreateStatic( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer ); |
| |
| configASSERT( puxStackBuffer != NULL ); |
| configASSERT( pxTaskBuffer != NULL ); |
| |
| #if ( configASSERT_DEFINED == 1 ) |
| { |
| /* Sanity check that the size of the structure used to declare a |
| * variable of type StaticTask_t equals the size of the real task |
| * structure. */ |
| volatile size_t xSize = sizeof( StaticTask_t ); |
| configASSERT( xSize == sizeof( TCB_t ) ); |
| ( void ) xSize; /* Prevent lint warning when configASSERT() is not used. */ |
| } |
| #endif /* configASSERT_DEFINED */ |
| |
| if( ( pxTaskBuffer != NULL ) && ( puxStackBuffer != NULL ) ) |
| { |
| /* The memory used for the task's TCB and stack are passed into this |
| * function - use them. */ |
| pxNewTCB = ( TCB_t * ) pxTaskBuffer; /*lint !e740 !e9087 Unusual cast is ok as the structures are designed to have the same alignment, and the size is checked by an assert. */ |
| ( void ) memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) ); |
| pxNewTCB->pxStack = ( StackType_t * ) puxStackBuffer; |
| |
| #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro has been consolidated for readability reasons. */ |
| { |
| /* Tasks can be created statically or dynamically, so note this |
| * task was created statically in case the task is later deleted. */ |
| pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_AND_TCB; |
| } |
| #endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */ |
| |
| prvInitialiseNewTask( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, &xReturn, pxNewTCB, NULL ); |
| |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) |
| { |
| /* Set the task's affinity before scheduling it. */ |
| pxNewTCB->uxCoreAffinityMask = uxCoreAffinityMask; |
| } |
| #endif |
| |
| prvAddNewTaskToReadyList( pxNewTCB ); |
| } |
| else |
| { |
| xReturn = NULL; |
| } |
| |
| traceRETURN_xTaskCreateStatic( xReturn ); |
| |
| return xReturn; |
| } |
| |
| #endif /* SUPPORT_STATIC_ALLOCATION */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) |
| |
| BaseType_t xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition, |
| TaskHandle_t * pxCreatedTask ) |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) |
| { |
| return xTaskCreateRestrictedStaticAffinitySet( pxTaskDefinition, tskNO_AFFINITY, pxCreatedTask ); |
| } |
| |
| BaseType_t xTaskCreateRestrictedStaticAffinitySet( const TaskParameters_t * const pxTaskDefinition, |
| UBaseType_t uxCoreAffinityMask, |
| TaskHandle_t * pxCreatedTask ) |
| #endif /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) */ |
| { |
| TCB_t * pxNewTCB; |
| BaseType_t xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY; |
| |
| traceENTER_xTaskCreateRestrictedStatic( pxTaskDefinition, pxCreatedTask ); |
| |
| configASSERT( pxTaskDefinition->puxStackBuffer != NULL ); |
| configASSERT( pxTaskDefinition->pxTaskBuffer != NULL ); |
| |
| if( ( pxTaskDefinition->puxStackBuffer != NULL ) && ( pxTaskDefinition->pxTaskBuffer != NULL ) ) |
| { |
| /* Allocate space for the TCB. Where the memory comes from depends |
| * on the implementation of the port malloc function and whether or |
| * not static allocation is being used. */ |
| pxNewTCB = ( TCB_t * ) pxTaskDefinition->pxTaskBuffer; |
| ( void ) memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) ); |
| |
| /* Store the stack location in the TCB. */ |
| pxNewTCB->pxStack = pxTaskDefinition->puxStackBuffer; |
| |
| #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) |
| { |
| /* Tasks can be created statically or dynamically, so note this |
| * task was created statically in case the task is later deleted. */ |
| pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_AND_TCB; |
| } |
| #endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */ |
| |
| prvInitialiseNewTask( pxTaskDefinition->pvTaskCode, |
| pxTaskDefinition->pcName, |
| ( uint32_t ) pxTaskDefinition->usStackDepth, |
| pxTaskDefinition->pvParameters, |
| pxTaskDefinition->uxPriority, |
| pxCreatedTask, pxNewTCB, |
| pxTaskDefinition->xRegions ); |
| |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) |
| { |
| /* Set the task's affinity before scheduling it. */ |
| pxNewTCB->uxCoreAffinityMask = uxCoreAffinityMask; |
| } |
| #endif |
| |
| prvAddNewTaskToReadyList( pxNewTCB ); |
| xReturn = pdPASS; |
| } |
| |
| traceRETURN_xTaskCreateRestrictedStatic( xReturn ); |
| |
| return xReturn; |
| } |
| |
| #endif /* ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) |
| |
| BaseType_t xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, |
| TaskHandle_t * pxCreatedTask ) |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) |
| { |
| return xTaskCreateRestrictedAffinitySet( pxTaskDefinition, tskNO_AFFINITY, pxCreatedTask ); |
| } |
| |
| BaseType_t xTaskCreateRestrictedAffinitySet( const TaskParameters_t * const pxTaskDefinition, |
| UBaseType_t uxCoreAffinityMask, |
| TaskHandle_t * pxCreatedTask ) |
| #endif /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) */ |
| { |
| TCB_t * pxNewTCB; |
| BaseType_t xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY; |
| |
| traceENTER_xTaskCreateRestricted( pxTaskDefinition, pxCreatedTask ); |
| |
| configASSERT( pxTaskDefinition->puxStackBuffer ); |
| |
| if( pxTaskDefinition->puxStackBuffer != NULL ) |
| { |
| pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); |
| |
| if( pxNewTCB != NULL ) |
| { |
| ( void ) memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) ); |
| |
| /* Store the stack location in the TCB. */ |
| pxNewTCB->pxStack = pxTaskDefinition->puxStackBuffer; |
| |
| #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) |
| { |
| /* Tasks can be created statically or dynamically, so note |
| * this task had a statically allocated stack in case it is |
| * later deleted. The TCB was allocated dynamically. */ |
| pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_ONLY; |
| } |
| #endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */ |
| |
| prvInitialiseNewTask( pxTaskDefinition->pvTaskCode, |
| pxTaskDefinition->pcName, |
| ( uint32_t ) pxTaskDefinition->usStackDepth, |
| pxTaskDefinition->pvParameters, |
| pxTaskDefinition->uxPriority, |
| pxCreatedTask, pxNewTCB, |
| pxTaskDefinition->xRegions ); |
| |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) |
| { |
| /* Set the task's affinity before scheduling it. */ |
| pxNewTCB->uxCoreAffinityMask = uxCoreAffinityMask; |
| } |
| #endif |
| |
| prvAddNewTaskToReadyList( pxNewTCB ); |
| xReturn = pdPASS; |
| } |
| } |
| |
| traceRETURN_xTaskCreateRestricted( xReturn ); |
| |
| return xReturn; |
| } |
| |
| #endif /* portUSING_MPU_WRAPPERS */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) |
| |
| BaseType_t xTaskCreate( TaskFunction_t pxTaskCode, |
| const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ |
| const configSTACK_DEPTH_TYPE usStackDepth, |
| void * const pvParameters, |
| UBaseType_t uxPriority, |
| TaskHandle_t * const pxCreatedTask ) |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) |
| { |
| return xTaskCreateAffinitySet( pxTaskCode, pcName, usStackDepth, pvParameters, uxPriority, tskNO_AFFINITY, pxCreatedTask ); |
| } |
| |
| BaseType_t xTaskCreateAffinitySet( TaskFunction_t pxTaskCode, |
| const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ |
| const configSTACK_DEPTH_TYPE usStackDepth, |
| void * const pvParameters, |
| UBaseType_t uxPriority, |
| UBaseType_t uxCoreAffinityMask, |
| TaskHandle_t * const pxCreatedTask ) |
| #endif /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) */ |
| { |
| TCB_t * pxNewTCB; |
| BaseType_t xReturn; |
| |
| traceENTER_xTaskCreate( pxTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask ); |
| |
| /* If the stack grows down then allocate the stack then the TCB so the stack |
| * does not grow into the TCB. Likewise if the stack grows up then allocate |
| * the TCB then the stack. */ |
| #if ( portSTACK_GROWTH > 0 ) |
| { |
| /* Allocate space for the TCB. Where the memory comes from depends on |
| * the implementation of the port malloc function and whether or not static |
| * allocation is being used. */ |
| pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); |
| |
| if( pxNewTCB != NULL ) |
| { |
| ( void ) memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) ); |
| |
| /* Allocate space for the stack used by the task being created. |
| * The base of the stack memory stored in the TCB so the task can |
| * be deleted later if required. */ |
| pxNewTCB->pxStack = ( StackType_t * ) pvPortMallocStack( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */ |
| |
| if( pxNewTCB->pxStack == NULL ) |
| { |
| /* Could not allocate the stack. Delete the allocated TCB. */ |
| vPortFree( pxNewTCB ); |
| pxNewTCB = NULL; |
| } |
| } |
| } |
| #else /* portSTACK_GROWTH */ |
| { |
| StackType_t * pxStack; |
| |
| /* Allocate space for the stack used by the task being created. */ |
| pxStack = pvPortMallocStack( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack and this allocation is the stack. */ |
| |
| if( pxStack != NULL ) |
| { |
| /* Allocate space for the TCB. */ |
| pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); /*lint !e9087 !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack, and the first member of TCB_t is always a pointer to the task's stack. */ |
| |
| if( pxNewTCB != NULL ) |
| { |
| ( void ) memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) ); |
| |
| /* Store the stack location in the TCB. */ |
| pxNewTCB->pxStack = pxStack; |
| } |
| else |
| { |
| /* The stack cannot be used as the TCB was not created. Free |
| * it again. */ |
| vPortFreeStack( pxStack ); |
| } |
| } |
| else |
| { |
| pxNewTCB = NULL; |
| } |
| } |
| #endif /* portSTACK_GROWTH */ |
| |
| if( pxNewTCB != NULL ) |
| { |
| #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e9029 !e731 Macro has been consolidated for readability reasons. */ |
| { |
| /* Tasks can be created statically or dynamically, so note this |
| * task was created dynamically in case it is later deleted. */ |
| pxNewTCB->ucStaticallyAllocated = tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB; |
| } |
| #endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */ |
| |
| prvInitialiseNewTask( pxTaskCode, pcName, ( uint32_t ) usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL ); |
| |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) |
| { |
| /* Set the task's affinity before scheduling it. */ |
| pxNewTCB->uxCoreAffinityMask = uxCoreAffinityMask; |
| } |
| #endif |
| |
| prvAddNewTaskToReadyList( pxNewTCB ); |
| xReturn = pdPASS; |
| } |
| else |
| { |
| xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY; |
| } |
| |
| traceRETURN_xTaskCreate( xReturn ); |
| |
| return xReturn; |
| } |
| |
| #endif /* configSUPPORT_DYNAMIC_ALLOCATION */ |
| /*-----------------------------------------------------------*/ |
| |
| static void prvInitialiseNewTask( TaskFunction_t pxTaskCode, |
| const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ |
| const uint32_t ulStackDepth, |
| void * const pvParameters, |
| UBaseType_t uxPriority, |
| TaskHandle_t * const pxCreatedTask, |
| TCB_t * pxNewTCB, |
| const MemoryRegion_t * const xRegions ) |
| { |
| StackType_t * pxTopOfStack; |
| UBaseType_t x; |
| |
| #if ( portUSING_MPU_WRAPPERS == 1 ) |
| /* Should the task be created in privileged mode? */ |
| BaseType_t xRunPrivileged; |
| |
| if( ( uxPriority & portPRIVILEGE_BIT ) != 0U ) |
| { |
| xRunPrivileged = pdTRUE; |
| } |
| else |
| { |
| xRunPrivileged = pdFALSE; |
| } |
| uxPriority &= ~portPRIVILEGE_BIT; |
| #endif /* portUSING_MPU_WRAPPERS == 1 */ |
| |
| /* Avoid dependency on memset() if it is not required. */ |
| #if ( tskSET_NEW_STACKS_TO_KNOWN_VALUE == 1 ) |
| { |
| /* Fill the stack with a known value to assist debugging. */ |
| ( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) ulStackDepth * sizeof( StackType_t ) ); |
| } |
| #endif /* tskSET_NEW_STACKS_TO_KNOWN_VALUE */ |
| |
| /* Calculate the top of stack address. This depends on whether the stack |
| * grows from high memory to low (as per the 80x86) or vice versa. |
| * portSTACK_GROWTH is used to make the result positive or negative as required |
| * by the port. */ |
| #if ( portSTACK_GROWTH < 0 ) |
| { |
| pxTopOfStack = &( pxNewTCB->pxStack[ ulStackDepth - ( uint32_t ) 1 ] ); |
| pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) ); /*lint !e923 !e9033 !e9078 MISRA exception. Avoiding casts between pointers and integers is not practical. Size differences accounted for using portPOINTER_SIZE_TYPE type. Checked by assert(). */ |
| |
| /* Check the alignment of the calculated top of stack is correct. */ |
| configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) ); |
| |
| #if ( configRECORD_STACK_HIGH_ADDRESS == 1 ) |
| { |
| /* Also record the stack's high address, which may assist |
| * debugging. */ |
| pxNewTCB->pxEndOfStack = pxTopOfStack; |
| } |
| #endif /* configRECORD_STACK_HIGH_ADDRESS */ |
| } |
| #else /* portSTACK_GROWTH */ |
| { |
| pxTopOfStack = pxNewTCB->pxStack; |
| pxTopOfStack = ( StackType_t * ) ( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) + portBYTE_ALIGNMENT_MASK ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) ); /*lint !e923 !e9033 !e9078 MISRA exception. Avoiding casts between pointers and integers is not practical. Size differences accounted for using portPOINTER_SIZE_TYPE type. Checked by assert(). */ |
| |
| /* Check the alignment of the calculated top of stack is correct. */ |
| configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) ); |
| |
| /* The other extreme of the stack space is required if stack checking is |
| * performed. */ |
| pxNewTCB->pxEndOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 ); |
| } |
| #endif /* portSTACK_GROWTH */ |
| |
| /* Store the task name in the TCB. */ |
| if( pcName != NULL ) |
| { |
| for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ ) |
| { |
| pxNewTCB->pcTaskName[ x ] = pcName[ x ]; |
| |
| /* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter than |
| * configMAX_TASK_NAME_LEN characters just in case the memory after the |
| * string is not accessible (extremely unlikely). */ |
| if( pcName[ x ] == ( char ) 0x00 ) |
| { |
| break; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| |
| /* Ensure the name string is terminated in the case that the string length |
| * was greater or equal to configMAX_TASK_NAME_LEN. */ |
| pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0'; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| /* This is used as an array index so must ensure it's not too large. */ |
| configASSERT( uxPriority < configMAX_PRIORITIES ); |
| |
| if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES ) |
| { |
| uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| pxNewTCB->uxPriority = uxPriority; |
| #if ( configUSE_MUTEXES == 1 ) |
| { |
| pxNewTCB->uxBasePriority = uxPriority; |
| } |
| #endif /* configUSE_MUTEXES */ |
| |
| vListInitialiseItem( &( pxNewTCB->xStateListItem ) ); |
| vListInitialiseItem( &( pxNewTCB->xEventListItem ) ); |
| |
| /* Set the pxNewTCB as a link back from the ListItem_t. This is so we can get |
| * back to the containing TCB from a generic item in a list. */ |
| listSET_LIST_ITEM_OWNER( &( pxNewTCB->xStateListItem ), pxNewTCB ); |
| |
| /* Event lists are always in priority order. */ |
| listSET_LIST_ITEM_VALUE( &( pxNewTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */ |
| listSET_LIST_ITEM_OWNER( &( pxNewTCB->xEventListItem ), pxNewTCB ); |
| |
| #if ( portUSING_MPU_WRAPPERS == 1 ) |
| { |
| vPortStoreTaskMPUSettings( &( pxNewTCB->xMPUSettings ), xRegions, pxNewTCB->pxStack, ulStackDepth ); |
| } |
| #else |
| { |
| /* Avoid compiler warning about unreferenced parameter. */ |
| ( void ) xRegions; |
| } |
| #endif |
| |
| #if ( configUSE_C_RUNTIME_TLS_SUPPORT == 1 ) |
| { |
| /* Allocate and initialize memory for the task's TLS Block. */ |
| configINIT_TLS_BLOCK( pxNewTCB->xTLSBlock, pxTopOfStack ); |
| } |
| #endif |
| |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) |
| { |
| pxNewTCB->uxCoreAffinityMask = tskNO_AFFINITY; |
| } |
| #endif |
| |
| #if ( configUSE_TASK_PREEMPTION_DISABLE == 1 ) |
| { |
| pxNewTCB->xPreemptionDisable = 0; |
| } |
| #endif |
| |
| /* Initialize the TCB stack to look as if the task was already running, |
| * but had been interrupted by the scheduler. The return address is set |
| * to the start of the task function. Once the stack has been initialised |
| * the top of stack variable is updated. */ |
| #if ( portUSING_MPU_WRAPPERS == 1 ) |
| { |
| /* If the port has capability to detect stack overflow, |
| * pass the stack end address to the stack initialization |
| * function as well. */ |
| #if ( portHAS_STACK_OVERFLOW_CHECKING == 1 ) |
| { |
| #if ( portSTACK_GROWTH < 0 ) |
| { |
| pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxStack, pxTaskCode, pvParameters, xRunPrivileged, &( pxNewTCB->xMPUSettings ) ); |
| } |
| #else /* portSTACK_GROWTH */ |
| { |
| pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxEndOfStack, pxTaskCode, pvParameters, xRunPrivileged, &( pxNewTCB->xMPUSettings ) ); |
| } |
| #endif /* portSTACK_GROWTH */ |
| } |
| #else /* portHAS_STACK_OVERFLOW_CHECKING */ |
| { |
| pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters, xRunPrivileged, &( pxNewTCB->xMPUSettings ) ); |
| } |
| #endif /* portHAS_STACK_OVERFLOW_CHECKING */ |
| } |
| #else /* portUSING_MPU_WRAPPERS */ |
| { |
| /* If the port has capability to detect stack overflow, |
| * pass the stack end address to the stack initialization |
| * function as well. */ |
| #if ( portHAS_STACK_OVERFLOW_CHECKING == 1 ) |
| { |
| #if ( portSTACK_GROWTH < 0 ) |
| { |
| pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxStack, pxTaskCode, pvParameters ); |
| } |
| #else /* portSTACK_GROWTH */ |
| { |
| pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxEndOfStack, pxTaskCode, pvParameters ); |
| } |
| #endif /* portSTACK_GROWTH */ |
| } |
| #else /* portHAS_STACK_OVERFLOW_CHECKING */ |
| { |
| pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters ); |
| } |
| #endif /* portHAS_STACK_OVERFLOW_CHECKING */ |
| } |
| #endif /* portUSING_MPU_WRAPPERS */ |
| |
| /* Initialize task state and task attributes. */ |
| #if ( configNUMBER_OF_CORES > 1 ) |
| { |
| pxNewTCB->xTaskRunState = taskTASK_NOT_RUNNING; |
| |
| /* Is this an idle task? */ |
| if( ( ( TaskFunction_t ) pxTaskCode == ( TaskFunction_t ) prvIdleTask ) || ( ( TaskFunction_t ) pxTaskCode == ( TaskFunction_t ) prvMinimalIdleTask ) ) |
| { |
| pxNewTCB->uxTaskAttributes |= taskATTRIBUTE_IS_IDLE; |
| } |
| } |
| #endif /* #if ( configNUMBER_OF_CORES > 1 ) */ |
| |
| if( pxCreatedTask != NULL ) |
| { |
| /* Pass the handle out in an anonymous way. The handle can be used to |
| * change the created task's priority, delete the created task, etc.*/ |
| *pxCreatedTask = ( TaskHandle_t ) pxNewTCB; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| /*-----------------------------------------------------------*/ |
| |
| #if ( configNUMBER_OF_CORES == 1 ) |
| |
| static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB ) |
| { |
| /* Ensure interrupts don't access the task lists while the lists are being |
| * updated. */ |
| taskENTER_CRITICAL(); |
| { |
| uxCurrentNumberOfTasks++; |
| |
| if( pxCurrentTCB == NULL ) |
| { |
| /* There are no other tasks, or all the other tasks are in |
| * the suspended state - make this the current task. */ |
| pxCurrentTCB = pxNewTCB; |
| |
| if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 ) |
| { |
| /* This is the first task to be created so do the preliminary |
| * initialisation required. We will not recover if this call |
| * fails, but we will report the failure. */ |
| prvInitialiseTaskLists(); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| else |
| { |
| /* If the scheduler is not already running, make this task the |
| * current task if it is the highest priority task to be created |
| * so far. */ |
| if( xSchedulerRunning == pdFALSE ) |
| { |
| if( pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority ) |
| { |
| pxCurrentTCB = pxNewTCB; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| |
| uxTaskNumber++; |
| |
| #if ( configUSE_TRACE_FACILITY == 1 ) |
| { |
| /* Add a counter into the TCB for tracing only. */ |
| pxNewTCB->uxTCBNumber = uxTaskNumber; |
| } |
| #endif /* configUSE_TRACE_FACILITY */ |
| traceTASK_CREATE( pxNewTCB ); |
| |
| prvAddTaskToReadyList( pxNewTCB ); |
| |
| portSETUP_TCB( pxNewTCB ); |
| } |
| taskEXIT_CRITICAL(); |
| |
| if( xSchedulerRunning != pdFALSE ) |
| { |
| /* If the created task is of a higher priority than the current task |
| * then it should run now. */ |
| taskYIELD_ANY_CORE_IF_USING_PREEMPTION( pxNewTCB ); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| |
| #else /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| |
| static void prvAddNewTaskToReadyList( TCB_t * pxNewTCB ) |
| { |
| /* Ensure interrupts don't access the task lists while the lists are being |
| * updated. */ |
| taskENTER_CRITICAL(); |
| { |
| uxCurrentNumberOfTasks++; |
| |
| if( xSchedulerRunning == pdFALSE ) |
| { |
| if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 ) |
| { |
| /* This is the first task to be created so do the preliminary |
| * initialisation required. We will not recover if this call |
| * fails, but we will report the failure. */ |
| prvInitialiseTaskLists(); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| if( ( pxNewTCB->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) != 0U ) |
| { |
| BaseType_t xCoreID; |
| |
| /* Check if a core is free. */ |
| for( xCoreID = ( BaseType_t ) 0; xCoreID < ( BaseType_t ) configNUMBER_OF_CORES; xCoreID++ ) |
| { |
| if( pxCurrentTCBs[ xCoreID ] == NULL ) |
| { |
| pxNewTCB->xTaskRunState = xCoreID; |
| pxCurrentTCBs[ xCoreID ] = pxNewTCB; |
| break; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| |
| uxTaskNumber++; |
| |
| #if ( configUSE_TRACE_FACILITY == 1 ) |
| { |
| /* Add a counter into the TCB for tracing only. */ |
| pxNewTCB->uxTCBNumber = uxTaskNumber; |
| } |
| #endif /* configUSE_TRACE_FACILITY */ |
| traceTASK_CREATE( pxNewTCB ); |
| |
| prvAddTaskToReadyList( pxNewTCB ); |
| |
| portSETUP_TCB( pxNewTCB ); |
| |
| if( xSchedulerRunning != pdFALSE ) |
| { |
| /* If the created task is of a higher priority than another |
| * currently running task and preemption is on then it should |
| * run now. */ |
| taskYIELD_ANY_CORE_IF_USING_PREEMPTION( pxNewTCB ); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| taskEXIT_CRITICAL(); |
| } |
| |
| #endif /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) ) |
| |
| static size_t prvSnprintfReturnValueToCharsWritten( int iSnprintfReturnValue, |
| size_t n ) |
| { |
| size_t uxCharsWritten; |
| |
| if( iSnprintfReturnValue < 0 ) |
| { |
| /* Encoding error - Return 0 to indicate that nothing |
| * was written to the buffer. */ |
| uxCharsWritten = 0; |
| } |
| else if( iSnprintfReturnValue >= ( int ) n ) |
| { |
| /* This is the case when the supplied buffer is not |
| * large to hold the generated string. Return the |
| * number of characters actually written without |
| * counting the terminating NULL character. */ |
| uxCharsWritten = n - 1; |
| } |
| else |
| { |
| /* Complete string was written to the buffer. */ |
| uxCharsWritten = ( size_t ) iSnprintfReturnValue; |
| } |
| |
| return uxCharsWritten; |
| } |
| |
| #endif /* #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) ) */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( INCLUDE_vTaskDelete == 1 ) |
| |
| void vTaskDelete( TaskHandle_t xTaskToDelete ) |
| { |
| TCB_t * pxTCB; |
| |
| traceENTER_vTaskDelete( xTaskToDelete ); |
| |
| taskENTER_CRITICAL(); |
| { |
| /* If null is passed in here then it is the calling task that is |
| * being deleted. */ |
| pxTCB = prvGetTCBFromHandle( xTaskToDelete ); |
| |
| /* Remove task from the ready/delayed list. */ |
| if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) |
| { |
| taskRESET_READY_PRIORITY( pxTCB->uxPriority ); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| /* Is the task waiting on an event also? */ |
| if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL ) |
| { |
| ( void ) uxListRemove( &( pxTCB->xEventListItem ) ); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| /* Increment the uxTaskNumber also so kernel aware debuggers can |
| * detect that the task lists need re-generating. This is done before |
| * portPRE_TASK_DELETE_HOOK() as in the Windows port that macro will |
| * not return. */ |
| uxTaskNumber++; |
| |
| /* If the task is running (or yielding), we must add it to the |
| * termination list so that an idle task can delete it when it is |
| * no longer running. */ |
| if( taskTASK_IS_RUNNING_OR_SCHEDULED_TO_YIELD( pxTCB ) != pdFALSE ) |
| { |
| /* A running task or a task which is scheduled to yield is being |
| * deleted. This cannot complete when the task is still running |
| * on a core, as a context switch to another task is required. |
| * Place the task in the termination list. The idle task will check |
| * the termination list and free up any memory allocated by the |
| * scheduler for the TCB and stack of the deleted task. */ |
| vListInsertEnd( &xTasksWaitingTermination, &( pxTCB->xStateListItem ) ); |
| |
| /* Increment the ucTasksDeleted variable so the idle task knows |
| * there is a task that has been deleted and that it should therefore |
| * check the xTasksWaitingTermination list. */ |
| ++uxDeletedTasksWaitingCleanUp; |
| |
| /* Call the delete hook before portPRE_TASK_DELETE_HOOK() as |
| * portPRE_TASK_DELETE_HOOK() does not return in the Win32 port. */ |
| traceTASK_DELETE( pxTCB ); |
| |
| /* The pre-delete hook is primarily for the Windows simulator, |
| * in which Windows specific clean up operations are performed, |
| * after which it is not possible to yield away from this task - |
| * hence xYieldPending is used to latch that a context switch is |
| * required. */ |
| #if ( configNUMBER_OF_CORES == 1 ) |
| portPRE_TASK_DELETE_HOOK( pxTCB, &( xYieldPendings[ 0 ] ) ); |
| #else |
| portPRE_TASK_DELETE_HOOK( pxTCB, &( xYieldPendings[ pxTCB->xTaskRunState ] ) ); |
| #endif |
| } |
| else |
| { |
| --uxCurrentNumberOfTasks; |
| traceTASK_DELETE( pxTCB ); |
| |
| /* Reset the next expected unblock time in case it referred to |
| * the task that has just been deleted. */ |
| prvResetNextTaskUnblockTime(); |
| } |
| } |
| |
| #if ( configNUMBER_OF_CORES == 1 ) |
| { |
| taskEXIT_CRITICAL(); |
| |
| /* If the task is not deleting itself, call prvDeleteTCB from outside of |
| * critical section. If a task deletes itself, prvDeleteTCB is called |
| * from prvCheckTasksWaitingTermination which is called from Idle task. */ |
| if( pxTCB != pxCurrentTCB ) |
| { |
| prvDeleteTCB( pxTCB ); |
| } |
| |
| /* Force a reschedule if it is the currently running task that has just |
| * been deleted. */ |
| if( xSchedulerRunning != pdFALSE ) |
| { |
| if( pxTCB == pxCurrentTCB ) |
| { |
| configASSERT( uxSchedulerSuspended == 0 ); |
| portYIELD_WITHIN_API(); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| } |
| #else /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| { |
| /* If a running task is not deleting itself, call prvDeleteTCB. If a running |
| * task deletes itself, prvDeleteTCB is called from prvCheckTasksWaitingTermination |
| * which is called from Idle task. */ |
| if( pxTCB->xTaskRunState == taskTASK_NOT_RUNNING ) |
| { |
| prvDeleteTCB( pxTCB ); |
| } |
| |
| /* Force a reschedule if the task that has just been deleted was running. */ |
| if( ( xSchedulerRunning != pdFALSE ) && ( taskTASK_IS_RUNNING( pxTCB ) == pdTRUE ) ) |
| { |
| if( pxTCB->xTaskRunState == ( BaseType_t ) portGET_CORE_ID() ) |
| { |
| configASSERT( uxSchedulerSuspended == 0 ); |
| vTaskYieldWithinAPI(); |
| } |
| else |
| { |
| prvYieldCore( pxTCB->xTaskRunState ); |
| } |
| } |
| |
| taskEXIT_CRITICAL(); |
| } |
| #endif /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| |
| traceRETURN_vTaskDelete(); |
| } |
| |
| #endif /* INCLUDE_vTaskDelete */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( INCLUDE_xTaskDelayUntil == 1 ) |
| |
| BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime, |
| const TickType_t xTimeIncrement ) |
| { |
| TickType_t xTimeToWake; |
| BaseType_t xAlreadyYielded, xShouldDelay = pdFALSE; |
| |
| traceENTER_xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement ); |
| |
| configASSERT( pxPreviousWakeTime ); |
| configASSERT( ( xTimeIncrement > 0U ) ); |
| |
| vTaskSuspendAll(); |
| { |
| /* Minor optimisation. The tick count cannot change in this |
| * block. */ |
| const TickType_t xConstTickCount = xTickCount; |
| |
| configASSERT( uxSchedulerSuspended == 1U ); |
| |
| /* Generate the tick time at which the task wants to wake. */ |
| xTimeToWake = *pxPreviousWakeTime + xTimeIncrement; |
| |
| if( xConstTickCount < *pxPreviousWakeTime ) |
| { |
| /* The tick count has overflowed since this function was |
| * lasted called. In this case the only time we should ever |
| * actually delay is if the wake time has also overflowed, |
| * and the wake time is greater than the tick time. When this |
| * is the case it is as if neither time had overflowed. */ |
| if( ( xTimeToWake < *pxPreviousWakeTime ) && ( xTimeToWake > xConstTickCount ) ) |
| { |
| xShouldDelay = pdTRUE; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| else |
| { |
| /* The tick time has not overflowed. In this case we will |
| * delay if either the wake time has overflowed, and/or the |
| * tick time is less than the wake time. */ |
| if( ( xTimeToWake < *pxPreviousWakeTime ) || ( xTimeToWake > xConstTickCount ) ) |
| { |
| xShouldDelay = pdTRUE; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| |
| /* Update the wake time ready for the next call. */ |
| *pxPreviousWakeTime = xTimeToWake; |
| |
| if( xShouldDelay != pdFALSE ) |
| { |
| traceTASK_DELAY_UNTIL( xTimeToWake ); |
| |
| /* prvAddCurrentTaskToDelayedList() needs the block time, not |
| * the time to wake, so subtract the current tick count. */ |
| prvAddCurrentTaskToDelayedList( xTimeToWake - xConstTickCount, pdFALSE ); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| xAlreadyYielded = xTaskResumeAll(); |
| |
| /* Force a reschedule if xTaskResumeAll has not already done so, we may |
| * have put ourselves to sleep. */ |
| if( xAlreadyYielded == pdFALSE ) |
| { |
| #if ( configNUMBER_OF_CORES == 1 ) |
| portYIELD_WITHIN_API(); |
| #else |
| vTaskYieldWithinAPI(); |
| #endif |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| traceRETURN_xTaskDelayUntil( xShouldDelay ); |
| |
| return xShouldDelay; |
| } |
| |
| #endif /* INCLUDE_xTaskDelayUntil */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( INCLUDE_vTaskDelay == 1 ) |
| |
| void vTaskDelay( const TickType_t xTicksToDelay ) |
| { |
| BaseType_t xAlreadyYielded = pdFALSE; |
| |
| traceENTER_vTaskDelay( xTicksToDelay ); |
| |
| /* A delay time of zero just forces a reschedule. */ |
| if( xTicksToDelay > ( TickType_t ) 0U ) |
| { |
| vTaskSuspendAll(); |
| { |
| configASSERT( uxSchedulerSuspended == 1U ); |
| |
| traceTASK_DELAY(); |
| |
| /* A task that is removed from the event list while the |
| * scheduler is suspended will not get placed in the ready |
| * list or removed from the blocked list until the scheduler |
| * is resumed. |
| * |
| * This task cannot be in an event list as it is the currently |
| * executing task. */ |
| prvAddCurrentTaskToDelayedList( xTicksToDelay, pdFALSE ); |
| } |
| xAlreadyYielded = xTaskResumeAll(); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| /* Force a reschedule if xTaskResumeAll has not already done so, we may |
| * have put ourselves to sleep. */ |
| if( xAlreadyYielded == pdFALSE ) |
| { |
| #if ( configNUMBER_OF_CORES == 1 ) |
| portYIELD_WITHIN_API(); |
| #else |
| vTaskYieldWithinAPI(); |
| #endif |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| traceRETURN_vTaskDelay(); |
| } |
| |
| #endif /* INCLUDE_vTaskDelay */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( ( INCLUDE_eTaskGetState == 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_xTaskAbortDelay == 1 ) ) |
| |
| eTaskState eTaskGetState( TaskHandle_t xTask ) |
| { |
| eTaskState eReturn; |
| List_t const * pxStateList; |
| List_t const * pxEventList; |
| List_t const * pxDelayedList; |
| List_t const * pxOverflowedDelayedList; |
| const TCB_t * const pxTCB = xTask; |
| |
| traceENTER_eTaskGetState( xTask ); |
| |
| configASSERT( pxTCB ); |
| |
| #if ( configNUMBER_OF_CORES == 1 ) |
| if( pxTCB == pxCurrentTCB ) |
| { |
| /* The task calling this function is querying its own state. */ |
| eReturn = eRunning; |
| } |
| else |
| #endif |
| { |
| taskENTER_CRITICAL(); |
| { |
| pxStateList = listLIST_ITEM_CONTAINER( &( pxTCB->xStateListItem ) ); |
| pxEventList = listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ); |
| pxDelayedList = pxDelayedTaskList; |
| pxOverflowedDelayedList = pxOverflowDelayedTaskList; |
| } |
| taskEXIT_CRITICAL(); |
| |
| if( pxEventList == &xPendingReadyList ) |
| { |
| /* The task has been placed on the pending ready list, so its |
| * state is eReady regardless of what list the task's state list |
| * item is currently placed on. */ |
| eReturn = eReady; |
| } |
| else if( ( pxStateList == pxDelayedList ) || ( pxStateList == pxOverflowedDelayedList ) ) |
| { |
| /* The task being queried is referenced from one of the Blocked |
| * lists. */ |
| eReturn = eBlocked; |
| } |
| |
| #if ( INCLUDE_vTaskSuspend == 1 ) |
| else if( pxStateList == &xSuspendedTaskList ) |
| { |
| /* The task being queried is referenced from the suspended |
| * list. Is it genuinely suspended or is it blocked |
| * indefinitely? */ |
| if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL ) |
| { |
| #if ( configUSE_TASK_NOTIFICATIONS == 1 ) |
| { |
| BaseType_t x; |
| |
| /* The task does not appear on the event list item of |
| * and of the RTOS objects, but could still be in the |
| * blocked state if it is waiting on its notification |
| * rather than waiting on an object. If not, is |
| * suspended. */ |
| eReturn = eSuspended; |
| |
| for( x = ( BaseType_t ) 0; x < ( BaseType_t ) configTASK_NOTIFICATION_ARRAY_ENTRIES; x++ ) |
| { |
| if( pxTCB->ucNotifyState[ x ] == taskWAITING_NOTIFICATION ) |
| { |
| eReturn = eBlocked; |
| break; |
| } |
| } |
| } |
| #else /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ |
| { |
| eReturn = eSuspended; |
| } |
| #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ |
| } |
| else |
| { |
| eReturn = eBlocked; |
| } |
| } |
| #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */ |
| |
| #if ( INCLUDE_vTaskDelete == 1 ) |
| else if( ( pxStateList == &xTasksWaitingTermination ) || ( pxStateList == NULL ) ) |
| { |
| /* The task being queried is referenced from the deleted |
| * tasks list, or it is not referenced from any lists at |
| * all. */ |
| eReturn = eDeleted; |
| } |
| #endif |
| |
| else /*lint !e525 Negative indentation is intended to make use of pre-processor clearer. */ |
| { |
| #if ( configNUMBER_OF_CORES == 1 ) |
| { |
| /* If the task is not in any other state, it must be in the |
| * Ready (including pending ready) state. */ |
| eReturn = eReady; |
| } |
| #else /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| { |
| if( taskTASK_IS_RUNNING( pxTCB ) == pdTRUE ) |
| { |
| /* Is it actively running on a core? */ |
| eReturn = eRunning; |
| } |
| else |
| { |
| /* If the task is not in any other state, it must be in the |
| * Ready (including pending ready) state. */ |
| eReturn = eReady; |
| } |
| } |
| #endif /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| } |
| } |
| |
| traceRETURN_eTaskGetState( eReturn ); |
| |
| return eReturn; |
| } /*lint !e818 xTask cannot be a pointer to const because it is a typedef. */ |
| |
| #endif /* INCLUDE_eTaskGetState */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( INCLUDE_uxTaskPriorityGet == 1 ) |
| |
| UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask ) |
| { |
| TCB_t const * pxTCB; |
| UBaseType_t uxReturn; |
| |
| traceENTER_uxTaskPriorityGet( xTask ); |
| |
| taskENTER_CRITICAL(); |
| { |
| /* If null is passed in here then it is the priority of the task |
| * that called uxTaskPriorityGet() that is being queried. */ |
| pxTCB = prvGetTCBFromHandle( xTask ); |
| uxReturn = pxTCB->uxPriority; |
| } |
| taskEXIT_CRITICAL(); |
| |
| traceRETURN_uxTaskPriorityGet( uxReturn ); |
| |
| return uxReturn; |
| } |
| |
| #endif /* INCLUDE_uxTaskPriorityGet */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( INCLUDE_uxTaskPriorityGet == 1 ) |
| |
| UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask ) |
| { |
| TCB_t const * pxTCB; |
| UBaseType_t uxReturn; |
| UBaseType_t uxSavedInterruptStatus; |
| |
| traceENTER_uxTaskPriorityGetFromISR( xTask ); |
| |
| /* RTOS ports that support interrupt nesting have the concept of a |
| * maximum system call (or maximum API call) interrupt priority. |
| * Interrupts that are above the maximum system call priority are keep |
| * permanently enabled, even when the RTOS kernel is in a critical section, |
| * but cannot make any calls to FreeRTOS API functions. If configASSERT() |
| * is defined in FreeRTOSConfig.h then |
| * portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion |
| * failure if a FreeRTOS API function is called from an interrupt that has |
| * been assigned a priority above the configured maximum system call |
| * priority. Only FreeRTOS functions that end in FromISR can be called |
| * from interrupts that have been assigned a priority at or (logically) |
| * below the maximum system call interrupt priority. FreeRTOS maintains a |
| * separate interrupt safe API to ensure interrupt entry is as fast and as |
| * simple as possible. More information (albeit Cortex-M specific) is |
| * provided on the following link: |
| * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */ |
| portASSERT_IF_INTERRUPT_PRIORITY_INVALID(); |
| |
| uxSavedInterruptStatus = taskENTER_CRITICAL_FROM_ISR(); |
| { |
| /* If null is passed in here then it is the priority of the calling |
| * task that is being queried. */ |
| pxTCB = prvGetTCBFromHandle( xTask ); |
| uxReturn = pxTCB->uxPriority; |
| } |
| taskEXIT_CRITICAL_FROM_ISR( uxSavedInterruptStatus ); |
| |
| traceRETURN_uxTaskPriorityGetFromISR( uxReturn ); |
| |
| return uxReturn; |
| } |
| |
| #endif /* INCLUDE_uxTaskPriorityGet */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( INCLUDE_vTaskPrioritySet == 1 ) |
| |
| void vTaskPrioritySet( TaskHandle_t xTask, |
| UBaseType_t uxNewPriority ) |
| { |
| TCB_t * pxTCB; |
| UBaseType_t uxCurrentBasePriority, uxPriorityUsedOnEntry; |
| BaseType_t xYieldRequired = pdFALSE; |
| |
| traceENTER_vTaskPrioritySet( xTask, uxNewPriority ); |
| |
| #if ( configNUMBER_OF_CORES > 1 ) |
| BaseType_t xYieldForTask = pdFALSE; |
| #endif |
| |
| configASSERT( uxNewPriority < configMAX_PRIORITIES ); |
| |
| /* Ensure the new priority is valid. */ |
| if( uxNewPriority >= ( UBaseType_t ) configMAX_PRIORITIES ) |
| { |
| uxNewPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| taskENTER_CRITICAL(); |
| { |
| /* If null is passed in here then it is the priority of the calling |
| * task that is being changed. */ |
| pxTCB = prvGetTCBFromHandle( xTask ); |
| |
| traceTASK_PRIORITY_SET( pxTCB, uxNewPriority ); |
| |
| #if ( configUSE_MUTEXES == 1 ) |
| { |
| uxCurrentBasePriority = pxTCB->uxBasePriority; |
| } |
| #else |
| { |
| uxCurrentBasePriority = pxTCB->uxPriority; |
| } |
| #endif |
| |
| if( uxCurrentBasePriority != uxNewPriority ) |
| { |
| /* The priority change may have readied a task of higher |
| * priority than a running task. */ |
| if( uxNewPriority > uxCurrentBasePriority ) |
| { |
| #if ( configNUMBER_OF_CORES == 1 ) |
| { |
| if( pxTCB != pxCurrentTCB ) |
| { |
| /* The priority of a task other than the currently |
| * running task is being raised. Is the priority being |
| * raised above that of the running task? */ |
| if( uxNewPriority > pxCurrentTCB->uxPriority ) |
| { |
| xYieldRequired = pdTRUE; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| else |
| { |
| /* The priority of the running task is being raised, |
| * but the running task must already be the highest |
| * priority task able to run so no yield is required. */ |
| } |
| } |
| #else /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| { |
| /* The priority of a task is being raised so |
| * perform a yield for this task later. */ |
| xYieldForTask = pdTRUE; |
| } |
| #endif /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| } |
| else if( taskTASK_IS_RUNNING( pxTCB ) == pdTRUE ) |
| { |
| /* Setting the priority of a running task down means |
| * there may now be another task of higher priority that |
| * is ready to execute. */ |
| #if ( configUSE_TASK_PREEMPTION_DISABLE == 1 ) |
| if( pxTCB->xPreemptionDisable == pdFALSE ) |
| #endif |
| { |
| xYieldRequired = pdTRUE; |
| } |
| } |
| else |
| { |
| /* Setting the priority of any other task down does not |
| * require a yield as the running task must be above the |
| * new priority of the task being modified. */ |
| } |
| |
| /* Remember the ready list the task might be referenced from |
| * before its uxPriority member is changed so the |
| * taskRESET_READY_PRIORITY() macro can function correctly. */ |
| uxPriorityUsedOnEntry = pxTCB->uxPriority; |
| |
| #if ( configUSE_MUTEXES == 1 ) |
| { |
| /* Only change the priority being used if the task is not |
| * currently using an inherited priority or the new priority |
| * is bigger than the inherited priority. */ |
| if( ( pxTCB->uxBasePriority == pxTCB->uxPriority ) || ( uxNewPriority > pxTCB->uxPriority ) ) |
| { |
| pxTCB->uxPriority = uxNewPriority; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| /* The base priority gets set whatever. */ |
| pxTCB->uxBasePriority = uxNewPriority; |
| } |
| #else /* if ( configUSE_MUTEXES == 1 ) */ |
| { |
| pxTCB->uxPriority = uxNewPriority; |
| } |
| #endif /* if ( configUSE_MUTEXES == 1 ) */ |
| |
| /* Only reset the event list item value if the value is not |
| * being used for anything else. */ |
| if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == 0UL ) |
| { |
| listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxNewPriority ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */ |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| /* If the task is in the blocked or suspended list we need do |
| * nothing more than change its priority variable. However, if |
| * the task is in a ready list it needs to be removed and placed |
| * in the list appropriate to its new priority. */ |
| if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ uxPriorityUsedOnEntry ] ), &( pxTCB->xStateListItem ) ) != pdFALSE ) |
| { |
| /* The task is currently in its ready list - remove before |
| * adding it to its new ready list. As we are in a critical |
| * section we can do this even if the scheduler is suspended. */ |
| if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) |
| { |
| /* It is known that the task is in its ready list so |
| * there is no need to check again and the port level |
| * reset macro can be called directly. */ |
| portRESET_READY_PRIORITY( uxPriorityUsedOnEntry, uxTopReadyPriority ); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| prvAddTaskToReadyList( pxTCB ); |
| } |
| else |
| { |
| #if ( configNUMBER_OF_CORES == 1 ) |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| #else |
| { |
| /* It's possible that xYieldForTask was already set to pdTRUE because |
| * its priority is being raised. However, since it is not in a ready list |
| * we don't actually need to yield for it. */ |
| xYieldForTask = pdFALSE; |
| } |
| #endif |
| } |
| |
| if( xYieldRequired != pdFALSE ) |
| { |
| /* The running task priority is set down. Request the task to yield. */ |
| taskYIELD_TASK_CORE_IF_USING_PREEMPTION( pxTCB ); |
| } |
| else |
| { |
| #if ( configNUMBER_OF_CORES > 1 ) |
| if( xYieldForTask != pdFALSE ) |
| { |
| /* The priority of the task is being raised. If a running |
| * task has priority lower than this task, it should yield |
| * for this task. */ |
| taskYIELD_ANY_CORE_IF_USING_PREEMPTION( pxTCB ); |
| } |
| else |
| #endif /* if ( configNUMBER_OF_CORES > 1 ) */ |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| |
| /* Remove compiler warning about unused variables when the port |
| * optimised task selection is not being used. */ |
| ( void ) uxPriorityUsedOnEntry; |
| } |
| } |
| taskEXIT_CRITICAL(); |
| |
| traceRETURN_vTaskPrioritySet(); |
| } |
| |
| #endif /* INCLUDE_vTaskPrioritySet */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) |
| void vTaskCoreAffinitySet( const TaskHandle_t xTask, |
| UBaseType_t uxCoreAffinityMask ) |
| { |
| TCB_t * pxTCB; |
| BaseType_t xCoreID; |
| UBaseType_t uxPrevCoreAffinityMask; |
| |
| #if ( configUSE_PREEMPTION == 1 ) |
| UBaseType_t uxPrevNotAllowedCores; |
| #endif |
| |
| traceENTER_vTaskCoreAffinitySet( xTask, uxCoreAffinityMask ); |
| |
| taskENTER_CRITICAL(); |
| { |
| pxTCB = prvGetTCBFromHandle( xTask ); |
| |
| uxPrevCoreAffinityMask = pxTCB->uxCoreAffinityMask; |
| pxTCB->uxCoreAffinityMask = uxCoreAffinityMask; |
| |
| if( xSchedulerRunning != pdFALSE ) |
| { |
| if( taskTASK_IS_RUNNING( pxTCB ) == pdTRUE ) |
| { |
| xCoreID = ( BaseType_t ) pxTCB->xTaskRunState; |
| |
| /* If the task can no longer run on the core it was running, |
| * request the core to yield. */ |
| if( ( uxCoreAffinityMask & ( ( UBaseType_t ) 1U << ( UBaseType_t ) xCoreID ) ) == 0U ) |
| { |
| prvYieldCore( xCoreID ); |
| } |
| } |
| else |
| { |
| #if ( configUSE_PREEMPTION == 1 ) |
| { |
| /* Calculate the cores on which this task was not allowed to |
| * run previously. */ |
| uxPrevNotAllowedCores = ( ~uxPrevCoreAffinityMask ) & ( ( 1U << configNUMBER_OF_CORES ) - 1U ); |
| |
| /* Does the new core mask enables this task to run on any of the |
| * previously not allowed cores? If yes, check if this task can be |
| * scheduled on any of those cores. */ |
| if( ( uxPrevNotAllowedCores & uxCoreAffinityMask ) != 0U ) |
| { |
| prvYieldForTask( pxTCB ); |
| } |
| } |
| #else /* #if( configUSE_PREEMPTION == 1 ) */ |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| #endif /* #if( configUSE_PREEMPTION == 1 ) */ |
| } |
| } |
| } |
| taskEXIT_CRITICAL(); |
| |
| traceRETURN_vTaskCoreAffinitySet(); |
| } |
| #endif /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) |
| UBaseType_t vTaskCoreAffinityGet( ConstTaskHandle_t xTask ) |
| { |
| const TCB_t * pxTCB; |
| UBaseType_t uxCoreAffinityMask; |
| |
| traceENTER_vTaskCoreAffinityGet( xTask ); |
| |
| taskENTER_CRITICAL(); |
| { |
| pxTCB = prvGetTCBFromHandle( xTask ); |
| uxCoreAffinityMask = pxTCB->uxCoreAffinityMask; |
| } |
| taskEXIT_CRITICAL(); |
| |
| traceRETURN_vTaskCoreAffinityGet( uxCoreAffinityMask ); |
| |
| return uxCoreAffinityMask; |
| } |
| #endif /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) */ |
| |
| /*-----------------------------------------------------------*/ |
| |
| #if ( configUSE_TASK_PREEMPTION_DISABLE == 1 ) |
| |
| void vTaskPreemptionDisable( const TaskHandle_t xTask ) |
| { |
| TCB_t * pxTCB; |
| |
| traceENTER_vTaskPreemptionDisable( xTask ); |
| |
| taskENTER_CRITICAL(); |
| { |
| pxTCB = prvGetTCBFromHandle( xTask ); |
| |
| pxTCB->xPreemptionDisable = pdTRUE; |
| } |
| taskEXIT_CRITICAL(); |
| |
| traceRETURN_vTaskPreemptionDisable(); |
| } |
| |
| #endif /* #if ( configUSE_TASK_PREEMPTION_DISABLE == 1 ) */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( configUSE_TASK_PREEMPTION_DISABLE == 1 ) |
| |
| void vTaskPreemptionEnable( const TaskHandle_t xTask ) |
| { |
| TCB_t * pxTCB; |
| BaseType_t xCoreID; |
| |
| traceENTER_vTaskPreemptionEnable( xTask ); |
| |
| taskENTER_CRITICAL(); |
| { |
| pxTCB = prvGetTCBFromHandle( xTask ); |
| |
| pxTCB->xPreemptionDisable = pdFALSE; |
| |
| if( xSchedulerRunning != pdFALSE ) |
| { |
| if( taskTASK_IS_RUNNING( pxTCB ) == pdTRUE ) |
| { |
| xCoreID = ( BaseType_t ) pxTCB->xTaskRunState; |
| prvYieldCore( xCoreID ); |
| } |
| } |
| } |
| taskEXIT_CRITICAL(); |
| |
| traceRETURN_vTaskPreemptionEnable(); |
| } |
| |
| #endif /* #if ( configUSE_TASK_PREEMPTION_DISABLE == 1 ) */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( INCLUDE_vTaskSuspend == 1 ) |
| |
| void vTaskSuspend( TaskHandle_t xTaskToSuspend ) |
| { |
| TCB_t * pxTCB; |
| |
| #if ( configNUMBER_OF_CORES > 1 ) |
| BaseType_t xTaskRunningOnCore; |
| #endif |
| |
| traceENTER_vTaskSuspend( xTaskToSuspend ); |
| |
| taskENTER_CRITICAL(); |
| { |
| /* If null is passed in here then it is the running task that is |
| * being suspended. */ |
| pxTCB = prvGetTCBFromHandle( xTaskToSuspend ); |
| |
| traceTASK_SUSPEND( pxTCB ); |
| |
| #if ( configNUMBER_OF_CORES > 1 ) |
| xTaskRunningOnCore = pxTCB->xTaskRunState; |
| #endif |
| |
| /* Remove task from the ready/delayed list and place in the |
| * suspended list. */ |
| if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) |
| { |
| taskRESET_READY_PRIORITY( pxTCB->uxPriority ); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| /* Is the task waiting on an event also? */ |
| if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL ) |
| { |
| ( void ) uxListRemove( &( pxTCB->xEventListItem ) ); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xStateListItem ) ); |
| |
| #if ( configUSE_TASK_NOTIFICATIONS == 1 ) |
| { |
| BaseType_t x; |
| |
| for( x = ( BaseType_t ) 0; x < ( BaseType_t ) configTASK_NOTIFICATION_ARRAY_ENTRIES; x++ ) |
| { |
| if( pxTCB->ucNotifyState[ x ] == taskWAITING_NOTIFICATION ) |
| { |
| /* The task was blocked to wait for a notification, but is |
| * now suspended, so no notification was received. */ |
| pxTCB->ucNotifyState[ x ] = taskNOT_WAITING_NOTIFICATION; |
| } |
| } |
| } |
| #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */ |
| } |
| |
| #if ( configNUMBER_OF_CORES == 1 ) |
| { |
| taskEXIT_CRITICAL(); |
| |
| if( xSchedulerRunning != pdFALSE ) |
| { |
| /* Reset the next expected unblock time in case it referred to the |
| * task that is now in the Suspended state. */ |
| taskENTER_CRITICAL(); |
| { |
| prvResetNextTaskUnblockTime(); |
| } |
| taskEXIT_CRITICAL(); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| if( pxTCB == pxCurrentTCB ) |
| { |
| if( xSchedulerRunning != pdFALSE ) |
| { |
| /* The current task has just been suspended. */ |
| configASSERT( uxSchedulerSuspended == 0 ); |
| portYIELD_WITHIN_API(); |
| } |
| else |
| { |
| /* The scheduler is not running, but the task that was pointed |
| * to by pxCurrentTCB has just been suspended and pxCurrentTCB |
| * must be adjusted to point to a different task. */ |
| if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks ) /*lint !e931 Right has no side effect, just volatile. */ |
| { |
| /* No other tasks are ready, so set pxCurrentTCB back to |
| * NULL so when the next task is created pxCurrentTCB will |
| * be set to point to it no matter what its relative priority |
| * is. */ |
| pxCurrentTCB = NULL; |
| } |
| else |
| { |
| vTaskSwitchContext(); |
| } |
| } |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| #else /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| { |
| if( xSchedulerRunning != pdFALSE ) |
| { |
| /* Reset the next expected unblock time in case it referred to the |
| * task that is now in the Suspended state. */ |
| prvResetNextTaskUnblockTime(); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| if( taskTASK_IS_RUNNING( pxTCB ) == pdTRUE ) |
| { |
| if( xSchedulerRunning != pdFALSE ) |
| { |
| if( xTaskRunningOnCore == ( BaseType_t ) portGET_CORE_ID() ) |
| { |
| /* The current task has just been suspended. */ |
| configASSERT( uxSchedulerSuspended == 0 ); |
| vTaskYieldWithinAPI(); |
| } |
| else |
| { |
| prvYieldCore( xTaskRunningOnCore ); |
| } |
| } |
| else |
| { |
| /* This code path is not possible because only Idle tasks are |
| * assigned a core before the scheduler is started ( i.e. |
| * taskTASK_IS_RUNNING is only true for idle tasks before |
| * the scheduler is started ) and idle tasks cannot be |
| * suspended. */ |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| taskEXIT_CRITICAL(); |
| } |
| #endif /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| |
| traceRETURN_vTaskSuspend(); |
| } |
| |
| #endif /* INCLUDE_vTaskSuspend */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( INCLUDE_vTaskSuspend == 1 ) |
| |
| static BaseType_t prvTaskIsTaskSuspended( const TaskHandle_t xTask ) |
| { |
| BaseType_t xReturn = pdFALSE; |
| const TCB_t * const pxTCB = xTask; |
| |
| /* Accesses xPendingReadyList so must be called from a critical |
| * section. */ |
| |
| /* It does not make sense to check if the calling task is suspended. */ |
| configASSERT( xTask ); |
| |
| /* Is the task being resumed actually in the suspended list? */ |
| if( listIS_CONTAINED_WITHIN( &xSuspendedTaskList, &( pxTCB->xStateListItem ) ) != pdFALSE ) |
| { |
| /* Has the task already been resumed from within an ISR? */ |
| if( listIS_CONTAINED_WITHIN( &xPendingReadyList, &( pxTCB->xEventListItem ) ) == pdFALSE ) |
| { |
| /* Is it in the suspended list because it is in the Suspended |
| * state, or because is is blocked with no timeout? */ |
| if( listIS_CONTAINED_WITHIN( NULL, &( pxTCB->xEventListItem ) ) != pdFALSE ) /*lint !e961. The cast is only redundant when NULL is used. */ |
| { |
| xReturn = pdTRUE; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| return xReturn; |
| } /*lint !e818 xTask cannot be a pointer to const because it is a typedef. */ |
| |
| #endif /* INCLUDE_vTaskSuspend */ |
| /*-----------------------------------------------------------*/ |
| |
| #if ( INCLUDE_vTaskSuspend == 1 ) |
| |
| void vTaskResume( TaskHandle_t xTaskToResume ) |
| { |
| TCB_t * const pxTCB = xTaskToResume; |
| |
| traceENTER_vTaskResume( xTaskToResume ); |
| |
| /* It does not make sense to resume the calling task. */ |
| configASSERT( xTaskToResume ); |
| |
| #if ( configNUMBER_OF_CORES == 1 ) |
| |
| /* The parameter cannot be NULL as it is impossible to resume the |
| * currently executing task. */ |
| if( ( pxTCB != pxCurrentTCB ) && ( pxTCB != NULL ) ) |
| #else |
| |
| /* The parameter cannot be NULL as it is impossible to resume the |
| * currently executing task. It is also impossible to resume a task |
| * that is actively running on another core but it is not safe |
| * to check their run state here. Therefore, we get into a critical |
| * section and check if the task is actually suspended or not. */ |
| if( pxTCB != NULL ) |
| #endif |
| { |
| taskENTER_CRITICAL(); |
| { |
| if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE ) |
| { |
| traceTASK_RESUME( pxTCB ); |
| |
| /* The ready list can be accessed even if the scheduler is |
| * suspended because this is inside a critical section. */ |
| ( void ) uxListRemove( &( pxTCB->xStateListItem ) ); |
| prvAddTaskToReadyList( pxTCB ); |
| |
| /* This yield may not cause the task just resumed to run, |
| * but will leave the lists in the correct state for the |
| * next yield. */ |
| taskYIELD_ANY_CORE_IF_USING_PREEMPTION( pxTCB ); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| taskEXIT_CRITICAL(); |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| traceRETURN_vTaskResume(); |
| } |
| |
| #endif /* INCLUDE_vTaskSuspend */ |
| |
| /*-----------------------------------------------------------*/ |
| |
| #if ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) ) |
| |
| BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume ) |
| { |
| BaseType_t xYieldRequired = pdFALSE; |
| TCB_t * const pxTCB = xTaskToResume; |
| UBaseType_t uxSavedInterruptStatus; |
| |
| traceENTER_xTaskResumeFromISR( xTaskToResume ); |
| |
| configASSERT( xTaskToResume ); |
| |
| /* RTOS ports that support interrupt nesting have the concept of a |
| * maximum system call (or maximum API call) interrupt priority. |
| * Interrupts that are above the maximum system call priority are keep |
| * permanently enabled, even when the RTOS kernel is in a critical section, |
| * but cannot make any calls to FreeRTOS API functions. If configASSERT() |
| * is defined in FreeRTOSConfig.h then |
| * portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion |
| * failure if a FreeRTOS API function is called from an interrupt that has |
| * been assigned a priority above the configured maximum system call |
| * priority. Only FreeRTOS functions that end in FromISR can be called |
| * from interrupts that have been assigned a priority at or (logically) |
| * below the maximum system call interrupt priority. FreeRTOS maintains a |
| * separate interrupt safe API to ensure interrupt entry is as fast and as |
| * simple as possible. More information (albeit Cortex-M specific) is |
| * provided on the following link: |
| * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */ |
| portASSERT_IF_INTERRUPT_PRIORITY_INVALID(); |
| |
| uxSavedInterruptStatus = taskENTER_CRITICAL_FROM_ISR(); |
| { |
| if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE ) |
| { |
| traceTASK_RESUME_FROM_ISR( pxTCB ); |
| |
| /* Check the ready lists can be accessed. */ |
| if( uxSchedulerSuspended == ( UBaseType_t ) 0U ) |
| { |
| #if ( configNUMBER_OF_CORES == 1 ) |
| { |
| /* Ready lists can be accessed so move the task from the |
| * suspended list to the ready list directly. */ |
| if( pxTCB->uxPriority > pxCurrentTCB->uxPriority ) |
| { |
| xYieldRequired = pdTRUE; |
| |
| /* Mark that a yield is pending in case the user is not |
| * using the return value to initiate a context switch |
| * from the ISR using portYIELD_FROM_ISR. */ |
| xYieldPendings[ 0 ] = pdTRUE; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| #endif /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| |
| ( void ) uxListRemove( &( pxTCB->xStateListItem ) ); |
| prvAddTaskToReadyList( pxTCB ); |
| } |
| else |
| { |
| /* The delayed or ready lists cannot be accessed so the task |
| * is held in the pending ready list until the scheduler is |
| * unsuspended. */ |
| vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) ); |
| } |
| |
| #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_PREEMPTION == 1 ) ) |
| { |
| prvYieldForTask( pxTCB ); |
| |
| if( xYieldPendings[ portGET_CORE_ID() ] != pdFALSE ) |
| { |
| xYieldRequired = pdTRUE; |
| } |
| } |
| #endif /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_PREEMPTION == 1 ) ) */ |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
| taskEXIT_CRITICAL_FROM_ISR( uxSavedInterruptStatus ); |
| |
| traceRETURN_xTaskResumeFromISR( xYieldRequired ); |
| |
| return xYieldRequired; |
| } |
| |
| #endif /* ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) ) */ |
| /*-----------------------------------------------------------*/ |
| |
| static BaseType_t prvCreateIdleTasks( void ) |
| { |
| BaseType_t xReturn = pdPASS; |
| |
| #if ( configNUMBER_OF_CORES == 1 ) |
| { |
| /* Add the idle task at the lowest priority. */ |
| #if ( configSUPPORT_STATIC_ALLOCATION == 1 ) |
| { |
| StaticTask_t * pxIdleTaskTCBBuffer = NULL; |
| StackType_t * pxIdleTaskStackBuffer = NULL; |
| uint32_t ulIdleTaskStackSize; |
| |
| /* The Idle task is created using user provided RAM - obtain the |
| * address of the RAM then create the idle task. */ |
| vApplicationGetIdleTaskMemory( &pxIdleTaskTCBBuffer, &pxIdleTaskStackBuffer, &ulIdleTaskStackSize ); |
| xIdleTaskHandles[ 0 ] = xTaskCreateStatic( prvIdleTask, |
| configIDLE_TASK_NAME, |
| ulIdleTaskStackSize, |
| ( void * ) NULL, /*lint !e961. The cast is not redundant for all compilers. */ |
| portPRIVILEGE_BIT, /* In effect ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), but tskIDLE_PRIORITY is zero. */ |
| pxIdleTaskStackBuffer, |
| pxIdleTaskTCBBuffer ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */ |
| |
| if( xIdleTaskHandles[ 0 ] != NULL ) |
| { |
| xReturn = pdPASS; |
| } |
| else |
| { |
| xReturn = pdFAIL; |
| } |
| } |
| #else /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */ |
| { |
| /* The Idle task is being created using dynamically allocated RAM. */ |
| xReturn = xTaskCreate( prvIdleTask, |
| configIDLE_TASK_NAME, |
| configMINIMAL_STACK_SIZE, |
| ( void * ) NULL, |
| portPRIVILEGE_BIT, /* In effect ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), but tskIDLE_PRIORITY is zero. */ |
| &xIdleTaskHandles[ 0 ] ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */ |
| } |
| #endif /* configSUPPORT_STATIC_ALLOCATION */ |
| } |
| #else /* #if ( configNUMBER_OF_CORES == 1 ) */ |
| { |
| BaseType_t xCoreID; |
| char cIdleName[ configMAX_TASK_NAME_LEN ]; |
| |
| /* Add each idle task at the lowest priority. */ |
| for( xCoreID = ( BaseType_t ) 0; xCoreID < ( BaseType_t ) configNUMBER_OF_CORES; xCoreID++ ) |
| { |
| BaseType_t x; |
| |
| if( xReturn == pdFAIL ) |
| { |
| break; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| |
| for( x = ( BaseType_t ) 0; x < ( BaseType_t ) configMAX_TASK_NAME_LEN; x++ ) |
| { |
| cIdleName[ x ] = configIDLE_TASK_NAME[ x ]; |
| |
| /* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter than |
| * configMAX_TASK_NAME_LEN characters just in case the memory after the |
| * string is not accessible (extremely unlikely). */ |
| if( cIdleName[ x ] == ( char ) 0x00 ) |
| { |
| break; |
| } |
| else |
| { |
| mtCOVERAGE_TEST_MARKER(); |
| } |
| } |
|