Интерфейс формально жив, счётчики ошибок молчат, а приложение ловит таймауты. Без понимания того, где ядро держит пакет в каждый момент, такой инцидент легко растянуть на сутки. Стек Linux похож на многоэтажное здание: в подвале сетевая карта, на чердаке процессы, а пакет между этажами ходит по лестницам и застревает в очередях. Ниже маршрут от send() до кольца DMA и обратно к recv(), с числами и командами для дежурства.

Сокет как дверь в ядро и цена системного вызова

Всё начинается с файлового дескриптора. socket(), bind(), listen(), accept(), connect() выглядят скучно, но за каждым ядро строит сразу две структуры. struct socket описывает общий слой, единый для IPv4, IPv6, unix-сокетов и netlink; struct sock, в коде её зовут просто sk, хранит транспортную конкретику: состояние, окна, таймеры, очереди. Дескриптор ведёт к struct file, та указывает на struct socket, откуда достают sk.

Самое ценное в sk - две очереди и два лимита. sk_receive_queue копит входящие данные, sk_write_queue ждёт отправки, sk_rcvbuf и sk_sndbuf задают пределы в байтах. Переполнение sk_rcvbuf заставляет ядро молча выбрасывать сегменты: исключений не будет, данные исчезнут.

int fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);

int on = 1;
setsockopt(fd, SOL_TCP, TCP_NODELAY, &on, sizeof(on));  /* без задержек Nagle */

int buf = 262144;
setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &buf, sizeof(buf));
/* ядро удвоит значение и ограничит его лимитом rmem_max */

Удвоение честное: sk_buff тратит память и на собственную структуру, и на truesize выравнивание, поэтому полезных байтов поместится примерно половина. Фактические значения показывает ss: в строке skmem поле rb это sk_rcvbuf, tb это sndbuf, r и t - числа skb в очередях, d - счётчик отброшенных сегментов.

Сервер на пятьдесят тысяч соединений с потоком на клиента рано или поздно упирается в планировщик. epoll_create1, epoll_ctl и epoll_wait снимают проблему: один вызов ждёт готовность тысяч дескрипторов. Механика проста: положив сегмент в sk_receive_queue, TCP дёргает коллбек sk_data_ready, тот через sock_def_readable будит wait-очередь, ep_poll_callback заносит дескриптор в готовый список epoll.

Системный вызов стоит сотни наносекунд туда и обратно. На десяти гигабитах миллион вызовов recv() в секунду съедает целый процессор на одних переключениях. Отсюда ручки net.core.busy_read и net.core.busy_poll со значениями в микросекундах, по умолчанию ноль, режим SO_BUSY_POLL на конкретном сокете и io_uring, выводящий часть цикла за пределы syscall.

От send до драйвера путь передачи через sk_buff и qdisc

send() внутри TCP превращается в tcp_sendmsg. Функция копирует данные из iovec в sk_buff, крупные куски сразу в страничные фрагменты, чтобы не гонять байты дважды. Дальше сегментация: при MTU 1500 MSS равен 1460 байтам, с включёнными timestamp-опциями 1448. Каждый сегмент становится отдельным skb, но вперёд его никто не отпускает бесконтрольно: ограничители - окно перегрузки, стартующее с десяти сегментов, и лимит tcp_wmem.

sk_buff - главный конверт всего стека. Четыре указателя head, data, tail, end очерчивают память пакета. Выделение идёт с запасом под максимум заголовков: skb_reserve отступает от начала, данные пишутся в хвост, заголовки наращиваются через skb_push, сначала TCP, потом IP, потом канальный. Обратный skb_pull снимает заголовок при подъёме наверх. truesize, честный размер со структурой и фрагментами, списывается с квоты сокета; сама struct sk_buff весит порядка двух сотен байт, и на миллионах пакетов в секунду этот налог виден в perf.

skb = alloc_skb(size + MAX_TCP_HEADER, GFP_ATOMIC);
skb_reserve(skb, MAX_TCP_HEADER);      /* место под все заголовки сразу */
skb_put(skb, payload);                 /* данные в хвост */
skb_push(skb, sizeof(struct tcphdr));  /* транспортный слой */
skb_push(skb, sizeof(struct iphdr));   /* сетевой слой */

Дальше вниз: tcp_write_xmit вызывает tcp_transmit_skb, тот строит сетевой заголовок через ip_queue_xmit. Здесь смотрится таблица маршрутизации и сосед, MAC-адрес следующего хопа из neigh-таблицы; при пустом кэше отправляется ARP-запрос. Дойдя до канального уровня, пакет попадает в dev_queue_xmit, где __dev_xmit_skb решает, отдать его сразу через sch_direct_xmit или поставить в qdisc.

И вот тут первая серьёзная очередь. qdisc живёт на каждом интерфейсе, по умолчанию txqueuelen 1000 пакетов: на виртуалке с virtio это pfifo_fast, на физическом сервере с Intel чаще mq и fq:

tc qdisc show dev ens3
# qdisc pfifo_fast 0: dev ens3 root refcnt 2 bands 3 priomap ...
tc qdisc replace dev ens3 root fq    # честная очередь с pacing

Из qdisc skb выдаётся драйверу через ndo_start_xmit. Драйвер пишет дескриптор в TX-кольцо, карта забирает данные по DMA; завершение приходит прерыванием, ядро освобождает skb и обновляет счётчики. Перед выдачей успевает сработать GSO: один большой skb уходит на сегментацию вниз, в драйвер или в карту с TSO.

Две механики держат очередь короткой. BQL, byte queue limits, считает отправленные байты и подрезает limit_max, чтобы qdisc не копил миллисекунды задержки; состояние видно в /sys/class/net/ens3/queues/tx-0/byte_queue_limits/. TSQ, TCP small queues, не даёт сокету заливать больше tcp_limit_output_bytes, по умолчанию 1048576. Кейс: офисный роутер с qdisc в тысячу пакетов даёт ping 300 мс под нагрузкой; замена на fq или cake возвращает 15 мс. Очередь в ядре должна быть почти пустой: буферизует сеть, а не сервер.

Кольца DMA и прерывания в работе сетевого драйвера

Приём начинается ещё до sk_buff: драйвер заранее выделил кольцо дескрипторов с буферами, карта по DMA кладёт пакет прямо в память. Размеры кольца посмотреть и поднять просто:

ethtool -g ens3
# Pre-set maximums:
# RX:             4096
# Current hardware settings:
# RX:             256
ethtool -G ens3 rx 4096 tx 4096

На загруженном 10G интерфейсе дефолтные 256 входных дескрипторов - десятки микросекунд запаса. Пришло прерывание, а кольцо заполнено: карта молча роняет кадр, растёт rx_missed_errors, ядро даже не в курсе; счётчики подтверждают: ethtool -S ens3 | grep -Ei 'missed|no_buffer'. Второй регулятор, coalescing: ethtool -C ens3 rx-usecs 25 adaptive-rx on. Больше rx-usecs - меньше прерываний, выше батчи и throughput, но ping растёт. Для биржевых систем coalescing выключают, для файлового архива ставят агрессивно.

Многоочередные карты размазывают нагрузку: RSS считает хэш от тьюпл адресов и портов и раскидывает потоки по очередям, у каждой своя линия прерывания. Число очередей меняет ethtool -L ens3 combined 8, привязку очередей передачи к процессорам задаёт XPS через /sys/class/net/ens3/queues/tx-N/xps_cpus. Отдельная ветка эволюции - XDP: eBPF-программа работает в драйвере до выделения sk_buff, а AF_XDP отдаёт кадры в пользовательскую память вообще без skb.

NAPI и softirq ядро собирает входящие пакеты пачками

Идея один кадр - одно прерывание работала, пока пакеты были редкими. На десяти миллионах кадров в секунду процессор живёт в обработчиках прерываний и не успевает ничего делать, классическая живая блокировка, live lock. Ответом стал NAPI, механизм опроса вместо шторма IRQ.

Работает это так: первое прерывание выключает дальнейшие IRQ и планирует опрос, napi_schedule поднимает флаг NET_RX_SOFTIRQ. Мягкое прерывание net_rx_action обходит список napi_struct и вызывает poll-функцию драйвера, например igb_poll, которая выгребает кольцо пачками. Лимиты жёсткие: netdev_budget 300 пакетов и netdev_budget_usecs 2000 микросекунд на проход; не успел - poll переезжает в следующий цикл softirq.

Не успевающие в контексте процессора прерывания подхватывают фоновые потоки ksoftirqd/N, по одному на CPU; заметный процент ksoftirqd в top означает, что приём пакетов стал конкурирующей работой. Обходной путь, netif_rx: пакет ставится в per-CPU очередь input_pkt_queue, длина ограничена net.core.netdev_max_backlog, по умолчанию 1000; всё, что не влезло, отбрасывается и считается в /proc/net/softnet_stat:

cat /proc/net/softnet_stat
# 013e394b 00000000 00002055 00000000 ...

Первая колонка файла - обработанные пакеты, вторая - дропы при полном backlog, третья - time_squeeze, случаи, когда softirq упёрся в лимит времени. В примере третья колонка 0x2055, то есть 8277 недоработок при нулевой второй: ядро справляется, но впритык. Лечение типовое: sysctl -w net.core.netdev_max_backlog=8192 и подъём netdev_budget, хотя честнее найти процессор, который не успевает.

GRO встраивается прямо в poll: napi_gro_receive склеивает сегменты одного потока в крупные, до 64 КБ. Верхние слои получают в разы меньше пакетов, кэш и блокировки дышат легче. Побочный эффект знает каждый, кто смотрел дампы: tcpdump показывает гигантские кадры; для отладки помогает ethtool -K ens3 gro off.

Восходящий путь от ip_rcv до очереди приёма сокета

Наверху пакет проходит netif_receive_skb. Сначала срабатывают слушатели AF_PACKET, тот самый tap, на котором висит tcpdump, потом tc ingress, потом обработчики протоколов по ethertype. ip_rcv валидирует заголовок, ставит пакет на крючки netfilter PREROUTING и спрашивает таблицу маршрутизации: нам или транзит? Здесь же conntrack записывает соединение в свою таблицу; её потолок nf_conntrack_max, а исчерпание видно в dmesg строкой table full, dropping packet.

Локальному пакету нужен TCP: ip_local_deliver собирает фрагменты, проходит LOCAL_IN и попадает в tcp_v4_rcv. Поиск сокета идёт по хэш-таблице ehash, ключ - тьюпл из четырёх значений адресов и портов; таблица на сотни тысяч бакетов делает lookup дешёвым. Дальше tcp_rcv_established: обновление окна, обработка ACK, и данные ложатся в sk_receive_queue.

Тонкость: сокет может быть занят пользователем, процесс внутри recvfrom держит блокировку. Тогда сегмент идёт в backlog-очередь sk и разбирается при выходе из системного вызова, в release_sock. Два соседних сегмента обрабатываются в разной фазе относительно приложения, но внутри TCP порядок сохраняется.

Финал всегда одинаков: sk_data_ready будит получателя, epoll_wait возвращает готовый дескриптор, recvfrom отдаёт данные. Для транзита маршрут другой: ip_forward, крючок FORWARD, проверка ttl, и пакет спускается обратно через dev_queue_xmit, полный круг без единого сокета. Запомнить стоит одно: tcpdump видит пакет раньше netfilter и раньше сокета, кадр в дампе ещё не значит, что приложение его получило.

Буферы приёма и передачи настройка лимитов и проверка потерь

Буферы сокетов настраиваются в трёх местах сразу, и в этом вся тонкость. Ванильные лимиты rmem_max и wmem_max равны 212992, около 208 КиБ. setsockopt(SO_RCVBUF) зажимается этим числом, а фактический sk_rcvbuf оказывается вдвое больше запрошенного. Для TCP работает автотюнинг tcp_moderate_rcvbuf, и реальный размер живёт в диапазоне tcp_rmem, по умолчанию 4096 131072 6291456; третий элемент задаёт потолок. На нагруженных серверах цифру поднимают, на одной машине с быстрым линком видно 4096 131072 30020352, почти 29 МБ. Аналогично tcp_wmem 4096 16384 4194304.

Зачем такие размеры? Правило толстых длинных труб: пропускная способность, умноженная на RTT. Линк 10 Гбит/с при 30 мс задержки даёт 37,5 МБ данных в полёте; если rcvbuf меньше, отправитель упирается в окно и канал недогружен. Масштабирование окна решает вопрос: поле окна 16 бит умножается на 2^wscale, максимум степени 14; в реальном выводе ss это wscale:9,9, множитель 512.

sysctl net.core.rmem_max net.ipv4.tcp_rmem
sysctl -w net.core.rmem_max=16777216
sysctl -w net.ipv4.tcp_rmem="4096 131072 16777216"

Для приёма соединений лимиты другие, и сюрпризы другие. somaxconn ограничивает очередь accept, в свежих ядрах по умолчанию 4096, раньше было 128. Переполнение видно в nstat: счётчики TcpExtListenOverflows и TcpExtListenDrops растут, ss -lnt на LISTEN-сокете показывает Recv-Q, текущую длину очереди. tcp_max_syn_backlog, здесь 256, защищает от полусобранных handshake, syncookies подхватывают при исчерпании.

Передача ограничена двумя ручками. tcp_limit_output_bytes, по умолчанию 1048576, держит квоту TSQ на сокет, чтобы один поток не забивал qdisc. tcp_notsent_lowat, по умолчанию неограничен, задаёт потолок неотправленных данных внутри sk_write_queue; на латентность-чувствительных сервисах ставят 16384. Общая память стека видна в /proc/net/sockstat: строка TCP: inuse 26 orphan 0 tw 9 alloc 35 mem 160 означает 160 страниц, примерно 640 КиБ; при превышении порогов tcp_mem ядро давит сокеты.

Диагностика потери на каждом этаже и полезные команды

Когда пакеты пропадают, порядок обхода важнее глубины познаний:

  1. счётчики карты: ethtool -S ens3 | grep -Ei 'missed|no_buffer|drop', рост rx_missed_errors означает мелкое RX-кольцо или жёсткий coalescing;
  2. мягкие прерывания: /proc/net/softnet_stat, вторая колонка это дропы backlog, третья time_squeeze, плюс ksoftirqd в top;
  3. очередь на выходе: tc -s qdisc show dev ens3, поле dropped при переполнении qdisc;
  4. TCP-слой: ss -ti, счётчики retrans и busy, рост retrans говорит о потерях в сети, а не в ядре;
  5. точка отбрасывания: perf record -e skb:kfree_skb -a sleep 10, затем perf script покажет функцию, в которой skb был выброшен;
  6. слушающие сокеты: nstat -az | grep -i listen и ss -lnt, для переполнений accept-очереди.

Команды для быстрой прикидки одним куском:

ip -s -s link show ens3                   # ошибки и дропы на интерфейсе
tc -s qdisc show dev ens3                 # dropped в qdisc
ethtool -S ens3 | grep -Ei 'missed|no_buffer|drop'
nstat -az | grep -Ei 'drop|overflow|listen'
perf record -e skb:kfree_skb -a sleep 10 && perf script | sort | uniq -c

Отдельная ловушка - место съёмки дампа. На передачу tcpdump смотрит в dev_queue_xmit до постановки в qdisc, на приём после GRO. Пакет красиво виден в tcpdump -i ens3, а на самом деле выброшен очередью qdisc, потому что tap срабатывает раньше. Против обратной ситуации помогает dropwatch: она подписана на skb:kfree_skb и печатает символ ядра, в котором был освобождён skb.

Что остаётся после такого маршрута? Ядро сети - конвейер очередей. У каждой очереди есть имя, лимит и счётчик: input_pkt_queue с netdev_max_backlog, qdisc с txqueuelen, sk_receive_queue с rcvbuf, backlog сокета, TX-кольцо в драйвере. Потеря пакета всегда локализована, нужно только знать адреса; sysctl перестаёт быть случайной догадкой и становится точной ручкой.

Форма этой конструкции удивительно устойчива: копирование переехало в DMA, контрольные суммы и сегментация в карту, а путь пакета по очередям от syscall до провода остался прежним. Тот, кто однажды прошёл его глазами, читает /proc и sysfs как открытую книгу.