Add some defensive programming in the default tickless mode in case the application...

git-svn-id: https://svn.code.sf.net/p/freertos/code/trunk@2057 1d2547de-c912-0410-9cb9-b8ca96c0e9e2

diff --git a/FreeRTOS/Source/portable/GCC/ARM_CM3/port.c b/FreeRTOS/Source/portable/GCC/ARM_CM3/port.c
index ed7b4e5e1318ec97c35a87b108b848c8269b6512..7603978c078bf249e49e82662ad48ed65b125c68 100644 (file)
--- a/FreeRTOS/Source/portable/GCC/ARM_CM3/port.c
+++ b/FreeRTOS/Source/portable/GCC/ARM_CM3/port.c
@@ -547,12 +547,24 @@ void xPortSysTickHandler( void )
 \r
                        if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )\r
                        {\r
+                               unsigned long ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt has already executed, and the SysTick\r
                                count reloaded with ulReloadValue.  Reset the\r
                                portNVIC_SYSTICK_LOAD_REG with whatever remains of this tick\r
                                period. */\r
-                               portNVIC_SYSTICK_LOAD_REG = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
-\r
+                               ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
+\r
+                               /* Don't allow a tiny value, or values that have somehow \r
+                               underflowed because the post sleep hook did something \r
+                               that took too long. */\r
+                               if( ( ulCalculatedLoadValue < ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )\r
+                               {\r
+                                       ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );\r
+                               }\r
+                               \r
+                               portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt handler will already have pended the tick\r
                                processing in the kernel.  As the pending tick will be\r
                                processed as soon as this function exits, the tick value\r

diff --git a/FreeRTOS/Source/portable/GCC/ARM_CM4F/port.c b/FreeRTOS/Source/portable/GCC/ARM_CM4F/port.c
index 0579ae92909f8f2439df40bee0cbfeb3199c3447..ee9e36262214fec0b847da4197b6d5b5e187f1da 100644 (file)
--- a/FreeRTOS/Source/portable/GCC/ARM_CM4F/port.c
+++ b/FreeRTOS/Source/portable/GCC/ARM_CM4F/port.c
@@ -590,12 +590,24 @@ void xPortSysTickHandler( void )
 \r
                        if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )\r
                        {\r
+                               unsigned long ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt has already executed, and the SysTick\r
                                count reloaded with ulReloadValue.  Reset the\r
                                portNVIC_SYSTICK_LOAD_REG with whatever remains of this tick\r
                                period. */\r
-                               portNVIC_SYSTICK_LOAD_REG = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
-\r
+                               ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
+\r
+                               /* Don't allow a tiny value, or values that have somehow \r
+                               underflowed because the post sleep hook did something \r
+                               that took too long. */\r
+                               if( ( ulCalculatedLoadValue < ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )\r
+                               {\r
+                                       ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );\r
+                               }\r
+                               \r
+                               portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt handler will already have pended the tick\r
                                processing in the kernel.  As the pending tick will be\r
                                processed as soon as this function exits, the tick value\r

diff --git a/FreeRTOS/Source/portable/IAR/ARM_CM3/port.c b/FreeRTOS/Source/portable/IAR/ARM_CM3/port.c
index 3ed02de16f265a2b43470254af73674353786b9b..45f768f3adb34022830280b6d5ad6a83fca2b640 100644 (file)
--- a/FreeRTOS/Source/portable/IAR/ARM_CM3/port.c
+++ b/FreeRTOS/Source/portable/IAR/ARM_CM3/port.c
@@ -440,12 +440,24 @@ void xPortSysTickHandler( void )
 \r
                        if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )\r
                        {\r
+                               unsigned long ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt has already executed, and the SysTick\r
                                count reloaded with ulReloadValue.  Reset the\r
                                portNVIC_SYSTICK_LOAD_REG with whatever remains of this tick\r
                                period. */\r
-                               portNVIC_SYSTICK_LOAD_REG = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
-\r
+                               ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
+\r
+                               /* Don't allow a tiny value, or values that have somehow \r
+                               underflowed because the post sleep hook did something \r
+                               that took too long. */\r
+                               if( ( ulCalculatedLoadValue < ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )\r
+                               {\r
+                                       ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );\r
+                               }\r
+                               \r
+                               portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt handler will already have pended the tick\r
                                processing in the kernel.  As the pending tick will be\r
                                processed as soon as this function exits, the tick value\r

diff --git a/FreeRTOS/Source/portable/IAR/ARM_CM4F/port.c b/FreeRTOS/Source/portable/IAR/ARM_CM4F/port.c
index 3cdd25b3048a49e5467c754993101fb2f27de034..21425e567af530d4cfdb1e62b4530c88f4ef3a60 100644 (file)
--- a/FreeRTOS/Source/portable/IAR/ARM_CM4F/port.c
+++ b/FreeRTOS/Source/portable/IAR/ARM_CM4F/port.c
@@ -154,6 +154,11 @@ extern void vPortStartFirstTask( void );
  */\r
 extern void vPortEnableVFP( void );\r
 \r
+/*\r
+ * Used to catch tasks that attempt to return from their implementing function.\r
+ */\r
+static void prvTaskExitError( void );\r
+\r
 /*-----------------------------------------------------------*/\r
 \r
 /*\r
@@ -208,7 +213,7 @@ portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE
        pxTopOfStack--;\r
        *pxTopOfStack = ( portSTACK_TYPE ) pxCode;      /* PC */\r
        pxTopOfStack--;\r
-       *pxTopOfStack = 0;      /* LR */\r
+       *pxTopOfStack = ( portSTACK_TYPE ) prvTaskExitError;    /* LR */\r
 \r
        /* Save code space by skipping register initialisation. */\r
        pxTopOfStack -= 5;      /* R12, R3, R2 and R1. */\r
@@ -225,6 +230,20 @@ portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE
 }\r
 /*-----------------------------------------------------------*/\r
 \r
+static void prvTaskExitError( void )\r
+{\r
+       /* A function that implements a task must not exit or attempt to return to\r
+       its caller as there is nothing to return to.  If a task wants to exit it\r
+       should instead call vTaskDelete( NULL ).\r
+\r
+       Artificially force an assert() to be triggered if configASSERT() is\r
+       defined, then stop here so application writers can catch the error. */\r
+       configASSERT( uxCriticalNesting == ~0UL );\r
+       portDISABLE_INTERRUPTS();\r
+       for( ;; );\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
 /*\r
  * See header file for description.\r
  */\r
@@ -393,9 +412,17 @@ void xPortSysTickHandler( void )
                to be unsuspended then abandon the low power entry. */\r
                if( eTaskConfirmSleepModeStatus() == eAbortSleep )\r
                {\r
+                       /* Restart from whatever is left in the count register to complete\r
+                       this tick period. */\r
+                       portNVIC_SYSTICK_LOAD_REG = portNVIC_SYSTICK_CURRENT_VALUE_REG;\r
+\r
                        /* Restart SysTick. */\r
                        portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT;\r
 \r
+                       /* Reset the reload register to the value required for normal tick\r
+                       periods. */\r
+                       portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;\r
+\r
                        /* Re-enable interrupts - see comments above __disable_interrupt()\r
                        call above. */\r
                        __enable_interrupt();\r
@@ -439,12 +466,24 @@ void xPortSysTickHandler( void )
 \r
                        if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )\r
                        {\r
+                               unsigned long ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt has already executed, and the SysTick\r
                                count reloaded with ulReloadValue.  Reset the\r
                                portNVIC_SYSTICK_LOAD_REG with whatever remains of this tick\r
                                period. */\r
-                               portNVIC_SYSTICK_LOAD_REG = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
-\r
+                               ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
+\r
+                               /* Don't allow a tiny value, or values that have somehow \r
+                               underflowed because the post sleep hook did something \r
+                               that took too long. */\r
+                               if( ( ulCalculatedLoadValue < ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )\r
+                               {\r
+                                       ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );\r
+                               }\r
+                               \r
+                               portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt handler will already have pended the tick\r
                                processing in the kernel.  As the pending tick will be\r
                                processed as soon as this function exits, the tick value\r

diff --git a/FreeRTOS/Source/portable/RVDS/ARM_CM3/port.c b/FreeRTOS/Source/portable/RVDS/ARM_CM3/port.c
index 9d1e53e677a8c7cde5e70c9323000e46bcf9e8e5..5e4c2b31dea89852e35e59db565cb61a50044a3f 100644 (file)
--- a/FreeRTOS/Source/portable/RVDS/ARM_CM3/port.c
+++ b/FreeRTOS/Source/portable/RVDS/ARM_CM3/port.c
@@ -516,12 +516,24 @@ void xPortSysTickHandler( void )
 \r
                        if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )\r
                        {\r
+                               unsigned long ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt has already executed, and the SysTick\r
                                count reloaded with ulReloadValue.  Reset the\r
                                portNVIC_SYSTICK_LOAD_REG with whatever remains of this tick\r
                                period. */\r
-                               portNVIC_SYSTICK_LOAD_REG = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
-\r
+                               ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
+\r
+                               /* Don't allow a tiny value, or values that have somehow \r
+                               underflowed because the post sleep hook did something \r
+                               that took too long. */\r
+                               if( ( ulCalculatedLoadValue < ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )\r
+                               {\r
+                                       ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );\r
+                               }\r
+                               \r
+                               portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt handler will already have pended the tick\r
                                processing in the kernel.  As the pending tick will be\r
                                processed as soon as this function exits, the tick value\r

diff --git a/FreeRTOS/Source/portable/RVDS/ARM_CM4F/port.c b/FreeRTOS/Source/portable/RVDS/ARM_CM4F/port.c
index a5b81f7bc1208521e806352923f032ec2d8a9b00..21f1a3be5a991ca9c864076320169dc2b9143bc4 100644 (file)
--- a/FreeRTOS/Source/portable/RVDS/ARM_CM4F/port.c
+++ b/FreeRTOS/Source/portable/RVDS/ARM_CM4F/port.c
@@ -587,12 +587,24 @@ void xPortSysTickHandler( void )
 \r
                        if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )\r
                        {\r
+                               unsigned long ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt has already executed, and the SysTick\r
                                count reloaded with ulReloadValue.  Reset the\r
                                portNVIC_SYSTICK_LOAD_REG with whatever remains of this tick\r
                                period. */\r
-                               portNVIC_SYSTICK_LOAD_REG = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
-\r
+                               ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );\r
+\r
+                               /* Don't allow a tiny value, or values that have somehow \r
+                               underflowed because the post sleep hook did something \r
+                               that took too long. */\r
+                               if( ( ulCalculatedLoadValue < ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )\r
+                               {\r
+                                       ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );\r
+                               }\r
+                               \r
+                               portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;\r
+                               \r
                                /* The tick interrupt handler will already have pended the tick\r
                                processing in the kernel.  As the pending tick will be\r
                                processed as soon as this function exits, the tick value\r