Handling Interrupt Nesting and Priority Inheritance

In this lesson, you will learn how to configure hardware interrupt controllers to allow nested events while ensuring that high-frequency interrupt bursts do not trigger priority inversion.

Understanding Interrupt Nesting

In many embedded systems, an Interrupt Service Routine (ISR) typically disables other interrupts of equal or lower priority to prevent re-entrancy issues. However, if a critical, high-priority event occurs during a long-running ISR, the system's responsiveness suffers. Interrupt nesting allows the hardware interrupt controller (like an NVIC on ARM Cortex-M) to preempt an active, lower-priority ISR with a higher-priority one.

To implement this safely, you must ensure that shared data accessed by nested ISRs is protected. If a high-priority ISR preempts a lower-priority one, and both try to access a shared resource (like a hardware peripheral or a global buffer), you face the same Priority Inversion risks seen in task synchronization.

Preventing Inversion During Bursts

When high-frequency interrupts occur, they can "starve" lower-priority tasks and ISRs. If a low-priority ISR holds a lock needed by a high-priority ISR, you have a classic priority inversion scenario within the hardware context.

To mitigate this, apply a Priority Ceiling or Inheritance logic to your interrupt handlers. When a high-priority ISR needs a resource currently held by a lower-priority ISR, you must ensure the low-priority ISR completes its critical section as fast as possible to release the resource.

// Example of a nested-safe resource access using a priority mask
void LowPriority_ISR(void) {
    uint32_t original_priority = set_interrupt_priority_mask(HIGH_PRIORITY_LEVEL);
    
    // Critical Section: Access shared hardware/buffer
    update_shared_data(); 
    
    restore_interrupt_priority_mask(original_priority);
}

By masking interrupts to a level that prevents preemption by only the competing high-priority source, you create a lightweight "ceiling" that ensures the low-priority ISR can finish its work without being blocked by tasks that don't need that specific resource. This prevents the "burst-induced inversion" where a flood of high-priority interrupts forces a system-wide stall because the resource holder is stuck in a preemption loop.

Key Takeaway: Interrupt nesting improves responsiveness, but you must pair it with strict priority masking to prevent low-priority ISRs from being preempted while they hold resources required by high-priority handlers.