interruptsafety

Interrupt safety is a property of code and interfaces that ensures correct behavior when execution may be interrupted by hardware or software interrupts. It is a concern in systems where an interrupt service routine (ISR) can preempt normal execution and access shared data or resources. An interrupt-safe function is one that can be invoked from an ISR or from normal thread context without causing data corruption or system instability. In practice this means the function completes quickly, does not block, and uses only reentrant or atomic operations.

Key requirements include avoiding blocking calls, memory allocation, and I/O within interrupt context; using atomic or lock-free data structures; and protecting shared data with very short critical sections. When possible, ISRs perform minimal work and defer longer processing to a non-interrupt context via queues or deferred procedure calls.

Common techniques are to use atomic operations for simple updates, disable interrupts only briefly around shared-state modifications, and employ lock-free ring buffers or double-buffered data structures. In many systems, ISRs should not acquire mutexes or perform operations that can sleep, and they must adhere to the platform's restrictions on what may be done in interrupt context. Testing interrupt safety often involves simulating ISRs and verifying that data remains consistent under preemption.

Interrupt safety is related to, but distinct from, thread safety. A function can be interrupt-safe yet not safe to call from multiple threads, and vice versa. Cross-references include async-signal safety in POSIX and typical RTOS guidelines.