Skip to content
The Chat Archive
gpt-4.1-mini-2025-04-14· OpenAI WildChat-4.8M (AI2)

#include <linux/bpf.h> #include <bpf/bpfhelpers.h> #include <linux/ifether.h> #include…

  1. 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 увеличить то будет ошибка

  2. Assistant

    В вашем eBPF/XDP-программе вы делаете проверку полезной нагрузки TCP-пакета на наличие подстроки «spam» и обрезаете максимальную длину для проверки до 900 байт (в комментарии написано, что раньше было 512, сейчас поднято до 900).

    Ваш вопрос: Почему увеличение max_len слишком сильно приводит к ошибке?


    Причина ошибки при увеличении max_len

    В eBPF (особенно в XDP) есть строгие ограничения по:

    • Времени выполнения (лимит инструкций – около 1 млн на вызов, но реально гораздо меньше),
    • По безопасному доступу к памяти,
    • Максимальному количеству циклов и вложенности.

    Основные причины ошибок при увеличении max_len:

    1. Проверка за пределами буфера (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 увеличен вручную выше, цикл может работать с неверным размером.

    2. Лимит по числу инструкций (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 скорее всего проверка проходит, но дальше нет.

    3. Требование передачи константных пределов в цикл

      При компиляции eBPF программа с циклом должна распознаться как однократный или небольшой цикл с фиксированным максимумом, чтобы verifier смог проверить отсутствие выхода за границы.


    Как устранить ошибку при увеличении max_len?

    1. Ограничьте max_len фиксированным константным значением, например:

      #define MAX_SCAN_LEN 512
      ...
      int max_len = payload_len;
      if (max_len > MAX_SCAN_LEN)
          max_len = MAX_SCAN_LEN;
      
    2. Используйте встроенную аннотацию компилятора для циклов с ограниченным числом итераций, например #pragma unroll или #pragma unroll_loop, чтобы verifier гарантировал количество итераций.

    3. Разбейте длинный цикл на несколько проходов или реализуйте поиск с меньшим максимальным числом итераций.

    4. Убедитесь в корректности проверки границ data_end, чтобы исключить выход за пределы буфера.


    Итог

    • Ваша ошибка связана с тем, что eBPF verifier не позволяет запускать циклы с слишком большим (и переменным!) количеством итераций, их надо сильно ограничивать и делать константными.
    • Также ошибка может быть связана с выходом за пределы памяти, если неверно посчитать payload_len или max_len.

    Если требуется просмотреть больше данных, то стоит либо:

    • увеличить max_len аккуратно, небольшими шагами, убедившись что проверка границ корректна;

    • использовать более сложные структуры (например, map с очередью, чтобы хранить состояние между пакетами);

    • либо прикладывать логику в userspace для анализа больших данных.


    Если хотите — могу помочь оптимизировать вашу программу под большую проверку с учетом ограничений eBPF.

  3. 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'

    и что это

  4. 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.

  5. User

    а если оптимизировать цикл for (int i = 0; i < MAX_SCAN_LEN - 4; i++) { ... }?

  6. 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'ом
    • Сделать проверку «вне буфера» простой и явной
    • Упростить функции в цикле — избегать вызовов функций, если это возможно
    • Если надо обходить большой объём данных, делайте это частями

    Если нужна помощь с полным исправленным примером — пишите, помогу.