/*\r
- FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.\r
+ FreeRTOS V9.0.0rc2 - Copyright (C) 2016 Real Time Engineers Ltd.\r
All rights reserved\r
\r
VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
#include <stdio.h>\r
#endif /* configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) */\r
\r
-/* Sanity check the configuration. */\r
-#if( configUSE_TICKLESS_IDLE != 0 )\r
- #if( INCLUDE_vTaskSuspend != 1 )\r
- #error INCLUDE_vTaskSuspend must be set to 1 if configUSE_TICKLESS_IDLE is not set to 0\r
- #endif /* INCLUDE_vTaskSuspend */\r
-#endif /* configUSE_TICKLESS_IDLE */\r
-\r
-#if( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION != 1 ) )\r
- #error configSUPPORT_STATIC_ALLOCATION must be set to 1 in FreeRTOSConfig.h when the MPU is used.\r
-#endif\r
-\r
-/*\r
- * Defines the size, in words, of the stack allocated to the idle task.\r
- */\r
-#define tskIDLE_STACK_SIZE configMINIMAL_STACK_SIZE\r
-\r
#if( configUSE_PREEMPTION == 0 )\r
/* If the cooperative scheduler is being used then a yield should not be\r
performed just because a higher priority task has been woken. */\r
#define taskYIELD_IF_USING_PREEMPTION() portYIELD_WITHIN_API()\r
#endif\r
\r
-/* Bits that can be set in tskTCB->ucStaticAllocationFlags to indicate that the\r
-stack and TCB were statically allocated respectively. When these are statically\r
-allocated they won't be freed if the task using the stack and TCB gets\r
-deleted. */\r
-#define taskSTATICALLY_ALLOCATED_STACK ( ( uint8_t ) 0x01 )\r
-#define taskSTATICALLY_ALLOCATED_TCB ( ( uint8_t ) 0x02 )\r
-\r
/* Values that can be assigned to the ucNotifyState member of the TCB. */\r
#define taskNOT_WAITING_NOTIFICATION ( ( uint8_t ) 0 )\r
#define taskWAITING_NOTIFICATION ( ( uint8_t ) 1 )\r
#define taskNOTIFICATION_RECEIVED ( ( uint8_t ) 2 )\r
\r
-/*\r
- * Task control block. A task control block (TCB) is allocated for each task,\r
- * and stores task state information, including a pointer to the task's context\r
- * (the task's run time environment, including register values)\r
- */\r
-typedef struct tskTaskControlBlock\r
-{\r
- 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. */\r
-\r
- #if ( portUSING_MPU_WRAPPERS == 1 )\r
- xMPU_SETTINGS xMPUSettings; /*< The MPU settings are defined as part of the port layer. THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */\r
- #endif\r
-\r
- ListItem_t xGenericListItem; /*< The list that the state list item of a task is reference from denotes the state of that task (Ready, Blocked, Suspended ). */\r
- ListItem_t xEventListItem; /*< Used to reference a task from an event list. */\r
- UBaseType_t uxPriority; /*< The priority of the task. 0 is the lowest priority. */\r
- StackType_t *pxStack; /*< Points to the start of the stack. */\r
- 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. */\r
-\r
- #if ( portSTACK_GROWTH > 0 )\r
- StackType_t *pxEndOfStack; /*< Points to the end of the stack on architectures where the stack grows up from low memory. */\r
- #endif\r
-\r
- #if ( portCRITICAL_NESTING_IN_TCB == 1 )\r
- UBaseType_t uxCriticalNesting; /*< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */\r
- #endif\r
-\r
- #if ( configUSE_TRACE_FACILITY == 1 )\r
- 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. */\r
- UBaseType_t uxTaskNumber; /*< Stores a number specifically for use by third party trace code. */\r
- #endif\r
-\r
- #if ( configUSE_MUTEXES == 1 )\r
- UBaseType_t uxBasePriority; /*< The priority last assigned to the task - used by the priority inheritance mechanism. */\r
- UBaseType_t uxMutexesHeld;\r
- #endif\r
-\r
- #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
- TaskHookFunction_t pxTaskTag;\r
- #endif\r
-\r
- #if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )\r
- void *pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];\r
- #endif\r
-\r
- #if( configGENERATE_RUN_TIME_STATS == 1 )\r
- uint32_t ulRunTimeCounter; /*< Stores the amount of time the task has spent in the Running state. */\r
- #endif\r
-\r
- #if ( configUSE_NEWLIB_REENTRANT == 1 )\r
- /* Allocate a Newlib reent structure that is specific to this task.\r
- Note Newlib support has been included by popular demand, but is not\r
- used by the FreeRTOS maintainers themselves. FreeRTOS is not\r
- responsible for resulting newlib operation. User must be familiar with\r
- newlib and must provide system-wide implementations of the necessary\r
- stubs. Be warned that (at the time of writing) the current newlib design\r
- implements a system-wide malloc() that must be provided with locks. */\r
- struct _reent xNewLib_reent;\r
- #endif\r
-\r
- #if( configUSE_TASK_NOTIFICATIONS == 1 )\r
- volatile uint32_t ulNotifiedValue;\r
- volatile uint8_t ucNotifyState;\r
- #endif\r
-\r
- #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
- uint8_t ucStaticAllocationFlags; /* Set to pdTRUE if the stack is a statically allocated array, and pdFALSE if the stack is dynamically allocated. */\r
- #endif\r
-\r
- #if( INCLUDE_xTaskAbortDelay == 1 )\r
- uint8_t ucDelayAborted;\r
- #endif\r
-\r
-} tskTCB;\r
-\r
-/* The old tskTCB name is maintained above then typedefed to the new TCB_t name\r
-below to enable the use of older kernel aware debuggers. */\r
-typedef tskTCB TCB_t;\r
-\r
-/*\r
- * Some kernel aware debuggers require the data the debugger needs access to be\r
- * global, rather than file scope.\r
- */\r
-#ifdef portREMOVE_STATIC_QUALIFIER\r
- #define static\r
-#endif\r
-\r
-/*lint -e956 A manual analysis and inspection has been used to determine which\r
-static variables must be declared volatile. */\r
-\r
-PRIVILEGED_DATA TCB_t * volatile pxCurrentTCB = NULL;\r
-\r
-/* Lists for ready and blocked tasks. --------------------*/\r
-PRIVILEGED_DATA static List_t pxReadyTasksLists[ configMAX_PRIORITIES ];/*< Prioritised ready tasks. */\r
-PRIVILEGED_DATA static List_t xDelayedTaskList1; /*< Delayed tasks. */\r
-PRIVILEGED_DATA static List_t xDelayedTaskList2; /*< Delayed tasks (two lists are used - one for delays that have overflowed the current tick count. */\r
-PRIVILEGED_DATA static List_t * volatile pxDelayedTaskList; /*< Points to the delayed task list currently being used. */\r
-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. */\r
-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. */\r
-\r
-#if ( INCLUDE_vTaskDelete == 1 )\r
-\r
- PRIVILEGED_DATA static List_t xTasksWaitingTermination; /*< Tasks that have been deleted - but their memory not yet freed. */\r
- PRIVILEGED_DATA static volatile UBaseType_t uxDeletedTasksWaitingCleanUp = ( UBaseType_t ) 0U;\r
-\r
-#endif\r
-\r
-#if ( INCLUDE_vTaskSuspend == 1 )\r
-\r
- PRIVILEGED_DATA static List_t xSuspendedTaskList; /*< Tasks that are currently suspended. */\r
-\r
-#endif\r
-\r
-/* Other file private variables. --------------------------------*/\r
-PRIVILEGED_DATA static volatile UBaseType_t uxCurrentNumberOfTasks = ( UBaseType_t ) 0U;\r
-PRIVILEGED_DATA static volatile TickType_t xTickCount = ( TickType_t ) 0U;\r
-PRIVILEGED_DATA static volatile UBaseType_t uxTopReadyPriority = tskIDLE_PRIORITY;\r
-PRIVILEGED_DATA static volatile BaseType_t xSchedulerRunning = pdFALSE;\r
-PRIVILEGED_DATA static volatile UBaseType_t uxPendedTicks = ( UBaseType_t ) 0U;\r
-PRIVILEGED_DATA static volatile BaseType_t xYieldPending = pdFALSE;\r
-PRIVILEGED_DATA static volatile BaseType_t xNumOfOverflows = ( BaseType_t ) 0;\r
-PRIVILEGED_DATA static UBaseType_t uxTaskNumber = ( UBaseType_t ) 0U;\r
-PRIVILEGED_DATA static volatile TickType_t xNextTaskUnblockTime = ( TickType_t ) 0U; /* Initialised to portMAX_DELAY before the scheduler starts. */\r
-PRIVILEGED_DATA static TaskHandle_t xIdleTaskHandle = NULL; /*< Holds the handle of the idle task. The idle task is created automatically when the scheduler is started. */\r
-\r
-/* Context switches are held pending while the scheduler is suspended. Also,\r
-interrupts must not manipulate the xGenericListItem of a TCB, or any of the\r
-lists the xGenericListItem can be referenced from, if the scheduler is suspended.\r
-If an interrupt needs to unblock a task while the scheduler is suspended then it\r
-moves the task's event list item into the xPendingReadyList, ready for the\r
-kernel to move the task from the pending ready list into the real ready list\r
-when the scheduler is unsuspended. The pending ready list itself can only be\r
-accessed from a critical section. */\r
-PRIVILEGED_DATA static volatile UBaseType_t uxSchedulerSuspended = ( UBaseType_t ) pdFALSE;\r
-\r
-#if ( configGENERATE_RUN_TIME_STATS == 1 )\r
-\r
- PRIVILEGED_DATA static uint32_t ulTaskSwitchedInTime = 0UL; /*< Holds the value of a timer/counter the last time a task was switched in. */\r
- PRIVILEGED_DATA static uint32_t ulTotalRunTime = 0UL; /*< Holds the total amount of execution time as defined by the run time counter clock. */\r
-\r
-#endif\r
-\r
-/*lint +e956 */\r
-\r
-/* Debugging and trace facilities private variables and macros. ------------*/\r
-\r
/*\r
* The value used to fill the stack of a task when the task is created. This\r
* is used purely for checking the high water mark for tasks.\r
#define tskDELETED_CHAR ( 'D' )\r
#define tskSUSPENDED_CHAR ( 'S' )\r
\r
-/*-----------------------------------------------------------*/\r
+/*\r
+ * Some kernel aware debuggers require the data the debugger needs access to be\r
+ * global, rather than file scope.\r
+ */\r
+#ifdef portREMOVE_STATIC_QUALIFIER\r
+ #define static\r
+#endif\r
\r
#if ( configUSE_PORT_OPTIMISED_TASK_SELECTION == 0 )\r
\r
\r
#define taskSELECT_HIGHEST_PRIORITY_TASK() \\r
{ \\r
+ UBaseType_t uxTopPriority = uxTopReadyPriority; \\r
+ \\r
/* Find the highest priority queue that contains ready tasks. */ \\r
- while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopReadyPriority ] ) ) ) \\r
+ while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopPriority ] ) ) ) \\r
{ \\r
- configASSERT( uxTopReadyPriority ); \\r
- --uxTopReadyPriority; \\r
+ configASSERT( uxTopPriority ); \\r
+ --uxTopPriority; \\r
} \\r
\\r
/* listGET_OWNER_OF_NEXT_ENTRY indexes through the list, so the tasks of \\r
the same priority get an equal share of the processor time. */ \\r
- listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopReadyPriority ] ) ); \\r
+ listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) ); \\r
+ uxTopReadyPriority = uxTopPriority; \\r
} /* taskSELECT_HIGHEST_PRIORITY_TASK */\r
\r
/*-----------------------------------------------------------*/\r
#define prvAddTaskToReadyList( pxTCB ) \\r
traceMOVED_TASK_TO_READY_STATE( pxTCB ); \\r
taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority ); \\r
- vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xGenericListItem ) ); \\r
+ vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xStateListItem ) ); \\r
tracePOST_MOVED_TASK_TO_READY_STATE( pxTCB )\r
/*-----------------------------------------------------------*/\r
\r
#define taskEVENT_LIST_ITEM_VALUE_IN_USE 0x80000000UL\r
#endif\r
\r
+/*\r
+ * Task control block. A task control block (TCB) is allocated for each task,\r
+ * and stores task state information, including a pointer to the task's context\r
+ * (the task's run time environment, including register values)\r
+ */\r
+typedef struct tskTaskControlBlock\r
+{\r
+ 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. */\r
+\r
+ #if ( portUSING_MPU_WRAPPERS == 1 )\r
+ xMPU_SETTINGS xMPUSettings; /*< The MPU settings are defined as part of the port layer. THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */\r
+ #endif\r
+\r
+ 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 ). */\r
+ ListItem_t xEventListItem; /*< Used to reference a task from an event list. */\r
+ UBaseType_t uxPriority; /*< The priority of the task. 0 is the lowest priority. */\r
+ StackType_t *pxStack; /*< Points to the start of the stack. */\r
+ 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. */\r
+\r
+ #if ( portSTACK_GROWTH > 0 )\r
+ StackType_t *pxEndOfStack; /*< Points to the end of the stack on architectures where the stack grows up from low memory. */\r
+ #endif\r
+\r
+ #if ( portCRITICAL_NESTING_IN_TCB == 1 )\r
+ UBaseType_t uxCriticalNesting; /*< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */\r
+ #endif\r
+\r
+ #if ( configUSE_TRACE_FACILITY == 1 )\r
+ 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. */\r
+ UBaseType_t uxTaskNumber; /*< Stores a number specifically for use by third party trace code. */\r
+ #endif\r
+\r
+ #if ( configUSE_MUTEXES == 1 )\r
+ UBaseType_t uxBasePriority; /*< The priority last assigned to the task - used by the priority inheritance mechanism. */\r
+ UBaseType_t uxMutexesHeld;\r
+ #endif\r
+\r
+ #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
+ TaskHookFunction_t pxTaskTag;\r
+ #endif\r
+\r
+ #if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )\r
+ void *pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];\r
+ #endif\r
+\r
+ #if( configGENERATE_RUN_TIME_STATS == 1 )\r
+ uint32_t ulRunTimeCounter; /*< Stores the amount of time the task has spent in the Running state. */\r
+ #endif\r
+\r
+ #if ( configUSE_NEWLIB_REENTRANT == 1 )\r
+ /* Allocate a Newlib reent structure that is specific to this task.\r
+ Note Newlib support has been included by popular demand, but is not\r
+ used by the FreeRTOS maintainers themselves. FreeRTOS is not\r
+ responsible for resulting newlib operation. User must be familiar with\r
+ newlib and must provide system-wide implementations of the necessary\r
+ stubs. Be warned that (at the time of writing) the current newlib design\r
+ implements a system-wide malloc() that must be provided with locks. */\r
+ struct _reent xNewLib_reent;\r
+ #endif\r
+\r
+ #if( configUSE_TASK_NOTIFICATIONS == 1 )\r
+ volatile uint32_t ulNotifiedValue;\r
+ volatile uint8_t ucNotifyState;\r
+ #endif\r
+\r
+ #if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
+ uint8_t ucStaticallyAllocated; /* Set to pdTRUE if the task is a statically allocated to ensure no attempt is made to free the memory. */\r
+ #endif\r
+\r
+ #if( INCLUDE_xTaskAbortDelay == 1 )\r
+ uint8_t ucDelayAborted;\r
+ #endif\r
+\r
+} tskTCB;\r
+\r
+/* The old tskTCB name is maintained above then typedefed to the new TCB_t name\r
+below to enable the use of older kernel aware debuggers. */\r
+typedef tskTCB TCB_t;\r
+\r
+/*lint -e956 A manual analysis and inspection has been used to determine which\r
+static variables must be declared volatile. */\r
+\r
+PRIVILEGED_DATA TCB_t * volatile pxCurrentTCB = NULL;\r
+\r
+/* Lists for ready and blocked tasks. --------------------*/\r
+PRIVILEGED_DATA static List_t pxReadyTasksLists[ configMAX_PRIORITIES ];/*< Prioritised ready tasks. */\r
+PRIVILEGED_DATA static List_t xDelayedTaskList1; /*< Delayed tasks. */\r
+PRIVILEGED_DATA static List_t xDelayedTaskList2; /*< Delayed tasks (two lists are used - one for delays that have overflowed the current tick count. */\r
+PRIVILEGED_DATA static List_t * volatile pxDelayedTaskList; /*< Points to the delayed task list currently being used. */\r
+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. */\r
+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. */\r
+\r
+#if( INCLUDE_vTaskDelete == 1 )\r
+\r
+ PRIVILEGED_DATA static List_t xTasksWaitingTermination; /*< Tasks that have been deleted - but their memory not yet freed. */\r
+ PRIVILEGED_DATA static volatile UBaseType_t uxDeletedTasksWaitingCleanUp = ( UBaseType_t ) 0U;\r
+\r
+#endif\r
+\r
+#if ( INCLUDE_vTaskSuspend == 1 )\r
+\r
+ PRIVILEGED_DATA static List_t xSuspendedTaskList; /*< Tasks that are currently suspended. */\r
+\r
+#endif\r
+\r
+/* Other file private variables. --------------------------------*/\r
+PRIVILEGED_DATA static volatile UBaseType_t uxCurrentNumberOfTasks = ( UBaseType_t ) 0U;\r
+PRIVILEGED_DATA static volatile TickType_t xTickCount = ( TickType_t ) 0U;\r
+PRIVILEGED_DATA static volatile UBaseType_t uxTopReadyPriority = tskIDLE_PRIORITY;\r
+PRIVILEGED_DATA static volatile BaseType_t xSchedulerRunning = pdFALSE;\r
+PRIVILEGED_DATA static volatile UBaseType_t uxPendedTicks = ( UBaseType_t ) 0U;\r
+PRIVILEGED_DATA static volatile BaseType_t xYieldPending = pdFALSE;\r
+PRIVILEGED_DATA static volatile BaseType_t xNumOfOverflows = ( BaseType_t ) 0;\r
+PRIVILEGED_DATA static UBaseType_t uxTaskNumber = ( UBaseType_t ) 0U;\r
+PRIVILEGED_DATA static volatile TickType_t xNextTaskUnblockTime = ( TickType_t ) 0U; /* Initialised to portMAX_DELAY before the scheduler starts. */\r
+PRIVILEGED_DATA static TaskHandle_t xIdleTaskHandle = NULL; /*< Holds the handle of the idle task. The idle task is created automatically when the scheduler is started. */\r
+\r
+/* Context switches are held pending while the scheduler is suspended. Also,\r
+interrupts must not manipulate the xStateListItem of a TCB, or any of the\r
+lists the xStateListItem can be referenced from, if the scheduler is suspended.\r
+If an interrupt needs to unblock a task while the scheduler is suspended then it\r
+moves the task's event list item into the xPendingReadyList, ready for the\r
+kernel to move the task from the pending ready list into the real ready list\r
+when the scheduler is unsuspended. The pending ready list itself can only be\r
+accessed from a critical section. */\r
+PRIVILEGED_DATA static volatile UBaseType_t uxSchedulerSuspended = ( UBaseType_t ) pdFALSE;\r
+\r
+#if ( configGENERATE_RUN_TIME_STATS == 1 )\r
+\r
+ PRIVILEGED_DATA static uint32_t ulTaskSwitchedInTime = 0UL; /*< Holds the value of a timer/counter the last time a task was switched in. */\r
+ PRIVILEGED_DATA static uint32_t ulTotalRunTime = 0UL; /*< Holds the total amount of execution time as defined by the run time counter clock. */\r
+\r
+#endif\r
+\r
+/*lint +e956 */\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
/* Callback function prototypes. --------------------------*/\r
#if( configCHECK_FOR_STACK_OVERFLOW > 0 )\r
extern void vApplicationStackOverflowHook( TaskHandle_t xTask, char *pcTaskName );\r
\r
/* File private functions. --------------------------------*/\r
\r
-/*\r
- * Utility to ready a TCB for a given task. Mainly just copies the parameters\r
- * into the TCB structure.\r
- */\r
-static void prvInitialiseTCBVariables( TCB_t * const pxTCB, const char * const pcName, UBaseType_t uxPriority, const MemoryRegion_t * const xRegions, const uint16_t usStackDepth ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
-\r
/**\r
* Utility task that simply returns pdTRUE if the task referenced by xTask is\r
* currently in the Suspended state, or pdFALSE if the task referenced by xTask\r
*/\r
static void prvAddCurrentTaskToDelayedList( TickType_t xTicksToWait, const BaseType_t xCanBlockIndefinitely ) PRIVILEGED_FUNCTION;\r
\r
-/*\r
- * Allocates memory from the heap for a TCB and associated stack. Checks the\r
- * allocation was successful.\r
- */\r
-static TCB_t *prvAllocateTCBAndStack( const uint16_t usStackDepth, StackType_t * const puxStackBuffer, TCB_t * const pucTCBBuffer ) PRIVILEGED_FUNCTION;\r
-\r
/*\r
* Fills an TaskStatus_t structure with information on each task that is\r
* referenced from the pxList list (which may be a ready list, a delayed list,\r
*/\r
#if ( INCLUDE_xTaskGetTaskHandle == 1 )\r
\r
- static TCB_t *prvSearchForNameWithinSingleList( List_t *pxList, const char pcNameToQuery[] );\r
+ static TCB_t *prvSearchForNameWithinSingleList( List_t *pxList, const char pcNameToQuery[] ) PRIVILEGED_FUNCTION;\r
\r
#endif\r
\r
* Helper function used to pad task names with spaces when printing out\r
* human readable tables of task information.\r
*/\r
- static char *prvWriteNameToBuffer( char *pcBuffer, const char *pcTaskName );\r
+ static char *prvWriteNameToBuffer( char *pcBuffer, const char *pcTaskName ) PRIVILEGED_FUNCTION;\r
\r
#endif\r
+\r
+/*\r
+ * Called after a Task_t structure has been allocated either statically or\r
+ * dynamically to fill in the structure's members.\r
+ */\r
+static void prvInitialiseNewTask( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, TCB_t *pxNewTCB ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
+\r
+/*\r
+ * Called after a new task has been created and initialised to place the task\r
+ * under the control of the scheduler.\r
+ */\r
+static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB ) PRIVILEGED_FUNCTION;\r
+\r
/*-----------------------------------------------------------*/\r
\r
-BaseType_t xTaskGenericCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, StackType_t * const puxStackBuffer, StaticTask_t * const pxTaskBuffer, const MemoryRegion_t * const xRegions ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
-{\r
-BaseType_t xReturn;\r
-TCB_t * pxNewTCB;\r
-StackType_t *pxTopOfStack;\r
+#if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
+\r
+ BaseType_t xTaskCreateStatic( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, StackType_t * const puxStackBuffer, StaticTask_t * const pxTaskBuffer ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
+ {\r
+ TCB_t *pxNewTCB;\r
+ BaseType_t xReturn;\r
+\r
+ configASSERT( puxStackBuffer != NULL );\r
+ configASSERT( pxTaskBuffer != NULL );\r
+\r
+ if( ( pxTaskBuffer != NULL ) && ( puxStackBuffer != NULL ) )\r
+ {\r
+ /* The memory used for the task's TCB and stack are passed into this\r
+ function - use them. */\r
+ pxNewTCB = ( TCB_t * ) pxTaskBuffer; /*lint !e740 Unusual cast is ok as the structures are designed to have the same alignment, and the size is checked by an assert. */\r
+ pxNewTCB->pxStack = ( StackType_t * ) puxStackBuffer;\r
+\r
+ #if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
+ {\r
+ /* Tasks can be created statically or dynamically, so note this\r
+ task was created statically in case the task is later deleted. */\r
+ pxNewTCB->ucStaticallyAllocated = pdTRUE;\r
+ }\r
+ #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
+\r
+ prvInitialiseNewTask( pxTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB );\r
+ prvAddNewTaskToReadyList( pxNewTCB );\r
+ xReturn = pdPASS;\r
+ }\r
+ else\r
+ {\r
+ xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;\r
+ }\r
+\r
+ return xReturn;\r
+ }\r
\r
- configASSERT( pxTaskCode );\r
- configASSERT( ( ( uxPriority & ( UBaseType_t ) ( ~portPRIVILEGE_BIT ) ) < ( UBaseType_t ) configMAX_PRIORITIES ) );\r
+#endif /* SUPPORT_STATIC_ALLOCATION */\r
+/*-----------------------------------------------------------*/\r
\r
- /* Allocate the memory required by the TCB and stack for the new task,\r
- checking that the allocation was successful. */\r
- pxNewTCB = prvAllocateTCBAndStack( usStackDepth, puxStackBuffer, ( TCB_t* ) pxTaskBuffer ); /*lint !e740 Unusual cast is ok as the structures are designed to have the same alignment, and the size is checked by an assert. */\r
+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
\r
- if( pxNewTCB != NULL )\r
+ BaseType_t xTaskCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
{\r
- #if( portUSING_MPU_WRAPPERS == 1 )\r
- /* Should the task be created in privileged mode? */\r
- BaseType_t xRunPrivileged;\r
- if( ( uxPriority & portPRIVILEGE_BIT ) != 0U )\r
+ TCB_t *pxNewTCB;\r
+ BaseType_t xReturn;\r
+\r
+ /* If the stack grows down then allocate the stack then the TCB so the stack\r
+ does not grow into the TCB. Likewise if the stack grows up then allocate\r
+ the TCB then the stack. */\r
+ #if( portSTACK_GROWTH > 0 )\r
+ {\r
+ /* Allocate space for the TCB. Where the memory comes from depends on\r
+ the implementation of the port malloc function and whether or not static\r
+ allocation is being used. */\r
+ pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );\r
+\r
+ if( pxNewTCB != NULL )\r
+ {\r
+ /* Allocate space for the stack used by the task being created.\r
+ The base of the stack memory stored in the TCB so the task can\r
+ be deleted later if required. */\r
+ pxNewTCB->pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */\r
+\r
+ if( pxNewTCB->pxStack == NULL )\r
+ {\r
+ /* Could not allocate the stack. Delete the allocated TCB. */\r
+ vPortFree( pxNewTCB );\r
+ pxNewTCB = NULL;\r
+ }\r
+ }\r
+ }\r
+ #else /* portSTACK_GROWTH */\r
+ {\r
+ StackType_t *pxStack;\r
+\r
+ /* Allocate space for the stack used by the task being created. */\r
+ pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */\r
+\r
+ if( pxStack != NULL )\r
{\r
- xRunPrivileged = pdTRUE;\r
+ /* Allocate space for the TCB. */\r
+ pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); /*lint !e961 MISRA exception as the casts are only redundant for some paths. */\r
+\r
+ if( pxNewTCB != NULL )\r
+ {\r
+ /* Store the stack location in the TCB. */\r
+ pxNewTCB->pxStack = pxStack;\r
+ }\r
+ else\r
+ {\r
+ /* The stack cannot be used as the TCB was not created. Free\r
+ it again. */\r
+ vPortFree( pxStack );\r
+ }\r
}\r
else\r
{\r
- xRunPrivileged = pdFALSE;\r
+ pxNewTCB = NULL;\r
}\r
- uxPriority &= ~portPRIVILEGE_BIT;\r
- #endif /* portUSING_MPU_WRAPPERS == 1 */\r
+ }\r
+ #endif /* portSTACK_GROWTH */\r
\r
- /* Calculate the top of stack address. This depends on whether the\r
- stack grows from high memory to low (as per the 80x86) or vice versa.\r
- portSTACK_GROWTH is used to make the result positive or negative as\r
- required by the port. */\r
- #if( portSTACK_GROWTH < 0 )\r
+ if( pxNewTCB != NULL )\r
{\r
- pxTopOfStack = pxNewTCB->pxStack + ( usStackDepth - ( uint16_t ) 1 );\r
- pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) ); /*lint !e923 MISRA exception. Avoiding casts between pointers and integers is not practical. Size differences accounted for using portPOINTER_SIZE_TYPE type. */\r
+ #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
+ {\r
+ /* Tasks can be created statically or dynamically, so note this\r
+ task was created dynamically in case it is later deleted. */\r
+ pxNewTCB->ucStaticallyAllocated = pdFALSE;\r
+ }\r
+ #endif /* configSUPPORT_STATIC_ALLOCATION */\r
\r
- /* Check the alignment of the calculated top of stack is correct. */\r
- configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );\r
+ prvInitialiseNewTask( pxTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB );\r
+ prvAddNewTaskToReadyList( pxNewTCB );\r
+ xReturn = pdPASS;\r
}\r
- #else /* portSTACK_GROWTH */\r
+ else\r
{\r
- pxTopOfStack = pxNewTCB->pxStack;\r
+ xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;\r
+ }\r
\r
- /* Check the alignment of the stack buffer is correct. */\r
- configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxNewTCB->pxStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );\r
+ return xReturn;\r
+ }\r
\r
- /* If we want to use stack checking on architectures that use\r
- a positive stack growth direction then we also need to store the\r
- other extreme of the stack space. */\r
- pxNewTCB->pxEndOfStack = pxNewTCB->pxStack + ( usStackDepth - ( uint16_t ) 1 );\r
- }\r
- #endif /* portSTACK_GROWTH */\r
+#endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
+/*-----------------------------------------------------------*/\r
\r
- /* Setup the newly allocated TCB with the initial state of the task. */\r
- prvInitialiseTCBVariables( pxNewTCB, pcName, uxPriority, xRegions, usStackDepth );\r
+static void prvInitialiseNewTask( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, TCB_t *pxNewTCB ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
+{\r
+StackType_t *pxTopOfStack;\r
+UBaseType_t x;\r
\r
- /* Initialize the TCB stack to look as if the task was already running,\r
- but had been interrupted by the scheduler. The return address is set\r
- to the start of the task function. Once the stack has been initialised\r
- the top of stack variable is updated. */\r
- #if( portUSING_MPU_WRAPPERS == 1 )\r
+ #if( portUSING_MPU_WRAPPERS == 1 )\r
+ /* Should the task be created in privileged mode? */\r
+ BaseType_t xRunPrivileged;\r
+ if( ( uxPriority & portPRIVILEGE_BIT ) != 0U )\r
{\r
- pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters, xRunPrivileged );\r
+ xRunPrivileged = pdTRUE;\r
}\r
- #else /* portUSING_MPU_WRAPPERS */\r
+ else\r
{\r
- pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters );\r
+ xRunPrivileged = pdFALSE;\r
}\r
- #endif /* portUSING_MPU_WRAPPERS */\r
+ uxPriority &= ~portPRIVILEGE_BIT;\r
+ #endif /* portUSING_MPU_WRAPPERS == 1 */\r
+\r
+ /* Avoid dependency on memset() if it is not required. */\r
+ #if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )\r
+ {\r
+ /* Fill the stack with a known value to assist debugging. */\r
+ ( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) usStackDepth * sizeof( StackType_t ) );\r
+ }\r
+ #endif /* ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) ) ) */\r
+\r
+ /* Calculate the top of stack address. This depends on whether the stack\r
+ grows from high memory to low (as per the 80x86) or vice versa.\r
+ portSTACK_GROWTH is used to make the result positive or negative as required\r
+ by the port. */\r
+ #if( portSTACK_GROWTH < 0 )\r
+ {\r
+ pxTopOfStack = pxNewTCB->pxStack + ( usStackDepth - ( uint16_t ) 1 );\r
+ pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) ); /*lint !e923 MISRA exception. Avoiding casts between pointers and integers is not practical. Size differences accounted for using portPOINTER_SIZE_TYPE type. */\r
\r
- if( ( void * ) pxCreatedTask != NULL )\r
+ /* Check the alignment of the calculated top of stack is correct. */\r
+ configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );\r
+ }\r
+ #else /* portSTACK_GROWTH */\r
+ {\r
+ pxTopOfStack = pxNewTCB->pxStack;\r
+\r
+ /* Check the alignment of the stack buffer is correct. */\r
+ configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxNewTCB->pxStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );\r
+\r
+ /* The other extreme of the stack space is required if stack checking is\r
+ performed. */\r
+ pxNewTCB->pxEndOfStack = pxNewTCB->pxStack + ( usStackDepth - ( uint16_t ) 1 );\r
+ }\r
+ #endif /* portSTACK_GROWTH */\r
+\r
+ /* Store the task name in the TCB. */\r
+ for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )\r
+ {\r
+ pxNewTCB->pcTaskName[ x ] = pcName[ x ];\r
+\r
+ /* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter than\r
+ configMAX_TASK_NAME_LEN characters just in case the memory after the\r
+ string is not accessible (extremely unlikely). */\r
+ if( pcName[ x ] == 0x00 )\r
{\r
- /* Pass the TCB out - in an anonymous way. The calling function/\r
- task can use this as a handle to delete the task later if\r
- required.*/\r
- *pxCreatedTask = ( TaskHandle_t ) pxNewTCB;\r
+ break;\r
}\r
else\r
{\r
mtCOVERAGE_TEST_MARKER();\r
}\r
+ }\r
\r
- /* Ensure interrupts don't access the task lists while they are being\r
- updated. */\r
- taskENTER_CRITICAL();\r
+ /* Ensure the name string is terminated in the case that the string length\r
+ was greater or equal to configMAX_TASK_NAME_LEN. */\r
+ pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';\r
+\r
+ /* This is used as an array index so must ensure it's not too large. First\r
+ remove the privilege bit if one is present. */\r
+ if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )\r
+ {\r
+ uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+\r
+ pxNewTCB->uxPriority = uxPriority;\r
+ #if ( configUSE_MUTEXES == 1 )\r
+ {\r
+ pxNewTCB->uxBasePriority = uxPriority;\r
+ pxNewTCB->uxMutexesHeld = 0;\r
+ }\r
+ #endif /* configUSE_MUTEXES */\r
+\r
+ vListInitialiseItem( &( pxNewTCB->xStateListItem ) );\r
+ vListInitialiseItem( &( pxNewTCB->xEventListItem ) );\r
+\r
+ /* Set the pxNewTCB as a link back from the ListItem_t. This is so we can get\r
+ back to the containing TCB from a generic item in a list. */\r
+ listSET_LIST_ITEM_OWNER( &( pxNewTCB->xStateListItem ), pxNewTCB );\r
+\r
+ /* Event lists are always in priority order. */\r
+ 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. */\r
+ listSET_LIST_ITEM_OWNER( &( pxNewTCB->xEventListItem ), pxNewTCB );\r
+\r
+ #if ( portCRITICAL_NESTING_IN_TCB == 1 )\r
+ {\r
+ pxNewTCB->uxCriticalNesting = ( UBaseType_t ) 0U;\r
+ }\r
+ #endif /* portCRITICAL_NESTING_IN_TCB */\r
+\r
+ #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
+ {\r
+ pxNewTCB->pxTaskTag = NULL;\r
+ }\r
+ #endif /* configUSE_APPLICATION_TASK_TAG */\r
+\r
+ #if ( configGENERATE_RUN_TIME_STATS == 1 )\r
+ {\r
+ pxNewTCB->ulRunTimeCounter = 0UL;\r
+ }\r
+ #endif /* configGENERATE_RUN_TIME_STATS */\r
+\r
+ #if ( portUSING_MPU_WRAPPERS == 1 )\r
+ {\r
+ vPortStoreTaskMPUSettings( &( pxNewTCB->xMPUSettings ), xRegions, pxNewTCB->pxStack, usStackDepth );\r
+ }\r
+ #endif\r
+\r
+ #if( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )\r
+ {\r
+ for( x = 0; x < ( UBaseType_t ) configNUM_THREAD_LOCAL_STORAGE_POINTERS; x++ )\r
{\r
- uxCurrentNumberOfTasks++;\r
- if( pxCurrentTCB == NULL )\r
- {\r
- /* There are no other tasks, or all the other tasks are in\r
- the suspended state - make this the current task. */\r
- pxCurrentTCB = pxNewTCB;\r
+ pxNewTCB->pvThreadLocalStoragePointers[ x ] = NULL;\r
+ }\r
+ }\r
+ #endif\r
\r
- if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 )\r
- {\r
- /* This is the first task to be created so do the preliminary\r
- initialisation required. We will not recover if this call\r
- fails, but we will report the failure. */\r
- prvInitialiseTaskLists();\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
+ #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
+ {\r
+ pxNewTCB->ulNotifiedValue = 0;\r
+ pxNewTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;\r
+ }\r
+ #endif\r
+\r
+ #if ( configUSE_NEWLIB_REENTRANT == 1 )\r
+ {\r
+ /* Initialise this task's Newlib reent structure. */\r
+ _REENT_INIT_PTR( ( &( pxNewTCB->xNewLib_reent ) ) );\r
+ }\r
+ #endif\r
+\r
+ #if( INCLUDE_xTaskAbortDelay == 1 )\r
+ {\r
+ pxNewTCB->ucDelayAborted = pdFALSE;\r
+ }\r
+ #endif\r
+\r
+ /* Initialize the TCB stack to look as if the task was already running,\r
+ but had been interrupted by the scheduler. The return address is set\r
+ to the start of the task function. Once the stack has been initialised\r
+ the top of stack variable is updated. */\r
+ #if( portUSING_MPU_WRAPPERS == 1 )\r
+ {\r
+ pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters, xRunPrivileged );\r
+ }\r
+ #else /* portUSING_MPU_WRAPPERS */\r
+ {\r
+ pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters );\r
+ }\r
+ #endif /* portUSING_MPU_WRAPPERS */\r
+\r
+ if( ( void * ) pxCreatedTask != NULL )\r
+ {\r
+ /* Pass the handle out in an anonymous way. The handle can be used to\r
+ change the created task's priority, delete the created task, etc.*/\r
+ *pxCreatedTask = ( TaskHandle_t ) pxNewTCB;\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB )\r
+{\r
+ /* Ensure interrupts don't access the task lists while the lists are being\r
+ updated. */\r
+ taskENTER_CRITICAL();\r
+ {\r
+ uxCurrentNumberOfTasks++;\r
+ if( pxCurrentTCB == NULL )\r
+ {\r
+ /* There are no other tasks, or all the other tasks are in\r
+ the suspended state - make this the current task. */\r
+ pxCurrentTCB = pxNewTCB;\r
+\r
+ if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 )\r
+ {\r
+ /* This is the first task to be created so do the preliminary\r
+ initialisation required. We will not recover if this call\r
+ fails, but we will report the failure. */\r
+ prvInitialiseTaskLists();\r
}\r
else\r
{\r
- /* If the scheduler is not already running, make this task the\r
- current task if it is the highest priority task to be created\r
- so far. */\r
- if( xSchedulerRunning == pdFALSE )\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+ }\r
+ else\r
+ {\r
+ /* If the scheduler is not already running, make this task the\r
+ current task if it is the highest priority task to be created\r
+ so far. */\r
+ if( xSchedulerRunning == pdFALSE )\r
+ {\r
+ if( pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority )\r
{\r
- if( pxCurrentTCB->uxPriority <= uxPriority )\r
- {\r
- pxCurrentTCB = pxNewTCB;\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
+ pxCurrentTCB = pxNewTCB;\r
}\r
else\r
{\r
mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
-\r
- uxTaskNumber++;\r
-\r
- #if ( configUSE_TRACE_FACILITY == 1 )\r
+ else\r
{\r
- /* Add a counter into the TCB for tracing only. */\r
- pxNewTCB->uxTCBNumber = uxTaskNumber;\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
- #endif /* configUSE_TRACE_FACILITY */\r
- traceTASK_CREATE( pxNewTCB );\r
+ }\r
\r
- prvAddTaskToReadyList( pxNewTCB );\r
+ uxTaskNumber++;\r
\r
- xReturn = pdPASS;\r
- portSETUP_TCB( pxNewTCB );\r
+ #if ( configUSE_TRACE_FACILITY == 1 )\r
+ {\r
+ /* Add a counter into the TCB for tracing only. */\r
+ pxNewTCB->uxTCBNumber = uxTaskNumber;\r
}\r
- taskEXIT_CRITICAL();\r
- }\r
- else\r
- {\r
- xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;\r
- traceTASK_CREATE_FAILED();\r
+ #endif /* configUSE_TRACE_FACILITY */\r
+ traceTASK_CREATE( pxNewTCB );\r
+\r
+ prvAddTaskToReadyList( pxNewTCB );\r
+\r
+ portSETUP_TCB( pxNewTCB );\r
}\r
+ taskEXIT_CRITICAL();\r
\r
- if( xReturn == pdPASS )\r
+ if( xSchedulerRunning != pdFALSE )\r
{\r
- if( xSchedulerRunning != pdFALSE )\r
+ /* If the created task is of a higher priority than the current task\r
+ then it should run now. */\r
+ if( pxCurrentTCB->uxPriority < pxNewTCB->uxPriority )\r
{\r
- /* If the created task is of a higher priority than the current task\r
- then it should run now. */\r
- if( pxCurrentTCB->uxPriority < uxPriority )\r
- {\r
- taskYIELD_IF_USING_PREEMPTION();\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
+ taskYIELD_IF_USING_PREEMPTION();\r
}\r
else\r
{\r
mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
-\r
- return xReturn;\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
}\r
/*-----------------------------------------------------------*/\r
\r
pxTCB = prvGetTCBFromHandle( xTaskToDelete );\r
\r
/* Remove task from the ready list. */\r
- if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )\r
+ if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )\r
{\r
taskRESET_READY_PRIORITY( pxTCB->uxPriority );\r
}\r
Place the task in the termination list. The idle task will\r
check the termination list and free up any memory allocated by\r
the scheduler for the TCB and stack of the deleted task. */\r
- vListInsertEnd( &xTasksWaitingTermination, &( pxTCB->xGenericListItem ) );\r
+ vListInsertEnd( &xTasksWaitingTermination, &( pxTCB->xStateListItem ) );\r
\r
/* Increment the ucTasksDeleted variable so the idle task knows\r
there is a task that has been deleted and that it should therefore\r
{\r
taskENTER_CRITICAL();\r
{\r
- pxStateList = ( List_t * ) listLIST_ITEM_CONTAINER( &( pxTCB->xGenericListItem ) );\r
+ pxStateList = ( List_t * ) listLIST_ITEM_CONTAINER( &( pxTCB->xStateListItem ) );\r
}\r
taskEXIT_CRITICAL();\r
\r
nothing more than change it's priority variable. However, if\r
the task is in a ready list it needs to be removed and placed\r
in the list appropriate to its new priority. */\r
- if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ uxPriorityUsedOnEntry ] ), &( pxTCB->xGenericListItem ) ) != pdFALSE )\r
+ if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ uxPriorityUsedOnEntry ] ), &( pxTCB->xStateListItem ) ) != pdFALSE )\r
{\r
/* The task is currently in its ready list - remove before adding\r
it to it's new ready list. As we are in a critical section we\r
can do this even if the scheduler is suspended. */\r
- if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )\r
+ if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )\r
{\r
/* It is known that the task is in its ready list so\r
there is no need to check again and the port level\r
\r
/* Remove task from the ready/delayed list and place in the\r
suspended list. */\r
- if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )\r
+ if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )\r
{\r
taskRESET_READY_PRIORITY( pxTCB->uxPriority );\r
}\r
mtCOVERAGE_TEST_MARKER();\r
}\r
\r
- vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xGenericListItem ) );\r
+ vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xStateListItem ) );\r
}\r
taskEXIT_CRITICAL();\r
\r
configASSERT( xTask );\r
\r
/* Is the task being resumed actually in the suspended list? */\r
- if( listIS_CONTAINED_WITHIN( &xSuspendedTaskList, &( pxTCB->xGenericListItem ) ) != pdFALSE )\r
+ if( listIS_CONTAINED_WITHIN( &xSuspendedTaskList, &( pxTCB->xStateListItem ) ) != pdFALSE )\r
{\r
/* Has the task already been resumed from within an ISR? */\r
if( listIS_CONTAINED_WITHIN( &xPendingReadyList, &( pxTCB->xEventListItem ) ) == pdFALSE )\r
\r
/* As we are in a critical section we can access the ready\r
lists even if the scheduler is suspended. */\r
- ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ ( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
prvAddTaskToReadyList( pxTCB );\r
\r
/* We may have just resumed a higher priority task. */\r
mtCOVERAGE_TEST_MARKER();\r
}\r
\r
- ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ ( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
prvAddTaskToReadyList( pxTCB );\r
}\r
else\r
void vTaskStartScheduler( void )\r
{\r
BaseType_t xReturn;\r
-StaticTask_t *pxIdleTaskTCBBuffer = NULL;\r
-StackType_t *pxIdleTaskStackBuffer = NULL;\r
-uint16_t usIdleTaskStackSize = tskIDLE_STACK_SIZE;\r
+uint16_t usIdleTaskStackSize = configMINIMAL_STACK_SIZE;\r
\r
+ /* Add the idle task at the lowest priority. */\r
#if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
{\r
+ StaticTask_t *pxIdleTaskTCBBuffer = NULL;\r
+ StackType_t *pxIdleTaskStackBuffer = NULL;\r
+\r
+ /* The Idle task is created using user provided RAM - obtain the\r
+ address of the RAM then create the idle task. */\r
vApplicationGetIdleTaskMemory( &pxIdleTaskTCBBuffer, &pxIdleTaskStackBuffer, &usIdleTaskStackSize );\r
+ xReturn = xTaskCreateStatic( prvIdleTask, "IDLE", usIdleTaskStackSize, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), &xIdleTaskHandle, pxIdleTaskStackBuffer, pxIdleTaskTCBBuffer ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */\r
+ }\r
+ #else\r
+ {\r
+ /* The Idle task is being created using dynamically allocated RAM. */\r
+ xReturn = xTaskCreate( prvIdleTask, "IDLE", usIdleTaskStackSize, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), &xIdleTaskHandle ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */\r
}\r
#endif /* configSUPPORT_STATIC_ALLOCATION */\r
\r
- /* Add the idle task at the lowest priority. */\r
- xReturn = xTaskGenericCreate( prvIdleTask, "IDLE", usIdleTaskStackSize, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), &xIdleTaskHandle, pxIdleTaskStackBuffer, pxIdleTaskTCBBuffer, NULL ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */\r
-\r
#if ( configUSE_TIMERS == 1 )\r
{\r
if( xReturn == pdPASS )\r
{\r
pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &xPendingReadyList ) );\r
( void ) uxListRemove( &( pxTCB->xEventListItem ) );\r
- ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ ( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
prvAddTaskToReadyList( pxTCB );\r
\r
/* If the moved task has a priority higher than the current\r
prvResetNextTaskUnblockTime();\r
}\r
\r
- /* If any ticks occurred while the scheduler was suspended then\r
- they should be processed now. This ensures the tick count does\r
- not slip, and that any delayed tasks are resumed at the correct\r
- time. */\r
- if( uxPendedTicks > ( UBaseType_t ) 0U )\r
- {\r
- while( uxPendedTicks > ( UBaseType_t ) 0U )\r
+ /* If any ticks occurred while the scheduler was suspended then\r
+ they should be processed now. This ensures the tick count does\r
+ not slip, and that any delayed tasks are resumed at the correct\r
+ time. */\r
+ {\r
+ UBaseType_t uxPendedCounts = uxPendedTicks; /* Non-volatile copy. */\r
+\r
+ if( uxPendedCounts > ( UBaseType_t ) 0U )\r
+ {\r
+ do\r
+ {\r
+ if( xTaskIncrementTick() != pdFALSE )\r
+ {\r
+ xYieldPending = pdTRUE;\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+ --uxPendedCounts;\r
+ } while( uxPendedCounts > ( UBaseType_t ) 0U );\r
+\r
+ uxPendedTicks = 0;\r
+ }\r
+ else\r
{\r
- if( xTaskIncrementTick() != pdFALSE )\r
- {\r
- xYieldPending = pdTRUE;\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
- --uxPendedTicks;\r
+ mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
\r
if( xYieldPending != pdFALSE )\r
{\r
}\r
/*-----------------------------------------------------------*/\r
\r
-#if ( INCLUDE_pcTaskGetTaskName == 1 )\r
-\r
- char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
- {\r
- TCB_t *pxTCB;\r
-\r
- /* If null is passed in here then the name of the calling task is being\r
- queried. */\r
- pxTCB = prvGetTCBFromHandle( xTaskToQuery );\r
- configASSERT( pxTCB );\r
- return &( pxTCB->pcTaskName[ 0 ] );\r
- }\r
+char *pcTaskGetName( TaskHandle_t xTaskToQuery ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
+{\r
+TCB_t *pxTCB;\r
\r
-#endif /* INCLUDE_pcTaskGetTaskName */\r
+ /* If null is passed in here then the name of the calling task is being\r
+ queried. */\r
+ pxTCB = prvGetTCBFromHandle( xTaskToQuery );\r
+ configASSERT( pxTCB );\r
+ return &( pxTCB->pcTaskName[ 0 ] );\r
+}\r
/*-----------------------------------------------------------*/\r
\r
#if ( INCLUDE_xTaskGetTaskHandle == 1 )\r
if( eTaskGetState( xTask ) == eBlocked )\r
{\r
/* Remove the reference to the task from the blocked list. An\r
- interrupt won't touch the xGenericListItem because the\r
+ interrupt won't touch the xStateListItem because the\r
scheduler is suspended. */\r
- ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ ( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
\r
/* Is the task waiting on an event also? If so remove it from\r
the event list too. Interrupts can touch the event list item,\r
traceTASK_INCREMENT_TICK( xTickCount );\r
if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )\r
{\r
+ /* Minor optimisation. The tick count cannot change in this\r
+ block. */\r
+ const TickType_t xConstTickCount = xTickCount + 1;\r
+\r
/* Increment the RTOS tick, switching the delayed and overflowed\r
delayed lists if it wraps to 0. */\r
- ++xTickCount;\r
+ xTickCount = xConstTickCount;\r
\r
+ if( xConstTickCount == ( TickType_t ) 0U )\r
{\r
- /* Minor optimisation. The tick count cannot change in this\r
- block. */\r
- const TickType_t xConstTickCount = xTickCount;\r
-\r
- if( xConstTickCount == ( TickType_t ) 0U )\r
- {\r
- taskSWITCH_DELAYED_LISTS();\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
+ taskSWITCH_DELAYED_LISTS();\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
\r
- /* See if this tick has made a timeout expire. Tasks are stored in\r
- the queue in the order of their wake time - meaning once one task\r
- has been found whose block time has not expired there is no need to\r
- look any further down the list. */\r
- if( xConstTickCount >= xNextTaskUnblockTime )\r
+ /* See if this tick has made a timeout expire. Tasks are stored in\r
+ the queue in the order of their wake time - meaning once one task\r
+ has been found whose block time has not expired there is no need to\r
+ look any further down the list. */\r
+ if( xConstTickCount >= xNextTaskUnblockTime )\r
+ {\r
+ for( ;; )\r
{\r
- for( ;; )\r
+ if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )\r
+ {\r
+ /* The delayed list is empty. Set xNextTaskUnblockTime\r
+ to the maximum possible value so it is extremely\r
+ unlikely that the\r
+ if( xTickCount >= xNextTaskUnblockTime ) test will pass\r
+ next time through. */\r
+ xNextTaskUnblockTime = portMAX_DELAY; /*lint !e961 MISRA exception as the casts are only redundant for some ports. */\r
+ break;\r
+ }\r
+ else\r
{\r
- if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )\r
+ /* The delayed list is not empty, get the value of the\r
+ item at the head of the delayed list. This is the time\r
+ at which the task at the head of the delayed list must\r
+ be removed from the Blocked state. */\r
+ pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList );\r
+ xItemValue = listGET_LIST_ITEM_VALUE( &( pxTCB->xStateListItem ) );\r
+\r
+ if( xConstTickCount < xItemValue )\r
{\r
- /* The delayed list is empty. Set xNextTaskUnblockTime\r
- to the maximum possible value so it is extremely\r
- unlikely that the\r
- if( xTickCount >= xNextTaskUnblockTime ) test will pass\r
- next time through. */\r
- xNextTaskUnblockTime = portMAX_DELAY;\r
+ /* It is not time to unblock this item yet, but the\r
+ item value is the time at which the task at the head\r
+ of the blocked list must be removed from the Blocked\r
+ state - so record the item value in\r
+ xNextTaskUnblockTime. */\r
+ xNextTaskUnblockTime = xItemValue;\r
break;\r
}\r
else\r
{\r
- /* The delayed list is not empty, get the value of the\r
- item at the head of the delayed list. This is the time\r
- at which the task at the head of the delayed list must\r
- be removed from the Blocked state. */\r
- pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList );\r
- xItemValue = listGET_LIST_ITEM_VALUE( &( pxTCB->xGenericListItem ) );\r
-\r
- if( xConstTickCount < xItemValue )\r
- {\r
- /* It is not time to unblock this item yet, but the\r
- item value is the time at which the task at the head\r
- of the blocked list must be removed from the Blocked\r
- state - so record the item value in\r
- xNextTaskUnblockTime. */\r
- xNextTaskUnblockTime = xItemValue;\r
- break;\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
+\r
+ /* It is time to remove the item from the Blocked state. */\r
+ ( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
+\r
+ /* Is the task waiting on an event also? If so remove\r
+ it from the event list. */\r
+ if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )\r
+ {\r
+ ( void ) uxListRemove( &( pxTCB->xEventListItem ) );\r
+ }\r
+ else\r
+ {\r
+ mtCOVERAGE_TEST_MARKER();\r
+ }\r
\r
- /* It is time to remove the item from the Blocked state. */\r
- ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ /* Place the unblocked task into the appropriate ready\r
+ list. */\r
+ prvAddTaskToReadyList( pxTCB );\r
\r
- /* Is the task waiting on an event also? If so remove\r
- it from the event list. */\r
- if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )\r
+ /* A task being unblocked cannot cause an immediate\r
+ context switch if preemption is turned off. */\r
+ #if ( configUSE_PREEMPTION == 1 )\r
+ {\r
+ /* Preemption is on, but a context switch should\r
+ only be performed if the unblocked task has a\r
+ priority that is equal to or higher than the\r
+ currently executing task. */\r
+ if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )\r
{\r
- ( void ) uxListRemove( &( pxTCB->xEventListItem ) );\r
+ xSwitchRequired = pdTRUE;\r
}\r
else\r
{\r
mtCOVERAGE_TEST_MARKER();\r
}\r
-\r
- /* Place the unblocked task into the appropriate ready\r
- list. */\r
- prvAddTaskToReadyList( pxTCB );\r
-\r
- /* A task being unblocked cannot cause an immediate\r
- context switch if preemption is turned off. */\r
- #if ( configUSE_PREEMPTION == 1 )\r
- {\r
- /* Preemption is on, but a context switch should\r
- only be performed if the unblocked task has a\r
- priority that is equal to or higher than the\r
- currently executing task. */\r
- if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )\r
- {\r
- xSwitchRequired = pdTRUE;\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
- }\r
- #endif /* configUSE_PREEMPTION */\r
}\r
+ #endif /* configUSE_PREEMPTION */\r
}\r
}\r
}\r
\r
if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )\r
{\r
- ( void ) uxListRemove( &( pxUnblockedTCB->xGenericListItem ) );\r
+ ( void ) uxListRemove( &( pxUnblockedTCB->xStateListItem ) );\r
prvAddTaskToReadyList( pxUnblockedTCB );\r
}\r
else\r
/* Remove the task from the delayed list and add it to the ready list. The\r
scheduler is suspended so interrupts will not be accessing the ready\r
lists. */\r
- ( void ) uxListRemove( &( pxUnblockedTCB->xGenericListItem ) );\r
+ ( void ) uxListRemove( &( pxUnblockedTCB->xStateListItem ) );\r
prvAddTaskToReadyList( pxUnblockedTCB );\r
\r
if( pxUnblockedTCB->uxPriority > pxCurrentTCB->uxPriority )\r
#endif /* configUSE_TICKLESS_IDLE */\r
/*-----------------------------------------------------------*/\r
\r
-static void prvInitialiseTCBVariables( TCB_t * const pxTCB, const char * const pcName, UBaseType_t uxPriority, const MemoryRegion_t * const xRegions, const uint16_t usStackDepth ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
-{\r
-UBaseType_t x;\r
-\r
- /* Store the task name in the TCB. */\r
- for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )\r
- {\r
- pxTCB->pcTaskName[ x ] = pcName[ x ];\r
-\r
- /* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter than\r
- configMAX_TASK_NAME_LEN characters just in case the memory after the\r
- string is not accessible (extremely unlikely). */\r
- if( pcName[ x ] == 0x00 )\r
- {\r
- break;\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
- }\r
-\r
- /* Ensure the name string is terminated in the case that the string length\r
- was greater or equal to configMAX_TASK_NAME_LEN. */\r
- pxTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';\r
-\r
- /* This is used as an array index so must ensure it's not too large. First\r
- remove the privilege bit if one is present. */\r
- if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )\r
- {\r
- uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
-\r
- pxTCB->uxPriority = uxPriority;\r
- #if ( configUSE_MUTEXES == 1 )\r
- {\r
- pxTCB->uxBasePriority = uxPriority;\r
- pxTCB->uxMutexesHeld = 0;\r
- }\r
- #endif /* configUSE_MUTEXES */\r
-\r
- vListInitialiseItem( &( pxTCB->xGenericListItem ) );\r
- vListInitialiseItem( &( pxTCB->xEventListItem ) );\r
-\r
- /* Set the pxTCB as a link back from the ListItem_t. This is so we can get\r
- back to the containing TCB from a generic item in a list. */\r
- listSET_LIST_ITEM_OWNER( &( pxTCB->xGenericListItem ), pxTCB );\r
-\r
- /* Event lists are always in priority order. */\r
- listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */\r
- listSET_LIST_ITEM_OWNER( &( pxTCB->xEventListItem ), pxTCB );\r
-\r
- #if ( portCRITICAL_NESTING_IN_TCB == 1 )\r
- {\r
- pxTCB->uxCriticalNesting = ( UBaseType_t ) 0U;\r
- }\r
- #endif /* portCRITICAL_NESTING_IN_TCB */\r
-\r
- #if ( configUSE_APPLICATION_TASK_TAG == 1 )\r
- {\r
- pxTCB->pxTaskTag = NULL;\r
- }\r
- #endif /* configUSE_APPLICATION_TASK_TAG */\r
-\r
- #if ( configGENERATE_RUN_TIME_STATS == 1 )\r
- {\r
- pxTCB->ulRunTimeCounter = 0UL;\r
- }\r
- #endif /* configGENERATE_RUN_TIME_STATS */\r
-\r
- #if ( portUSING_MPU_WRAPPERS == 1 )\r
- {\r
- vPortStoreTaskMPUSettings( &( pxTCB->xMPUSettings ), xRegions, pxTCB->pxStack, usStackDepth );\r
- }\r
- #else /* portUSING_MPU_WRAPPERS */\r
- {\r
- ( void ) xRegions;\r
- ( void ) usStackDepth;\r
- }\r
- #endif /* portUSING_MPU_WRAPPERS */\r
-\r
- #if( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )\r
- {\r
- for( x = 0; x < ( UBaseType_t ) configNUM_THREAD_LOCAL_STORAGE_POINTERS; x++ )\r
- {\r
- pxTCB->pvThreadLocalStoragePointers[ x ] = NULL;\r
- }\r
- }\r
- #endif\r
-\r
- #if ( configUSE_TASK_NOTIFICATIONS == 1 )\r
- {\r
- pxTCB->ulNotifiedValue = 0;\r
- pxTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;\r
- }\r
- #endif\r
-\r
- #if ( configUSE_NEWLIB_REENTRANT == 1 )\r
- {\r
- /* Initialise this task's Newlib reent structure. */\r
- _REENT_INIT_PTR( ( &( pxTCB->xNewLib_reent ) ) );\r
- }\r
- #endif\r
-\r
- #if( INCLUDE_xTaskAbortDelay == 1 )\r
- {\r
- pxTCB->ucDelayAborted = pdFALSE;\r
- }\r
- #endif\r
-}\r
-/*-----------------------------------------------------------*/\r
-\r
#if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )\r
\r
void vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue )\r
static void prvCheckTasksWaitingTermination( void )\r
{\r
\r
- /** THIS FUNCTION IS CALLED FROM THE RTOS IDLE TASK **/\r
+ /** THIS FUNCTION IS CALLED FROM THE RTOS IDLE TASK **/\r
\r
#if ( INCLUDE_vTaskDelete == 1 )\r
{\r
taskENTER_CRITICAL();\r
{\r
pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &xTasksWaitingTermination ) );\r
- ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ ( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
--uxCurrentNumberOfTasks;\r
--uxDeletedTasksWaitingCleanUp;\r
}\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static TCB_t *prvAllocateTCBAndStack( const uint16_t usStackDepth, StackType_t * const puxStackBuffer, TCB_t * const pxTaskBuffer )\r
-{\r
-TCB_t *pxNewTCB;\r
-\r
- #if( ( configASSERT_DEFINED == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
- {\r
- /* Sanity check that the size of the structure used to declare a\r
- variable of type StaticTask_t matches the size of the actual TCB_t\r
- structure. */\r
- volatile size_t xSize = sizeof( StaticTask_t );\r
- configASSERT( xSize == sizeof( TCB_t ) );\r
- }\r
- #endif /* configASSERT_DEFINED */\r
-\r
- /* If the stack grows down then allocate the stack then the TCB so the stack\r
- does not grow into the TCB. Likewise if the stack grows up then allocate\r
- the TCB then the stack. */\r
- #if( portSTACK_GROWTH > 0 )\r
- {\r
- /* Allocate space for the TCB. Where the memory comes from depends on\r
- the implementation of the port malloc function. */\r
- pxNewTCB = ( TCB_t * ) pvPortMallocAligned( sizeof( TCB_t ), pxTaskBuffer );\r
-\r
- if( pxNewTCB != NULL )\r
- {\r
- /* Allocate space for the stack used by the task being created.\r
- The base of the stack memory stored in the TCB so the task can\r
- be deleted later if required. */\r
- pxNewTCB->pxStack = ( StackType_t * ) pvPortMallocAligned( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ), puxStackBuffer ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */\r
-\r
- if( pxNewTCB->pxStack == NULL )\r
- {\r
- /* Could not allocate the stack. Delete the allocated TCB - if\r
- it was allocated dynamically. */\r
- if( pxTaskBuffer == NULL )\r
- {\r
- vPortFree( pxNewTCB );\r
- }\r
- pxNewTCB = NULL;\r
- }\r
- }\r
- }\r
- #else /* portSTACK_GROWTH */\r
- {\r
- StackType_t *pxStack;\r
-\r
- /* Allocate space for the stack used by the task being created. */\r
- pxStack = ( StackType_t * ) pvPortMallocAligned( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ), puxStackBuffer ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */\r
-\r
- if( pxStack != NULL )\r
- {\r
- /* Allocate space for the TCB. */\r
- pxNewTCB = ( TCB_t * ) pvPortMallocAligned( sizeof( TCB_t ), pxTaskBuffer ); /*lint !e961 MISRA exception as the casts are only redundant for some paths. */\r
-\r
- if( pxNewTCB != NULL )\r
- {\r
- /* Store the stack location in the TCB. */\r
- pxNewTCB->pxStack = pxStack;\r
- }\r
- else\r
- {\r
- /* The stack cannot be used as the TCB was not created. Free it\r
- again. */\r
- if( puxStackBuffer == NULL )\r
- {\r
- vPortFree( pxStack );\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
- }\r
- }\r
- else\r
- {\r
- pxNewTCB = NULL;\r
- }\r
- }\r
- #endif /* portSTACK_GROWTH */\r
-\r
- if( pxNewTCB != NULL )\r
- {\r
- /* Avoid dependency on memset() if it is not required. */\r
- #if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )\r
- {\r
- /* Just to help debugging. */\r
- ( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) usStackDepth * sizeof( StackType_t ) );\r
- }\r
- #endif /* ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) ) ) */\r
-\r
- #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
- {\r
- pxNewTCB->ucStaticAllocationFlags = 0;\r
-\r
- if( puxStackBuffer != NULL )\r
- {\r
- /* The application provided its own stack - note the fact so no\r
- attempt is made to delete the stack if the task is deleted. */\r
- pxNewTCB->ucStaticAllocationFlags |= taskSTATICALLY_ALLOCATED_STACK;\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
-\r
- if( pxTaskBuffer != NULL )\r
- {\r
- /* The application provided its own TCB. Note the fact so no\r
- attempt is made to delete the TCB if the task is deleted. */\r
- pxNewTCB->ucStaticAllocationFlags |= taskSTATICALLY_ALLOCATED_TCB;\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
- }\r
- #endif /* configSUPPORT_STATIC_ALLOCATION */\r
- }\r
-\r
- return pxNewTCB;\r
-}\r
-/*-----------------------------------------------------------*/\r
-\r
#if( configUSE_TRACE_FACILITY == 1 )\r
\r
void vTaskGetTaskInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState )\r
}\r
#endif /* configUSE_NEWLIB_REENTRANT */\r
\r
- #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
+ #if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )\r
{\r
- /* Only free the stack and TCB if they were allocated dynamically in\r
- the first place. */\r
- if( ( pxTCB->ucStaticAllocationFlags & taskSTATICALLY_ALLOCATED_STACK ) == ( uint8_t ) 0 )\r
- {\r
- vPortFreeAligned( pxTCB->pxStack );\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
-\r
- if( ( pxTCB->ucStaticAllocationFlags & taskSTATICALLY_ALLOCATED_TCB ) == ( uint8_t ) 0 )\r
+ /* The task can only have been allocated dynamically - free it\r
+ again. */\r
+ vPortFree( pxTCB->pxStack );\r
+ vPortFree( pxTCB );\r
+ }\r
+ #elif( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
+ {\r
+ /* The task could have been allocated statically or dynamically, so\r
+ check before attempting to free the memory. */\r
+ if( pxTCB->ucStaticallyAllocated == ( uint8_t ) pdFALSE )\r
{\r
- vPortFreeAligned( pxTCB );\r
+ vPortFree( pxTCB->pxStack );\r
+ vPortFree( pxTCB );\r
}\r
else\r
{\r
mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
- #else\r
- {\r
- vPortFreeAligned( pxTCB->pxStack );\r
- vPortFree( pxTCB );\r
- }\r
- #endif\r
+ #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
}\r
\r
#endif /* INCLUDE_vTaskDelete */\r
which the task at the head of the delayed list should be removed\r
from the Blocked state. */\r
( pxTCB ) = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList );\r
- xNextTaskUnblockTime = listGET_LIST_ITEM_VALUE( &( ( pxTCB )->xGenericListItem ) );\r
+ xNextTaskUnblockTime = listGET_LIST_ITEM_VALUE( &( ( pxTCB )->xStateListItem ) );\r
}\r
}\r
/*-----------------------------------------------------------*/\r
\r
/* If the task being modified is in the ready state it will need\r
to be moved into a new list. */\r
- if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxTCB->uxPriority ] ), &( pxTCB->xGenericListItem ) ) != pdFALSE )\r
+ if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxTCB->uxPriority ] ), &( pxTCB->xStateListItem ) ) != pdFALSE )\r
{\r
- if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )\r
+ if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )\r
{\r
taskRESET_READY_PRIORITY( pxTCB->uxPriority );\r
}\r
given from an interrupt, and if a mutex is given by the\r
holding task then it must be the running state task. Remove\r
the holding task from the ready list. */\r
- if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )\r
+ if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )\r
{\r
taskRESET_READY_PRIORITY( pxTCB->uxPriority );\r
}\r
function is executing. */\r
uxArraySize = uxCurrentNumberOfTasks;\r
\r
- /* Allocate an array index for each task. */\r
+ /* Allocate an array index for each task. NOTE! if\r
+ configSUPPORT_DYNAMIC_ALLOCATION is set to 0 then pvPortMalloc() will\r
+ equate to NULL. */\r
pxTaskStatusArray = pvPortMalloc( uxCurrentNumberOfTasks * sizeof( TaskStatus_t ) );\r
\r
if( pxTaskStatusArray != NULL )\r
pcWriteBuffer += strlen( pcWriteBuffer );\r
}\r
\r
- /* Free the array again. */\r
+ /* Free the array again. NOTE! If configSUPPORT_DYNAMIC_ALLOCATION\r
+ is 0 then vPortFree() will be #defined to nothing. */\r
vPortFree( pxTaskStatusArray );\r
}\r
else\r
function is executing. */\r
uxArraySize = uxCurrentNumberOfTasks;\r
\r
- /* Allocate an array index for each task. */\r
+ /* Allocate an array index for each task. NOTE! If\r
+ configSUPPORT_DYNAMIC_ALLOCATION is set to 0 then pvPortMalloc() will\r
+ equate to NULL. */\r
pxTaskStatusArray = pvPortMalloc( uxCurrentNumberOfTasks * sizeof( TaskStatus_t ) );\r
\r
if( pxTaskStatusArray != NULL )\r
mtCOVERAGE_TEST_MARKER();\r
}\r
\r
- /* Free the array again. */\r
+ /* Free the array again. NOTE! If configSUPPORT_DYNAMIC_ALLOCATION\r
+ is 0 then vPortFree() will be #defined to nothing. */\r
vPortFree( pxTaskStatusArray );\r
}\r
else\r
}\r
else\r
{\r
- ( pxCurrentTCB->ulNotifiedValue )--;\r
+ pxCurrentTCB->ulNotifiedValue = ulReturn - 1;\r
}\r
}\r
else\r
notification then unblock it now. */\r
if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )\r
{\r
- ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ ( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
prvAddTaskToReadyList( pxTCB );\r
\r
/* The task should not have been on an event list. */\r
\r
if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )\r
{\r
- ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ ( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
prvAddTaskToReadyList( pxTCB );\r
}\r
else\r
\r
if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )\r
{\r
- ( void ) uxListRemove( &( pxTCB->xGenericListItem ) );\r
+ ( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
prvAddTaskToReadyList( pxTCB );\r
}\r
else\r
static void prvAddCurrentTaskToDelayedList( TickType_t xTicksToWait, const BaseType_t xCanBlockIndefinitely )\r
{\r
TickType_t xTimeToWake;\r
+const TickType_t xConstTickCount = xTickCount;\r
\r
#if( INCLUDE_xTaskAbortDelay == 1 )\r
{\r
\r
/* Remove the task from the ready list before adding it to the blocked list\r
as the same list item is used for both lists. */\r
- if( uxListRemove( &( pxCurrentTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )\r
+ if( uxListRemove( &( pxCurrentTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )\r
{\r
/* The current task must be in a ready list, so there is no need to\r
check, and the port reset macro can be called directly. */\r
mtCOVERAGE_TEST_MARKER();\r
}\r
\r
-\r
#if ( INCLUDE_vTaskSuspend == 1 )\r
{\r
if( ( xTicksToWait == portMAX_DELAY ) && ( xCanBlockIndefinitely != pdFALSE ) )\r
/* Add the task to the suspended task list instead of a delayed task\r
list to ensure it is not woken by a timing event. It will block\r
indefinitely. */\r
- vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xGenericListItem ) );\r
+ vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xStateListItem ) );\r
}\r
else\r
{\r
/* Calculate the time at which the task should be woken if the event\r
does not occur. This may overflow but this doesn't matter, the\r
kernel will manage it correctly. */\r
- xTimeToWake = xTickCount + xTicksToWait;\r
+ xTimeToWake = xConstTickCount + xTicksToWait;\r
\r
/* The list item will be inserted in wake time order. */\r
- listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xGenericListItem ), xTimeToWake );\r
+ listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake );\r
\r
- if( xTimeToWake < xTickCount )\r
+ if( xTimeToWake < xConstTickCount )\r
{\r
/* Wake time has overflowed. Place this item in the overflow\r
list. */\r
- vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB->xGenericListItem ) );\r
+ vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );\r
}\r
else\r
{\r
/* The wake time has not overflowed, so the current block list\r
is used. */\r
- vListInsert( pxDelayedTaskList, &( pxCurrentTCB->xGenericListItem ) );\r
+ vListInsert( pxDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );\r
\r
/* If the task entering the blocked state was placed at the\r
head of the list of blocked tasks then xNextTaskUnblockTime\r
/* Calculate the time at which the task should be woken if the event\r
does not occur. This may overflow but this doesn't matter, the kernel\r
will manage it correctly. */\r
- xTimeToWake = xTickCount + xTicksToWait;\r
+ xTimeToWake = xConstTickCount + xTicksToWait;\r
\r
/* The list item will be inserted in wake time order. */\r
- listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xGenericListItem ), xTimeToWake );\r
+ listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake );\r
\r
- if( xTimeToWake < xTickCount )\r
+ if( xTimeToWake < xConstTickCount )\r
{\r
/* Wake time has overflowed. Place this item in the overflow list. */\r
- vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB->xGenericListItem ) );\r
+ vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );\r
}\r
else\r
{\r
/* The wake time has not overflowed, so the current block list is used. */\r
- vListInsert( pxDelayedTaskList, &( pxCurrentTCB->xGenericListItem ) );\r
+ vListInsert( pxDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );\r
\r
/* If the task entering the blocked state was placed at the head of the\r
list of blocked tasks then xNextTaskUnblockTime needs to be updated\r
projects / freertos / blobdiff