Critical sections and interrupt disabling in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of nested critical sections in FreeRTOS

Consider the following FreeRTOS code snippet. What will be the output printed to the console?

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include <stdio.h>

void exampleFunction() {
    taskENTER_CRITICAL();
    printf("Inside first critical section\n");
    taskENTER_CRITICAL();
    printf("Inside nested critical section\n");
    taskEXIT_CRITICAL();
    printf("Exited nested critical section\n");
    taskEXIT_CRITICAL();
    printf("Exited first critical section\n");
}

int main() {
    exampleFunction();
    return 0;
}

A

Inside first critical section
Inside nested critical section
Exited first critical section
Exited nested critical section

B

Inside first critical section
Exited nested critical section
Inside nested critical section
Exited first critical section

C

Inside first critical section
Inside nested critical section
Exited nested critical section
Exited first critical section

D

Inside nested critical section
Inside first critical section
Exited nested critical section
Exited first critical section

💡 Hint

Remember that nested critical sections in FreeRTOS use a counter to track entry and exit.

FreeRTOS allows nested critical sections by incrementing a nesting count on each taskENTER_CRITICAL call and decrementing it on taskEXIT_CRITICAL. The output follows the order of the print statements inside and after each critical section.

❓ Predict Output

intermediate

Effect of interrupt disabling on task switching

What will happen if interrupts are disabled globally in FreeRTOS for a long time inside a task?

FreeRTOS

void vTaskFunction(void *pvParameters) {
    portDISABLE_INTERRUPTS();
    // Simulate long processing
    for (volatile int i = 0; i < 1000000; i++) {}
    portENABLE_INTERRUPTS();
    vTaskDelete(NULL);
}

A The system will block all interrupts, causing no task switching and possible system freeze.

B The task will yield automatically despite interrupts being disabled.

C Only software interrupts will be blocked, hardware interrupts continue normally.

D The system will continue running normally with task switching unaffected.

💡 Hint

Think about what disabling interrupts globally means for the scheduler.

Disabling interrupts globally prevents the FreeRTOS scheduler from running, so no context switches occur. This can cause the system to freeze if interrupts are disabled for too long.

🔧 Debug

advanced

Identify the error in critical section usage

What error will the following FreeRTOS code cause when run on a Cortex-M microcontroller?

FreeRTOS

void faultyFunction() {
    taskENTER_CRITICAL();
    // Critical code
    taskEXIT_CRITICAL();
    taskEXIT_CRITICAL(); // Extra exit
}

A Undefined behavior due to decrementing critical nesting count below zero.

B Stack overflow due to unbalanced critical section exit calls.

C No error, code runs normally.

D Compile-time error due to extra taskEXIT_CRITICAL call.

💡 Hint

Check how FreeRTOS tracks critical section nesting internally.

Calling taskEXIT_CRITICAL more times than taskENTER_CRITICAL causes the nesting count to go below zero, leading to undefined behavior and possible system instability.

🧠 Conceptual

advanced

Why use portENTER_CRITICAL instead of taskENTER_CRITICAL?

In FreeRTOS, what is the main difference between portENTER_CRITICAL() and taskENTER_CRITICAL(), and when should portENTER_CRITICAL be used?

A portENTER_CRITICAL disables interrupts globally and is used in ISR context; taskENTER_CRITICAL disables scheduler only and is used in tasks.

B portENTER_CRITICAL disables interrupts at the port level and is used in low-level code; taskENTER_CRITICAL is a wrapper used in tasks.

C portENTER_CRITICAL enables interrupts; taskENTER_CRITICAL disables interrupts.

D There is no difference; both are aliases and can be used interchangeably.

💡 Hint

Consider the abstraction layers in FreeRTOS and hardware-specific code.

portENTER_CRITICAL is a macro that disables interrupts at the hardware port level and is used in low-level or ISR code. taskENTER_CRITICAL is a higher-level macro that calls portENTER_CRITICAL and manages nesting for tasks.

❓ Predict Output

expert

Output of interrupt priority masking in critical section

Given the following FreeRTOS code on a Cortex-M with configMAX_SYSCALL_INTERRUPT_PRIORITY set to 5, what is the value of variable x after the critical section?

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include "cmsis_os.h"

volatile int x = 0;

void vTask(void *pvParameters) {
    taskENTER_CRITICAL();
    x = 10;
    taskEXIT_CRITICAL();
}

int main() {
    NVIC_SetPriorityGrouping(3); // Priority grouping
    NVIC_SetPriority(SysTick_IRQn, 6); // Lower priority than max syscall
    NVIC_SetPriority(USART1_IRQn, 4); // Higher priority than max syscall

    x = 0;
    vTask(NULL);
    return x;
}

A Undefined, depends on interrupt timing

B 0

C 1

D 10

💡 Hint

Recall that taskENTER_CRITICAL disables interrupts up to configMAX_SYSCALL_INTERRUPT_PRIORITY.

taskENTER_CRITICAL disables interrupts with priority equal or lower than configMAX_SYSCALL_INTERRUPT_PRIORITY (5). Since SysTick_IRQn is priority 6 (lower priority), it is masked. USART1_IRQn with priority 4 (higher priority) is not masked but does not affect x here. So x is set to 10 safely.