Lines Matching +full:release +full:- +full:requirements
5 * SPDX-License-Identifier: MIT
82 if( pxCurrentTCB->uxPriority < ( pxTCB )->uxPriority ) \
95 …#define taskYIELD_TASK_CORE_IF_USING_PREEMPTION( pxTCB ) prvYieldCore( ( pxTCB )->xTaskRunState…
168 /*-----------------------------------------------------------*/
179 --uxTopPriority; \
193 /*-----------------------------------------------------------*/
210 /*-----------------------------------------------------------*/
222 /*-----------------------------------------------------------*/
237 /*-----------------------------------------------------------*/
255 /*-----------------------------------------------------------*/
264 …taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority ); …
265 …listINSERT_END( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xStateListItem ) );…
268 /*-----------------------------------------------------------*/
283 * the scheduler that the value should not be changed - in which case it is the
295 #define taskTASK_NOT_RUNNING ( ( BaseType_t ) ( -1 ) )
298 #define taskTASK_SCHEDULED_TO_YIELD ( ( BaseType_t ) ( -2 ) )
305 …( pxTCB ) ( ( ( ( pxTCB )->xTaskRunState >= ( BaseType_t ) 0 ) && ( ( pxT…
306 …#define taskTASK_IS_RUNNING_OR_SCHEDULED_TO_YIELD( pxTCB ) ( ( ( pxTCB )->xTaskRunState != task…
313 …#define portGET_CRITICAL_NESTING_COUNT() ( pxCurrentTCBs[ portGET_CORE_ID() ]->uxCritical…
314 …#define portSET_CRITICAL_NESTING_COUNT( x ) ( pxCurrentTCBs[ portGET_CORE_ID() ]->uxCritical…
315 …#define portINCREMENT_CRITICAL_NESTING_COUNT() ( pxCurrentTCBs[ portGET_CORE_ID() ]->uxCritical…
316 …rtDECREMENT_CRITICAL_NESTING_COUNT() ( pxCurrentTCBs[ portGET_CORE_ID() ]->uxCriticalNesting-- )
336 if( pxCurrentTCBs[ ( xCoreID ) ]->xTaskRunState != taskTASK_SCHEDULED_TO_YIELD ) \
339 pxCurrentTCBs[ ( xCoreID ) ]->xTaskRunState = taskTASK_SCHEDULED_TO_YIELD; \
344 /*-----------------------------------------------------------*/
368 … running on, if the task is running. Otherwise, identifies the task's state - not running or yield…
369 …UBaseType_t uxTaskAttributes; /**< Task's attributes - currently used to identify the id…
391 …UBaseType_t uxBasePriority; /**< The priority last assigned to the task - used by the priority inh…
437 /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-84 */
442 /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-84 */
448 /* Lists for ready and blocked tasks. --------------------
454 …edTaskList2; /**< Delayed tasks (two lists are used - one for delays that …
461 …PRIVILEGED_DATA static List_t xTasksWaitingTermination; /**< Tasks that have been deleted - but th…
478 /* Other file private variables. --------------------------------*/
493 static const volatile UBaseType_t uxTopUsedPriority = configMAX_PRIORITIES - 1U;
518 /*-----------------------------------------------------------*/
520 /* File private functions. --------------------------------*/
575 * In the FreeRTOS SMP, configNUMBER_OF_CORES - 1 passive idle tasks are also
635 * Searches pxList for a task with name pcNameToQuery - returning a handle to
787 * From 1 and 2 above ==> Only when the return value is non-negative
795 /*-----------------------------------------------------------*/
810 while( pxThisTCB->xTaskRunState == taskTASK_SCHEDULED_TO_YIELD ) in prvCheckForRunStateChange()
817 * the suspension and critical nesting counts, as well as release in prvCheckForRunStateChange()
836 configASSERT( pxThisTCB->xTaskRunState == taskTASK_SCHEDULED_TO_YIELD ); in prvCheckForRunStateChange()
843 configASSERT( pxThisTCB->xTaskRunState != taskTASK_SCHEDULED_TO_YIELD ); in prvCheckForRunStateChange()
859 /*-----------------------------------------------------------*/
866 BaseType_t xLowestPriorityCore = ( BaseType_t ) -1; in prvYieldForTask()
880 if( pxTCB->uxPriority >= uxTopReadyPriority ) in prvYieldForTask()
886 xLowestPriorityToPreempt = ( BaseType_t ) pxTCB->uxPriority; in prvYieldForTask()
888 /* xLowestPriorityToPreempt will be decremented to -1 if the priority of pxTCB in prvYieldForTask()
889 * is 0. This is ok as we will give system idle tasks a priority of -1 below. */ in prvYieldForTask()
890 --xLowestPriorityToPreempt; in prvYieldForTask()
894 xCurrentCoreTaskPriority = ( BaseType_t ) pxCurrentTCBs[ xCoreID ]->uxPriority; in prvYieldForTask()
896 /* System idle tasks are being assigned a priority of tskIDLE_PRIORITY - 1 here. */ in prvYieldForTask()
897 if( ( pxCurrentTCBs[ xCoreID ]->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) != 0U ) in prvYieldForTask()
899 xCurrentCoreTaskPriority = xCurrentCoreTaskPriority - 1; in prvYieldForTask()
911 … if( ( pxTCB->uxCoreAffinityMask & ( ( UBaseType_t ) 1U << ( UBaseType_t ) xCoreID ) ) != 0U ) in prvYieldForTask()
915 if( pxCurrentTCBs[ xCoreID ]->xPreemptionDisable == pdFALSE ) in prvYieldForTask()
931 /* Yield all currently running non-idle tasks with a priority lower than in prvYieldForTask()
933 … if( ( xCurrentCoreTaskPriority > ( ( BaseType_t ) tskIDLE_PRIORITY - 1 ) ) && in prvYieldForTask()
934 ( xCurrentCoreTaskPriority < ( BaseType_t ) pxTCB->uxPriority ) ) in prvYieldForTask()
963 … if( ( ( pxCurrentTCBs[ portGET_CORE_ID() ]->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) == 0U ) && in prvYieldForTask()
964 ( pxTCB->uxPriority > pxCurrentTCBs[ portGET_CORE_ID() ]->uxPriority ) ) in prvYieldForTask()
973 /*-----------------------------------------------------------*/
1002 if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxCurrentTCBs[ xCoreID ]->uxPriority ] ), in prvSelectHighestPriorityTask()
1003 &pxCurrentTCBs[ xCoreID ]->xStateListItem ) == pdTRUE ) in prvSelectHighestPriorityTask()
1005 ( void ) uxListRemove( &pxCurrentTCBs[ xCoreID ]->xStateListItem ); in prvSelectHighestPriorityTask()
1006 vListInsertEnd( &( pxReadyTasksLists[ pxCurrentTCBs[ xCoreID ]->uxPriority ] ), in prvSelectHighestPriorityTask()
1007 &pxCurrentTCBs[ xCoreID ]->xStateListItem ); in prvSelectHighestPriorityTask()
1037 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvSelectHighestPriorityTask()
1048 if( ( pxTCB->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) == 0U ) in prvSelectHighestPriorityTask()
1056 if( pxTCB->xTaskRunState == taskTASK_NOT_RUNNING ) in prvSelectHighestPriorityTask()
1059 … if( ( pxTCB->uxCoreAffinityMask & ( ( UBaseType_t ) 1U << ( UBaseType_t ) xCoreID ) ) != 0U ) in prvSelectHighestPriorityTask()
1063 pxCurrentTCBs[ xCoreID ]->xTaskRunState = taskTASK_NOT_RUNNING; in prvSelectHighestPriorityTask()
1067 pxTCB->xTaskRunState = xCoreID; in prvSelectHighestPriorityTask()
1074 …configASSERT( ( pxTCB->xTaskRunState == xCoreID ) || ( pxTCB->xTaskRunState == taskTASK_SCHEDULED_… in prvSelectHighestPriorityTask()
1077 … if( ( pxTCB->uxCoreAffinityMask & ( ( UBaseType_t ) 1U << ( UBaseType_t ) xCoreID ) ) != 0U ) in prvSelectHighestPriorityTask()
1081 pxTCB->xTaskRunState = xCoreID; in prvSelectHighestPriorityTask()
1102 uxTopReadyPriority--; in prvSelectHighestPriorityTask()
1117 uxCurrentPriority--; in prvSelectHighestPriorityTask()
1140 if( ( pxCurrentTCBs[ x ]->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) != 0U ) in prvSelectHighestPriorityTask()
1154 …istIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxPreviousTCB->uxPriority ] ), &( pxPreviousTCB->xSt… in prvSelectHighestPriorityTask()
1158 UBaseType_t uxCoreMap = pxPreviousTCB->uxCoreAffinityMask; in prvSelectHighestPriorityTask()
1159 BaseType_t xLowestPriority = ( BaseType_t ) pxPreviousTCB->uxPriority; in prvSelectHighestPriorityTask()
1160 BaseType_t xLowestPriorityCore = -1; in prvSelectHighestPriorityTask()
1163 if( ( pxPreviousTCB->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) != 0U ) in prvSelectHighestPriorityTask()
1165 xLowestPriority = xLowestPriority - 1; in prvSelectHighestPriorityTask()
1176 * is allowed to run. The reason is - when more than one cores are in prvSelectHighestPriorityTask()
1188 uxCoreMap &= ~( pxCurrentTCBs[ xCoreID ]->uxCoreAffinityMask ); in prvSelectHighestPriorityTask()
1197 uxCoreMap &= ( ( 1U << configNUMBER_OF_CORES ) - 1U ); in prvSelectHighestPriorityTask()
1199 … for( x = ( ( BaseType_t ) configNUMBER_OF_CORES - 1 ); x >= ( BaseType_t ) 0; x-- ) in prvSelectHighestPriorityTask()
1206 xTaskPriority = ( BaseType_t ) pxCurrentTCBs[ uxCore ]->uxPriority; in prvSelectHighestPriorityTask()
1208 … if( ( pxCurrentTCBs[ uxCore ]->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) != 0U ) in prvSelectHighestPriorityTask()
1210 xTaskPriority = xTaskPriority - ( BaseType_t ) 1; in prvSelectHighestPriorityTask()
1220 if( pxCurrentTCBs[ uxCore ]->xPreemptionDisable == pdFALSE ) in prvSelectHighestPriorityTask()
1242 /*-----------------------------------------------------------*/
1274 * function - use them. */ in prvCreateStaticTask()
1276 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-113 */ in prvCreateStaticTask()
1280 pxNewTCB->pxStack = ( StackType_t * ) puxStackBuffer; in prvCreateStaticTask()
1286 pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_AND_TCB; in prvCreateStaticTask()
1299 /*-----------------------------------------------------------*/
1321 pxNewTCB->uxCoreAffinityMask = tskNO_AFFINITY; in xTaskCreateStatic()
1336 /*-----------------------------------------------------------*/
1358 pxNewTCB->uxCoreAffinityMask = uxCoreAffinityMask; in xTaskCreateStaticAffinitySet()
1374 /*-----------------------------------------------------------*/
1382 configASSERT( pxTaskDefinition->puxStackBuffer != NULL ); in prvCreateRestrictedStaticTask()
1383 configASSERT( pxTaskDefinition->pxTaskBuffer != NULL ); in prvCreateRestrictedStaticTask()
1385 … if( ( pxTaskDefinition->puxStackBuffer != NULL ) && ( pxTaskDefinition->pxTaskBuffer != NULL ) ) in prvCreateRestrictedStaticTask()
1390 pxNewTCB = ( TCB_t * ) pxTaskDefinition->pxTaskBuffer; in prvCreateRestrictedStaticTask()
1394 pxNewTCB->pxStack = pxTaskDefinition->puxStackBuffer; in prvCreateRestrictedStaticTask()
1400 pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_AND_TCB; in prvCreateRestrictedStaticTask()
1404 prvInitialiseNewTask( pxTaskDefinition->pvTaskCode, in prvCreateRestrictedStaticTask()
1405 pxTaskDefinition->pcName, in prvCreateRestrictedStaticTask()
1406 ( uint32_t ) pxTaskDefinition->usStackDepth, in prvCreateRestrictedStaticTask()
1407 pxTaskDefinition->pvParameters, in prvCreateRestrictedStaticTask()
1408 pxTaskDefinition->uxPriority, in prvCreateRestrictedStaticTask()
1410 pxTaskDefinition->xRegions ); in prvCreateRestrictedStaticTask()
1419 /*-----------------------------------------------------------*/
1438 pxNewTCB->uxCoreAffinityMask = tskNO_AFFINITY; in xTaskCreateRestrictedStatic()
1454 /*-----------------------------------------------------------*/
1473 pxNewTCB->uxCoreAffinityMask = uxCoreAffinityMask; in xTaskCreateRestrictedStaticAffinitySet()
1490 /*-----------------------------------------------------------*/
1498 configASSERT( pxTaskDefinition->puxStackBuffer ); in prvCreateRestrictedTask()
1500 if( pxTaskDefinition->puxStackBuffer != NULL ) in prvCreateRestrictedTask()
1503 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvCreateRestrictedTask()
1512 pxNewTCB->pxStack = pxTaskDefinition->puxStackBuffer; in prvCreateRestrictedTask()
1519 pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_ONLY; in prvCreateRestrictedTask()
1523 prvInitialiseNewTask( pxTaskDefinition->pvTaskCode, in prvCreateRestrictedTask()
1524 pxTaskDefinition->pcName, in prvCreateRestrictedTask()
1525 ( uint32_t ) pxTaskDefinition->usStackDepth, in prvCreateRestrictedTask()
1526 pxTaskDefinition->pvParameters, in prvCreateRestrictedTask()
1527 pxTaskDefinition->uxPriority, in prvCreateRestrictedTask()
1529 pxTaskDefinition->xRegions ); in prvCreateRestrictedTask()
1539 /*-----------------------------------------------------------*/
1556 pxNewTCB->uxCoreAffinityMask = tskNO_AFFINITY; in xTaskCreateRestricted()
1573 /*-----------------------------------------------------------*/
1590 pxNewTCB->uxCoreAffinityMask = uxCoreAffinityMask; in xTaskCreateRestrictedAffinitySet()
1609 /*-----------------------------------------------------------*/
1630 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvCreateTask()
1642 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvCreateTask()
1644 …pxNewTCB->pxStack = ( StackType_t * ) pvPortMallocStack( ( ( ( size_t ) usStackDepth ) * sizeof( S… in prvCreateTask()
1646 if( pxNewTCB->pxStack == NULL ) in prvCreateTask()
1660 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvCreateTask()
1668 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvCreateTask()
1677 pxNewTCB->pxStack = pxStack; in prvCreateTask()
1699 pxNewTCB->ucStaticallyAllocated = tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB; in prvCreateTask()
1708 /*-----------------------------------------------------------*/
1729 pxNewTCB->uxCoreAffinityMask = tskNO_AFFINITY; in xTaskCreate()
1745 /*-----------------------------------------------------------*/
1766 pxNewTCB->uxCoreAffinityMask = uxCoreAffinityMask; in xTaskCreateAffinitySet()
1783 /*-----------------------------------------------------------*/
1816 …( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) ulStackDepth * sizeof( … in prvInitialiseNewTask()
1826 pxTopOfStack = &( pxNewTCB->pxStack[ ulStackDepth - ( uint32_t ) 1 ] ); in prvInitialiseNewTask()
1836 pxNewTCB->pxEndOfStack = pxTopOfStack; in prvInitialiseNewTask()
1842 pxTopOfStack = pxNewTCB->pxStack; in prvInitialiseNewTask()
1850 pxNewTCB->pxEndOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 ); in prvInitialiseNewTask()
1859 pxNewTCB->pcTaskName[ x ] = pcName[ x ]; in prvInitialiseNewTask()
1876 pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1U ] = '\0'; in prvInitialiseNewTask()
1888 uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U; in prvInitialiseNewTask()
1895 pxNewTCB->uxPriority = uxPriority; in prvInitialiseNewTask()
1898 pxNewTCB->uxBasePriority = uxPriority; in prvInitialiseNewTask()
1902 vListInitialiseItem( &( pxNewTCB->xStateListItem ) ); in prvInitialiseNewTask()
1903 vListInitialiseItem( &( pxNewTCB->xEventListItem ) ); in prvInitialiseNewTask()
1907 listSET_LIST_ITEM_OWNER( &( pxNewTCB->xStateListItem ), pxNewTCB ); in prvInitialiseNewTask()
1910 …listSET_LIST_ITEM_VALUE( &( pxNewTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( Ti… in prvInitialiseNewTask()
1911 listSET_LIST_ITEM_OWNER( &( pxNewTCB->xEventListItem ), pxNewTCB ); in prvInitialiseNewTask()
1915 …vPortStoreTaskMPUSettings( &( pxNewTCB->xMPUSettings ), xRegions, pxNewTCB->pxStack, ulStackDepth … in prvInitialiseNewTask()
1927 configINIT_TLS_BLOCK( pxNewTCB->xTLSBlock, pxTopOfStack ); in prvInitialiseNewTask()
1944 …pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxStack, pxTaskCode, pvPar… in prvInitialiseNewTask()
1948 …pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxEndOfStack, pxTaskCode, … in prvInitialiseNewTask()
1954 …pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters, xRunPrivil… in prvInitialiseNewTask()
1967 …pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxStack, pxTaskCode, pvPar… in prvInitialiseNewTask()
1971 …pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxEndOfStack, pxTaskCode, … in prvInitialiseNewTask()
1977 … pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters ); in prvInitialiseNewTask()
1986 pxNewTCB->xTaskRunState = taskTASK_NOT_RUNNING; in prvInitialiseNewTask()
1991 pxNewTCB->uxTaskAttributes |= taskATTRIBUTE_IS_IDLE; in prvInitialiseNewTask()
2007 /*-----------------------------------------------------------*/
2022 * the suspended state - make this the current task. */ in prvAddNewTaskToReadyList()
2044 if( pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority ) in prvAddNewTaskToReadyList()
2064 pxNewTCB->uxTCBNumber = uxTaskNumber; in prvAddNewTaskToReadyList()
2111 if( ( pxNewTCB->uxTaskAttributes & taskATTRIBUTE_IS_IDLE ) != 0U ) in prvAddNewTaskToReadyList()
2120 pxNewTCB->xTaskRunState = xCoreID; in prvAddNewTaskToReadyList()
2141 pxNewTCB->uxTCBNumber = uxTaskNumber; in prvAddNewTaskToReadyList()
2166 /*-----------------------------------------------------------*/
2177 /* Encoding error - Return 0 to indicate that nothing in prvSnprintfReturnValueToCharsWritten()
2187 uxCharsWritten = n - 1U; in prvSnprintfReturnValueToCharsWritten()
2199 /*-----------------------------------------------------------*/
2216 if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) in vTaskDelete()
2218 taskRESET_READY_PRIORITY( pxTCB->uxPriority ); in vTaskDelete()
2226 if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL ) in vTaskDelete()
2228 ( void ) uxListRemove( &( pxTCB->xEventListItem ) ); in vTaskDelete()
2236 * detect that the task lists need re-generating. This is done before in vTaskDelete()
2252 vListInsertEnd( &xTasksWaitingTermination, &( pxTCB->xStateListItem ) ); in vTaskDelete()
2263 /* The pre-delete hook is primarily for the Windows simulator, in vTaskDelete()
2265 * after which it is not possible to yield away from this task - in vTaskDelete()
2271 portPRE_TASK_DELETE_HOOK( pxTCB, &( xYieldPendings[ pxTCB->xTaskRunState ] ) ); in vTaskDelete()
2276 --uxCurrentNumberOfTasks; in vTaskDelete()
2317 if( pxTCB->xTaskRunState == taskTASK_NOT_RUNNING ) in vTaskDelete()
2325 if( pxTCB->xTaskRunState == ( BaseType_t ) portGET_CORE_ID() ) in vTaskDelete()
2332 prvYieldCore( pxTCB->xTaskRunState ); in vTaskDelete()
2344 /*-----------------------------------------------------------*/
2410 prvAddCurrentTaskToDelayedList( xTimeToWake - xConstTickCount, pdFALSE ); in xTaskDelayUntil()
2436 /*-----------------------------------------------------------*/
2486 /*-----------------------------------------------------------*/
2514 pxStateList = listLIST_ITEM_CONTAINER( &( pxTCB->xStateListItem ) ); in eTaskGetState()
2515 pxEventList = listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ); in eTaskGetState()
2541 if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL ) in eTaskGetState()
2556 if( pxTCB->ucNotifyState[ x ] == taskWAITING_NOTIFICATION ) in eTaskGetState()
2618 /*-----------------------------------------------------------*/
2634 uxReturn = pxTCB->uxPriority; in uxTaskPriorityGet()
2644 /*-----------------------------------------------------------*/
2669 * simple as possible. More information (albeit Cortex-M specific) is in uxTaskPriorityGetFromISR()
2671 * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */ in uxTaskPriorityGetFromISR()
2679 uxReturn = pxTCB->uxPriority; in uxTaskPriorityGetFromISR()
2689 /*-----------------------------------------------------------*/
2705 uxReturn = pxTCB->uxBasePriority; in uxTaskBasePriorityGet()
2715 /*-----------------------------------------------------------*/
2740 * simple as possible. More information (albeit Cortex-M specific) is in uxTaskBasePriorityGetFromISR()
2742 * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */ in uxTaskBasePriorityGetFromISR()
2750 uxReturn = pxTCB->uxBasePriority; in uxTaskBasePriorityGetFromISR()
2760 /*-----------------------------------------------------------*/
2782 uxNewPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U; in vTaskPrioritySet()
2799 uxCurrentBasePriority = pxTCB->uxBasePriority; in vTaskPrioritySet()
2803 uxCurrentBasePriority = pxTCB->uxPriority; in vTaskPrioritySet()
2820 if( uxNewPriority > pxCurrentTCB->uxPriority ) in vTaskPrioritySet()
2850 if( pxTCB->xPreemptionDisable == pdFALSE ) in vTaskPrioritySet()
2866 uxPriorityUsedOnEntry = pxTCB->uxPriority; in vTaskPrioritySet()
2873 … if( ( pxTCB->uxBasePriority == pxTCB->uxPriority ) || ( uxNewPriority > pxTCB->uxPriority ) ) in vTaskPrioritySet()
2875 pxTCB->uxPriority = uxNewPriority; in vTaskPrioritySet()
2883 pxTCB->uxBasePriority = uxNewPriority; in vTaskPrioritySet()
2887 pxTCB->uxPriority = uxNewPriority; in vTaskPrioritySet()
2893 …if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) =… in vTaskPrioritySet()
2895 …listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( ( TickType_t ) configMAX_PRIORITIES - ( Tic… in vTaskPrioritySet()
2906 …_CONTAINED_WITHIN( &( pxReadyTasksLists[ uxPriorityUsedOnEntry ] ), &( pxTCB->xStateListItem ) ) !… in vTaskPrioritySet()
2908 /* The task is currently in its ready list - remove before in vTaskPrioritySet()
2911 if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) in vTaskPrioritySet()
2974 /*-----------------------------------------------------------*/
2994 uxPrevCoreAffinityMask = pxTCB->uxCoreAffinityMask; in vTaskCoreAffinitySet()
2995 pxTCB->uxCoreAffinityMask = uxCoreAffinityMask; in vTaskCoreAffinitySet()
3001 xCoreID = ( BaseType_t ) pxTCB->xTaskRunState; in vTaskCoreAffinitySet()
3016 … uxPrevNotAllowedCores = ( ~uxPrevCoreAffinityMask ) & ( ( 1U << configNUMBER_OF_CORES ) - 1U ); in vTaskCoreAffinitySet()
3039 /*-----------------------------------------------------------*/
3052 uxCoreAffinityMask = pxTCB->uxCoreAffinityMask; in vTaskCoreAffinityGet()
3062 /*-----------------------------------------------------------*/
3076 pxTCB->xPreemptionDisable = pdTRUE; in vTaskPreemptionDisable()
3084 /*-----------------------------------------------------------*/
3099 pxTCB->xPreemptionDisable = pdFALSE; in vTaskPreemptionEnable()
3105 xCoreID = ( BaseType_t ) pxTCB->xTaskRunState; in vTaskPreemptionEnable()
3116 /*-----------------------------------------------------------*/
3139 xTaskRunningOnCore = pxTCB->xTaskRunState; in vTaskSuspend()
3144 if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) in vTaskSuspend()
3146 taskRESET_READY_PRIORITY( pxTCB->uxPriority ); in vTaskSuspend()
3154 if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL ) in vTaskSuspend()
3156 ( void ) uxListRemove( &( pxTCB->xEventListItem ) ); in vTaskSuspend()
3163 vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xStateListItem ) ); in vTaskSuspend()
3171 if( pxTCB->ucNotifyState[ x ] == taskWAITING_NOTIFICATION ) in vTaskSuspend()
3175 pxTCB->ucNotifyState[ x ] = taskNOT_WAITING_NOTIFICATION; in vTaskSuspend()
3284 /*-----------------------------------------------------------*/
3300 if( listIS_CONTAINED_WITHIN( &xSuspendedTaskList, &( pxTCB->xStateListItem ) ) != pdFALSE ) in prvTaskIsTaskSuspended()
3303 … if( listIS_CONTAINED_WITHIN( &xPendingReadyList, &( pxTCB->xEventListItem ) ) == pdFALSE ) in prvTaskIsTaskSuspended()
3307 if( listIS_CONTAINED_WITHIN( NULL, &( pxTCB->xEventListItem ) ) != pdFALSE ) in prvTaskIsTaskSuspended()
3322 if( pxTCB->ucNotifyState[ x ] == taskWAITING_NOTIFICATION ) in prvTaskIsTaskSuspended()
3354 /*-----------------------------------------------------------*/
3390 ( void ) uxListRemove( &( pxTCB->xStateListItem ) ); in vTaskResume()
3415 /*-----------------------------------------------------------*/
3442 * simple as possible. More information (albeit Cortex-M specific) is in xTaskResumeFromISR()
3444 * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */ in xTaskResumeFromISR()
3460 if( pxTCB->uxPriority > pxCurrentTCB->uxPriority ) in xTaskResumeFromISR()
3476 ( void ) uxListRemove( &( pxTCB->xStateListItem ) ); in xTaskResumeFromISR()
3484 vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) ); in xTaskResumeFromISR()
3511 /*-----------------------------------------------------------*/
3547 /* In the FreeRTOS SMP, configNUMBER_OF_CORES - 1 passive idle tasks in prvCreateIdleTasks()
3594 /* The Idle task is created using user provided RAM - obtain the in prvCreateIdleTasks()
3608 …eIdleTaskMemory( &pxIdleTaskTCBBuffer, &pxIdleTaskStackBuffer, &ulIdleTaskStackSize, xCoreID - 1 ); in prvCreateIdleTasks()
3655 /*-----------------------------------------------------------*/
3700 * so interrupts will automatically get re-enabled when the first task in vTaskStartScheduler()
3706 /* Switch C-Runtime's TLS Block to point to the TLS in vTaskStartScheduler()
3708 configSET_TLS_BLOCK( pxCurrentTCB->xTLSBlock ); in vTaskStartScheduler()
3758 /*-----------------------------------------------------------*/
3773 /*----------------------------------------------------------*/
3783 * post in the FreeRTOS support forum before reporting this as a bug! - in vTaskSuspendAll()
3790 /* The scheduler is suspended if uxSchedulerSuspended is non-zero. An increment in vTaskSuspendAll()
3810 * It is safe to re-enable interrupts after releasing the ISR lock and incrementing in vTaskSuspendAll()
3841 /* The scheduler is suspended if uxSchedulerSuspended is non-zero. An increment in vTaskSuspendAll()
3858 /*----------------------------------------------------------*/
3886 * care of the case where the co-operative scheduler is in use. */ in prvGetExpectedIdleTime()
3894 if( pxCurrentTCB->uxPriority > tskIDLE_PRIORITY ) in prvGetExpectedIdleTime()
3915 xReturn -= xTickCount; in prvGetExpectedIdleTime()
3922 /*----------------------------------------------------------*/
3949 --uxSchedulerSuspended; in xTaskResumeAll()
3961 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in xTaskResumeAll()
3964 listREMOVE_ITEM( &( pxTCB->xEventListItem ) ); in xTaskResumeAll()
3966 listREMOVE_ITEM( &( pxTCB->xStateListItem ) ); in xTaskResumeAll()
3973 if( pxTCB->uxPriority > pxCurrentTCB->uxPriority ) in xTaskResumeAll()
3995 * re-calculated, in which case re-calculate it now. Mainly in xTaskResumeAll()
4012 TickType_t xPendedCounts = xPendedTicks; /* Non-volatile copy. */ in xTaskResumeAll()
4029 --xPendedCounts; in xTaskResumeAll()
4072 /*-----------------------------------------------------------*/
4091 /*-----------------------------------------------------------*/
4112 * More information (albeit Cortex-M specific) is provided on the following in xTaskGetTickCountFromISR()
4113 * link: https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */ in xTaskGetTickCountFromISR()
4126 /*-----------------------------------------------------------*/
4138 /*-----------------------------------------------------------*/
4151 traceRETURN_pcTaskGetName( &( pxTCB->pcTaskName[ 0 ] ) ); in pcTaskGetName()
4153 return &( pxTCB->pcTaskName[ 0 ] ); in pcTaskGetName()
4155 /*-----------------------------------------------------------*/
4175 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvSearchForNameWithinSingleList()
4182 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvSearchForNameWithinSingleList()
4192 cNextChar = pxNextTCB->pcTaskName[ x ]; in prvSearchForNameWithinSingleList()
4249 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvSearchForNameWithinSingleList()
4259 cNextChar = pxTCB->pcTaskName[ x ]; in prvSearchForNameWithinSingleList()
4301 /*-----------------------------------------------------------*/
4312 /* Task names will be truncated to configMAX_TASK_NAME_LEN - 1 bytes. */ in xTaskGetHandle()
4320 uxQueue--; in xTaskGetHandle()
4369 /*-----------------------------------------------------------*/
4389 if( pxTCB->ucStaticallyAllocated == tskSTATICALLY_ALLOCATED_STACK_AND_TCB ) in xTaskGetStaticBuffers()
4391 *ppuxStackBuffer = pxTCB->pxStack; in xTaskGetStaticBuffers()
4393 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-113 */ in xTaskGetStaticBuffers()
4398 else if( pxTCB->ucStaticallyAllocated == tskSTATICALLY_ALLOCATED_STACK_ONLY ) in xTaskGetStaticBuffers()
4400 *ppuxStackBuffer = pxTCB->pxStack; in xTaskGetStaticBuffers()
4411 *ppuxStackBuffer = pxTCB->pxStack; in xTaskGetStaticBuffers()
4423 /*-----------------------------------------------------------*/
4444 uxQueue--; in uxTaskGetSystemState()
4502 /*----------------------------------------------------------*/
4538 /*----------------------------------------------------------*/
4572 xTicksToJump--; in vTaskStepTick()
4586 /*----------------------------------------------------------*/
4614 /*----------------------------------------------------------*/
4638 ( void ) uxListRemove( &( pxTCB->xStateListItem ) ); in xTaskAbortDelay()
4646 if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL ) in xTaskAbortDelay()
4648 ( void ) uxListRemove( &( pxTCB->xEventListItem ) ); in xTaskAbortDelay()
4651 * blocked state so it should not re-evaluate its block time and in xTaskAbortDelay()
4653 pxTCB->ucDelayAborted = pdTRUE; in xTaskAbortDelay()
4674 if( pxTCB->uxPriority > pxCurrentTCB->uxPriority ) in xTaskAbortDelay()
4710 /*----------------------------------------------------------*/
4753 * the queue in the order of their wake time - meaning once one task in xTaskIncrementTick()
4777 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in xTaskIncrementTick()
4780 xItemValue = listGET_LIST_ITEM_VALUE( &( pxTCB->xStateListItem ) ); in xTaskIncrementTick()
4787 * state - so record the item value in in xTaskIncrementTick()
4798 listREMOVE_ITEM( &( pxTCB->xStateListItem ) ); in xTaskIncrementTick()
4802 if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL ) in xTaskIncrementTick()
4804 listREMOVE_ITEM( &( pxTCB->xEventListItem ) ); in xTaskIncrementTick()
4829 if( pxTCB->uxPriority > pxCurrentTCB->uxPriority ) in xTaskIncrementTick()
4856 … if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ pxCurrentTCB->uxPriority ] ) ) > 1U ) in xTaskIncrementTick()
4871 …if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ pxCurrentTCBs[ xCoreID ]->uxPriority ] ) ) > 1U… in xTaskIncrementTick()
4922 if( pxCurrentTCBs[ xCoreID ]->xPreemptionDisable == pdFALSE ) in xTaskIncrementTick()
4964 /*-----------------------------------------------------------*/
4990 xTCB->pxTaskTag = pxHookFunction; in vTaskSetApplicationTaskTag()
4998 /*-----------------------------------------------------------*/
5016 xReturn = pxTCB->pxTaskTag; in xTaskGetApplicationTaskTag()
5026 /*-----------------------------------------------------------*/
5045 xReturn = pxTCB->pxTaskTag; in xTaskGetApplicationTaskTagFromISR()
5055 /*-----------------------------------------------------------*/
5077 if( xTCB->pxTaskTag != NULL ) in xTaskCallApplicationTaskHook()
5079 xReturn = xTCB->pxTaskTag( pvParameter ); in xTaskCallApplicationTaskHook()
5092 /*-----------------------------------------------------------*/
5101 /* The scheduler is currently suspended - do not allow a context in vTaskSwitchContext()
5123 * against suspect run time stat counter implementations - which in vTaskSwitchContext()
5127 … pxCurrentTCB->ulRunTimeCounter += ( ulTotalRunTime[ 0 ] - ulTaskSwitchedInTime[ 0 ] ); in vTaskSwitchContext()
5144 pxCurrentTCB->iTaskErrno = FreeRTOS_errno; in vTaskSwitchContext()
5151 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in vTaskSwitchContext()
5164 FreeRTOS_errno = pxCurrentTCB->iTaskErrno; in vTaskSwitchContext()
5170 /* Switch C-Runtime's TLS Block to point to the TLS in vTaskSwitchContext()
5172 configSET_TLS_BLOCK( pxCurrentTCB->xTLSBlock ); in vTaskSwitchContext()
5185 * - The ISR lock protects the ready list from simultaneous access by in vTaskSwitchContext()
5187 * - We also take the task lock to pause here in case another core has in vTaskSwitchContext()
5202 /* The scheduler is currently suspended - do not allow a context in vTaskSwitchContext()
5224 * against suspect run time stat counter implementations - which in vTaskSwitchContext()
5228 …pxCurrentTCBs[ xCoreID ]->ulRunTimeCounter += ( ulTotalRunTime[ xCoreID ] - ulTaskSwitchedInTime[ … in vTaskSwitchContext()
5245 pxCurrentTCBs[ xCoreID ]->iTaskErrno = FreeRTOS_errno; in vTaskSwitchContext()
5261 FreeRTOS_errno = pxCurrentTCBs[ xCoreID ]->iTaskErrno; in vTaskSwitchContext()
5267 /* Switch C-Runtime's TLS Block to point to the TLS in vTaskSwitchContext()
5269 configSET_TLS_BLOCK( pxCurrentTCBs[ xCoreID ]->xTLSBlock ); in vTaskSwitchContext()
5280 /*-----------------------------------------------------------*/
5298 * xItemValue = ( configMAX_PRIORITIES - uxPriority ) in vTaskPlaceOnEventList()
5303 vListInsert( pxEventList, &( pxCurrentTCB->xEventListItem ) ); in vTaskPlaceOnEventList()
5309 /*-----------------------------------------------------------*/
5326 …listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xEventListItem ), xItemValue | taskEVENT_LIST_ITEM_VALUE… in vTaskPlaceOnUnorderedEventList()
5330 * event group implementation - and interrupts don't access event groups in vTaskPlaceOnUnorderedEventList()
5333 listINSERT_END( pxEventList, &( pxCurrentTCB->xEventListItem ) ); in vTaskPlaceOnUnorderedEventList()
5339 /*-----------------------------------------------------------*/
5353 * designed for use by kernel code, and has special calling requirements - in vTaskPlaceOnEventListRestricted()
5361 listINSERT_END( pxEventList, &( pxCurrentTCB->xEventListItem ) ); in vTaskPlaceOnEventListRestricted()
5378 /*-----------------------------------------------------------*/
5395 * get called - the lock count on the queue will get modified instead. This in xTaskRemoveFromEventList()
5401 /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in xTaskRemoveFromEventList()
5405 listREMOVE_ITEM( &( pxUnblockedTCB->xEventListItem ) ); in xTaskRemoveFromEventList()
5409 listREMOVE_ITEM( &( pxUnblockedTCB->xStateListItem ) ); in xTaskRemoveFromEventList()
5420 * at the earliest possible time - so reset xNextTaskUnblockTime here to in xTaskRemoveFromEventList()
5430 listINSERT_END( &( xPendingReadyList ), &( pxUnblockedTCB->xEventListItem ) ); in xTaskRemoveFromEventList()
5435 if( pxUnblockedTCB->uxPriority > pxCurrentTCB->uxPriority ) in xTaskRemoveFromEventList()
5471 /*-----------------------------------------------------------*/
5490 /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in vTaskRemoveFromUnorderedEventList()
5504 * at the earliest possible time - so reset xNextTaskUnblockTime here to in vTaskRemoveFromUnorderedEventList()
5513 listREMOVE_ITEM( &( pxUnblockedTCB->xStateListItem ) ); in vTaskRemoveFromUnorderedEventList()
5518 if( pxUnblockedTCB->uxPriority > pxCurrentTCB->uxPriority ) in vTaskRemoveFromUnorderedEventList()
5543 /*-----------------------------------------------------------*/
5552 pxTimeOut->xOverflowCount = xNumOfOverflows; in vTaskSetTimeOutState()
5553 pxTimeOut->xTimeOnEntering = xTickCount; in vTaskSetTimeOutState()
5559 /*-----------------------------------------------------------*/
5566 pxTimeOut->xOverflowCount = xNumOfOverflows; in vTaskInternalSetTimeOutState()
5567 pxTimeOut->xTimeOnEntering = xTickCount; in vTaskInternalSetTimeOutState()
5571 /*-----------------------------------------------------------*/
5587 const TickType_t xElapsedTime = xConstTickCount - pxTimeOut->xTimeOnEntering; in xTaskCheckForTimeOut()
5590 if( pxCurrentTCB->ucDelayAborted != ( uint8_t ) pdFALSE ) in xTaskCheckForTimeOut()
5594 pxCurrentTCB->ucDelayAborted = pdFALSE; in xTaskCheckForTimeOut()
5611 …if( ( xNumOfOverflows != pxTimeOut->xOverflowCount ) && ( xConstTickCount >= pxTimeOut->xTimeOnEnt… in xTaskCheckForTimeOut()
5624 *pxTicksToWait -= xElapsedTime; in xTaskCheckForTimeOut()
5640 /*-----------------------------------------------------------*/
5651 /*-----------------------------------------------------------*/
5665 uxReturn = pxTCB->uxTaskNumber; in uxTaskGetTaskNumber()
5678 /*-----------------------------------------------------------*/
5692 pxTCB->uxTaskNumber = uxHandle; in vTaskSetTaskNumber()
5699 /*-----------------------------------------------------------*/
5702 * -----------------------------------------------------------
5704 * ----------------------------------------------------------
5776 * -----------------------------------------------------------
5778 * ----------------------------------------------------------
5792 /** THIS IS THE RTOS IDLE TASK - WHICH IS CREATED AUTOMATICALLY WHEN THE in portTASK_FUNCTION()
5810 /* See if any tasks have deleted themselves - if so then the idle task in portTASK_FUNCTION()
5919 /*-----------------------------------------------------------*/
5954 …else if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == ( uxCurrentNumberOfTasks - uxNonApplica… in eTaskConfirmSleepModeStatus()
5974 /*-----------------------------------------------------------*/
5991 pxTCB->pvThreadLocalStoragePointers[ xIndex ] = pvValue; in vTaskSetThreadLocalStoragePointer()
5998 /*-----------------------------------------------------------*/
6014 pvReturn = pxTCB->pvThreadLocalStoragePointers[ xIndex ]; in pvTaskGetThreadLocalStoragePointer()
6027 /*-----------------------------------------------------------*/
6042 vPortStoreTaskMPUSettings( &( pxTCB->xMPUSettings ), pxRegions, NULL, 0 ); in vTaskAllocateMPURegions()
6048 /*-----------------------------------------------------------*/
6080 /*-----------------------------------------------------------*/
6100 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvCheckTasksWaitingTermination()
6103 ( void ) uxListRemove( &( pxTCB->xStateListItem ) ); in prvCheckTasksWaitingTermination()
6104 --uxCurrentNumberOfTasks; in prvCheckTasksWaitingTermination()
6105 --uxDeletedTasksWaitingCleanUp; in prvCheckTasksWaitingTermination()
6124 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvCheckTasksWaitingTermination()
6128 if( pxTCB->xTaskRunState == taskTASK_NOT_RUNNING ) in prvCheckTasksWaitingTermination()
6130 ( void ) uxListRemove( &( pxTCB->xStateListItem ) ); in prvCheckTasksWaitingTermination()
6131 --uxCurrentNumberOfTasks; in prvCheckTasksWaitingTermination()
6132 --uxDeletedTasksWaitingCleanUp; in prvCheckTasksWaitingTermination()
6156 /*-----------------------------------------------------------*/
6172 pxTaskStatus->xHandle = pxTCB; in vTaskGetInfo()
6173 pxTaskStatus->pcTaskName = ( const char * ) &( pxTCB->pcTaskName[ 0 ] ); in vTaskGetInfo()
6174 pxTaskStatus->uxCurrentPriority = pxTCB->uxPriority; in vTaskGetInfo()
6175 pxTaskStatus->pxStackBase = pxTCB->pxStack; in vTaskGetInfo()
6177 pxTaskStatus->pxTopOfStack = ( StackType_t * ) pxTCB->pxTopOfStack; in vTaskGetInfo()
6178 pxTaskStatus->pxEndOfStack = pxTCB->pxEndOfStack; in vTaskGetInfo()
6180 pxTaskStatus->xTaskNumber = pxTCB->uxTCBNumber; in vTaskGetInfo()
6184 pxTaskStatus->uxCoreAffinityMask = pxTCB->uxCoreAffinityMask; in vTaskGetInfo()
6190 pxTaskStatus->uxBasePriority = pxTCB->uxBasePriority; in vTaskGetInfo()
6194 pxTaskStatus->uxBasePriority = 0; in vTaskGetInfo()
6200 pxTaskStatus->ulRunTimeCounter = pxTCB->ulRunTimeCounter; in vTaskGetInfo()
6204 pxTaskStatus->ulRunTimeCounter = ( configRUN_TIME_COUNTER_TYPE ) 0; in vTaskGetInfo()
6209 * value of eState passed into this function is eInvalid - otherwise the in vTaskGetInfo()
6215 pxTaskStatus->eCurrentState = eRunning; in vTaskGetInfo()
6219 pxTaskStatus->eCurrentState = eState; in vTaskGetInfo()
6224 * chance it is actually just blocked indefinitely - so really in vTaskGetInfo()
6230 if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL ) in vTaskGetInfo()
6232 pxTaskStatus->eCurrentState = eBlocked; in vTaskGetInfo()
6245 if( pxTCB->ucNotifyState[ x ] == taskWAITING_NOTIFICATION ) in vTaskGetInfo()
6247 pxTaskStatus->eCurrentState = eBlocked; in vTaskGetInfo()
6263 … if( listIS_CONTAINED_WITHIN( &xPendingReadyList, &( pxTCB->xEventListItem ) ) != pdFALSE ) in vTaskGetInfo()
6265 pxTaskStatus->eCurrentState = eReady; in vTaskGetInfo()
6273 pxTaskStatus->eCurrentState = eTaskGetState( pxTCB ); in vTaskGetInfo()
6282 …pxTaskStatus->usStackHighWaterMark = prvTaskCheckFreeStackSpace( ( uint8_t * ) pxTCB->pxEndOfStack… in vTaskGetInfo()
6286 … pxTaskStatus->usStackHighWaterMark = prvTaskCheckFreeStackSpace( ( uint8_t * ) pxTCB->pxStack ); in vTaskGetInfo()
6292 pxTaskStatus->usStackHighWaterMark = 0; in vTaskGetInfo()
6299 /*-----------------------------------------------------------*/
6314 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvListTasksWithinSingleList()
6325 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in prvListTasksWithinSingleList()
6341 /*-----------------------------------------------------------*/
6351 pucStackByte -= portSTACK_GROWTH; in prvTaskCheckFreeStackSpace()
6361 /*-----------------------------------------------------------*/
6368 * overflowing on 8-bit types without breaking backward compatibility for
6369 * applications that expect an 8-bit return type. */
6381 * problem of the value overflowing on 8-bit types without breaking in uxTaskGetStackHighWaterMark2()
6382 * backward compatibility for applications that expect an 8-bit return in uxTaskGetStackHighWaterMark2()
6389 pucEndOfStack = ( uint8_t * ) pxTCB->pxStack; in uxTaskGetStackHighWaterMark2()
6393 pucEndOfStack = ( uint8_t * ) pxTCB->pxEndOfStack; in uxTaskGetStackHighWaterMark2()
6405 /*-----------------------------------------------------------*/
6421 pucEndOfStack = ( uint8_t * ) pxTCB->pxStack; in uxTaskGetStackHighWaterMark()
6425 pucEndOfStack = ( uint8_t * ) pxTCB->pxEndOfStack; in uxTaskGetStackHighWaterMark()
6437 /*-----------------------------------------------------------*/
6451 configDEINIT_TLS_BLOCK( pxTCB->xTLSBlock ); in prvDeleteTCB()
6457 /* The task can only have been allocated dynamically - free both in prvDeleteTCB()
6459 vPortFreeStack( pxTCB->pxStack ); in prvDeleteTCB()
6467 if( pxTCB->ucStaticallyAllocated == tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB ) in prvDeleteTCB()
6471 vPortFreeStack( pxTCB->pxStack ); in prvDeleteTCB()
6474 else if( pxTCB->ucStaticallyAllocated == tskSTATICALLY_ALLOCATED_STACK_ONLY ) in prvDeleteTCB()
6484 … configASSERT( pxTCB->ucStaticallyAllocated == tskSTATICALLY_ALLOCATED_STACK_AND_TCB ); in prvDeleteTCB()
6492 /*-----------------------------------------------------------*/
6513 /*-----------------------------------------------------------*/
6570 /*-----------------------------------------------------------*/
6610 /*-----------------------------------------------------------*/
6628 if( pxMutexHolderTCB->uxPriority < pxCurrentTCB->uxPriority ) in xTaskPriorityInherit()
6633 …if( ( listGET_LIST_ITEM_VALUE( &( pxMutexHolderTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE… in xTaskPriorityInherit()
6635 …T_ITEM_VALUE( &( pxMutexHolderTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickT… in xTaskPriorityInherit()
6644 …_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxMutexHolderTCB->uxPriority ] ), &( pxMutexHolderTCB->xS… in xTaskPriorityInherit()
6646 if( uxListRemove( &( pxMutexHolderTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) in xTaskPriorityInherit()
6651 … portRESET_READY_PRIORITY( pxMutexHolderTCB->uxPriority, uxTopReadyPriority ); in xTaskPriorityInherit()
6659 pxMutexHolderTCB->uxPriority = pxCurrentTCB->uxPriority; in xTaskPriorityInherit()
6675 pxMutexHolderTCB->uxPriority = pxCurrentTCB->uxPriority; in xTaskPriorityInherit()
6678 traceTASK_PRIORITY_INHERIT( pxMutexHolderTCB, pxCurrentTCB->uxPriority ); in xTaskPriorityInherit()
6685 if( pxMutexHolderTCB->uxBasePriority < pxCurrentTCB->uxPriority ) in xTaskPriorityInherit()
6713 /*-----------------------------------------------------------*/
6731 configASSERT( pxTCB->uxMutexesHeld ); in xTaskPriorityDisinherit()
6732 ( pxTCB->uxMutexesHeld )--; in xTaskPriorityDisinherit()
6736 if( pxTCB->uxPriority != pxTCB->uxBasePriority ) in xTaskPriorityDisinherit()
6739 if( pxTCB->uxMutexesHeld == ( UBaseType_t ) 0 ) in xTaskPriorityDisinherit()
6746 if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) in xTaskPriorityDisinherit()
6748 portRESET_READY_PRIORITY( pxTCB->uxPriority, uxTopReadyPriority ); in xTaskPriorityDisinherit()
6757 traceTASK_PRIORITY_DISINHERIT( pxTCB, pxTCB->uxBasePriority ); in xTaskPriorityDisinherit()
6758 pxTCB->uxPriority = pxTCB->uxBasePriority; in xTaskPriorityDisinherit()
6763 …listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickT… in xTaskPriorityDisinherit()
6771 prvYieldCore( pxTCB->xTaskRunState ); in xTaskPriorityDisinherit()
6807 /*-----------------------------------------------------------*/
6824 configASSERT( pxTCB->uxMutexesHeld ); in vTaskPriorityDisinheritAfterTimeout()
6830 if( pxTCB->uxBasePriority < uxHighestPriorityWaitingTask ) in vTaskPriorityDisinheritAfterTimeout()
6836 uxPriorityToUse = pxTCB->uxBasePriority; in vTaskPriorityDisinheritAfterTimeout()
6840 if( pxTCB->uxPriority != uxPriorityToUse ) in vTaskPriorityDisinheritAfterTimeout()
6846 if( pxTCB->uxMutexesHeld == uxOnlyOneMutexHeld ) in vTaskPriorityDisinheritAfterTimeout()
6857 uxPriorityUsedOnEntry = pxTCB->uxPriority; in vTaskPriorityDisinheritAfterTimeout()
6858 pxTCB->uxPriority = uxPriorityToUse; in vTaskPriorityDisinheritAfterTimeout()
6862 …if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) =… in vTaskPriorityDisinheritAfterTimeout()
6864 …listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickT… in vTaskPriorityDisinheritAfterTimeout()
6877 …_CONTAINED_WITHIN( &( pxReadyTasksLists[ uxPriorityUsedOnEntry ] ), &( pxTCB->xStateListItem ) ) !… in vTaskPriorityDisinheritAfterTimeout()
6879 if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) in vTaskPriorityDisinheritAfterTimeout()
6884 portRESET_READY_PRIORITY( pxTCB->uxPriority, uxTopReadyPriority ); in vTaskPriorityDisinheritAfterTimeout()
6898 prvYieldCore( pxTCB->xTaskRunState ); in vTaskPriorityDisinheritAfterTimeout()
6927 /*-----------------------------------------------------------*/
6952 /*-----------------------------------------------------------*/
6964 ( pxCurrentTCB->uxCriticalNesting )++; in vTaskEnterCritical()
6972 if( pxCurrentTCB->uxCriticalNesting == 1U ) in vTaskEnterCritical()
6986 /*-----------------------------------------------------------*/
7036 /*-----------------------------------------------------------*/
7068 /*-----------------------------------------------------------*/
7078 /* If pxCurrentTCB->uxCriticalNesting is zero then this function in vTaskExitCritical()
7080 configASSERT( pxCurrentTCB->uxCriticalNesting > 0U ); in vTaskExitCritical()
7086 if( pxCurrentTCB->uxCriticalNesting > 0U ) in vTaskExitCritical()
7088 ( pxCurrentTCB->uxCriticalNesting )--; in vTaskExitCritical()
7090 if( pxCurrentTCB->uxCriticalNesting == 0U ) in vTaskExitCritical()
7113 /*-----------------------------------------------------------*/
7174 /*-----------------------------------------------------------*/
7216 /*-----------------------------------------------------------*/
7230 … for( x = strlen( pcBuffer ); x < ( size_t ) ( ( size_t ) configMAX_TASK_NAME_LEN - 1U ); x++ ) in prvWriteNameToBuffer()
7243 /*-----------------------------------------------------------*/
7271 * on top of stack - not the number of bytes. in vTaskListTasks()
7277 * many of the FreeRTOS/Demo sub-directories in a file called in vTaskListTasks()
7278 * printf-stdarg.c (note printf-stdarg.c does not provide a full in vTaskListTasks()
7298 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in vTaskListTasks()
7346 … uxConsumedBufferLength = uxConsumedBufferLength + ( configMAX_TASK_NAME_LEN - 1U ); in vTaskListTasks()
7348 /* Is there space left in the buffer? -1 is done because snprintf in vTaskListTasks()
7350 * checking if the buffer has space to write at least one non-null in vTaskListTasks()
7352 if( uxConsumedBufferLength < ( uxBufferLength - 1U ) ) in vTaskListTasks()
7357 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-216 */ in vTaskListTasks()
7360 … uxBufferLength - uxConsumedBufferLength, in vTaskListTasks()
7369 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-216 */ in vTaskListTasks()
7372 … uxBufferLength - uxConsumedBufferLength, in vTaskListTasks()
7379 … prvSnprintfReturnValueToCharsWritten( iSnprintfReturnValue, uxBufferLength - uxConsumedBufferLeng… in vTaskListTasks()
7413 /*----------------------------------------------------------*/
7447 * snprintf() is provided in many of the FreeRTOS/Demo sub-directories in in vTaskGetRunTimeStatistics()
7448 * a file called printf-stdarg.c (note printf-stdarg.c does not provide in vTaskGetRunTimeStatistics()
7467 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */ in vTaskGetRunTimeStatistics()
7498 … uxConsumedBufferLength = uxConsumedBufferLength + ( configMAX_TASK_NAME_LEN - 1U ); in vTaskGetRunTimeStatistics()
7500 /* Is there space left in the buffer? -1 is done because snprintf in vTaskGetRunTimeStatistics()
7502 * checking if the buffer has space to write at least one non-null in vTaskGetRunTimeStatistics()
7504 if( uxConsumedBufferLength < ( uxBufferLength - 1U ) ) in vTaskGetRunTimeStatistics()
7511 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-216 */ in vTaskGetRunTimeStatistics()
7514 … uxBufferLength - uxConsumedBufferLength, in vTaskGetRunTimeStatistics()
7524 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-216 */ in vTaskGetRunTimeStatistics()
7527 … uxBufferLength - uxConsumedBufferLength, in vTaskGetRunTimeStatistics()
7541 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-216 */ in vTaskGetRunTimeStatistics()
7544 … uxBufferLength - uxConsumedBufferLength, in vTaskGetRunTimeStatistics()
7553 … /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-216 */ in vTaskGetRunTimeStatistics()
7556 … uxBufferLength - uxConsumedBufferLength, in vTaskGetRunTimeStatistics()
7563 … prvSnprintfReturnValueToCharsWritten( iSnprintfReturnValue, uxBufferLength - uxConsumedBufferLeng… in vTaskGetRunTimeStatistics()
7601 /*-----------------------------------------------------------*/
7609 uxReturn = listGET_LIST_ITEM_VALUE( &( pxCurrentTCB->xEventListItem ) ); in uxTaskResetEventItemValue()
7611 /* Reset the event list item to its normal value - so it can be used with in uxTaskResetEventItemValue()
7613 …LIST_ITEM_VALUE( &( pxCurrentTCB->xEventListItem ), ( ( TickType_t ) configMAX_PRIORITIES - ( Tick… in uxTaskResetEventItemValue()
7619 /*-----------------------------------------------------------*/
7635 ( pxTCB->uxMutexesHeld )++; in pvTaskIncrementMutexHeldCount()
7644 /*-----------------------------------------------------------*/
7661 /* Only block if the notification count is not already non-zero. */ in ulTaskGenericNotifyTake()
7662 if( pxCurrentTCB->ulNotifiedValue[ uxIndexToWaitOn ] == 0UL ) in ulTaskGenericNotifyTake()
7665 pxCurrentTCB->ucNotifyState[ uxIndexToWaitOn ] = taskWAITING_NOTIFICATION; in ulTaskGenericNotifyTake()
7679 * 2. Interrupt - ISR calls xTaskNotifyFromISR which adds the in ulTaskGenericNotifyTake()
7693 * 3. Interrupt - ISR calls xTaskNotifyFromISR which adds the in ulTaskGenericNotifyTake()
7735 ulReturn = pxCurrentTCB->ulNotifiedValue[ uxIndexToWaitOn ]; in ulTaskGenericNotifyTake()
7741 pxCurrentTCB->ulNotifiedValue[ uxIndexToWaitOn ] = ( uint32_t ) 0UL; in ulTaskGenericNotifyTake()
7745 pxCurrentTCB->ulNotifiedValue[ uxIndexToWaitOn ] = ulReturn - ( uint32_t ) 1; in ulTaskGenericNotifyTake()
7753 pxCurrentTCB->ucNotifyState[ uxIndexToWaitOn ] = taskNOT_WAITING_NOTIFICATION; in ulTaskGenericNotifyTake()
7763 /*-----------------------------------------------------------*/
7782 if( pxCurrentTCB->ucNotifyState[ uxIndexToWaitOn ] != taskNOTIFICATION_RECEIVED ) in xTaskGenericNotifyWait()
7787 pxCurrentTCB->ulNotifiedValue[ uxIndexToWaitOn ] &= ~ulBitsToClearOnEntry; in xTaskGenericNotifyWait()
7790 pxCurrentTCB->ucNotifyState[ uxIndexToWaitOn ] = taskWAITING_NOTIFICATION; in xTaskGenericNotifyWait()
7804 * 2. Interrupt - ISR calls xTaskNotifyFromISR which adds the in xTaskGenericNotifyWait()
7818 * 3. Interrupt - ISR calls xTaskNotifyFromISR which adds the in xTaskGenericNotifyWait()
7865 *pulNotificationValue = pxCurrentTCB->ulNotifiedValue[ uxIndexToWaitOn ]; in xTaskGenericNotifyWait()
7872 if( pxCurrentTCB->ucNotifyState[ uxIndexToWaitOn ] != taskNOTIFICATION_RECEIVED ) in xTaskGenericNotifyWait()
7881 pxCurrentTCB->ulNotifiedValue[ uxIndexToWaitOn ] &= ~ulBitsToClearOnExit; in xTaskGenericNotifyWait()
7885 pxCurrentTCB->ucNotifyState[ uxIndexToWaitOn ] = taskNOT_WAITING_NOTIFICATION; in xTaskGenericNotifyWait()
7895 /*-----------------------------------------------------------*/
7919 *pulPreviousNotificationValue = pxTCB->ulNotifiedValue[ uxIndexToNotify ]; in xTaskGenericNotify()
7922 ucOriginalNotifyState = pxTCB->ucNotifyState[ uxIndexToNotify ]; in xTaskGenericNotify()
7924 pxTCB->ucNotifyState[ uxIndexToNotify ] = taskNOTIFICATION_RECEIVED; in xTaskGenericNotify()
7929 pxTCB->ulNotifiedValue[ uxIndexToNotify ] |= ulValue; in xTaskGenericNotify()
7933 ( pxTCB->ulNotifiedValue[ uxIndexToNotify ] )++; in xTaskGenericNotify()
7937 pxTCB->ulNotifiedValue[ uxIndexToNotify ] = ulValue; in xTaskGenericNotify()
7944 pxTCB->ulNotifiedValue[ uxIndexToNotify ] = ulValue; in xTaskGenericNotify()
7976 listREMOVE_ITEM( &( pxTCB->xStateListItem ) ); in xTaskGenericNotify()
7980 configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL ); in xTaskGenericNotify()
7991 * sleep mode at the earliest possible time - so reset in xTaskGenericNotify()
8015 /*-----------------------------------------------------------*/
8049 * simple as possible. More information (albeit Cortex-M specific) is in xTaskGenericNotifyFromISR()
8051 * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */ in xTaskGenericNotifyFromISR()
8060 *pulPreviousNotificationValue = pxTCB->ulNotifiedValue[ uxIndexToNotify ]; in xTaskGenericNotifyFromISR()
8063 ucOriginalNotifyState = pxTCB->ucNotifyState[ uxIndexToNotify ]; in xTaskGenericNotifyFromISR()
8064 pxTCB->ucNotifyState[ uxIndexToNotify ] = taskNOTIFICATION_RECEIVED; in xTaskGenericNotifyFromISR()
8069 pxTCB->ulNotifiedValue[ uxIndexToNotify ] |= ulValue; in xTaskGenericNotifyFromISR()
8073 ( pxTCB->ulNotifiedValue[ uxIndexToNotify ] )++; in xTaskGenericNotifyFromISR()
8077 pxTCB->ulNotifiedValue[ uxIndexToNotify ] = ulValue; in xTaskGenericNotifyFromISR()
8084 pxTCB->ulNotifiedValue[ uxIndexToNotify ] = ulValue; in xTaskGenericNotifyFromISR()
8116 configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL ); in xTaskGenericNotifyFromISR()
8120 listREMOVE_ITEM( &( pxTCB->xStateListItem ) ); in xTaskGenericNotifyFromISR()
8127 listINSERT_END( &( xPendingReadyList ), &( pxTCB->xEventListItem ) ); in xTaskGenericNotifyFromISR()
8132 if( pxTCB->uxPriority > pxCurrentTCB->uxPriority ) in xTaskGenericNotifyFromISR()
8178 /*-----------------------------------------------------------*/
8208 * simple as possible. More information (albeit Cortex-M specific) is in vTaskGenericNotifyGiveFromISR()
8210 * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */ in vTaskGenericNotifyGiveFromISR()
8217 ucOriginalNotifyState = pxTCB->ucNotifyState[ uxIndexToNotify ]; in vTaskGenericNotifyGiveFromISR()
8218 pxTCB->ucNotifyState[ uxIndexToNotify ] = taskNOTIFICATION_RECEIVED; in vTaskGenericNotifyGiveFromISR()
8222 ( pxTCB->ulNotifiedValue[ uxIndexToNotify ] )++; in vTaskGenericNotifyGiveFromISR()
8231 configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL ); in vTaskGenericNotifyGiveFromISR()
8235 listREMOVE_ITEM( &( pxTCB->xStateListItem ) ); in vTaskGenericNotifyGiveFromISR()
8242 listINSERT_END( &( xPendingReadyList ), &( pxTCB->xEventListItem ) ); in vTaskGenericNotifyGiveFromISR()
8247 if( pxTCB->uxPriority > pxCurrentTCB->uxPriority ) in vTaskGenericNotifyGiveFromISR()
8291 /*-----------------------------------------------------------*/
8311 if( pxTCB->ucNotifyState[ uxIndexToClear ] == taskNOTIFICATION_RECEIVED ) in xTaskGenericNotifyStateClear()
8313 pxTCB->ucNotifyState[ uxIndexToClear ] = taskNOT_WAITING_NOTIFICATION; in xTaskGenericNotifyStateClear()
8329 /*-----------------------------------------------------------*/
8352 ulReturn = pxTCB->ulNotifiedValue[ uxIndexToClear ]; in ulTaskGenericNotifyValueClear()
8353 pxTCB->ulNotifiedValue[ uxIndexToClear ] &= ~ulBitsToClear; in ulTaskGenericNotifyValueClear()
8363 /*-----------------------------------------------------------*/
8375 traceRETURN_ulTaskGetRunTimeCounter( pxTCB->ulRunTimeCounter ); in ulTaskGetRunTimeCounter()
8377 return pxTCB->ulRunTimeCounter; in ulTaskGetRunTimeCounter()
8381 /*-----------------------------------------------------------*/
8401 ulReturn = pxTCB->ulRunTimeCounter / ulTotalTime; in ulTaskGetRunTimePercent()
8414 /*-----------------------------------------------------------*/
8427 ulReturn += xIdleTaskHandles[ i ]->ulRunTimeCounter; in ulTaskGetIdleRunTimeCounter()
8436 /*-----------------------------------------------------------*/
8458 ulRunTimeCounter += xIdleTaskHandles[ i ]->ulRunTimeCounter; in ulTaskGetIdleRunTimePercent()
8474 /*-----------------------------------------------------------*/
8489 pxCurrentTCB->ucDelayAborted = pdFALSE; in prvAddCurrentTaskToDelayedList()
8495 if( uxListRemove( &( pxCurrentTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) in prvAddCurrentTaskToDelayedList()
8499 portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority ); in prvAddCurrentTaskToDelayedList()
8513 listINSERT_END( &xSuspendedTaskList, &( pxCurrentTCB->xStateListItem ) ); in prvAddCurrentTaskToDelayedList()
8523 listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake ); in prvAddCurrentTaskToDelayedList()
8530 vListInsert( pxOverflowDelayedList, &( pxCurrentTCB->xStateListItem ) ); in prvAddCurrentTaskToDelayedList()
8537 vListInsert( pxDelayedList, &( pxCurrentTCB->xStateListItem ) ); in prvAddCurrentTaskToDelayedList()
8561 listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake ); in prvAddCurrentTaskToDelayedList()
8567 vListInsert( pxOverflowDelayedList, &( pxCurrentTCB->xStateListItem ) ); in prvAddCurrentTaskToDelayedList()
8573 vListInsert( pxDelayedList, &( pxCurrentTCB->xStateListItem ) ); in prvAddCurrentTaskToDelayedList()
8593 /*-----------------------------------------------------------*/
8605 traceRETURN_xTaskGetMPUSettings( &( pxTCB->xMPUSettings ) ); in xTaskGetMPUSettings()
8607 return &( pxTCB->xMPUSettings ); in xTaskGetMPUSettings()
8611 /*-----------------------------------------------------------*/
8634 /*-----------------------------------------------------------*/
8664 static StaticTask_t xIdleTaskTCBs[ configNUMBER_OF_CORES - 1 ]; in vApplicationGetPassiveIdleTaskMemory()
8665 … static StackType_t uxIdleTaskStacks[ configNUMBER_OF_CORES - 1 ][ configMINIMAL_STACK_SIZE ]; in vApplicationGetPassiveIdleTaskMemory()
8675 /*-----------------------------------------------------------*/
8699 /*-----------------------------------------------------------*/