From ba505118219b94ced30fb8961287216e74f8fe80 Mon Sep 17 00:00:00 2001
From: Gaurav Aggarwal <aggarg@amazon.com>
Date: Wed, 6 Oct 2021 19:13:48 -0700
Subject: [PATCH] Change xPortRaisePrivilege and vPortResetPrivilege to macros

This prevents non-kernel code from calling these functions.

Signed-off-by: Gaurav Aggarwal <aggarg@amazon.com>
---
 include/mpu_wrappers.h           |  32 ++-
 portable/Common/mpu_wrappers.c   | 466 ++++++++++++++++++-------------
 portable/GCC/ARM_CM3_MPU/port.c  |  17 +-
 portable/GCC/ARM_CM4_MPU/port.c  |  17 +-
 portable/IAR/ARM_CM4F_MPU/port.c |  21 +-
 portable/RVDS/ARM_CM4_MPU/port.c |  17 +-
 6 files changed, 337 insertions(+), 233 deletions(-)

diff --git a/include/mpu_wrappers.h b/include/mpu_wrappers.h
index 14b712eea..8fbce8e9b 100644
--- a/include/mpu_wrappers.h
+++ b/include/mpu_wrappers.h
@@ -165,11 +165,41 @@
 
     #else /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */
 
-/* Ensure API functions go in the privileged execution section. */
+        /* Ensure API functions go in the privileged execution section. */
         #define PRIVILEGED_FUNCTION     __attribute__( ( section( "privileged_functions" ) ) )
         #define PRIVILEGED_DATA         __attribute__( ( section( "privileged_data" ) ) )
         #define FREERTOS_SYSTEM_CALL    __attribute__( ( section( "freertos_system_calls" ) ) )
 
+        /**
+         * @brief Calls the port specific code to raise the privilege.
+         *
+         * Sets xRunningPrivileged to pdFALSE if privilege was raised, else sets
+         * it to pdTRUE.
+         */
+        #define xPortRaisePrivilege( xRunningPrivileged )                      \
+        {                                                                      \
+            /* Check whether the processor is already privileged. */           \
+            xRunningPrivileged = portIS_PRIVILEGED();                          \
+                                                                               \
+            /* If the processor is not already privileged, raise privilege. */ \
+            if( xRunningPrivileged == pdFALSE )                                \
+            {                                                                  \
+                portRAISE_PRIVILEGE();                                         \
+            }                                                                  \
+        }
+
+        /**
+         * @brief If xRunningPrivileged is not pdTRUE, calls the port specific
+         * code to reset the privilege, otherwise does nothing.
+         */
+        #define vPortResetPrivilege( xRunningPrivileged )   \
+        {                                                   \
+            if( xRunningPrivileged == pdFALSE )             \
+            {                                               \
+                portRESET_PRIVILEGE();                      \
+            }                                               \
+        }
+
     #endif /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */
 
 #else /* portUSING_MPU_WRAPPERS */
diff --git a/portable/Common/mpu_wrappers.c b/portable/Common/mpu_wrappers.c
index 48d1def72..571676a24 100644
--- a/portable/Common/mpu_wrappers.c
+++ b/portable/Common/mpu_wrappers.c
@@ -44,45 +44,6 @@
 #include "mpu_prototypes.h"
 
 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
-
-/**
- * @brief Calls the port specific code to raise the privilege.
- *
- * @return pdFALSE if privilege was raised, pdTRUE otherwise.
- */
-BaseType_t xPortRaisePrivilege( void ) FREERTOS_SYSTEM_CALL;
-
-/**
- * @brief If xRunningPrivileged is not pdTRUE, calls the port specific
- * code to reset the privilege, otherwise does nothing.
- */
-void vPortResetPrivilege( BaseType_t xRunningPrivileged );
-/*-----------------------------------------------------------*/
-
-BaseType_t xPortRaisePrivilege( void ) /* FREERTOS_SYSTEM_CALL */
-{
-    BaseType_t xRunningPrivileged;
-
-    /* Check whether the processor is already privileged. */
-    xRunningPrivileged = portIS_PRIVILEGED();
-
-    /* If the processor is not already privileged, raise privilege. */
-    if( xRunningPrivileged == pdFALSE )
-    {
-        portRAISE_PRIVILEGE();
-    }
-
-    return xRunningPrivileged;
-}
-/*-----------------------------------------------------------*/
-
-void vPortResetPrivilege( BaseType_t xRunningPrivileged )
-{
-    if( xRunningPrivileged == pdFALSE )
-    {
-        portRESET_PRIVILEGE();
-    }
-}
 /*-----------------------------------------------------------*/
 
 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
@@ -93,11 +54,12 @@ void vPortResetPrivilege( BaseType_t xRunningPrivileged )
                                 UBaseType_t uxPriority,
                                 TaskHandle_t * pxCreatedTask ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
@@ -113,10 +75,12 @@ void vPortResetPrivilege( BaseType_t xRunningPrivileged )
                                         StaticTask_t * const pxTaskBuffer ) /* FREERTOS_SYSTEM_CALL */
     {
         TaskHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskCreateStatic( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* configSUPPORT_STATIC_ALLOCATION */
@@ -125,8 +89,9 @@ void vPortResetPrivilege( BaseType_t xRunningPrivileged )
 #if ( INCLUDE_vTaskDelete == 1 )
     void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTaskDelete( pxTaskToDelete );
         vPortResetPrivilege( xRunningPrivileged );
     }
@@ -137,34 +102,37 @@ void vPortResetPrivilege( BaseType_t xRunningPrivileged )
     BaseType_t MPU_xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
                                     TickType_t xTimeIncrement ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
-        BaseType_t xReturn;
+        BaseType_t xRunningPrivileged, xReturn;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( INCLUDE_xTaskDelayUntil == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( INCLUDE_xTaskAbortDelay == 1 )
     BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskAbortDelay( xTask );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( INCLUDE_xTaskAbortDelay == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( INCLUDE_vTaskDelay == 1 )
     void MPU_vTaskDelay( TickType_t xTicksToDelay ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTaskDelay( xTicksToDelay );
         vPortResetPrivilege( xRunningPrivileged );
     }
@@ -175,38 +143,43 @@ void vPortResetPrivilege( BaseType_t xRunningPrivileged )
     UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */
     {
         UBaseType_t uxReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         uxReturn = uxTaskPriorityGet( pxTask );
         vPortResetPrivilege( xRunningPrivileged );
+
         return uxReturn;
     }
-#endif
+#endif /* if ( INCLUDE_uxTaskPriorityGet == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( INCLUDE_vTaskPrioritySet == 1 )
     void MPU_vTaskPrioritySet( TaskHandle_t pxTask,
                                UBaseType_t uxNewPriority ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTaskPrioritySet( pxTask, uxNewPriority );
         vPortResetPrivilege( xRunningPrivileged );
     }
-#endif
+#endif /* if ( INCLUDE_vTaskPrioritySet == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( INCLUDE_eTaskGetState == 1 )
     eTaskState MPU_eTaskGetState( TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
         eTaskState eReturn;
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         eReturn = eTaskGetState( pxTask );
         vPortResetPrivilege( xRunningPrivileged );
+
         return eReturn;
     }
-#endif
+#endif /* if ( INCLUDE_eTaskGetState == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( configUSE_TRACE_FACILITY == 1 )
@@ -215,8 +188,9 @@ void vPortResetPrivilege( BaseType_t xRunningPrivileged )
                            BaseType_t xGetFreeStackSpace,
                            eTaskState eState ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );
         vPortResetPrivilege( xRunningPrivileged );
     }
@@ -227,20 +201,23 @@ void vPortResetPrivilege( BaseType_t xRunningPrivileged )
     TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
     {
         TaskHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskGetIdleTaskHandle();
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( INCLUDE_vTaskSuspend == 1 )
     void MPU_vTaskSuspend( TaskHandle_t pxTaskToSuspend ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTaskSuspend( pxTaskToSuspend );
         vPortResetPrivilege( xRunningPrivileged );
     }
@@ -250,8 +227,9 @@ void vPortResetPrivilege( BaseType_t xRunningPrivileged )
 #if ( INCLUDE_vTaskSuspend == 1 )
     void MPU_vTaskResume( TaskHandle_t pxTaskToResume ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTaskResume( pxTaskToResume );
         vPortResetPrivilege( xRunningPrivileged );
     }
@@ -260,8 +238,9 @@ void vPortResetPrivilege( BaseType_t xRunningPrivileged )
 
 void MPU_vTaskSuspendAll( void ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     vTaskSuspendAll();
     vPortResetPrivilege( xRunningPrivileged );
 }
@@ -269,11 +248,12 @@ void MPU_vTaskSuspendAll( void ) /* FREERTOS_SYSTEM_CALL */
 
 BaseType_t MPU_xTaskResumeAll( void ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xTaskResumeAll();
     vPortResetPrivilege( xRunningPrivileged );
+
     return xReturn;
 }
 /*-----------------------------------------------------------*/
@@ -281,10 +261,12 @@ BaseType_t MPU_xTaskResumeAll( void ) /* FREERTOS_SYSTEM_CALL */
 TickType_t MPU_xTaskGetTickCount( void ) /* FREERTOS_SYSTEM_CALL */
 {
     TickType_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xTaskGetTickCount();
     vPortResetPrivilege( xRunningPrivileged );
+
     return xReturn;
 }
 /*-----------------------------------------------------------*/
@@ -292,10 +274,12 @@ TickType_t MPU_xTaskGetTickCount( void ) /* FREERTOS_SYSTEM_CALL */
 UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) /* FREERTOS_SYSTEM_CALL */
 {
     UBaseType_t uxReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     uxReturn = uxTaskGetNumberOfTasks();
     vPortResetPrivilege( xRunningPrivileged );
+
     return uxReturn;
 }
 /*-----------------------------------------------------------*/
@@ -303,10 +287,12 @@ UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) /* FREERTOS_SYSTEM_CALL */
 char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* FREERTOS_SYSTEM_CALL */
 {
     char * pcReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     pcReturn = pcTaskGetName( xTaskToQuery );
     vPortResetPrivilege( xRunningPrivileged );
+
     return pcReturn;
 }
 /*-----------------------------------------------------------*/
@@ -315,20 +301,23 @@ char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* FREERTOS_SYSTEM_CALL */
     TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) /* FREERTOS_SYSTEM_CALL */
     {
         TaskHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskGetHandle( pcNameToQuery );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( INCLUDE_xTaskGetHandle == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
     void MPU_vTaskList( char * pcWriteBuffer ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTaskList( pcWriteBuffer );
         vPortResetPrivilege( xRunningPrivileged );
     }
@@ -338,8 +327,9 @@ char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* FREERTOS_SYSTEM_CALL */
 #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
     void MPU_vTaskGetRunTimeStats( char * pcWriteBuffer ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTaskGetRunTimeStats( pcWriteBuffer );
         vPortResetPrivilege( xRunningPrivileged );
     }
@@ -350,38 +340,43 @@ char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* FREERTOS_SYSTEM_CALL */
     uint32_t MPU_ulTaskGetIdleRunTimeCounter( void ) /* FREERTOS_SYSTEM_CALL */
     {
         uint32_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = ulTaskGetIdleRunTimeCounter();
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
 /*-----------------------------------------------------------*/
 
 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
     void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask,
                                          TaskHookFunction_t pxTagValue ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTaskSetApplicationTaskTag( xTask, pxTagValue );
         vPortResetPrivilege( xRunningPrivileged );
     }
-#endif
+#endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( configUSE_APPLICATION_TASK_TAG == 1 )
     TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
     {
         TaskHookFunction_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskGetApplicationTaskTag( xTask );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
@@ -389,12 +384,13 @@ char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* FREERTOS_SYSTEM_CALL */
                                                 BaseType_t xIndex,
                                                 void * pvValue ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
         vPortResetPrivilege( xRunningPrivileged );
     }
-#endif
+#endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
 /*-----------------------------------------------------------*/
 
 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
@@ -402,10 +398,12 @@ char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* FREERTOS_SYSTEM_CALL */
                                                    BaseType_t xIndex ) /* FREERTOS_SYSTEM_CALL */
     {
         void * pvReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
         vPortResetPrivilege( xRunningPrivileged );
+
         return pvReturn;
     }
 #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
@@ -415,11 +413,12 @@ char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* FREERTOS_SYSTEM_CALL */
     BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask,
                                                  void * pvParameter ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
@@ -431,10 +430,12 @@ char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* FREERTOS_SYSTEM_CALL */
                                           uint32_t * pulTotalRunTime ) /* FREERTOS_SYSTEM_CALL */
     {
         UBaseType_t uxReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );
         vPortResetPrivilege( xRunningPrivileged );
+
         return uxReturn;
     }
 #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
@@ -442,11 +443,12 @@ char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) /* FREERTOS_SYSTEM_CALL */
 
 BaseType_t MPU_xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xTaskCatchUpTicks( xTicksToCatchUp );
     vPortResetPrivilege( xRunningPrivileged );
+
     return xReturn;
 }
 /*-----------------------------------------------------------*/
@@ -455,58 +457,66 @@ BaseType_t MPU_xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) /* FREERTOS_SYSTE
     UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
     {
         UBaseType_t uxReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         uxReturn = uxTaskGetStackHighWaterMark( xTask );
         vPortResetPrivilege( xRunningPrivileged );
+
         return uxReturn;
     }
-#endif
+#endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
     configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
     {
         configSTACK_DEPTH_TYPE uxReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         uxReturn = uxTaskGetStackHighWaterMark2( xTask );
         vPortResetPrivilege( xRunningPrivileged );
+
         return uxReturn;
     }
-#endif
+#endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) */
 /*-----------------------------------------------------------*/
 
-#if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ))
+#if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) )
     TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
     {
         TaskHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskGetCurrentTaskHandle();
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) ) */
 /*-----------------------------------------------------------*/
 
 #if ( INCLUDE_xTaskGetSchedulerState == 1 )
     BaseType_t MPU_xTaskGetSchedulerState( void ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskGetSchedulerState();
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( INCLUDE_xTaskGetSchedulerState == 1 ) */
 /*-----------------------------------------------------------*/
 
 void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     vTaskSetTimeOutState( pxTimeOut );
     vPortResetPrivilege( xRunningPrivileged );
 }
@@ -515,11 +525,12 @@ void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* FREERTOS_SYSTEM_
 BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
                                      TickType_t * const pxTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
     vPortResetPrivilege( xRunningPrivileged );
+
     return xReturn;
 }
 /*-----------------------------------------------------------*/
@@ -531,11 +542,12 @@ BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
                                        eNotifyAction eAction,
                                        uint32_t * pulPreviousNotificationValue ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
@@ -548,11 +560,12 @@ BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
                                            uint32_t * pulNotificationValue,
                                            TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskGenericNotifyWait( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
@@ -564,10 +577,12 @@ BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
                                           TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
     {
         uint32_t ulReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait );
         vPortResetPrivilege( xRunningPrivileged );
+
         return ulReturn;
     }
 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
@@ -577,11 +592,12 @@ BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
     BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask,
                                                  UBaseType_t uxIndexToClear ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
@@ -593,10 +609,12 @@ BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
                                                 uint32_t ulBitsToClear ) /* FREERTOS_SYSTEM_CALL */
     {
         uint32_t ulReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear );
         vPortResetPrivilege( xRunningPrivileged );
+
         return ulReturn;
     }
 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
@@ -608,10 +626,12 @@ BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
                                            uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
     {
         QueueHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */
@@ -625,10 +645,12 @@ BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
                                                  const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
     {
         QueueHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
@@ -637,11 +659,12 @@ BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
 BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue,
                                    BaseType_t xNewQueue ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xQueueGenericReset( pxQueue, xNewQueue );
     vPortResetPrivilege( xRunningPrivileged );
+
     return xReturn;
 }
 /*-----------------------------------------------------------*/
@@ -651,33 +674,38 @@ BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue,
                                   TickType_t xTicksToWait,
                                   BaseType_t xCopyPosition ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );
     vPortResetPrivilege( xRunningPrivileged );
+
     return xReturn;
 }
 /*-----------------------------------------------------------*/
 
 UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
     UBaseType_t uxReturn;
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     uxReturn = uxQueueMessagesWaiting( pxQueue );
     vPortResetPrivilege( xRunningPrivileged );
+
     return uxReturn;
 }
 /*-----------------------------------------------------------*/
 
 UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
     UBaseType_t uxReturn;
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     uxReturn = uxQueueSpacesAvailable( xQueue );
     vPortResetPrivilege( xRunningPrivileged );
+
     return uxReturn;
 }
 /*-----------------------------------------------------------*/
@@ -686,11 +714,12 @@ BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue,
                               void * const pvBuffer,
                               TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
-    BaseType_t xReturn;
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );
     vPortResetPrivilege( xRunningPrivileged );
+
     return xReturn;
 }
 /*-----------------------------------------------------------*/
@@ -699,11 +728,12 @@ BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue,
                            void * const pvBuffer,
                            TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
-    BaseType_t xReturn;
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );
     vPortResetPrivilege( xRunningPrivileged );
+
     return xReturn;
 }
 /*-----------------------------------------------------------*/
@@ -711,11 +741,12 @@ BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue,
 BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
                                     TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
-    BaseType_t xReturn;
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );
     vPortResetPrivilege( xRunningPrivileged );
+
     return xReturn;
 }
 /*-----------------------------------------------------------*/
@@ -723,27 +754,31 @@ BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
     TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
         void * xReturn;
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueGetMutexHolder( xSemaphore );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
 /*-----------------------------------------------------------*/
 
 #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
     QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
     {
         QueueHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueCreateMutex( ucQueueType );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
 /*-----------------------------------------------------------*/
 
 #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
@@ -751,10 +786,12 @@ BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
                                                StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
     {
         QueueHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
@@ -765,10 +802,12 @@ BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
                                                      UBaseType_t uxInitialCount ) /* FREERTOS_SYSTEM_CALL */
     {
         QueueHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
@@ -781,10 +820,12 @@ BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
                                                            StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
     {
         QueueHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
@@ -794,11 +835,12 @@ BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
     BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex,
                                              TickType_t xBlockTime ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
@@ -807,27 +849,30 @@ BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
     BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueGiveMutexRecursive( xMutex );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
     QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength ) /* FREERTOS_SYSTEM_CALL */
     {
         QueueSetHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueCreateSet( uxEventQueueLength );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
-#endif
+#endif /* if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
 /*-----------------------------------------------------------*/
 
 #if ( configUSE_QUEUE_SETS == 1 )
@@ -835,10 +880,12 @@ BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
                                                     TickType_t xBlockTimeTicks ) /* FREERTOS_SYSTEM_CALL */
     {
         QueueSetMemberHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
@@ -848,11 +895,12 @@ BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
     BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
                                    QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
@@ -862,11 +910,12 @@ BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
     BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
                                         QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
         vPortResetPrivilege( xRunningPrivileged );
+
         return xReturn;
     }
 #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
@@ -876,36 +925,37 @@ BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
     void MPU_vQueueAddToRegistry( QueueHandle_t xQueue,
                                   const char * pcName ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vQueueAddToRegistry( xQueue, pcName );
-
         vPortResetPrivilege( xRunningPrivileged );
     }
-#endif
+#endif /* if configQUEUE_REGISTRY_SIZE > 0 */
 /*-----------------------------------------------------------*/
 
 #if configQUEUE_REGISTRY_SIZE > 0
     void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vQueueUnregisterQueue( xQueue );
-
         vPortResetPrivilege( xRunningPrivileged );
     }
-#endif
+#endif /* if configQUEUE_REGISTRY_SIZE > 0 */
 /*-----------------------------------------------------------*/
 
 #if configQUEUE_REGISTRY_SIZE > 0
     const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
         const char * pcReturn;
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         pcReturn = pcQueueGetName( xQueue );
-
         vPortResetPrivilege( xRunningPrivileged );
+
         return pcReturn;
     }
 #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
@@ -913,10 +963,10 @@ BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
 
 void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     vQueueDelete( xQueue );
-
     vPortResetPrivilege( xRunningPrivileged );
 }
 /*-----------------------------------------------------------*/
@@ -929,8 +979,9 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
                                     TimerCallbackFunction_t pxCallbackFunction ) /* FREERTOS_SYSTEM_CALL */
     {
         TimerHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTimerCreate( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -948,8 +999,9 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
                                           StaticTimer_t * pxTimerBuffer ) /* FREERTOS_SYSTEM_CALL */
     {
         TimerHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTimerCreateStatic( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxTimerBuffer );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -962,8 +1014,9 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
     void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
     {
         void * pvReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         pvReturn = pvTimerGetTimerID( xTimer );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -976,20 +1029,21 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
     void MPU_vTimerSetTimerID( TimerHandle_t xTimer,
                                void * pvNewID ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTimerSetTimerID( xTimer, pvNewID );
         vPortResetPrivilege( xRunningPrivileged );
     }
-#endif
+#endif /* if ( configUSE_TIMERS == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( configUSE_TIMERS == 1 )
     BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTimerIsTimerActive( xTimer );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -1002,8 +1056,9 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
     TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
     {
         TaskHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTimerGetTimerDaemonTaskHandle();
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -1018,9 +1073,9 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
                                            uint32_t ulParameter2,
                                            TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xReturn, xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTimerPendFunctionCall( xFunctionToPend, pvParameter1, ulParameter2, xTicksToWait );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -1033,33 +1088,37 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
     void MPU_vTimerSetReloadMode( TimerHandle_t xTimer,
                                   const UBaseType_t uxAutoReload ) /* FREERTOS_SYSTEM_CALL */
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         vTimerSetReloadMode( xTimer, uxAutoReload );
         vPortResetPrivilege( xRunningPrivileged );
     }
-#endif
+#endif /* if ( configUSE_TIMERS == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( configUSE_TIMERS == 1 )
     UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer )
     {
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
         UBaseType_t uxReturn;
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         uxReturn = uxTimerGetReloadMode( xTimer );
         vPortResetPrivilege( xRunningPrivileged );
+
         return uxReturn;
     }
-#endif
+#endif /* if ( configUSE_TIMERS == 1 ) */
 /*-----------------------------------------------------------*/
 
 #if ( configUSE_TIMERS == 1 )
     const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
     {
         const char * pcReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         pcReturn = pcTimerGetName( xTimer );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -1072,8 +1131,9 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
     TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
     {
         TickType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTimerGetPeriod( xTimer );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -1086,8 +1146,9 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
     TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
     {
         TickType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTimerGetExpiryTime( xTimer );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -1104,8 +1165,9 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
                                          const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
     {
         BaseType_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xTimerGenericCommand( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -1118,8 +1180,9 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
     EventGroupHandle_t MPU_xEventGroupCreate( void ) /* FREERTOS_SYSTEM_CALL */
     {
         EventGroupHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xEventGroupCreate();
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -1132,8 +1195,9 @@ void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
     EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) /* FREERTOS_SYSTEM_CALL */
     {
         EventGroupHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -1149,8 +1213,9 @@ EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
                                      TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 {
     EventBits_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1162,8 +1227,9 @@ EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup,
                                       const EventBits_t uxBitsToClear ) /* FREERTOS_SYSTEM_CALL */
 {
     EventBits_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1175,8 +1241,9 @@ EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup,
                                     const EventBits_t uxBitsToSet ) /* FREERTOS_SYSTEM_CALL */
 {
     EventBits_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1190,8 +1257,9 @@ EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,
                                  TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 {
     EventBits_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1201,8 +1269,9 @@ EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,
 
 void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     vEventGroupDelete( xEventGroup );
     vPortResetPrivilege( xRunningPrivileged );
 }
@@ -1214,8 +1283,9 @@ size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
                               TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 {
     size_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1226,8 +1296,9 @@ size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
 size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
 {
     size_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1241,8 +1312,9 @@ size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
                                  TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
 {
     size_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1252,8 +1324,9 @@ size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
 
 void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     vStreamBufferDelete( xStreamBuffer );
     vPortResetPrivilege( xRunningPrivileged );
 }
@@ -1261,9 +1334,9 @@ void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_S
 
 BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xStreamBufferIsFull( xStreamBuffer );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1273,9 +1346,9 @@ BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* FREE
 
 BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xStreamBufferIsEmpty( xStreamBuffer );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1285,9 +1358,9 @@ BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* FRE
 
 BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xStreamBufferReset( xStreamBuffer );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1298,8 +1371,9 @@ BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* FREER
 size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
 {
     size_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1310,8 +1384,9 @@ size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /*
 size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
 {
     size_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1322,9 +1397,9 @@ size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /*
 BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
                                              size_t xTriggerLevel ) /* FREERTOS_SYSTEM_CALL */
 {
-    BaseType_t xReturn;
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xReturn, xRunningPrivileged;
 
+    xPortRaisePrivilege( xRunningPrivileged );
     xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
     vPortResetPrivilege( xRunningPrivileged );
 
@@ -1338,8 +1413,9 @@ BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
                                                          BaseType_t xIsMessageBuffer ) /* FREERTOS_SYSTEM_CALL */
     {
         StreamBufferHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xStreamBufferGenericCreate( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -1356,8 +1432,9 @@ BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
                                                                StaticStreamBuffer_t * const pxStaticStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
     {
         StreamBufferHandle_t xReturn;
-        BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+        BaseType_t xRunningPrivileged;
 
+        xPortRaisePrivilege( xRunningPrivileged );
         xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, xIsMessageBuffer, pucStreamBufferStorageArea, pxStaticStreamBuffer );
         vPortResetPrivilege( xRunningPrivileged );
 
@@ -1372,13 +1449,14 @@ BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
  * must take the same format as those above whereby the privilege state on exit
  * equals the privilege state on entry.  For example:
  *
+ * void MPU_FunctionName( [parameters ] ) FREERTOS_SYSTEM_CALL;
  * void MPU_FunctionName( [parameters ] )
  * {
- * BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+ * BaseType_t xRunningPrivileged;
  *
- *  FunctionName( [parameters ] );
- *
- *  vPortResetPrivilege( xRunningPrivileged );
+ * xPortRaisePrivilege( xRunningPrivileged );
+ * FunctionName( [parameters ] );
+ * vPortResetPrivilege( xRunningPrivileged );
  * }
  */
 
diff --git a/portable/GCC/ARM_CM3_MPU/port.c b/portable/GCC/ARM_CM3_MPU/port.c
index e66a7c323..49a84e542 100644
--- a/portable/GCC/ARM_CM3_MPU/port.c
+++ b/portable/GCC/ARM_CM3_MPU/port.c
@@ -158,17 +158,14 @@ BaseType_t xIsPrivileged( void ) __attribute__( ( naked ) );
 void vResetPrivilege( void ) __attribute__( ( naked ) );
 
 /**
- * @brief Calls the port specific code to raise the privilege.
- *
- * @return pdFALSE if privilege was raised, pdTRUE otherwise.
+ * @brief Enter critical section.
  */
-extern BaseType_t xPortRaisePrivilege( void );
+void vPortEnterCritical( void ) FREERTOS_SYSTEM_CALL;
 
 /**
- * @brief If xRunningPrivileged is not pdTRUE, calls the port specific
- * code to reset the privilege, otherwise does nothing.
+ * @brief Exit from critical section.
  */
-extern void vPortResetPrivilege( BaseType_t xRunningPrivileged );
+void vPortExitCritical( void ) FREERTOS_SYSTEM_CALL;
 /*-----------------------------------------------------------*/
 
 /* Each task maintains its own interrupt status in the critical nesting
@@ -481,7 +478,8 @@ void vPortEndScheduler( void )
 
 void vPortEnterCritical( void )
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
+    xPortRaisePrivilege( xRunningPrivileged );
 
     portDISABLE_INTERRUPTS();
     uxCriticalNesting++;
@@ -492,7 +490,8 @@ void vPortEnterCritical( void )
 
 void vPortExitCritical( void )
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
+    xPortRaisePrivilege( xRunningPrivileged );
 
     configASSERT( uxCriticalNesting );
     uxCriticalNesting--;
diff --git a/portable/GCC/ARM_CM4_MPU/port.c b/portable/GCC/ARM_CM4_MPU/port.c
index a1d8809b5..90f215683 100644
--- a/portable/GCC/ARM_CM4_MPU/port.c
+++ b/portable/GCC/ARM_CM4_MPU/port.c
@@ -171,17 +171,14 @@ BaseType_t xIsPrivileged( void ) __attribute__( ( naked ) );
 void vResetPrivilege( void ) __attribute__( ( naked ) );
 
 /**
- * @brief Calls the port specific code to raise the privilege.
- *
- * @return pdFALSE if privilege was raised, pdTRUE otherwise.
+ * @brief Enter critical section.
  */
-extern BaseType_t xPortRaisePrivilege( void );
+void vPortEnterCritical( void ) FREERTOS_SYSTEM_CALL;
 
 /**
- * @brief If xRunningPrivileged is not pdTRUE, calls the port specific
- * code to reset the privilege, otherwise does nothing.
+ * @brief Exit from critical section.
  */
-extern void vPortResetPrivilege( BaseType_t xRunningPrivileged );
+void vPortExitCritical( void ) FREERTOS_SYSTEM_CALL;
 /*-----------------------------------------------------------*/
 
 /* Each task maintains its own interrupt status in the critical nesting
@@ -517,7 +514,8 @@ void vPortEndScheduler( void )
 
 void vPortEnterCritical( void )
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
+    xPortRaisePrivilege( xRunningPrivileged );
 
     portDISABLE_INTERRUPTS();
     uxCriticalNesting++;
@@ -528,7 +526,8 @@ void vPortEnterCritical( void )
 
 void vPortExitCritical( void )
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
+    xPortRaisePrivilege( xRunningPrivileged );
 
     configASSERT( uxCriticalNesting );
     uxCriticalNesting--;
diff --git a/portable/IAR/ARM_CM4F_MPU/port.c b/portable/IAR/ARM_CM4F_MPU/port.c
index 6e69acd6f..0c6ac2af6 100644
--- a/portable/IAR/ARM_CM4F_MPU/port.c
+++ b/portable/IAR/ARM_CM4F_MPU/port.c
@@ -184,17 +184,14 @@ void vPortSVCHandler_C( uint32_t * pulParam );
 extern void vPortRestoreContextOfFirstTask( void ) PRIVILEGED_FUNCTION;
 
 /**
- * @brief Calls the port specific code to raise the privilege.
- *
- * @return pdFALSE if privilege was raised, pdTRUE otherwise.
+ * @brief Enter critical section.
  */
-extern BaseType_t xPortRaisePrivilege( void );
+void vPortEnterCritical( void ) FREERTOS_SYSTEM_CALL;
 
 /**
- * @brief If xRunningPrivileged is not pdTRUE, calls the port specific
- * code to reset the privilege, otherwise does nothing.
+ * @brief Exit from critical section.
  */
-extern void vPortResetPrivilege( BaseType_t xRunningPrivileged );
+void vPortExitCritical( void ) FREERTOS_SYSTEM_CALL;
 /*-----------------------------------------------------------*/
 
 /* Each task maintains its own interrupt status in the critical nesting
@@ -445,13 +442,12 @@ void vPortEndScheduler( void )
 
 void vPortEnterCritical( void )
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
+    xPortRaisePrivilege( xRunningPrivileged );
 
     portDISABLE_INTERRUPTS();
     uxCriticalNesting++;
 
-    vPortResetPrivilege( xRunningPrivileged );
-
     /* This is not the interrupt safe version of the enter critical function so
      * assert() if it is being called from an interrupt context.  Only API
      * functions that end in "FromISR" can be used in an interrupt.  Only assert if
@@ -461,12 +457,15 @@ void vPortEnterCritical( void )
     {
         configASSERT( ( portNVIC_INT_CTRL_REG & portVECTACTIVE_MASK ) == 0 );
     }
+
+    vPortResetPrivilege( xRunningPrivileged );
 }
 /*-----------------------------------------------------------*/
 
 void vPortExitCritical( void )
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
+    xPortRaisePrivilege( xRunningPrivileged );
 
     configASSERT( uxCriticalNesting );
 
diff --git a/portable/RVDS/ARM_CM4_MPU/port.c b/portable/RVDS/ARM_CM4_MPU/port.c
index a94f378c8..72538a473 100644
--- a/portable/RVDS/ARM_CM4_MPU/port.c
+++ b/portable/RVDS/ARM_CM4_MPU/port.c
@@ -185,17 +185,14 @@ BaseType_t xIsPrivileged( void );
 void vResetPrivilege( void );
 
 /**
- * @brief Calls the port specific code to raise the privilege.
- *
- * @return pdFALSE if privilege was raised, pdTRUE otherwise.
+ * @brief Enter critical section.
  */
-extern BaseType_t xPortRaisePrivilege( void );
+void vPortEnterCritical( void ) FREERTOS_SYSTEM_CALL;
 
 /**
- * @brief If xRunningPrivileged is not pdTRUE, calls the port specific
- * code to reset the privilege, otherwise does nothing.
+ * @brief Exit from critical section.
  */
-extern void vPortResetPrivilege( BaseType_t xRunningPrivileged );
+void vPortExitCritical( void ) FREERTOS_SYSTEM_CALL;
 /*-----------------------------------------------------------*/
 
 /*
@@ -520,7 +517,8 @@ void vPortEndScheduler( void )
 
 void vPortEnterCritical( void )
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
+    xPortRaisePrivilege( xRunningPrivileged );
 
     portDISABLE_INTERRUPTS();
     uxCriticalNesting++;
@@ -531,7 +529,8 @@ void vPortEnterCritical( void )
 
 void vPortExitCritical( void )
 {
-    BaseType_t xRunningPrivileged = xPortRaisePrivilege();
+    BaseType_t xRunningPrivileged;
+    xPortRaisePrivilege( xRunningPrivileged );
 
     configASSERT( uxCriticalNesting );
     uxCriticalNesting--;