Опрашивать устройство в цикле расточительно: процессор тратит такты, даже когда сетевая карта молчит, а диск еще не завершил запись. Прерывание решает эту проблему сигналом, который на аппаратном уровне приостанавливает текущий поток исполнения и передает управление заранее подготовленному коду ядра. Через прерывания ядро узнает о приходе сетевых пакетов, готовности блочных запросов, тиках таймера и нажатиях клавиш. Дальше прослеживается весь путь сигнала: контроллеры на плате, регистрация обработчика, разделение на верхнюю и нижнюю половины, мягкие прерывания, workqueue и сообщаемые прерывания MSI, а в конце наблюдение и настройка через /proc.

Аппаратная база контроллеры прерываний и сигналы от устройств

Исторически на x86 стоял контроллер Intel 8259A: два каскадированных чипа давали 15 линий, и каждая линия жестко закреплена за одним вектором. Однопроцессорным машинам этого хватало, но в многопроцессорных системах линии не маршрутизируются на конкретные ядра. Решением стала связка из локального APIC внутри каждого ядра и внешнего I/O APIC, который принимает линии устройств и раздает векторы выбранным CPU. Локальный APIC заодно обслуживает таймер ядра и межпроцессорные прерывания IPI, через которые планировщик рассылает команды, а ядро просит соседние ядра сбросить записи TLB. На ARM аналогичную работу выполняет контроллер GIC с дистрибьютором прерываний и интерфейсами CPU.

Ядро прячет этот разнобой за иерархией irq_domain и irq_chip: драйвер описывает собственный контроллер, универсальный слой строит отображение между номером линии и вектором Linux, и обработчики не зависят от модели чипа. Сигнал приходит фронтом или уровнем. Фронтовый фиксируется как факт перехода, уровневый держится, пока причина активна, и требует маскирования линии до завершения обработчика, иначе контроллер снова и снова дергает CPU, и получается шторм прерываний. Старые линии PCI INTx разделялись несколькими устройствами, отсюда привычка проверять, кто именно поднял линию. Отдельный класс образуют каскадные контроллеры GPIO-расширителей: в дереве устройств они описываются дочерними доменами, и линия GPIO превращается в полноценный вектор с собственным флагом триггера.

Путь сигнала в типичной x86 машине складывается из таких шагов:
1. устройство активирует свою линию или отправляет сообщение в память через шину;
2. контроллер I/O APIC или GIC превращает сигнал в номер вектора и выбирает целевой процессор;
3. локальный APIC принимает вектор и прерывает текущую задачу;
4. ядро сохраняет контекст, поднимает приоритет и вызывает обработчик, зарегистрированный драйвером;
5. обработчик гасит причину на устройстве, а медленную работу переносит в отложенные механизмы.

Регистрация обработчиков через request_irq и флаги прерываний

Драйвер получает линию вызовом request_irq, объявленным в include/linux/interrupt.h:

static irqreturn_t nic_isr(int irq, void *dev_id)
{
    struct net_device *ndev = dev_id;
    struct nic_priv *priv = netdev_priv(ndev);

    if (!nic_events_pending(priv))
        return IRQ_NONE;

    nic_mask_hw_irq(priv);
    napi_schedule(&priv->napi);
    return IRQ_HANDLED;
}

ret = request_irq(pdev->irq, nic_isr, IRQF_SHARED, "nic0", ndev);
if (ret)
    return ret;

Обработчик обязан вернуть IRQ_HANDLED, если обслужил сигнал, и IRQ_NONE, если линия не его. На разделяемых линиях ядро считает длинную серию IRQ_NONE признаком зависшего соседа и печатает предупреждение вида irq 7: nobody cared, а при загрузке с параметром irqpoll такие случаи лечатся принудительным опросом линий. Флаги задают поведение: IRQF_SHARED разрешает совместную работу нескольких драйверов на одной линии и требует уникальный dev_id, по которому free_irq находит нужную привязку; IRQF_TRIGGER_RISING, IRQF_TRIGGER_FALLING, IRQF_TRIGGER_HIGH и IRQF_TRIGGER_LOW выбирают фронт или уровень; IRQF_ONESHOT удерживает линию замаскированной до конца потокового обработчика. Занятая линия без флага разделяемого режима вернет запрос с кодом -EBUSY. Обертка devm_request_irq привязывает освобождение к жизненному циклу устройства и снимает обработчик автоматически при отвязке.

Верхняя и нижняя половины обработки и разделение работы

Обработчик аппаратного прерывания, верхняя половина, исполняется с выключенным вытеснением и с замаскированной собственной линией. В таком контексте нельзя спать, выделять память с GFP_KERNEL, захватывать мьютексы и вызывать блокирующий ввод-вывод. Пока обработчик работает, тот же CPU не отвечает на часть остальных событий, поэтому каждая лишняя микросекунда верхних половин превращается в потерянную пропускную способность и рост задержки; в top эта работа видна в колонке hi. Обработчикам не положено рассчитывать на текущий процесс: контекст исполнения привязан к CPU, а не к задаче, поэтому current в такой момент почти случаен, и на него нельзя опираться.

Устоявшаяся схема выглядит так: быстро сделать только то, что нельзя отложить, сбросить признак в регистре устройства, запомнить пришедшее и поставить остальное в очередь. Нижняя половина выполняется в более мягких условиях, и механизм выбирается по требованиям. Мягкие прерывания и tasklet годятся для максимально коротких задач без сна; потоковые прерывания и workqueue позволяют спать, брать мьютексы и делить время с другими задачами. Сетевой стек с NAPI демонстрирует классический шаблон: обработчик отключает аппаратные прерывания и ставит в план опрос, а функция poll собирает пакеты до опустошения кольца или исчерпания бюджета, после чего снова разрешает прерывания. Для измерений удобен perf: трассировка irq:irq_handler_entry показывает, какие линии и обработчики съедают время, а разница колонок hi и si в top отделяет аппаратную часть от мягкой.

Мягкие прерывания softirq и их типы в ядре

Мягкое прерывание это статически объявленный тип отложенной работы, а не произвольный обработчик, регистрируемый модулем на ходу. Набор фиксирован на этапе сборки: HI, TIMER, NET_TX, NET_RX, BLOCK, IRQ_POLL, TASKLET, SCHED, HRTIMER, RCU. Типы HI и TASKLET обслуживают механизм tasklet, TIMER и HRTIMER разгружают таймерные подсистемы, NET_RX вместе с NAPI собирает сетевой трафик, BLOCK обрабатывает блочные очереди запросов. Возбуждение делает raise_softirq, установку типов open_softirq, исполнение проходит в do_softirq. Запускаются мягкие прерывания в трех местах: при выходе из аппаратного прерывания, на выходе в userspace, если есть ожидающие типы, и в живущем на каждом CPU потоке ksoftirqd, который подхватывает очередь при высокой нагрузке. Один проход ограничен по времени и числу повторных циклов, все не успевшее достается ksoftirqd, чтобы не заморозить систему.

Счетчики по каждому типу и CPU показывает /proc/softirqs:

$ cat /proc/softirqs | head -5
                    CPU0       CPU1
          HI:          0          0
       TIMER:     123456     123001
      NET_TX:       4321       4390
      NET_RX:     987654     985210

Стремительный рост NET_RX при плоской загрузке CPU обычно означает, что пакетный трафик обрабатывается в контексте мягких прерываний, и повод проверить распределение очередей по ядрам. Мягкие прерывания возбуждаются и из кода, работающего в контексте процессов, поэтому их следы видны далеко за пределами сетевой подсистемы: планировщик использует SCHED для балансировки нагрузки, RCU выполняет там отложенное освобождение объектов.

Tasklet workqueue и threaded irq для отложенных задач

Tasklet построен поверх мягких прерываний TASKLET_SOFTIRQ и HI_SOFTIRQ и дает простое обещание: один и тот же tasklet никогда не исполняется параллельно на двух CPU, поэтому его внутреннее состояние обходится без блокировок. Запуск по tasklet_schedule, исполнение атомарное, без сна. Механизм признан устаревшим: сопровождающие ядра переводят драйверы на workqueue и потоковые прерывания, и для нового кода tasklet не рекомендуются.

Workqueue выполняет функции в контексте процессов: трудятся потоки kworker, спать разрешено, доступны мьютексы, аллокации GFP_KERNEL и обращения к подсистемам, требующим ожидания. Пул управляется автоматически с 2.6.36, когда появилась concurrency managed workqueue: ядро само заводит нужное число потоков и борется одновременно с простоем и с перегрузкой. Очередь создается через alloc_workqueue с флагами вроде WQ_HIGHPRI и WQ_UNBOUND; флаг WQ_UNBOUND отвязывает работу от конкретного CPU и оставляет решение планировщику, что удобно там, где важнее равномерность загрузки, чем локальность кэша. Тяжелую инициализацию и таймауты драйверы гоняют именно там, а единичный запуск выглядит тривиально:

INIT_WORK(&priv->reset_work, nic_reset_worker);
schedule_work(&priv->reset_work);

Третий путь это потоковые прерывания. request_threaded_irq принимает два обработчика: быстрый аппаратный и функцию thread_fn, исполняемую в выделенном потоке с именем вида irq/48-nic0. Флаг IRQF_ONESHOT держит линию замаскированной, пока поток не завершится, поэтому драйверу не нужен ручной контроль маски. Такой способ удобен для устройств с тяжелой логикой, например сенсоров и контроллеров питания, где задержка в сотни микросекунд не страшна, а сон в обработчике нужен постоянно.

Сообщаемые прерывания MSI и MSI-X в PCIe устройствах

Классическая схема с физическими линиями плохо масштабируется: линии разделяются, маршрутизация идет через внешний контроллер, а подтверждение требует чтения регистров. MSI переворачивает схему: прерывание становится обычной записью в память, устройству задаются адрес и значение, и шина сама доводит сообщение до контроллера прерываний. Физических линий нет, разделения нет, а упорядоченность транзакций гарантирует, что прерывание дойдет после всех предшествующих записей в память устройства, то есть к моменту вызова обработчика кольца уже видны свежие пакеты. Приятный бонус схемы: подтверждение не требует медленного чтения регистра устройства, и каждое событие обходится одной транзакцией шины.

Протокол PCI ограничивает MSI 32 векторами на функцию и одним базовым адресом. MSI-X снимает ограничения: до 2048 векторов, у каждого собственные адрес и содержимое, таблица лежит в отдельной области BAR. Именно поэтому современные сетевые карты поднимают по вектору на каждую очередь приема и передачи, а NVMe по вектору на очередь завершения. Векторы привязываются к ядрам, соседним с памятью очереди, что убирает трафик между NUMA узлами. Универсальный интерфейс появился в ядре 4.8: pci_alloc_irq_vectors(pdev, min_vecs, max_vecs, PCI_IRQ_MSIX | PCI_IRQ_MSI | PCI_IRQ_LEGACY) подберет лучший доступный тип, а pci_irq_vector вернет Linux-номер для конкретного индекса. Если устройство и прошивка не умеют ничего лучше линий, запрос тихо откатится к legacy режиму. Виртуализация добавляет posted interrupts: контроллер IOMMU доставляет сообщение прямо в контекст гостя, когда его vCPU исполняется, и не заставляет гипервизор перехватывать каждый сигнал.

Наблюдение и настройка через proc и sysfs

Файл /proc/interrupts остается главным окном в картину: номер линии, счетчики по каждому CPU, имя контроллера и метки устройств. Метки вида eth0-TxRx-0 означают отдельные векторы MSI-X для очередей. В хвосте живут локальные счетчики LOC для таймера, RES для межпроцессорных пересылок и ERR с MIS для ложных срабатываний. Пара полезных команд:

$ watch -d 'cat /proc/interrupts'
$ cat /proc/softirqs
$ echo 4 > /proc/irq/48/smp_affinity        # mask 0x4 = CPU2 only
$ echo 2 > /proc/irq/48/smp_affinity_list
$ systemctl status irqbalance

smp_affinity принимает шестнадцатеричную маску, smp_affinity_list привычный список номеров CPU. Драйверы часто заполняют файл affinity_hint подсказкой, по которой служба irqbalance раскладывает векторы по ядрам, и для большинства серверов этого достаточно. Для задач с жесткой задержкой службу отключают, векторы привязывают вручную к выделенным ядрам и следят, что счетчики перестали гулять. Привязку удобно сверять с выводом lscpu, показывающим номера NUMA узлов у каждого ядра. Счетчики в /proc/interrupts нарастают монотонно и обнуляются только перезагрузкой, поэтому скорость обработки снимают двумя замерами с паузой, а файл spurious внутри каталога линии покажет статистику ложных срабатываний. Число аппаратных очередей сетевых карт регулирует ethtool -L, а mpstat -I ALL суммирует долю времени CPU в обработке прерываний в колонке %irq.

Понимание полного пути сигнала объясняет странные цифры в мониторинге: почему нагрузка висит на одном CPU при свободных соседях, откуда берется ksoftirqd в топе и зачем драйверу два обработчика вместо одного. Практический вывод простой: быстрая верхняя половина, осознанный выбор нижней, отдельные векторы MSI-X на очередь и привязка к NUMA дают прирост, который не купишь никакой тонкой настройкой планировщика.