Stack overflow detection (method 1 and 2) in FreeRTOS - Step-by-Step Execution

Concept Flow - Stack overflow detection (method 1 and 2)

Task starts

↓

Stack allocated

↓

Method 1: Check guard value

↓

Is guard value intact?

No→Stack overflow detected

↓

Method 2: Check stack pointer limits

↓

Is stack pointer within limits?

No→Stack overflow detected

↓

Task runs safely

↓

Repeat checks periodically

The system uses two methods to detect stack overflow: checking a guard value and verifying the stack pointer stays within limits. If either fails, overflow is detected.

Execution Sample

FreeRTOS

// Example of stack overflow checks performed by FreeRTOS (simplified)
// Method 1: Check guard value
if (*guard_value != EXPECTED) {
  // Overflow detected - call vApplicationStackOverflowHook
}
// Method 2: Check stack pointer
if (stack_pointer < stack_start || stack_pointer > stack_end) {
  // Overflow detected - call vApplicationStackOverflowHook
}

This code snippet shows two checks: one for a guard value and one for stack pointer limits to detect stack overflow.

Execution Table

Step	Check Type	Condition	Result	Action
1	Method 1: Guard Value	guard_value == EXPECTED	True	No overflow, continue
2	Method 2: Stack Pointer	stack_pointer within stack_start and stack_end	True	No overflow, continue
3	Method 1: Guard Value	guard_value == EXPECTED	False	Overflow detected, call hook
4	Method 2: Stack Pointer	stack_pointer within stack_start and stack_end	False	Overflow detected, call hook
5	End	N/A	N/A	Stop checks or handle error

💡 Checks stop when overflow is detected or task ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
guard_value	EXPECTED	EXPECTED	EXPECTED	CORRUPTED	CORRUPTED	CORRUPTED
stack_pointer	within limits	within limits	within limits	within limits	out of limits	out of limits

Key Moments - 3 Insights

Why do we check a guard value in Method 1?

The guard value is a known fixed pattern placed at the stack boundary. If it changes (see execution_table row 3), it means the stack has overflowed into that area.

How does Method 2 detect overflow using the stack pointer?

Method 2 checks if the current stack pointer is outside the allocated stack range (see execution_table row 4). If it is, overflow has occurred.

Can both methods detect overflow at the same time?

Yes, both methods run independently and can detect overflow separately (see execution_table rows 3 and 4). This provides double safety.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result of Method 1 check at Step 3?

A True - No overflow

B Condition not checked

C False - Overflow detected

D Stack pointer out of limits

💡 Hint

Check the 'Result' column for Step 3 in execution_table.

At which step does Method 2 detect stack pointer out of limits?

A Step 1

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the 'Check Type' and 'Result' columns in execution_table for stack pointer checks.

If the guard value is corrupted, what will happen in Method 1?

A Overflow detected and hook called

B No overflow detected

C Stack pointer checked instead

D Task continues normally

💡 Hint

Refer to execution_table row 3 and key_moments about guard value.

Concept Snapshot

Stack overflow detection uses two methods:
1. Guard value check: a known pattern at stack boundary is verified.
2. Stack pointer check: verifies pointer stays within stack limits.
If either fails, overflow is detected and handled.
This ensures task stack safety in FreeRTOS.

Full Transcript

In FreeRTOS, stack overflow detection uses two main methods. Method 1 places a guard value at the edge of the stack. The system checks if this value remains unchanged; if it is corrupted, it means the stack overflowed into that area. Method 2 checks the current stack pointer to ensure it stays within the allocated stack memory range. If the pointer goes outside these limits, overflow is detected. Both methods run periodically during task execution. If either method detects overflow, a hook function is called to handle the error. This double-check approach helps keep tasks safe from stack overflows.