Prerequisites

Two Categories of IRQ Control

There are really two different problems that “enable/disable IRQ” APIs solve, and beginners often mix them up. The first category disables all interrupts on the current CPU core. The second category disables one specific IRQ line, system-wide, regardless of which core it fires on.

local_irq_save() and local_irq_restore(): Protecting a Critical Section

When your driver needs to touch a data structure that is also accessed inside its own interrupt handler, you must prevent that handler from running on the current core while you’re working. The safest pattern is local_irq_save() combined with local_irq_restore(), because it remembers the previous interrupt state instead of blindly turning interrupts back on.

#include <linux/interrupt.h>
#include <linux/spinlock.h>

struct ep_ring_buffer {
    u32 head;
    u32 tail;
    u32 data[64];
};

static struct ep_ring_buffer ep_rb;

static void ep_rb_push(u32 value)
{
    unsigned long flags;

    local_irq_save(flags);           /* save state, disable local IRQs */

    ep_rb.data[ep_rb.head % 64] = value;
    ep_rb.head++;

    local_irq_restore(flags);        /* restore previous IRQ state */
}

static irqreturn_t ep_sensor_handler(int irq, void *dev_id)
{
    ep_rb_push(ep_sensor_read_fifo());
    return IRQ_HANDLED;
}

disable_irq() vs disable_irq_nosync(): Per-Line Control

Sometimes you don’t want to freeze the entire CPU — you only want to stop one specific device’s interrupt line, for example while you reconfigure that device. disable_irq() and disable_irq_nosync() do exactly this.

#include <linux/interrupt.h>

static void ep_reconfigure_device(struct ep_dev *edev)
{
    /* Stop new interrupts on this line and wait for any handler
     * currently running (on another CPU) to finish first */
    disable_irq(edev->irq);

    ep_hw_reprogram_registers(edev);

    enable_irq(edev->irq);
}

static irqreturn_t ep_dev_handler(int irq, void *dev_id)
{
    struct ep_dev *edev = dev_id;

    /* Called from inside an interrupt context ourselves,
     * so we must use the "nosync" variant to avoid deadlock */
    if (ep_hw_error_detected(edev))
        disable_irq_nosync(edev->irq);

    return IRQ_HANDLED;
}

disable_irq() vs disable_irq_nosync() vs disable_hardirq()

Real-World Use Cases

• Temporarily stopping a UART’s RX interrupt while flushing or resetting its FIFO.
• Disabling a GPIO interrupt line while a debounce timer is settling.
• Protecting a shared ring buffer between an interrupt handler and a driver’s read() implementation.
• Safely quiescing a network interrupt line before a hardware reset, using disable_irq_nosync() inside netpoll-style atomic code paths.

Common Mistakes and Troubleshooting

Best Practices

Performance and Security Considerations

Disabling all local interrupts, even briefly, increases response latency for every other device on that core, which matters a lot on real-time or low-latency embedded systems. From a security angle, an interrupt handler that can be disabled by unprivileged user-triggered code paths (for example, through a poorly designed ioctl) could be abused to create a denial-of-service condition, so always restrict who can trigger driver code paths that call disable_irq().

Summary / Key Takeaways

• local_irq_save/restore protects against this CPU’s own interrupts during a critical section.
• disable_irq()/enable_irq() control one specific IRQ line system-wide and must be called in matching pairs.
• disable_irq_nosync() is mandatory when disabling a line from within its own interrupt context, to avoid deadlock.
• disable_hardirq() is a specialized, atomic-context-safe variant used in cases like netpoll.

Conclusion

Getting comfortable with how to enable disable irq linux kernel APIs behave will save you from some of the nastiest bugs in driver development — deadlocks and interrupt storms. Use the right tool for the right job: local CPU control for short critical sections, and per-line control for reconfiguring or quiescing a specific device. In the next lecture of this free Linux device drivers course, we’ll look at the non-maskable interrupt (NMI) and how the kernel’s magic SysRq facility uses it for live debugging.

FAQ