Системные вызовы poll, select и epoll давно решили задачу ожидания готовности дескрипторов, но лишь для сокетов и каналов: к обычным файлам epoll не подключается, ядро отвечает EPERM, а само чтение остаётся синхронным вызовом, замораживающим поток до завершения операции. Нишу асинхронной работы с дисками в ядре Linux занял интерфейс io_uring, появившийся в версии 5.1 в 2019 году стараниями Jens Axboe. Его идея проста: обмен с ядром идёт через общую память и кольцевые буферы, запросы складываются в очередь пачками, а результаты снимаются такими же пачками. К ядру 5.19 механизм дорос до универсального инструмента для файлов, сокетов, таймеров и сырых команд NVMe, и сегодня это главный путь развития асинхронного ввода-вывода в Linux.

Пределы классических механизмов асинхронного ввода и вывода

У асинхронного дискового ввода-вывода в Linux долго не было вменяемого пути. Posix AIO из glibc с функциями aio_read и aio_write выглядит честно только снаружи: библиотека заводит пул потоков, и каждый запрос исполняется в отдельном потоке тем же блокирующим read. Масштабирование упирается в число потоков, латентность скачет, поведение зависит от планировщика. Нативный интерфейс io_submit из libaio ближе к настоящей асинхронности, но работает лишь с файлами, открытыми с флагом O_DIRECT, требует выравнивания буферов и почти не развивается: его основные потребители, СУБД, годами мирились с ограничениями. Сетевой мир жил в модели epoll, где epoll_wait сообщает о готовности, а дальше на каждый дескриптор приходится отдельный read или write. Poll и select к обычным файлам подключаются, но всегда объявляют их готовыми, так что ожидание вырождается в пустой цикл. Цена входа в ядро после встраивания защит от уязвимостей класса Spectre заметно выросла, и когда в очереди тысячи операций, разница между тысячей системных вызовов и одним обращением к кольцу превращается в проценты процессорного времени, потраченные на доставку запросов вместо полезной работы.

Отдельный слой потерь создают пробуждения. Классическая схема на epoll вынуждена будить поток на каждое событие, а поток в ответ выполняет ещё один системный вызов чтения. При мелких блоках, скажем 4 КиБ, накладные расходы на переключения контекстов становятся сопоставимы с полезной работой. io_uring переворачивает схему: приложение и ядро общаются через память, а разбор завершений ведётся сразу пачкой, без единого лишнего входа в ядро.

Кольцевые буферы SQ и CQ в архитектуре io_uring

Основу io_uring составляют два кольцевых буфера в памяти, общей для процесса и ядра: очередь отправки SQ и очередь завершения CQ. Ядро отображает их в адресное пространство приложения через mmap с офсетами IORING_OFF_SQ_RING, IORING_OFF_CQ_RING и IORING_OFF_SQES. Пользовательская сторона пишет в SQ элементы-запросы SQE по 64 байта, где описаны операция, дескриптор файла, буфер, смещение и сквозной идентификатор user_data. Ядро по мере выполнения кладёт в CQ элементы-результаты CQE по 16 байтов: тот же user_data, код возврата и флаги. Обе стороны двигают индексы атомарно, поэтому запрос можно положить в кольцо вовсе без системного вызова, а пачку готовых результатов тем более несложно забрать. Всё общение с ядром умещается в три вызова:

int io_uring_setup(unsigned entries, struct io_uring_params *p);
int io_uring_enter(int fd, unsigned to_submit, unsigned min_complete,
                   unsigned flags, sigset_t *sig);
int io_uring_register(int fd, unsigned opcode, void *arg, unsigned nr_args);

io_uring_setup создаёт кольцо нужной глубины, io_uring_enter отправляет запросы и собирает завершения, io_uring_register заранее фиксирует файлы, буферы и другие объекты, чтобы не учитывать их при каждой операции заново. Библиотека liburing прячет всю работу с mmap, барьерами памяти и индексами за аккуратным API, поэтому руками эти вызовы собирают редко.

Устройство кольца заслуживает внимания, поскольку от него напрямую зависит производительность. Головка и хвост очереди лежат в начале общей области, рядом с ними размещается массив индексов, который ссылается на слоты SQE. Хвост двигает пишущая сторона, головку - читающая, обе обновляют значения атомарно и с барьерами памяти. Переполнение очереди завершений ядро умеет удерживать в отдельном списке, но с версии 5.5 доступен режим IORING_SETUP_CQSIZE, позволяющий задать размер CQ больше стандартного и спокойно переживать пиковые всплески результатов.

Режимы работы от одиночных запросов до фонового потока SQPOLL

Глубина интеграции с ядром настраивается под нагрузку. В базовом режиме приложение заполняет SQE, вызывает io_uring_enter с числом готовых запросов, затем обращается к нему снова с флагом IORING_ENTER_GETEVENTS и ждёт завершений. Выигрыш виден уже здесь: один вызов отправляет сотни операций, а второй собирает результаты сразу по многим. Второй режим совмещает шаги: io_uring_enter отправляет пачку и в том же вызове ждёт, пока завершится не меньше min_complete операций. Для систем, чувствительных к задержке, есть IORING_SETUP_SQPOLL: ядро заводит отдельный поток, который сам непрерывно читает кольцо отправки и исполняет запросы без участия пользователя. Приложение лишь пишет SQE в общую память, и на горячем пути не остаётся ни одного системного вызова, а уснувший поток будит вызов enter с флагом IORING_ENTER_SQ_WAKEUP. Для блочных устройств с O_DIRECT существует и busy-wait режим IORING_SETUP_IOPOLL, когда завершения снимаются с контроллера без прерываний. Плата за низкую задержку очевидна: SQPOLL и IOPOLL держат ядро процессора занятым даже в простое, поэтому включать их имеет смысл только под измеримой нагрузкой.

Забирать завершения тоже лучше пачкой: функция io_uring_peek_batch_cqe возвращает сразу массив CQE, а io_uring_wait_cqes умеет ждать с таймаутом, чтобы не зависать в простое. Для перекрытия отправки и приёма классикой считается схема, когда приложение наполняет кольцо до половины глубины, отправляет пачку и только затем разбирает готовые результаты, поддерживая в полёте постоянное число операций.

Первый пример на liburing с очередью запросов чтения

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

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <liburing.h>

#define DEPTH 64
#define BLOCK 4096

int main(int argc, char **argv)
{
    struct io_uring ring;
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    char bufs[DEPTH][BLOCK];
    void *ptrs[DEPTH];
    int fd, i, ret;

    if (argc < 2)
        return 1;
    fd = open(argv[1], O_RDONLY);
    io_uring_queue_init(DEPTH, &ring, 0);

    for (i = 0; i < DEPTH; i++) {
        ptrs[i] = bufs[i];
        sqe = io_uring_get_sqe(&ring);
        io_uring_prep_read(sqe, fd, bufs[i], BLOCK, (off_t)i * BLOCK);
        io_uring_sqe_set_data(sqe, ptrs[i]);
    }
    io_uring_submit(&ring);

    for (i = 0; i < DEPTH; i++) {
        ret = io_uring_wait_cqe(&ring, &cqe);
        if (ret < 0)
            break;
        if (cqe->res < 0)
            fprintf(stderr, "read failed: %s\n", strerror(-cqe->res));
        io_uring_cqe_seen(&ring, cqe);
    }
    io_uring_queue_exit(&ring);
    close(fd);
    return 0;
}

Сборка выглядит так:

gcc -O2 -o reader reader.c -luring

Функция io_uring_prep_read заполняет SQE операцией IORING_OP_READ, которая появилась в ядре 5.6 и избавила от ручного заполнения iovec для простого чтения. Связку запроса и результата держит поле user_data: сюда кладут указатель на буфер, номер блока или контекст высокоуровневой задачи. Движку при этом не нужен O_DIRECT: кольцо одинаково обслуживает кэшируемое чтение, прямое и работу с сокетами.

Отдельного разговора требуют ошибки. Поле res несёт либо число обработанных байтов, либо минус код errno, а короткое чтение, когда res меньше запрошенного размера, обычное дело для сокетов и файлов с конца. Зрелое приложение ведёт конечный автомат на каждый user_data и повторяет недочитанное со смещением, равным сумме уже полученных байтов.

Измерение производительности в fio на разных глубинах очереди

fio поддерживает io_uring как полноценный движок ввода-вывода, и это стандартный способ проверить, даёт ли интерфейс выигрыш на конкретном железе. Минимальный файл задания выглядит так:

[global]
ioengine=io_uring
iodepth=32
iodepth_batch_submit=8
iodepth_batch_complete_min=8
direct=1
bs=4k
rw=randread
time_based
runtime=30
size=4g
group_reporting
filename=/data/fio-test

[read]

Тот же сценарий стоит прогнать с ioengine=psync и ioengine=libaio. psync покажет базу синхронного ввода-вывода с одним запросом за раз, libaio станет эталоном для O_DIRECT, а на кэшируемой нагрузке io_uring останется единственным из трёх, кто вообще способен держать очередь на обычных файлах. На прямом вводе-выводе при больших глубинах разница между libaio и io_uring обычно умещается в погрешность, зато на малых глубинах и в смешанных профилях чтения и записи кольца экономят системные вызовы и процессор. Полезно построить кривую зависимости задержки от пропускной способности, поднимая iodepth с 1 до 256, и взять метрики clat и lat из вывода fio: точка, где кривая загибается, подсказывает разумную глубину очереди для приложения.

Для проверки записи с гарантией durability замените rw=randread на randwrite и включите fdatasync=1: io_uring ставит fsync в ту же очередь, что и обычные операции, тогда как libaio работать с fsync не умел вовсе. Накопителям NVMe соответствует движок io_uring_cmd, который прогоняет passthrough-команды мимо блочного слоя. В отчёте fio интересны не только средние значения, но и перцентили clat: очередь на глубине 32 может дать больше операций в секунду при заметно выросшем хвостовом времени, и решение о глубине надо принимать по требованиям сервиса, а не по максимуму IOPS.

Эволюция интерфейса от ядра 5.1 до версии 5.19

Первый релиз в ядре 5.1 умел немного: чтение и запись через векторы, fsync, poll и регистрация файлов и буферов. Ядро 5.3 добавило связанные команды через флаг IOSQE_IO_LINK, когда результат одной операции становится входом следующей: открыть файл, прочитать и закрыть можно одной цепочкой без участия потока приложения. В 5.6 появились операции IORING_OP_READ и IORING_OP_WRITE без векторов, а также предоставляемые буферы, когда пул буферов заранее передаётся ядру, а SQE лишь ссылается на номер группы. Ядро 5.13 принесло многоразовые запросы poll, которые не снимаются после первого срабатывания и подходят для долго живущих соединений. В 5.18 сетевые send и recv оформились отдельными командами вместо универсальных sendmsg и recvmsg. Версия 5.19 стала переломной: код io_uring отвязали от блочного слоя, что упростило развитие интерфейса, добавили многоразовый приём recv и команду IORING_OP_URING_CMD для прямого проброса запросов к драйверам, на практике к NVMe. Дальше список возможностей продолжал расти: нулевое копирование при отправке, режимы COOP_TASKRUN и DEFER_TASKRUN со сниженными накладными расходами на пробуждения.

Практическая ценность цепочек хорошо видна на чтении маленького конфига: связка openat, read, close отправляется тремя SQE, но исполняется как единая операция, и поток приложения не участвует вовсе. Похожим образом связывают сетку, запись в журнал и fsync, убирая из горячих путей лишние синхронизации между потоками.

Практические советы по внедрению и типичные ошибки разработчиков

Переезд с epoll на io_uring редко оправдан целиком: сетевые службы с десятками тысяч коротких соединений часто спокойно живут на epoll, а вот горячие пути работы с дисками, журналирование, кэши и логи окупают переписывание быстро. Несколько правил сберегут время:

  1. измерьте базовую линию под текущей моделью ввода-вывода на реальной нагрузке, а не на синтетике;
  2. переносите сначала самые горячие операции, обычно чтение и запись больших объёмов;
  3. после стабилизации включите регистрацию файлов и буферов через io_uring_register, она убирает часть работы с таблицей дескрипторов при каждой операции;
  4. обрабатывайте короткие чтения и коды ошибок из поля res кольца завершений, включая EAGAIN;
  5. закрепите выигрыш повторным прогоном fio и замером процессора на единицу работы.

Из частых ловушек назовём три. Первая: поток SQPOLL в простое всё равно держит ядро процессора, и на слабых виртуалках это заметно. Вторая: глубина очереди ограничена, кольцо можно переполнить, поэтому свободное место стоит сверять через io_uring_sq_space_left из liburing. Третья: безопасность. Плотный поток уязвимостей в io_uring привёл к тому, что отдельные вендоры, в частности Google, ограничили его использование в Android и ChromeOS, а строгие профили безопасности могут блокировать вызовы io_uring_setup и io_uring_enter.

Диагностика несложна: strace -e trace=io_uring_enter покажет, сколько запросов уходит за один вызов, а статистика блочного уровня в sysfs подскажет, где узкое место. Если приложение должно работать на разных ядрах, проверяйте поддержку конкретных операций функцией io_uring_get_probe из liburing: команда, появившаяся позже, на старом ядре вернёт EINVAL, и выяснять это лучше на старте, а не в проде. Для СУБД и гипервизоров ограничения безопасности не преграда: PostgreSQL 18 включил io_uring в число методов своего асинхронного слоя ввода-вывода, а QEMU использует кольца в backend виртуальных дисков. Зрелость интерфейса уже позволяет считать его базовой частью пользовательского API ядра, и новые проекты, которым важна предсказуемая и высокая производительность ввода-вывода, начинают проектирование сразу вокруг колец.