#include <linux/bpf.h> #include <bpf/bpfhelpers.h> #include <linux/ifether.h> #include…
- User
#include <linux/bpf.h> #include <bpf/bpf_helpers.h> #include <linux/if_ether.h> #include <linux/ip.h> #include <linux/tcp.h>
#ifndef IPPROTO_TCP #define IPPROTO_TCP 6 #endif
static __always_inline __u8 tolower_u8(__u8 c) { if (c >= 'A' && c <= 'Z') return c + 32; return c; }
SEC("xdp") int xdp_filter(struct xdp_md *ctx) { void *data = (void *)(long)ctx->data; void *data_end = (void *)(long)ctx->data_end;
struct ethhdr *eth = data; if ((void *)(eth + 1) > data_end) return XDP_PASS; if (eth->h_proto != __constant_htons(ETH_P_IP)) return XDP_PASS; struct iphdr *ip = data + sizeof(*eth); if ((void *)(ip + 1) > data_end) return XDP_PASS; if (ip->protocol != IPPROTO_TCP) return XDP_PASS; struct tcphdr *tcp = (void *)ip + ip->ihl * 4; if ((void *)(tcp + 1) > data_end) return XDP_PASS; unsigned char *payload = (unsigned char *)tcp + tcp->doff * 4; if ((void *)payload > data_end) return XDP_PASS; __u16 ip_total_len = __builtin_bswap16(ip->tot_len); __u8 ip_hdr_len = ip->ihl * 4; __u8 tcp_hdr_len = tcp->doff * 4; int payload_len = ip_total_len - ip_hdr_len - tcp_hdr_len; if (payload_len < 4) return XDP_PASS; if ((void *)(payload + payload_len) > data_end) payload_len = (char *)data_end - (char *)payload; // Максимальный размер для проверки увеличен до 512 байт int max_len = payload_len; if (max_len > 900) max_len = 900; for (int i = 0; i <= max_len - 4; i++) { if ((void *)(payload + i + 4) > data_end) break; if ( tolower_u8(payload[i + 0]) == 's' && tolower_u8(payload[i + 1]) == 'p' && tolower_u8(payload[i + 2]) == 'a' && tolower_u8(payload[i + 3]) == 'm' ) { return XDP_DROP; } } return XDP_PASS;}
char _license[] SEC("license") = "GPL"; почему если max_len увеличить то будет ошибка
- Assistant
В вашем eBPF/XDP-программе вы делаете проверку полезной нагрузки TCP-пакета на наличие подстроки «spam» и обрезаете максимальную длину для проверки до 900 байт (в комментарии написано, что раньше было 512, сейчас поднято до 900).
Ваш вопрос: Почему увеличение
max_lenслишком сильно приводит к ошибке?
Причина ошибки при увеличении max_len
В eBPF (особенно в XDP) есть строгие ограничения по:
- Времени выполнения (лимит инструкций – около 1 млн на вызов, но реально гораздо меньше),
- По безопасному доступу к памяти,
- Максимальному количеству циклов и вложенности.
Основные причины ошибок при увеличении max_len:
-
Проверка за пределами буфера (out-of-bounds access)
Если вы увеличиваете максимальную длину не соответствующе реальному размеру данных, то в цикле вы начнёте читать за пределами пакета, что вызывает нарушение безопасного чтения памяти и перепроверку BPF verifier'ом => ошибка сборки/загрузки программы.
В вашем коде вы делаете проверку
if ((void *)(payload + i + 4) > data_end) break;— это правильно. Но если
max_lenучитывается некорректно, проверка может некорректно работать:-
До этого вы вычисляете:
if ((void *)(payload + payload_len) > data_end) payload_len = (char *)data_end - (char *)payload;То есть payload_len корректируются по размеру до конца буфера.
-
Затем берётся
max_len = payload_len, где payload_len вычислен.
Если
payload_lenв реальности меньше, аmax_lenувеличен вручную выше, цикл может работать с неверным размером. -
-
Лимит по числу инструкций (loops unroll) и ограничения verifier'а
eBPF verifier требует знать верхний предел количества итераций в циклах на этапе компиляции или иметь их явно ограниченными. В вашем цикле у вас цикл с переменной
max_len, но которая не является константой. eBPF verifier не поддерживает произвольные циклы с большими (или переменными) итерациями.При увеличении
max_lenвыше какого-то порога verifier не сможет подтвердить безопасность выполнения цикла потому что будет слишком много инструкций/не фиксированное количество итераций:-
В вашем цикле
for (int i=0; i<=max_len-4; i++), если max_len будет слишком большим (например, 10000), verifier откажется загружать программу. -
При значениях до ~512 или ~900 скорее всего проверка проходит, но дальше нет.
-
-
Требование передачи константных пределов в цикл
При компиляции eBPF программа с циклом должна распознаться как однократный или небольшой цикл с фиксированным максимумом, чтобы verifier смог проверить отсутствие выхода за границы.
Как устранить ошибку при увеличении max_len?
-
Ограничьте max_len фиксированным константным значением, например:
#define MAX_SCAN_LEN 512 ... int max_len = payload_len; if (max_len > MAX_SCAN_LEN) max_len = MAX_SCAN_LEN; -
Используйте встроенную аннотацию компилятора для циклов с ограниченным числом итераций, например
#pragma unrollили#pragma unroll_loop, чтобы verifier гарантировал количество итераций. -
Разбейте длинный цикл на несколько проходов или реализуйте поиск с меньшим максимальным числом итераций.
-
Убедитесь в корректности проверки границ
data_end, чтобы исключить выход за пределы буфера.
Итог
- Ваша ошибка связана с тем, что eBPF verifier не позволяет запускать циклы с слишком большим (и переменным!) количеством итераций, их надо сильно ограничивать и делать константными.
- Также ошибка может быть связана с выходом за пределы памяти, если неверно посчитать payload_len или max_len.
Если требуется просмотреть больше данных, то стоит либо:
-
увеличить max_len аккуратно, небольшими шагами, убедившись что проверка границ корректна;
-
использовать более сложные структуры (например, map с очередью, чтобы хранить состояние между пакетами);
-
либо прикладывать логику в userspace для анализа больших данных.
Если хотите — могу помочь оптимизировать вашу программу под большую проверку с учетом ограничений eBPF.
- User
да на max scan len 950 уже вывод 59: (57) r5 &= 255 ; R5_w=scalar(smin=smin32=0,smax=umax=smax32=umax32=255,var_off=(0x0; 0xff)) 60: (15) if r5 == 0x6d goto pc+4 ; R5_w=scalar(smin=smin32=0,smax=umax=smax32=umax32=255,var_off=(0x0; 0xff)) 61: (07) r1 += 1 ; R1_w=pkt(id=6,off=927,r=926,smin=smin32=0,smax=umax=smax32=umax32=120,var_off=(0x0; 0x7c)) 62: (07) r3 += -1 ; R3_w=38 63: (b7) r0 = 2 ; R0_w=2 64: (55) if r3 != 0x0 goto pc+1 ; R3_w=38 66: (b7) r0 = 2 ; R0_w=2 67: (2d) if r1 > r2 goto pc-3 ; R1_w=pkt(id=6,off=927,r=927,smin=smin32=0,smax=umax=smax32=umax32=120,var_off=(0x0; 0x7c)) R2=pkt_end() 68: (71) r5 = *(u8 *)(r1 -4) ; R1_w=pkt(id=6,off=927,r=927,smin=smin32=0,smax=umax=smax32=umax32=120,var_off=(0x0; 0x7c)) R5_w=scalar(smin=smin32=0,smax=umax=smax32=umax32=255,var_off=(0x0; 0xff)) 69: (bf) r6 = r5 ; R5_w=scalar(id=3643,smin=smin32=0,smax=umax=smax32=umax32=255,var_off=(0x0; 0xff)) R6_w=scalar(id=3643,smin=smin32=0,smax=umax=smax32=umax32=255,var_off=(0x0; 0xff)) 70: (07) r6 += -65 ; R6_w=scalar(smin=smin32=-65,smax=smax32=190) 71: (57) r6 &= 255 ; R6_w=scalar(smin=smin32=0,smax=umax=smax32=umax32=255,var_off=(0x0; 0xff)) 72: (bf) r0 = r5 ; R0_w=scalar(id=3643,smin=smin32=0,smax=umax=smax32=umax32=255,var_off=(0x0; 0xff)) R5_w=scalar(id=3643,smin=smin32=0,smax=umax=smax32=umax32=255,var_off=(0x0; 0xff)) 73: (47) r0 |= 32 ; R0_w=scalar(smin=umin=smin32=umin32=32,smax=umax=smax32=umax32=255,var_off=(0x20; 0xdf)) 74: (2d) if r4 > r6 goto pc+1 The sequence of 8193 jumps is too complex. processed 43699 insns (limit 1000000) max_states_per_insn 4 total_states 513 peak_states 513 mark_read 5 -- END PROG LOAD LOG -- libbpf: prog 'xdp_filter': failed to load: -14 libbpf: failed to load object 'filter_xdp_antispam.o'
и что это
- Assistant
Ошибка, которую вы видите:
The sequence of 8193 jumps is too complex. ... libbpf: prog 'xdp_filter': failed to load: -14означает, что eBPF verifier отказался загрузить вашу программу из-за слишком сложной (огромной) последовательности переходов (jump sequence).
Что произошло и почему?
В
xdp_filterу вас цикл, который перебирает символы в полезной нагрузке TCP:for (int i = 0; i <= max_len - 4; i++) { if ((void *)(payload + i + 4) > data_end) break; // сравнения символов }- Переменная
max_lenкак правило динамическая (зависит от длины пакета), но verifier eBPF требует, чтобы количество итераций было компильным и относительно небольшим. - Компилятор/верифайер превращает этот цикл в развернутый набор инструкций и переходов — "unroll" цикла — или симулирует все ветвления для проверки безопасности.
- При значении
max_lenоколо 950 (почти 1000 итераций) количество инструкций и переходов становится слишком большим. - Верификатор имеет ограничение на сложность графа переходов и не может проанализировать такую программу → ошибка.
Почему ограничение так жесткое?
- Безопасность и гарантия отсутствия бесконечных циклов — ключевая задача verifier'а.
- Все циклы в eBPF нужно обязательно ограничивать либо фиксированным константным числом итераций.
- Версификатор нуждается в том, чтобы четко понимать максимально возможное число переходов.
- Слишком большой цикл (тысячи итераций) влечет огромный граф состояний для статического анализа — это не поддерживается.
Как это можно исправить?
1. Сделайте фиксированный, маленький
max_lenПоддерживайте строго константный верхний предел, например:
#define MAX_SCAN_LEN 256 ... int max_len = payload_len; if (max_len > MAX_SCAN_LEN) max_len = MAX_SCAN_LEN;Verifier сможет распознать небольшой фиксированный цикл и разрешит загрузку.
2. Принудительно unroll цикл (
#pragma unroll) с небольшим максимумомДобавьте перед циклом:
#pragma unroll for (int i = 0; i < MAX_SCAN_LEN - 4; i++) { ... }Это заставит компилятор развернуть цикл, но limiter MAX_SCAN_LEN должен быть небольшим (~128, 256).
3. Альтернативный подход: использовать прерывание цикла
Если нужны большие объёмы данных — разбивайте задачу:
- Проверяйте пакеты порциями,
- Используйте eBPF maps для сохранения состояния между пакетами,
- Осуществляйте более детальный анализ в userspace.
Итог
- Ошибка
The sequence of 8193 jumps is too complex= во-первых, слишком большой цикл по длине, фактически слишком много ветвлений для verifier'а. - eBPF verifier накладывает строгие ограничения на циклы и переходы, чтобы обеспечить безопасность и гарантированное завершение программы.
- Уменьшите
max_lenна уровне кода до относительно небольшого числа (около 256) и используйте#pragma unroll. - Если хотите обрабатывать большие объемы, нужно переработать логику.
Если хотите, могу помочь с примером кода с вызовом
#pragma unrollи фиксированнымmax_len. - Переменная
- User
а если оптимизировать цикл for (int i = 0; i < MAX_SCAN_LEN - 4; i++) { ... }?
- Assistant
Да, оптимизация цикла в eBPF-программе очень важна для успешной загрузки и работы из-за ограничений verifier'а. Вот некоторые проверенные подходы, чтобы ваш цикл был приемлем для verifier'а и эффективно выполнялся:
Рекомендации и пример оптимизации цикла в вашем случае
1. Сделать максимальное количество итераций константой и небольшим числом
#define MAX_SCAN_LEN 256 #pragma unroll for (int i = 0; i < MAX_SCAN_LEN - 4; i++) { // Проверяем выход за конец области (safe boundary check): if ((void *)(payload + i + 4) > data_end) break; if ( tolower_u8(payload[i + 0]) == 's' && tolower_u8(payload[i + 1]) == 'p' && tolower_u8(payload[i + 2]) == 'a' && tolower_u8(payload[i + 3]) == 'm' ) { return XDP_DROP; } }Verfier понимает, что цикл максимум 252 итерации (256 - 4), и с
#pragma unrollон разворачивает его в набор последовательных проверок, что повышает стабильность загрузки.
2. Избегайте динамических условий в счетчике цикла
Не используйте что-то типа:
for (int i=0; i <= payload_len-4; i++)где
payload_len— переменная. Лучше ограничить и уменьшить счётчик сверху, чтобы он был фиксирован.
3. Упростите
tolower_u8()В вашем коде
tolower_u8()достаточно простая функция, но в цикле лучше делать приведение к нижнему регистру максимально лёгким — можно сделать inline-макрос, либо unroll сравнения с учетом и заглавных, и строчных букв через сравнительный набор вроде:static __always_inline bool is_spam_at(unsigned char *p) { return (p[0] == 's' || p[0] == 'S') && (p[1] == 'p' || p[1] == 'P') && (p[2] == 'a' || p[2] == 'A') && (p[3] == 'm' || p[3] == 'M'); }Это сэкономит инструкции вместо вызова
tolower_u8().
4. Используйте unroll и разбивайте длинные проверки
Если хотите проверить большое количество байт (больше 256), разбиение проверки на несколько проходов с меньшим числом итераций — хорошая практика.
Пример:
#define SCAN_BLOCK_SIZE 128 #pragma unroll for (int i = 0; i < SCAN_BLOCK_SIZE - 4; ++i) { if ((void *)(payload + i + 4) > data_end) break; if (is_spam_at(payload + i)) return XDP_DROP; }При загрузке если
payload_len>SCAN_BLOCK_SIZE, можно вызывать такую проверку несколько раз с разным смещением (в смежных XDP пакетах или в userspace).
5. Пример полностью оптимизированного цикла
#define MAX_SCAN_LEN 256 static __always_inline bool is_spam_at(unsigned char *p, void* data_end) { if ((void *)(p + 4) > data_end) return false; return (p[0] == 's' || p[0] == 'S') && (p[1] == 'p' || p[1] == 'P') && (p[2] == 'a' || p[2] == 'A') && (p[3] == 'm' || p[3] == 'M'); } SEC("xdp") int xdp_filter(struct xdp_md *ctx) { void *data = (void *)(long)ctx->data; void *data_end = (void *)(long)ctx->data_end; // ... (парсинг Ethernet/IP/TCP) int payload_len = ip_total_len - ip_hdr_len - tcp_hdr_len; if (payload_len < 4) return XDP_PASS; int max_len = payload_len; if (max_len > MAX_SCAN_LEN) max_len = MAX_SCAN_LEN; #pragma unroll for (int i = 0; i <= MAX_SCAN_LEN - 4; i++) { if (i >= max_len) // Останавливаемся по фактическому размеру полезной нагрузки break; if (is_spam_at(payload + i, data_end)) return XDP_DROP; } return XDP_PASS; }
Резюме
- Уменьшить максимальное число итераций цикла (например, ≤256)
- Использовать
#pragma unrollчтобы явным образом разворачивать цикл, это упрощает проверку uBPF verifier'ом - Сделать проверку «вне буфера» простой и явной
- Упростить функции в цикле — избегать вызовов функций, если это возможно
- Если надо обходить большой объём данных, делайте это частями
Если нужна помощь с полным исправленным примером — пишите, помогу.