Обход ограничений eBPF: как запустить XDP на исходящем трафикеСтатья · дайджест за 10 ноября
Сетевая плата сервера с разъёмами оптических трансиверов и направленными неоновыми световыми лучами данных
Статья4 раздела≈ 8 мин

Обход ограничений eBPF: как запустить XDP на исходящем трафике

Когда процесс внутри контейнера отправляет сетевой пакет наружу, в ядре Linux запускается длинная бюрократическая цепочка. Для твоего кода вызов выглядит мгновенным, но за кулисами массив байтов проходит через выделение памяти, копирование буферов, таблицы маршрутизации, правила межсетевого экрана и систему отслеживания соединений. На обычном сервере эта внутренняя кухня незаметна. Но когда скорость сетевой карты вырастает до 100 или 200 Гбит/с, а счет идет на десятки миллионов пакетов в секунду, штатный конвейер ядра становится главным тормозом инфраструктуры.

С этой стеной столкнулся ведущий инженер Loophole Labs Алекс Сёрли (Alex Sørlie) при создании платформы живой миграции Architect. Во время переноса работающего контейнера между облаками каждый пакет нужно перехватить, модифицировать, упаковать в туннель и перенаправить на новый узел без разрыва соединения. В Linux для обработки трафика на скорости физического канала существует технология XDP (eXpress Data Path — экспресс-путь данных на базе eBPF). Вот только по архитектуре ядра XDP работает исключительно на входящем трафике, а для исходящих пакетов контейнера он недоступен. Но так ли неприступно это ограничение, если заглянуть в устройство виртуальных интерфейсов?

Почему подсистема Traffic Control захлебывается на 21,1 Гбит/с и сколько стоит буфер ядра

Ты наверняка спросишь: зачем протаскивать XDP на выход, если в Linux уже есть штатный механизм перехвата исходящих пакетов через eBPF — подсистема Traffic Control (TC)? Именно на хуках TC строят фильтрацию исходящего трафика сетевые плагины Kubernetes. О базовом пути пакета в кластере мы говорили в разборе архитектуры сетей Kubernetes от сетевого стека Linux до eBPF. На фоне таблиц iptables, которые в тестах команды на канале 200 Гбит/с при MTU 1500 выдали всего 15,6 Гбит/с с разбросом задержек из-за борьбы за процессор, перехват через TC выглядит шагом вперед.

Однако на практике пропускная способность Traffic Control упирается в потолок: на двухсотгигабитном стенде между двумя машинами AWS EC2 программа на TC прокачала лишь 21,1 Гбит/с на исходящем трафике и 23 Гбит/с на входящем. Для живой миграции нагруженных узлов это потеря почти 90% скорости канала.

Причина в том, когда и с какими данными работает TC. Хук запускается поздно — после маршрутизации, фаервола и таблицы отслеживания состояний conntrack. Но главный удар наносит структура struct sk_buff (сокет-буфер ядра). На каждый кадр ядро выделяет этот тяжеловесный объект в памяти и копирует туда метаданные. Представь курьерскую службу, где каждое письмо перед отправкой перекладывают в деревянный ящик, оклеивают бланками для всех отделов сортировки и только у дверей склада спрашивают твоего разрешения на выезд. При миллионах пакетов в секунду аллокации sk_buff сжигают ресурсы процессора еще до старта eBPF-программы.

Как устроен спринт XDP в драйвере сетевой карты и почему ему закрыт выход

В отличие от сокет-буфера, XDP работает как мгновенный фейсконтроль на пороге сетевой карты. Когда пакет прилетает из кабеля, адаптер через прямой доступ к памяти (DMA) записывает байты в кольцевой буфер приема (RX ring buffer) и посылает прерывание драйверу. Драйвер переносит указатель на пакет во входную очередь приема (RX queue) — и ровно здесь запускается программа XDP. Структуры sk_buff еще не существует, ядро Linux даже не знает о прибытии кадра, а обработка идет по сырым байтам в режиме нулевого копирования (zero-copy).

Почему же этот скоростной механизм работает только на вход? Изучив исходники ядра Linux, инженеры заметили важную деталь: ядро вообще не ставит на пакеты метку «входящий». Единственным триггером для вызова XDP служит сам факт попадания кадра в очередь приема RX. Когда приложение внутри контейнера отправляет данные наружу, пакет сразу падает в очередь передачи (TX queue). Входная очередь RX не используется, а значит, у драйвера просто нет точки запуска XDP.

Разворот через зеркальный туннель veth и цена полного обхода ядра

Раз ядро определяет входящий трафик только по попаданию в очередь RX, нужно заставить исходящий пакет контейнера притвориться входящим для хоста. И подходящий инструмент уже встроен в каждый сервер с Docker, containerd или Kubernetes.

Сетевое пространство имен (network namespace) каждого контейнера соединяется с хостом через пару виртуальных интерфейсов veth (Virtual Ethernet), работающую как сквозная труба. Один конец (veth0-A) находится внутри контейнера, а второй (veth1-A) — на хосте. Когда контейнер отправляет пакет в очередь TX своего интерфейса veth0-A, драйвер просто перекладывает указатель на память пакета во входную очередь приема RX парного интерфейса veth1-A.

С точки зрения хоста пакет только что поступил в очередь RX! Поскольку с ядра Linux 4.19 драйвер veth поддерживает нативный XDP, мы вешаем XDP-программу на veth1-A, меняем заголовки и через вердикт XDP_REDIRECT сбрасываем кадр напрямую в очередь TX физической карты eth0 в обход сетевого стека Linux.

Правда, при первом же запуске на стенде пакеты исчезли по дороге: дамп tcpdump на коммутаторе показал, что свитч молча отбрасывает кадры. Обходя сетевой стек ядра, ты обязан вручную выполнять его работу — пересчитывать контрольные суммы после подмены IP-адресов (NAT) и искать MAC-адрес получателя по протоколу ARP. Чтобы не пересчитывать сумму по всему буферу и самостоятельно проставить MAC-адрес следующего узла, в XDP-программу внедряют инкрементальное сложение и собственную ARP-таблицу в карте eBPF:

static __always_inline __u16 csum16_add(__u16 csum, __u16 addend) {
    csum += addend;
    return csum + (csum < addend);
}
struct arp_entry { __u8 mac[ETH_ALEN]; };
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, __be32);
    __type(value, struct arp_entry);
    __uint(max_entries, 65535);
} arp_table SEC(".maps");

csum = csum16_add(~tcp->check, ~old_ip_high);
csum = csum16_add(csum, ~old_ip_low);
csum = csum16_add(csum, new_ip_high);
csum = csum16_add(csum, new_ip_low);
tcp->check = ~csum;

struct arp_entry *entry = bpf_map_lookup_elem(&arp_table, &dest_ip);
if (entry) memcpy(eth->h_dest, entry->mac, ETH_ALEN);

Посмотрим, как этот код спасает пакеты в рантайме. Функция csum16_add складывает 16-битные слова с учетом переноса разряда csum < addend. Вместо чтения всего пакета мы берем инвертированную старую сумму ~tcp->check, вычитаем половинки старого IP (~old_ip_high, ~old_ip_low), прибавляем новый адрес и записываем инвертированный итог в tcp->check за пару тактов процессора. А хеш-таблица arp_table (BPF_MAP_TYPE_HASH на 65 535 записей) сопоставляет IP-адрес __be32 со структурой arp_entry: вызов bpf_map_lookup_elem находит запись для dest_ip, и memcpy копирует физический адрес entry->mac в заголовок кадра eth->h_dest. Коммутатор получает валидный Ethernet-кадр без обращения к ядру Linux.

Контраст четырех режимов на стенде 200 Гбит/с и границы метода в Kubernetes

Чтобы проверить решение в бою, авторы запустили iPerf3 в стандартных контейнерах с парами veth между двумя инстансами AWS EC2 с сетью 200 Гбит/с и MTU 1500. Менялся только механизм переброски пакета из veth в физический адаптер:

Режим на выходе контейнераСкорость (MTU 1500)Что происходит под капотом
iptables (PREROUTING)15,6 Гбит/сПроход через ядро, NAT и conntrack; борьба за CPU и скачки задержек
Traffic Control (TC egress)21,1 Гбит/сЗапуск после выделения struct sk_buff и базовых подсистем стека
Generic XDP на vethНиже 21,1 Гбит/сПрограммный запуск после аллокации sk_buff без оптимизаций TC
Native XDP на veth194 Гбит/сПерехват в очереди RX до ядра; рост в 12,4× к iptables и в 9,2× к TC

Показательна ловушка режима Generic XDP: он оказался медленнее Traffic Control, так как запускается в тестовом режиме уже после создания sk_buff, теряя плюсы раннего перехвата. Лишь включение нативного драйвера (xdpdrv через ip link set dev veth1 xdpgeneric off && ip link set dev veth1 xdpdrv object xdp_egress.o section xdp) позволило выжать 194 Гбит/с при минимальном разбросе задержек.

Для сетевых микросервисов, систем живой миграции и Docker-окружений (команда готовит открытый сетевой плагин на замену стандартному мосту Docker) это способ кратно ускорить сеть без патчей ядра. Однако в кластерах Kubernetes полный обход стека через XDP_REDIRECT означает, что пакеты исчезают с радаров модуля conntrack. Если в классических CNI инженеры борются с тормозами распухших таблиц сессий (мы разбирали это в статье про устранение 80-секундных задержек в Kubernetes из-за таблицы conntrack в Cilium CNI), то при переходе на чистый XDP отслеживание состояний соединений и фоновое обновление таблицы ARP через демон в пространстве пользователя придется брать на себя.

Сухой остаток этой истории прост: ограничение XDP только входящим трафиком оказалось лишь следствием работы драйвера с очередью приема, а стандартная пара интерфейсов veth позволяет превратить выход контейнера во вход хоста и разогнать отправку пакетов с 21,1 до 194 Гбит/с на обычном ядре Linux.

Хочу подробный разборГолоса помогают выбрать, что разобрать подробно. За этот материал 0 голосов.
Источники · 2