/*\r
- FreeRTOS V9.0.1 - Copyright (C) 2017 Real Time Engineers Ltd.\r
- All rights reserved\r
-\r
- VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
-\r
- This file is part of the FreeRTOS distribution.\r
-\r
- FreeRTOS is free software; you can redistribute it and/or modify it under\r
- the terms of the GNU General Public License (version 2) as published by the\r
- Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.\r
-\r
- ***************************************************************************\r
- >>! NOTE: The modification to the GPL is included to allow you to !<<\r
- >>! distribute a combined work that includes FreeRTOS without being !<<\r
- >>! obliged to provide the source code for proprietary components !<<\r
- >>! outside of the FreeRTOS kernel. !<<\r
- ***************************************************************************\r
-\r
- FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
- WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
- FOR A PARTICULAR PURPOSE. Full license text is available on the following\r
- link: http://www.freertos.org/a00114.html\r
-\r
- ***************************************************************************\r
- * *\r
- * FreeRTOS provides completely free yet professionally developed, *\r
- * robust, strictly quality controlled, supported, and cross *\r
- * platform software that is more than just the market leader, it *\r
- * is the industry's de facto standard. *\r
- * *\r
- * Help yourself get started quickly while simultaneously helping *\r
- * to support the FreeRTOS project by purchasing a FreeRTOS *\r
- * tutorial book, reference manual, or both: *\r
- * http://www.FreeRTOS.org/Documentation *\r
- * *\r
- ***************************************************************************\r
-\r
- http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading\r
- the FAQ page "My application does not run, what could be wrong?". Have you\r
- defined configASSERT()?\r
-\r
- http://www.FreeRTOS.org/support - In return for receiving this top quality\r
- embedded software for free we request you assist our global community by\r
- participating in the support forum.\r
-\r
- http://www.FreeRTOS.org/training - Investing in training allows your team to\r
- be as productive as possible as early as possible. Now you can receive\r
- FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers\r
- Ltd, and the world's leading authority on the world's leading RTOS.\r
-\r
- http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
- including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
- compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
-\r
- http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.\r
- Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.\r
-\r
- http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High\r
- Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS\r
- licenses offer ticketed support, indemnification and commercial middleware.\r
-\r
- http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
- engineered and independently SIL3 certified version for use in safety and\r
- mission critical applications that require provable dependability.\r
-\r
- 1 tab == 4 spaces!\r
-*/\r
+ * FreeRTOS Kernel V10.1.0\r
+ * Copyright (C) 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
\r
/* Standard includes. */\r
#include <stdlib.h>\r
#include "FreeRTOS.h"\r
#include "task.h"\r
#include "timers.h"\r
-#include "StackMacros.h"\r
+#include "stack_macros.h"\r
\r
-/* Lint e961 and e750 are suppressed as a MISRA exception justified because the\r
-MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined for the\r
-header files above, but not in this file, in order to generate the correct\r
-privileged Vs unprivileged linkage and placement. */\r
-#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750. */\r
+/* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified\r
+because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined\r
+for the header files above, but not in this file, in order to generate the\r
+correct privileged Vs unprivileged linkage and placement. */\r
+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021. */\r
\r
/* Set configUSE_STATS_FORMATTING_FUNCTIONS to 2 to include the stats formatting\r
functions but without including stdio.h here. */\r
/*\r
* Macros used by vListTask to indicate which state a task is in.\r
*/\r
+#define tskRUNNING_CHAR ( 'X' )\r
#define tskBLOCKED_CHAR ( 'B' )\r
#define tskREADY_CHAR ( 'R' )\r
#define tskDELETED_CHAR ( 'D' )\r
* task should be used in place of the parameter. This macro simply checks to\r
* see if the parameter is NULL and returns a pointer to the appropriate TCB.\r
*/\r
-#define prvGetTCBFromHandle( pxHandle ) ( ( ( pxHandle ) == NULL ) ? ( TCB_t * ) pxCurrentTCB : ( TCB_t * ) ( pxHandle ) )\r
+#define prvGetTCBFromHandle( pxHandle ) ( ( ( pxHandle ) == NULL ) ? pxCurrentTCB : ( pxHandle ) )\r
\r
/* The item value of the event list item is normally used to hold the priority\r
of the task to which it belongs (coded to allow it to be held in reverse\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
+typedef struct TaskControlBlock_t\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
\r
/* See the comments above the definition of\r
tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE. */\r
- #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 Macro has been consolidated for readability reasons. */\r
+ #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro has been consolidated for readability reasons. */\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
uint8_t ucDelayAborted;\r
#endif\r
\r
+ #if( configUSE_POSIX_ERRNO == 1 )\r
+ int iTaskErrno;\r
+ #endif\r
+\r
} tskTCB;\r
\r
/* The old tskTCB name is maintained above then typedefed to the new TCB_t name\r
\r
/*lint -save -e956 A manual analysis and inspection has been used to determine\r
which 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
#endif\r
\r
+/* Global POSIX errno. Its value is changed upon context switching to match\r
+the errno of the currently running task. */\r
+#if ( configUSE_POSIX_ERRNO == 1 )\r
+ int FreeRTOS_errno = 0;\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 ) configINITIAL_TICK_COUNT;\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 -restore */\r
\r
/*-----------------------------------------------------------*/\r
\r
#if( configUSE_TICK_HOOK > 0 )\r
\r
- extern void vApplicationTickHook( void );\r
+ extern void vApplicationTickHook( void ); /*lint !e526 Symbol not defined as it is an application callback. */\r
\r
#endif\r
\r
#if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
\r
- extern void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize );\r
+ extern void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize ); /*lint !e526 Symbol not defined as it is an application callback. */\r
\r
#endif\r
\r
*/\r
#if ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )\r
\r
- static uint16_t prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte ) PRIVILEGED_FUNCTION;\r
+ static configSTACK_DEPTH_TYPE prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte ) PRIVILEGED_FUNCTION;\r
\r
#endif\r
\r
structure. */\r
volatile size_t xSize = sizeof( StaticTask_t );\r
configASSERT( xSize == sizeof( TCB_t ) );\r
+ ( void ) xSize; /* Prevent lint warning when configASSERT() is not used. */\r
}\r
#endif /* configASSERT_DEFINED */\r
\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 = ( TCB_t * ) pxTaskBuffer; /*lint !e740 !e9087 Unusual cast is ok as the structures are designed to have the same alignment, and the size is checked by an assert. */\r
pxNewTCB->pxStack = ( StackType_t * ) puxStackBuffer;\r
\r
- #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 Macro has been consolidated for readability reasons. */\r
+ #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro has been consolidated for readability reasons. */\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
#endif /* ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) */\r
/*-----------------------------------------------------------*/\r
\r
-#if( ( portUSING_MPU_WRAPPERS == 1 ) && ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) )\r
+#if( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )\r
\r
BaseType_t xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask )\r
{\r
/* Store the stack location in the TCB. */\r
pxNewTCB->pxStack = pxTaskDefinition->puxStackBuffer;\r
\r
- /* Tasks can be created statically or dynamically, so note\r
- this task had a statically allocated stack in case it is\r
- later deleted. The TCB was allocated dynamically. */\r
- pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_ONLY;\r
+ #if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
+ {\r
+ /* Tasks can be created statically or dynamically, so note\r
+ this task had a statically allocated stack in case it is\r
+ later deleted. The TCB was allocated dynamically. */\r
+ pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_ONLY;\r
+ }\r
+ #endif\r
\r
prvInitialiseNewTask( pxTaskDefinition->pvTaskCode,\r
pxTaskDefinition->pcName,\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
+ pxStack = pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack and this allocation is the stack. */\r
\r
if( pxStack != NULL )\r
{\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
+ pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); /*lint !e9087 !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack, and the first member of TCB_t is always a pointer to the task's stack. */\r
\r
if( pxNewTCB != NULL )\r
{\r
\r
if( pxNewTCB != NULL )\r
{\r
- #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 Macro has been consolidated for readability reasons. */\r
+ #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e9029 !e731 Macro has been consolidated for readability reasons. */\r
{\r
/* Tasks can be created statically or dynamically, so note this\r
task was created dynamically in case it is later deleted. */\r
uxPriority &= ~portPRIVILEGE_BIT;\r
#endif /* portUSING_MPU_WRAPPERS == 1 */\r
\r
+ configASSERT( pcName );\r
+\r
/* Avoid dependency on memset() if it is not required. */\r
#if( tskSET_NEW_STACKS_TO_KNOWN_VALUE == 1 )\r
{\r
by the port. */\r
#if( portSTACK_GROWTH < 0 )\r
{\r
- pxTopOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_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
+ pxTopOfStack = &( pxNewTCB->pxStack[ ulStackDepth - ( uint32_t ) 1 ] );\r
+ pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) ); /*lint !e923 !e9033 !e9078 MISRA exception. Avoiding casts between pointers and integers is not practical. Size differences accounted for using portPOINTER_SIZE_TYPE type. Checked by assert(). */\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
/* 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
+ if( pcName[ x ] == ( char ) 0x00 )\r
{\r
break;\r
}\r
}\r
#endif /* portUSING_MPU_WRAPPERS */\r
\r
- if( ( void * ) pxCreatedTask != NULL )\r
+ if( 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
eTaskState eTaskGetState( TaskHandle_t xTask )\r
{\r
eTaskState eReturn;\r
- List_t *pxStateList;\r
- const TCB_t * const pxTCB = ( TCB_t * ) xTask;\r
+ List_t const * pxStateList, *pxDelayedList, *pxOverflowedDelayedList;\r
+ const TCB_t * const pxTCB = xTask;\r
\r
configASSERT( pxTCB );\r
\r
{\r
taskENTER_CRITICAL();\r
{\r
- pxStateList = ( List_t * ) listLIST_ITEM_CONTAINER( &( pxTCB->xStateListItem ) );\r
+ pxStateList = listLIST_ITEM_CONTAINER( &( pxTCB->xStateListItem ) );\r
+ pxDelayedList = pxDelayedTaskList;\r
+ pxOverflowedDelayedList = pxOverflowDelayedTaskList;\r
}\r
taskEXIT_CRITICAL();\r
\r
- if( ( pxStateList == pxDelayedTaskList ) || ( pxStateList == pxOverflowDelayedTaskList ) )\r
+ if( ( pxStateList == pxDelayedList ) || ( pxStateList == pxOverflowedDelayedList ) )\r
{\r
/* The task being queried is referenced from one of the Blocked\r
lists. */\r
else if( pxStateList == &xSuspendedTaskList )\r
{\r
/* The task being queried is referenced from the suspended\r
- list. Is it genuinely suspended or is it block\r
+ list. Is it genuinely suspended or is it blocked\r
indefinitely? */\r
if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL )\r
{\r
- eReturn = eSuspended;\r
+ #if( configUSE_TASK_NOTIFICATIONS == 1 )\r
+ {\r
+ /* The task does not appear on the event list item of\r
+ and of the RTOS objects, but could still be in the\r
+ blocked state if it is waiting on its notification\r
+ rather than waiting on an object. */\r
+ if( pxTCB->ucNotifyState == taskWAITING_NOTIFICATION )\r
+ {\r
+ eReturn = eBlocked;\r
+ }\r
+ else\r
+ {\r
+ eReturn = eSuspended;\r
+ }\r
+ }\r
+ #else\r
+ {\r
+ eReturn = eSuspended;\r
+ }\r
+ #endif\r
}\r
else\r
{\r
\r
#if ( INCLUDE_uxTaskPriorityGet == 1 )\r
\r
- UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask )\r
+ UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask )\r
{\r
- TCB_t *pxTCB;\r
+ TCB_t const *pxTCB;\r
UBaseType_t uxReturn;\r
\r
taskENTER_CRITICAL();\r
{\r
- /* If null is passed in here then it is the priority of the that\r
- called uxTaskPriorityGet() that is being queried. */\r
+ /* If null is passed in here then it is the priority of the task\r
+ that called uxTaskPriorityGet() that is being queried. */\r
pxTCB = prvGetTCBFromHandle( xTask );\r
uxReturn = pxTCB->uxPriority;\r
}\r
\r
#if ( INCLUDE_uxTaskPriorityGet == 1 )\r
\r
- UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask )\r
+ UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask )\r
{\r
- TCB_t *pxTCB;\r
+ TCB_t const *pxTCB;\r
UBaseType_t uxReturn, uxSavedInterruptState;\r
\r
/* RTOS ports that support interrupt nesting have the concept of a\r
separate interrupt safe API to ensure interrupt entry is as fast and as\r
simple as possible. More information (albeit Cortex-M specific) is\r
provided on the following link:\r
- http://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
+ https://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
portASSERT_IF_INTERRUPT_PRIORITY_INVALID();\r
\r
uxSavedInterruptState = portSET_INTERRUPT_MASK_FROM_ISR();\r
/* The scheduler is not running, but the task that was pointed\r
to by pxCurrentTCB has just been suspended and pxCurrentTCB\r
must be adjusted to point to a different task. */\r
- if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks )\r
+ if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks ) /*lint !e931 Right has no side effect, just volatile. */\r
{\r
/* No other tasks are ready, so set pxCurrentTCB back to\r
NULL so when the next task is created pxCurrentTCB will\r
static BaseType_t prvTaskIsTaskSuspended( const TaskHandle_t xTask )\r
{\r
BaseType_t xReturn = pdFALSE;\r
- const TCB_t * const pxTCB = ( TCB_t * ) xTask;\r
+ const TCB_t * const pxTCB = xTask;\r
\r
/* Accesses xPendingReadyList so must be called from a critical\r
section. */\r
\r
void vTaskResume( TaskHandle_t xTaskToResume )\r
{\r
- TCB_t * const pxTCB = ( TCB_t * ) xTaskToResume;\r
+ TCB_t * const pxTCB = xTaskToResume;\r
\r
/* It does not make sense to resume the calling task. */\r
configASSERT( xTaskToResume );\r
\r
/* The parameter cannot be NULL as it is impossible to resume the\r
currently executing task. */\r
- if( ( pxTCB != NULL ) && ( pxTCB != pxCurrentTCB ) )\r
+ if( ( pxTCB != pxCurrentTCB ) && ( pxTCB != NULL ) )\r
{\r
taskENTER_CRITICAL();\r
{\r
BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume )\r
{\r
BaseType_t xYieldRequired = pdFALSE;\r
- TCB_t * const pxTCB = ( TCB_t * ) xTaskToResume;\r
+ TCB_t * const pxTCB = xTaskToResume;\r
UBaseType_t uxSavedInterruptStatus;\r
\r
configASSERT( xTaskToResume );\r
separate interrupt safe API to ensure interrupt entry is as fast and as\r
simple as possible. More information (albeit Cortex-M specific) is\r
provided on the following link:\r
- http://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
+ https://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
portASSERT_IF_INTERRUPT_PRIORITY_INVALID();\r
\r
uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();\r
configIDLE_TASK_NAME,\r
ulIdleTaskStackSize,\r
( void * ) NULL, /*lint !e961. The cast is not redundant for all compilers. */\r
- ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ),\r
+ portPRIVILEGE_BIT, /* In effect ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), but tskIDLE_PRIORITY is zero. */\r
pxIdleTaskStackBuffer,\r
pxIdleTaskTCBBuffer ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */\r
\r
configIDLE_TASK_NAME,\r
configMINIMAL_STACK_SIZE,\r
( void * ) NULL,\r
- ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ),\r
+ portPRIVILEGE_BIT, /* In effect ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), but tskIDLE_PRIORITY is zero. */\r
&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
xNextTaskUnblockTime = portMAX_DELAY;\r
xSchedulerRunning = pdTRUE;\r
- xTickCount = ( TickType_t ) 0U;\r
+ xTickCount = ( TickType_t ) configINITIAL_TICK_COUNT;\r
\r
/* If configGENERATE_RUN_TIME_STATS is defined then the following\r
macro must be defined to configure the timer/counter used to generate\r
FreeRTOSConfig.h file. */\r
portCONFIGURE_TIMER_FOR_RUN_TIME_STATS();\r
\r
+ traceTASK_SWITCHED_IN();\r
+\r
/* Setting up the timer tick is hardware specific and thus in the\r
portable interface. */\r
if( xPortStartScheduler() != pdFALSE )\r
appropriate ready list. */\r
while( listLIST_IS_EMPTY( &xPendingReadyList ) == pdFALSE )\r
{\r
- pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &xPendingReadyList ) );\r
+ pxTCB = listGET_OWNER_OF_HEAD_ENTRY( ( &xPendingReadyList ) ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
( void ) uxListRemove( &( pxTCB->xEventListItem ) );\r
( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
prvAddTaskToReadyList( pxTCB );\r
system call interrupt priority. FreeRTOS maintains a separate interrupt\r
safe API to ensure interrupt entry is as fast and as simple as possible.\r
More information (albeit Cortex-M specific) is provided on the following\r
- link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
+ link: https://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
portASSERT_IF_INTERRUPT_PRIORITY_INVALID();\r
\r
uxSavedInterruptStatus = portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR();\r
TCB_t *pxNextTCB, *pxFirstTCB, *pxReturn = NULL;\r
UBaseType_t x;\r
char cNextChar;\r
+ BaseType_t xBreakLoop;\r
\r
/* This function is called with the scheduler suspended. */\r
\r
if( listCURRENT_LIST_LENGTH( pxList ) > ( UBaseType_t ) 0 )\r
{\r
- listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList );\r
+ listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
\r
do\r
{\r
- listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList );\r
+ listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
\r
/* Check each character in the name looking for a match or\r
mismatch. */\r
+ xBreakLoop = pdFALSE;\r
for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )\r
{\r
cNextChar = pxNextTCB->pcTaskName[ x ];\r
if( cNextChar != pcNameToQuery[ x ] )\r
{\r
/* Characters didn't match. */\r
- break;\r
+ xBreakLoop = pdTRUE;\r
}\r
- else if( cNextChar == 0x00 )\r
+ else if( cNextChar == ( char ) 0x00 )\r
{\r
/* Both strings terminated, a match must have been\r
found. */\r
pxReturn = pxNextTCB;\r
- break;\r
+ xBreakLoop = pdTRUE;\r
}\r
else\r
{\r
mtCOVERAGE_TEST_MARKER();\r
}\r
+\r
+ if( xBreakLoop != pdFALSE )\r
+ {\r
+ break;\r
+ }\r
}\r
\r
if( pxReturn != NULL )\r
}\r
( void ) xTaskResumeAll();\r
\r
- return ( TaskHandle_t ) pxTCB;\r
+ return pxTCB;\r
}\r
\r
#endif /* INCLUDE_xTaskGetHandle */\r
\r
BaseType_t xTaskAbortDelay( TaskHandle_t xTask )\r
{\r
- TCB_t *pxTCB = ( TCB_t * ) xTask;\r
+ TCB_t *pxTCB = xTask;\r
BaseType_t xReturn;\r
\r
configASSERT( pxTCB );\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
+ pxTCB = listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
xItemValue = listGET_LIST_ITEM_VALUE( &( pxTCB->xStateListItem ) );\r
\r
if( xConstTickCount < xItemValue )\r
state - so record the item value in\r
xNextTaskUnblockTime. */\r
xNextTaskUnblockTime = xItemValue;\r
- break;\r
+ break; /*lint !e9011 Code structure here is deedmed easier to understand with multiple breaks. */\r
}\r
else\r
{\r
}\r
else\r
{\r
- xTCB = ( TCB_t * ) xTask;\r
+ xTCB = xTask;\r
}\r
\r
/* Save the hook function in the TCB. A critical section is required as\r
the value can be accessed from an interrupt. */\r
taskENTER_CRITICAL();\r
+ {\r
xTCB->pxTaskTag = pxHookFunction;\r
+ }\r
taskEXIT_CRITICAL();\r
}\r
\r
}\r
else\r
{\r
- xTCB = ( TCB_t * ) xTask;\r
+ xTCB = xTask;\r
}\r
\r
/* Save the hook function in the TCB. A critical section is required as\r
/* If xTask is NULL then we are calling our own task hook. */\r
if( xTask == NULL )\r
{\r
- xTCB = ( TCB_t * ) pxCurrentTCB;\r
+ xTCB = pxCurrentTCB;\r
}\r
else\r
{\r
- xTCB = ( TCB_t * ) xTask;\r
+ xTCB = xTask;\r
}\r
\r
if( xTCB->pxTaskTag != NULL )\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
#ifdef portALT_GET_RUN_TIME_COUNTER_VALUE\r
portALT_GET_RUN_TIME_COUNTER_VALUE( ulTotalRunTime );\r
#else\r
/* Check for stack overflow, if configured. */\r
taskCHECK_FOR_STACK_OVERFLOW();\r
\r
+ /* Before the currently running task is switched out, save its errno. */\r
+ #if( configUSE_POSIX_ERRNO == 1 )\r
+ {\r
+ pxCurrentTCB->iTaskErrno = FreeRTOS_errno;\r
+ }\r
+ #endif\r
+\r
/* Select a new task to run using either the generic C or port\r
optimised asm code. */\r
- taskSELECT_HIGHEST_PRIORITY_TASK();\r
+ taskSELECT_HIGHEST_PRIORITY_TASK(); /*lint !e9079 void * is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
traceTASK_SWITCHED_IN();\r
\r
+ /* After the new task is switched in, update the global errno. */\r
+ #if( configUSE_POSIX_ERRNO == 1 )\r
+ {\r
+ FreeRTOS_errno = pxCurrentTCB->iTaskErrno;\r
+ }\r
+ #endif\r
+\r
#if ( configUSE_NEWLIB_REENTRANT == 1 )\r
{\r
/* Switch Newlib's _impure_ptr variable to point to the _reent\r
\r
This function assumes that a check has already been made to ensure that\r
pxEventList is not empty. */\r
- pxUnblockedTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList );\r
+ pxUnblockedTCB = listGET_OWNER_OF_HEAD_ENTRY( pxEventList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
configASSERT( pxUnblockedTCB );\r
( void ) uxListRemove( &( pxUnblockedTCB->xEventListItem ) );\r
\r
\r
/* Remove the event list form the event flag. Interrupts do not access\r
event flags. */\r
- pxUnblockedTCB = ( TCB_t * ) listGET_LIST_ITEM_OWNER( pxEventListItem );\r
+ pxUnblockedTCB = listGET_LIST_ITEM_OWNER( pxEventListItem ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
configASSERT( pxUnblockedTCB );\r
( void ) uxListRemove( pxEventListItem );\r
\r
const TickType_t xElapsedTime = xConstTickCount - pxTimeOut->xTimeOnEntering;\r
\r
#if( INCLUDE_xTaskAbortDelay == 1 )\r
- if( pxCurrentTCB->ucDelayAborted != pdFALSE )\r
+ if( pxCurrentTCB->ucDelayAborted != ( uint8_t ) pdFALSE )\r
{\r
/* The delay was aborted, which is not the same as a time out,\r
but has the same result. */\r
}\r
else\r
{\r
+ *pxTicksToWait = 0;\r
xReturn = pdTRUE;\r
}\r
}\r
UBaseType_t uxTaskGetTaskNumber( TaskHandle_t xTask )\r
{\r
UBaseType_t uxReturn;\r
- TCB_t *pxTCB;\r
+ TCB_t const *pxTCB;\r
\r
if( xTask != NULL )\r
{\r
- pxTCB = ( TCB_t * ) xTask;\r
+ pxTCB = xTask;\r
uxReturn = pxTCB->uxTaskNumber;\r
}\r
else\r
\r
void vTaskSetTaskNumber( TaskHandle_t xTask, const UBaseType_t uxHandle )\r
{\r
- TCB_t *pxTCB;\r
+ TCB_t * pxTCB;\r
\r
if( xTask != NULL )\r
{\r
- pxTCB = ( TCB_t * ) xTask;\r
+ pxTCB = xTask;\r
pxTCB->uxTaskNumber = uxHandle;\r
}\r
}\r
/** THIS IS THE RTOS IDLE TASK - WHICH IS CREATED AUTOMATICALLY WHEN THE\r
SCHEDULER IS STARTED. **/\r
\r
+ /* In case a task that has a secure context deletes itself, in which case\r
+ the idle task is responsible for deleting the task's secure context, if\r
+ any. */\r
+ portTASK_CALLS_SECURE_FUNCTIONS();\r
+\r
for( ;; )\r
{\r
/* See if any tasks have deleted themselves - if so then the idle task\r
static void prvInitialiseTaskLists( void )\r
{\r
UBaseType_t uxPriority;\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
\r
for( uxPriority = ( UBaseType_t ) 0U; uxPriority < ( UBaseType_t ) configMAX_PRIORITIES; uxPriority++ )\r
{\r
\r
#if ( INCLUDE_vTaskDelete == 1 )\r
{\r
- BaseType_t xListIsEmpty;\r
+ TCB_t *pxTCB;\r
\r
- /* ucTasksDeleted is used to prevent vTaskSuspendAll() being called\r
- too often in the idle task. */\r
+ /* uxDeletedTasksWaitingCleanUp is used to prevent taskENTER_CRITICAL()\r
+ being called too often in the idle task. */\r
while( uxDeletedTasksWaitingCleanUp > ( UBaseType_t ) 0U )\r
{\r
- vTaskSuspendAll();\r
+ taskENTER_CRITICAL();\r
{\r
- xListIsEmpty = listLIST_IS_EMPTY( &xTasksWaitingTermination );\r
+ pxTCB = listGET_OWNER_OF_HEAD_ENTRY( ( &xTasksWaitingTermination ) ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
+ ( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
+ --uxCurrentNumberOfTasks;\r
+ --uxDeletedTasksWaitingCleanUp;\r
}\r
- ( void ) xTaskResumeAll();\r
-\r
- if( xListIsEmpty == pdFALSE )\r
- {\r
- TCB_t *pxTCB;\r
-\r
- taskENTER_CRITICAL();\r
- {\r
- pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &xTasksWaitingTermination ) );\r
- ( void ) uxListRemove( &( pxTCB->xStateListItem ) );\r
- --uxCurrentNumberOfTasks;\r
- --uxDeletedTasksWaitingCleanUp;\r
- }\r
- taskEXIT_CRITICAL();\r
+ taskEXIT_CRITICAL();\r
\r
- prvDeleteTCB( pxTCB );\r
- }\r
- else\r
- {\r
- mtCOVERAGE_TEST_MARKER();\r
- }\r
+ prvDeleteTCB( pxTCB );\r
}\r
}\r
#endif /* INCLUDE_vTaskDelete */\r
}\r
else\r
{\r
- pxTaskStatus->eCurrentState = eTaskGetState( xTask );\r
+ pxTaskStatus->eCurrentState = eTaskGetState( pxTCB );\r
}\r
\r
/* Obtaining the stack space takes some time, so the xGetFreeStackSpace\r
\r
if( listCURRENT_LIST_LENGTH( pxList ) > ( UBaseType_t ) 0 )\r
{\r
- listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList );\r
+ listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
\r
/* Populate an TaskStatus_t structure within the\r
pxTaskStatusArray array for each task that is referenced from\r
meaning of each TaskStatus_t structure member. */\r
do\r
{\r
- listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList );\r
+ listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
vTaskGetInfo( ( TaskHandle_t ) pxNextTCB, &( pxTaskStatusArray[ uxTask ] ), pdTRUE, eState );\r
uxTask++;\r
} while( pxNextTCB != pxFirstTCB );\r
\r
#if ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )\r
\r
- static uint16_t prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte )\r
+ static configSTACK_DEPTH_TYPE prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte )\r
{\r
uint32_t ulCount = 0U;\r
\r
\r
ulCount /= ( uint32_t ) sizeof( StackType_t ); /*lint !e961 Casting is not redundant on smaller architectures. */\r
\r
- return ( uint16_t ) ulCount;\r
+ return ( configSTACK_DEPTH_TYPE ) ulCount;\r
}\r
\r
#endif /* ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) ) */\r
vPortFree( pxTCB->pxStack );\r
vPortFree( pxTCB );\r
}\r
- #elif( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 Macro has been consolidated for readability reasons. */\r
+ #elif( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro has been consolidated for readability reasons. */\r
{\r
/* The task could have been allocated statically or dynamically, so\r
check what was statically allocated before trying to free the\r
{\r
/* Neither the stack nor the TCB were allocated dynamically, so\r
nothing needs to be freed. */\r
- configASSERT( pxTCB->ucStaticallyAllocated == tskSTATICALLY_ALLOCATED_STACK_AND_TCB )\r
+ configASSERT( pxTCB->ucStaticallyAllocated == tskSTATICALLY_ALLOCATED_STACK_AND_TCB );\r
mtCOVERAGE_TEST_MARKER();\r
}\r
}\r
the item at the head of the delayed list. This is the time at\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
+ ( pxTCB ) = listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too. Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
xNextTaskUnblockTime = listGET_LIST_ITEM_VALUE( &( ( pxTCB )->xStateListItem ) );\r
}\r
}\r
\r
BaseType_t xTaskPriorityInherit( TaskHandle_t const pxMutexHolder )\r
{\r
- TCB_t * const pxMutexHolderTCB = ( TCB_t * ) pxMutexHolder;\r
+ TCB_t * const pxMutexHolderTCB = pxMutexHolder;\r
BaseType_t xReturn = pdFALSE;\r
\r
/* If the mutex was given back by an interrupt while the queue was\r
\r
BaseType_t xTaskPriorityDisinherit( TaskHandle_t const pxMutexHolder )\r
{\r
- TCB_t * const pxTCB = ( TCB_t * ) pxMutexHolder;\r
+ TCB_t * const pxTCB = pxMutexHolder;\r
BaseType_t xReturn = pdFALSE;\r
\r
if( pxMutexHolder != NULL )\r
\r
void vTaskPriorityDisinheritAfterTimeout( TaskHandle_t const pxMutexHolder, UBaseType_t uxHighestPriorityWaitingTask )\r
{\r
- TCB_t * const pxTCB = ( TCB_t * ) pxMutexHolder;\r
+ TCB_t * const pxTCB = pxMutexHolder;\r
UBaseType_t uxPriorityUsedOnEntry, uxPriorityToUse;\r
const UBaseType_t uxOnlyOneMutexHeld = ( UBaseType_t ) 1;\r
\r
}\r
\r
/* Terminate. */\r
- pcBuffer[ x ] = 0x00;\r
+ pcBuffer[ x ] = ( char ) 0x00;\r
\r
/* Return the new end of string. */\r
return &( pcBuffer[ x ] );\r
void vTaskList( char * pcWriteBuffer )\r
{\r
TaskStatus_t *pxTaskStatusArray;\r
- volatile UBaseType_t uxArraySize, x;\r
+ UBaseType_t uxArraySize, x;\r
char cStatus;\r
\r
/*\r
\r
\r
/* Make sure the write buffer does not contain a string. */\r
- *pcWriteBuffer = 0x00;\r
+ *pcWriteBuffer = ( char ) 0x00;\r
\r
/* Take a snapshot of the number of tasks in case it changes while this\r
function is executing. */\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
+ pxTaskStatusArray = pvPortMalloc( uxCurrentNumberOfTasks * sizeof( TaskStatus_t ) ); /*lint !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack and this allocation allocates a struct that has the alignment requirements of a pointer. */\r
\r
if( pxTaskStatusArray != NULL )\r
{\r
{\r
switch( pxTaskStatusArray[ x ].eCurrentState )\r
{\r
+ case eRunning: cStatus = tskRUNNING_CHAR;\r
+ break;\r
+\r
case eReady: cStatus = tskREADY_CHAR;\r
break;\r
\r
case eDeleted: cStatus = tskDELETED_CHAR;\r
break;\r
\r
+ case eInvalid: /* Fall through. */\r
default: /* Should not get here, but it is included\r
to prevent static checking errors. */\r
- cStatus = 0x00;\r
+ cStatus = ( char ) 0x00;\r
break;\r
}\r
\r
pcWriteBuffer = prvWriteNameToBuffer( pcWriteBuffer, pxTaskStatusArray[ x ].pcTaskName );\r
\r
/* Write the rest of the string. */\r
- sprintf( pcWriteBuffer, "\t%c\t%u\t%u\t%u\r\n", cStatus, ( unsigned int ) pxTaskStatusArray[ x ].uxCurrentPriority, ( unsigned int ) pxTaskStatusArray[ x ].usStackHighWaterMark, ( unsigned int ) pxTaskStatusArray[ x ].xTaskNumber );\r
- pcWriteBuffer += strlen( pcWriteBuffer );\r
+ sprintf( pcWriteBuffer, "\t%c\t%u\t%u\t%u\r\n", cStatus, ( unsigned int ) pxTaskStatusArray[ x ].uxCurrentPriority, ( unsigned int ) pxTaskStatusArray[ x ].usStackHighWaterMark, ( unsigned int ) pxTaskStatusArray[ x ].xTaskNumber ); /*lint !e586 sprintf() allowed as this is compiled with many compilers and this is a utility function only - not part of the core kernel implementation. */\r
+ pcWriteBuffer += strlen( pcWriteBuffer ); /*lint !e9016 Pointer arithmetic ok on char pointers especially as in this case where it best denotes the intent of the code. */\r
}\r
\r
/* Free the array again. NOTE! If configSUPPORT_DYNAMIC_ALLOCATION\r
void vTaskGetRunTimeStats( char *pcWriteBuffer )\r
{\r
TaskStatus_t *pxTaskStatusArray;\r
- volatile UBaseType_t uxArraySize, x;\r
+ UBaseType_t uxArraySize, x;\r
uint32_t ulTotalTime, ulStatsAsPercentage;\r
\r
#if( configUSE_TRACE_FACILITY != 1 )\r
*/\r
\r
/* Make sure the write buffer does not contain a string. */\r
- *pcWriteBuffer = 0x00;\r
+ *pcWriteBuffer = ( char ) 0x00;\r
\r
/* Take a snapshot of the number of tasks in case it changes while this\r
function is executing. */\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
+ pxTaskStatusArray = pvPortMalloc( uxCurrentNumberOfTasks * sizeof( TaskStatus_t ) ); /*lint !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack and this allocation allocates a struct that has the alignment requirements of a pointer. */\r
\r
if( pxTaskStatusArray != NULL )\r
{\r
ulTotalTime /= 100UL;\r
\r
/* Avoid divide by zero errors. */\r
- if( ulTotalTime > 0 )\r
+ if( ulTotalTime > 0UL )\r
{\r
/* Create a human readable table from the binary data. */\r
for( x = 0; x < uxArraySize; x++ )\r
{\r
/* sizeof( int ) == sizeof( long ) so a smaller\r
printf() library can be used. */\r
- sprintf( pcWriteBuffer, "\t%u\t\t%u%%\r\n", ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter, ( unsigned int ) ulStatsAsPercentage );\r
+ sprintf( pcWriteBuffer, "\t%u\t\t%u%%\r\n", ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter, ( unsigned int ) ulStatsAsPercentage ); /*lint !e586 sprintf() allowed as this is compiled with many compilers and this is a utility function only - not part of the core kernel implementation. */\r
}\r
#endif\r
}\r
{\r
/* sizeof( int ) == sizeof( long ) so a smaller\r
printf() library can be used. */\r
- sprintf( pcWriteBuffer, "\t%u\t\t<1%%\r\n", ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter );\r
+ sprintf( pcWriteBuffer, "\t%u\t\t<1%%\r\n", ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter ); /*lint !e586 sprintf() allowed as this is compiled with many compilers and this is a utility function only - not part of the core kernel implementation. */\r
}\r
#endif\r
}\r
\r
- pcWriteBuffer += strlen( pcWriteBuffer );\r
+ pcWriteBuffer += strlen( pcWriteBuffer ); /*lint !e9016 Pointer arithmetic ok on char pointers especially as in this case where it best denotes the intent of the code. */\r
}\r
}\r
else\r
\r
#if ( configUSE_MUTEXES == 1 )\r
\r
- void *pvTaskIncrementMutexHeldCount( void )\r
+ TaskHandle_t pvTaskIncrementMutexHeldCount( void )\r
{\r
/* If xSemaphoreCreateMutex() is called before any tasks have been created\r
then pxCurrentTCB will be NULL. */\r
uint8_t ucOriginalNotifyState;\r
\r
configASSERT( xTaskToNotify );\r
- pxTCB = ( TCB_t * ) xTaskToNotify;\r
+ pxTCB = xTaskToNotify;\r
\r
taskENTER_CRITICAL();\r
{\r
/* The task is being notified without its notify value being\r
updated. */\r
break;\r
+\r
+ default:\r
+ /* Should not get here if all enums are handled.\r
+ Artificially force an assert by testing a value the\r
+ compiler can't assume is const. */\r
+ configASSERT( pxTCB->ulNotifiedValue == ~0UL );\r
+\r
+ break;\r
}\r
\r
traceTASK_NOTIFY();\r
http://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
portASSERT_IF_INTERRUPT_PRIORITY_INVALID();\r
\r
- pxTCB = ( TCB_t * ) xTaskToNotify;\r
+ pxTCB = xTaskToNotify;\r
\r
uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();\r
{\r
/* The task is being notified without its notify value being\r
updated. */\r
break;\r
+\r
+ default:\r
+ /* Should not get here if all enums are handled.\r
+ Artificially force an assert by testing a value the\r
+ compiler can't assume is const. */\r
+ configASSERT( pxTCB->ulNotifiedValue == ~0UL );\r
+ break;\r
}\r
\r
traceTASK_NOTIFY_FROM_ISR();\r
{\r
*pxHigherPriorityTaskWoken = pdTRUE;\r
}\r
- else\r
- {\r
- /* Mark that a yield is pending in case the user is not\r
- using the "xHigherPriorityTaskWoken" parameter to an ISR\r
- safe FreeRTOS function. */\r
- xYieldPending = pdTRUE;\r
- }\r
+\r
+ /* Mark that a yield is pending in case the user is not\r
+ using the "xHigherPriorityTaskWoken" parameter to an ISR\r
+ safe FreeRTOS function. */\r
+ xYieldPending = pdTRUE;\r
}\r
else\r
{\r
http://www.freertos.org/RTOS-Cortex-M3-M4.html */\r
portASSERT_IF_INTERRUPT_PRIORITY_INVALID();\r
\r
- pxTCB = ( TCB_t * ) xTaskToNotify;\r
+ pxTCB = xTaskToNotify;\r
\r
uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();\r
{\r
{\r
*pxHigherPriorityTaskWoken = pdTRUE;\r
}\r
- else\r
- {\r
- /* Mark that a yield is pending in case the user is not\r
- using the "xHigherPriorityTaskWoken" parameter in an ISR\r
- safe FreeRTOS function. */\r
- xYieldPending = pdTRUE;\r
- }\r
+\r
+ /* Mark that a yield is pending in case the user is not\r
+ using the "xHigherPriorityTaskWoken" parameter in an ISR\r
+ safe FreeRTOS function. */\r
+ xYieldPending = pdTRUE;\r
}\r
else\r
{\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
- portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );\r
+ portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority ); /*lint !e931 pxCurrentTCB cannot change as it is the calling task. pxCurrentTCB->uxPriority and uxTopReadyPriority cannot change as called with scheduler suspended or in a critical section. */\r
}\r
else\r
{\r
\r
#include "freertos_tasks_c_additions.h"\r
\r
- static void freertos_tasks_c_additions_init( void )\r
- {\r
- #ifdef FREERTOS_TASKS_C_ADDITIONS_INIT\r
+ #ifdef FREERTOS_TASKS_C_ADDITIONS_INIT\r
+ static void freertos_tasks_c_additions_init( void )\r
+ {\r
FREERTOS_TASKS_C_ADDITIONS_INIT();\r
- #endif\r
- }\r
+ }\r
+ #endif\r
\r
#endif\r
\r
projects / freertos / blobdiff