eBPF XDP程序内存访问验证错误排查与修复求助

错误原因分析 #

错误1：无效数据包访问 #

你在aggregate_payload中对payload[i]的边界检查逻辑存在缺陷：尽管入口处验证了(void*)(pkt +1) > data_end，但循环中使用(void*)(payload + i) >= data_end时，eBPF验证器无法有效跟踪循环变量i对应的内存偏移是否始终在数据包范围内。当start_index + loop_len超过数据包实际承载的payload长度时，就会触发越界访问报错。

错误2：无界内存访问 #

这个错误的核心是错误地将per-CPU数组的内存与数据包的data_end做边界检查。agg_result是从agg_result_map（per-CPU数组映射）中获取的内核内存指针，和数据包内存完全无关，用(void*)(agg_result + i) >= data_end做检查毫无意义，验证器会判定这是未做有效边界检查的无界内存访问。

修复方案 #

1. 修正per-CPU数组的边界检查 #

针对agg_result（map内存），应基于数组最大长度MAX_ARRAY_LEN做边界检查，确保索引i不会超出数组有效范围。

2. 优化数据包payload的边界检查 #

将payload的边界检查改为静态可跟踪的方式：先计算payload的合法结束地址（取数组末尾和数据包末尾的较小值），循环中直接检查访问指针是否在该范围内，让验证器能明确判断访问合法性。

3. 限制循环的最大迭代次数 #

添加对loop_len的上限裁剪，确保循环次数不超过MAX_ARRAY_LEN - start_index，避免验证器判定循环无界。

修改后的完整代码 #

#include <bpf/bpf_helpers.h>

#define MAX_ARRAY_LEN 100

struct fragment_packet {
    __u32 payload[MAX_ARRAY_LEN];
};

struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(key_size, sizeof(__u32));
    __uint(value_size, sizeof(__u32) * MAX_ARRAY_LEN);
    __uint(max_entries, 1);
} agg_result_map SEC(".maps");

struct {
    __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
    __uint(key_size, sizeof(__u32));
    __uint(value_size, sizeof(__u32));
    __uint(max_entries, 1);
} tail_call_map SEC(".maps");

static __always_inline void aggregate_payload(__u32* agg_result, __u32* payload, __u32 start_index, int loop_len, void* data_end) {
    // 限制loop_len的最大值，避免无界循环
    if (loop_len <= 0 || start_index >= MAX_ARRAY_LEN)
        return;
    if (start_index + loop_len > MAX_ARRAY_LEN)
        loop_len = MAX_ARRAY_LEN - start_index;

    // 计算payload的合法结束地址（数组末尾与数据包末尾的较小值）
    void* payload_end = (void*)&payload[MAX_ARRAY_LEN];
    if (payload_end > data_end)
        payload_end = data_end;

    for (__u32 i = start_index; i < start_index + loop_len; i++) {
        // 检查payload访问是否在数据包合法范围内
        void* payload_ptr = (void*)(payload + i);
        if (payload_ptr >= payload_end)
            break;

        // 检查agg_result访问是否在per-CPU数组合法范围内
        if (i >= MAX_ARRAY_LEN)
            break;

        bpf_printk("AGGREGATE: payload[%u] = %u\n", i, payload[i]);
        bpf_printk("AGGREGATE: agg_result[%u] = %u\n", i, agg_result[i]);
        // 此处可添加聚合逻辑，例如 agg_result[i] += payload[i];
    }
}

SEC("xdp")
int aggr_handler_entry(struct xdp_md* ctx) {
    void* data_end = (void*)(long)ctx->data_end;
    void* data = (void*)(long)ctx->data;

    struct fragment_packet* pkt = data;
    // 先检查数据包至少能容纳payload的起始位置
    if ((void*)(&pkt->payload[0]) >= data_end)
        return XDP_PASS;

    __u32 key = 0;
    __u32* agg_result = bpf_map_lookup_elem(&agg_result_map, &key);
    if (!agg_result)
        return XDP_DROP;

    bpf_tail_call(ctx, &tail_call_map, 0);
    return XDP_DROP;
}

SEC("xdp")
int aggr_handler_tail(struct xdp_md* ctx) {
    void* data_end = (void*)(long)ctx->data_end;
    void* data = (void*)(long)ctx->data;

    struct fragment_packet* pkt = data;
    if ((void*)(&pkt->payload[0]) >= data_end)
        return XDP_PASS;

    __u32 key = 0;
    __u32* agg_result = bpf_map_lookup_elem(&agg_result_map, &key);
    if (!agg_result)
        return XDP_DROP;

    __u32 start_index = 0; // 示例起始索引
    __u32 loop_len = 50;    // 示例迭代长度

    aggregate_payload(agg_result, pkt->payload, start_index, loop_len, data_end);

    // 后续尾调用逻辑：可通过将start_index存储到map等方式传递给下一次调用
    // bpf_tail_call(ctx, &tail_call_map, 0);

    return XDP_DROP;
}

关键修复点说明 #

• 对loop_len做上限裁剪，确保循环不会超出MAX_ARRAY_LEN范围，让验证器能确定循环是有界的。
• 提前计算payload_end，循环中直接对比访问指针与该地址，验证器可清晰跟踪内存边界。
• 针对agg_result的访问，直接基于MAX_ARRAY_LEN检查索引，避免了错误的数据包边界对比，确保访问合法。

内容的提问来源于stack exchange，提问作者Jack