---
title: Interrupt Subsystem
url: https://doc.liz6.com/en/linux-kernel/04-interrupts-and-clocks/01-interrupt-subsystem
locale: en
area: linux-kernel
tags:
- linux-kernel
- interrupts-and-clocks
date: 2026-06-30
modified: 2026-07-16
description: 'Coverage: irq_desc/irq_chip/irq_domain → Interrupt handling flow (top/bottom half) → softirq/tasklet/workqueue → threaded IRQ → MSI/MSI-X → APIC/IOMMU interrupt remapping Kernel version: 2.6 ~ 6.x'
---
# Interrupt Subsystem
> Coverage: irq_desc/irq_chip/irq_domain → Interrupt handling flow (top/bottom half) → softirq/tasklet/workqueue → threaded IRQ → MSI/MSI-X → APIC/IOMMU interrupt remapping
> Kernel version: 2.6 ~ 6.x
## Overview
The interrupt subsystem is the part of the kernel most tightly coupled with hardware. When a network card receives a packet, a disk completes a DMA operation, or a timer expires, the hardware sends an interrupt signal to the CPU via the interrupt controller (APIC/GIC). The kernel's interrupt subsystem is responsible for: routing interrupts to the correct CPU, dispatching them to the corresponding device driver handler, and deferring time-consuming work to the bottom half.
The core abstractions of the modern interrupt subsystem are three layers:
- **irq_chip**: Hardware interrupt controller (IO-APIC, GIC, etc.)
- **irq_domain**: Mapping from hardware interrupt numbers to Linux IRQ numbers
- **irq_desc**: Descriptor for each Linux IRQ (handler, statistics, affinity)
---
## Hardware Interrupt vs. Linux IRQ
```
Hardware Interrupt Number (hwirq):
Interrupt line number inside the interrupt controller
Different controllers can have the same hwirq
Linux IRQ Number (virq):
Unified virtual interrupt number in the kernel
Mapped via irq_domain: virq = irq_domain->map(hwirq)
The numbers seen in /proc/interrupts are Linux IRQ numbers
```
### irq_desc
```c
// include/linux/irqdesc.h
struct irq_desc {
struct irq_common_data irq_common_data;
struct irq_data irq_data;
unsigned int __percpu *kstat_irqs; // per-CPU interrupt count (/proc/interrupts)
irq_flow_handler_t handle_irq; // High-level handler (handle_fasteoi, ...)
struct irqaction *action; // Linked list of handlers registered by drivers
unsigned int depth; // Disable counter
unsigned int istate; // Internal state
};
```
### irqaction: Handler registered by the driver
```c
// include/linux/interrupt.h
struct irqaction {
irq_handler_t handler; // Handler provided by the driver
unsigned long flags; // IRQF_SHARED, IRQF_ONESHOT, ...
const char *name; // Name displayed in /proc/interrupts
void *dev_id; // Device identifier (must be unique for shared interrupts)
struct irqaction *next; // Next action for shared interrupts
};
```
---
## Interrupt Handling Flow
### Hardware to Kernel
### handle_irq_desc() Path
### Shared Interrupts
```
IRQF_SHARED: Multiple devices share the same interrupt line
→ All registered handlers are called in sequence
→ Each handler checks "is this interrupt from my device?"
(Read device register; if no match → return IRQ_NONE)
→ If all handlers return IRQ_NONE → Spurious interrupt
+ Increment spurious count → If it reaches 100k times → Disable this interrupt
```
---
## Bottom Half
The interrupt handler only does the most urgent tasks (acknowledge interrupt, mask device, copy data). Time-consuming operations (processing protocol stack, writing back cache) are handed over to the bottom half.
### softirq
```c
// kernel/softirq.c
// Predefined softirq types (determined at compile time):
enum {
HI_SOFTIRQ = 0, // High-priority tasklet
TIMER_SOFTIRQ = 1, // Timer expiration
NET_TX_SOFTIRQ = 2, // Network transmission
NET_RX_SOFTIRQ = 3, // Network reception (NAPI)
BLOCK_SOFTIRQ = 4, // Block layer
TASKLET_SOFTIRQ = 6, // Regular tasklet
RCU_SOFTIRQ = 9, // RCU callbacks
NR_SOFTIRQS
};
// softirq runs in interrupt context (but with interrupts enabled)
// Triggered by irq_exit() check:
// if (in_interrupt()) return; // Not in nested hardware interrupt
// do_softirq() → __do_softirq() → Traverse softirq bitmap
// ksoftirqd: Per-CPU kernel thread
// When softirq processing is too heavy (MAX_SOFTIRQ_RESTART) → Hand over to ksoftirqd
// → Yield CPU to user processes
```
### tasklet (Deprecated, replaced by threaded IRQ)
```c
// kernel/softirq.c
// tasklet is based on softirq (HI_SOFTIRQ or TASKLET_SOFTIRQ)
// Tasklets of the same type do not run simultaneously (simplifies synchronization)
// ⚠️ Deprecated in kernels 2022+: New code should use threaded IRQ
struct tasklet_struct {
void (*func)(unsigned long);
unsigned long data;
};
```
### Threaded IRQ: Currently Recommended Approach
```c
// kernel/irq/manage.c
// Each interrupt can have its own kernel thread
// Handler returns IRQ_WAKE_THREAD → Kernel schedules threaded_fn to run
request_threaded_irq(irq, handler, thread_fn, flags, name, dev);
// handler: Runs in hardware interrupt context (does minimal work)
// thread_fn: Runs in an independent kernel thread (can sleep, can take mutex)
//
// Advantages:
// - Reduces interrupt disable time
// - Bottom half can sleep (take mutex, perform IO)
// - Can be managed by real-time scheduling policies
```
### Workqueue: Heavier Bottom Half
```c
// kernel/workqueue.c
// Workqueue runs in process context (kernel thread kworker)
// Suitable for: Work that requires sleeping or long execution times
// Main differences from tasklet/softirq:
// workqueue: Process context, can sleep
// tasklet/softirq: Interrupt context, cannot sleep
schedule_work(&work); // System workqueue
queue_work(my_wq, &work); // Dedicated workqueue
```
---
## MSI / MSI-X
```c
// kernel/irq/msi.c
// Message Signaled Interrupts
// Device writes directly to a memory address → Interrupt Controller (not via interrupt line)
// Advantages:
// - No need to share (each MSI has a unique address)
// - Higher performance (PCIe posted write vs. slow INTx level signal)
// - MSI-X allows devices to have multiple interrupt vectors (e.g., one per queue for NVMe)
// Enable MSI for PCI device:
pci_alloc_irq_vectors(pdev, 1, 16, PCI_IRQ_MSI);
→ Device allocates 16 MSI vectors
→ Returns Linux IRQ numbers (one per vector)
```
---
## Interrupt Affinity and Load Balancing
```bash
# View interrupt distribution
cat /proc/interrupts
# Set interrupt affinity (which CPU handles which interrupt)
echo 2 > /proc/irq//smp_affinity # Bind to CPU 1
# irqbalance daemon automatically balances
# Based on interrupt counts and CPU load
# Certain interrupts (e.g., NVMe) are directly bound to NUMA-local CPUs
```
---
## References and Further Reading
- **Kernel Documentation**: `Documentation/core-api/irq/`, `Documentation/PCI/msi-howto.rst`
- **LWN**: "The design of the interrupt subsystem", "Threaded interrupt handlers"
- **Source Code**:
- `kernel/irq/` — Interrupt core (handle, manage, chip, domain, msi)
- `kernel/softirq.c` — softirq and tasklet
- `kernel/workqueue.c` — workqueue
- `arch/x86/kernel/irq.c` — x86 interrupt entry
- `arch/x86/kernel/apic/` — APIC driver
---
*Keywords: irq_desc, irq_chip, irq_domain, softirq, tasklet, threaded IRQ, workqueue, MSI/MSI-X, interrupt affinity*