标签: XDP

  • 深入 eBPF/XDP 陷阱排查:滥用全局 Hash Map 引发的 NAPI 轮询饥饿与软中断雪崩实战

    近期排查了一起极其离谱的网关性能抖动问题。某业务核心 API 网关在正常流量下,99 线延迟突然从 2ms 飙升到 400ms,部分节点出现大量 TCP 丢包。排查结论先放在这里:安全团队在网关宿主机上热挂载了一个基于 XDP (eXpress Data Path) 的反 DDoS 统计程序,但由于缺乏内核并发编程常识,错误地使用了全局 BPF_MAP_TYPE_HASH 来统计 IP 访问频率。在网卡多队列并发下,多个 CPU 核心疯狂争抢同一个 Map 的自旋锁,引发严重的 Cache Line Bouncing(缓存行颠簸),直接耗尽了 NAPI 轮询的 budget(配额),导致 ksoftirqd 软中断被打满,真正的业务报文在网卡 Ring Buffer 中被静默丢弃。

    解决方式很简单:将 eBPF 代码中的 BPF_MAP_TYPE_HASH 改为 BPF_MAP_TYPE_PERCPU_HASH,重新编译注入,延迟瞬间恢复 1ms。

    不要以为用了 eBPF/XDP 就能原地起飞。XDP 是让你在网卡驱动层操作报文,这意味着你写下的每一行代码都在内核极为底层的中断上下文中运行。违背底层硬件常识的代码,不仅起不到加速效果,还会把网卡直接干挂。

    现场还原与故障排查

    当时网关集群报警,QPS 并没有明显增长,网络 PPS(每秒包数)大约在 80w 左右。对于一块现代 25G 网卡来说,这点 PPS 连塞牙缝都不够。但节点状态却非常诡异。

    通过 mpstat -P ALL 1 观察,发现绑定了网卡 RX 队列的几个 CPU 核心,%soft (软中断) 使用率死死钉在 100%。

    执行 ethtool -S eth0 | grep rx_missed_errors,发现硬件层面的丢包计数在疯狂增加:

    rx_missed_errors: 4598212
    rx_fifo_errors: 4598212
    

    这说明网卡的 Ring Buffer 已经满了,CPU 处理不过来,导致后续报文直接被网卡丢弃。

    进一步抓取 CPU 热点,直接用 perf top -a -g 探查,屏幕上霸榜的函数让人血压飙升:

      38.42%  [kernel]  [k] _raw_spin_lock_irqsave
      29.15%  [kernel]  [k] htab_map_update_elem
      12.03%  [bpf]     [k] bpf_prog_3a2b1c9d_xdp_ddos_filter
    

    htab_map_update_elem 占用了近 30% 的 CPU,并引发了大量的锁自旋 _raw_spin_lock_irqsave。内核网络协议栈的正常函数(如 ip_rcv, tcp_v4_rcv)全被挤到了下面。

    bpftool 查看当前加载的程序:

    $ bpftool prog show
    102: xdp  name xdp_ddos_filter  tag 3a2b1c9d  gpl
            loaded_at ...  uid 0
            xlated 528B  jited 284B  memlock 4096B  map_ids 15
    

    真相大白,网卡 eth0 上挂了一个 XDP 程序,这玩意儿正在吞噬所有的 CPU 资源。

    源码级剖析:为什么全局 Map 会引发灾难?

    拉出肇事的 eBPF C 源码,核心逻辑如下:

    // 灾难级别的 Map 定义
    struct {
        __uint(type, BPF_MAP_TYPE_HASH); // 全局 Hash Map
        __uint(max_entries, 1000000);
        __type(key, __u32); // Source IP
        __type(value, __u64); // Packet Count
    } ip_stats SEC(".maps");
    
    SEC("xdp")
    int xdp_ddos_filter(struct xdp_md *ctx) {
        // ... 解析以太网和IP头 ...
        __u32 src_ip = iph->saddr;
        __u64 *count, init_val = 1;
    
        count = bpf_map_lookup_elem(&ip_stats, &src_ip);
        if (count) {
            __sync_fetch_and_add(count, 1); // 原子加
        } else {
            bpf_map_update_elem(&ip_stats, &src_ip, &init_val, BPF_ANY);
        }
        return XDP_PASS;
    }
    

    代码看起来“逻辑通顺”,甚至还知道用 __sync_fetch_and_add 做原子操作。但这正是缺乏内核并发意识的典型表现。

    1. NAPI 机制与多队列网卡:现代网卡都有多个 RX 队列(RX Queue),通常通过 RSS(Receive Side Scaling)根据 IP/Port 将报文打散到不同的队列。每个队列由一个专门的 CPU 核心通过软中断(ksoftirqd)以 NAPI 轮询的方式处理。

    2. 全局锁与 Cache Line Bouncing:当流量达到 80w PPS 时,分布在 16 个 CPU 核心上的 XDP 程序同时在执行。如果这些 IP 大量重合(例如几个高频源 IP),16 个核心都在并发试图修改同一个内存地址(count)。

    3. 性能黑洞__sync_fetch_and_add 依赖底层的总线锁或缓存锁定机制。多核高频修改同一地址,导致 L3 Cache 中的这行数据在各个核心的 L1/L2 Cache 之间不断失效和同步(Cache Line Bouncing)。更糟糕的是,当出现新 IP 时,bpf_map_update_elem 对全局 BPF_MAP_TYPE_HASH 的操作会在内核底层触发自旋锁(Bucket Lock)。

    4. 软中断雪崩:锁争抢导致 CPU 耗费大量时钟周期在等待上,使得每个报文的处理时间被拉长。NAPI 的一次 poll 默认有 64 个 budget,因为处理太慢,budget 耗尽时 Ring Buffer 中的报文根本来不及被取走,进而引发 rx_missed_errors 丢包。

    优雅的解法:Per-CPU Map 与空间换时间

    在内核数据面上做统计,第一原则永远是避免跨核共享状态

    修复方案非常直接,将全局 Hash Map 替换为 Per-CPU Hash Map:

    // 正确的 Map 定义
    struct {
        __uint(type, BPF_MAP_TYPE_PERCPU_HASH); // Per-CPU Hash Map
        __uint(max_entries, 1000000);
        __type(key, __u32);
        __type(value, __u64);
    } ip_stats SEC(".maps");
    
    SEC("xdp")
    int xdp_ddos_filter(struct xdp_md *ctx) {
        // ... 解析逻辑 ...
        __u32 src_ip = iph->saddr;
        __u64 *count, init_val = 1;
    
        count = bpf_map_lookup_elem(&ip_stats, &src_ip);
        if (count) {
            // 由于是当前 CPU 独占的内存,无需原子操作,直接累加!
            *count += 1;
        } else {
            bpf_map_update_elem(&ip_stats, &src_ip, &init_val, BPF_ANY);
        }
        return XDP_PASS;
    }
    

    为什么这样能解决问题? BPF_MAP_TYPE_PERCPU_HASH 在内核层面为每个 CPU 核心分配了独立的 Value 内存空间。在 XDP 执行时(当前抢占已禁用,且绑定在固定的 CPU 核心上运行),操作的完全是当前 CPU 本地 Cache 的数据。没有任何锁竞争,没有任何 Cache Line 颠簸,报文处理速度达到真正的网卡线速。最终的总量统计,交给用户态程序(如 Go/Rust Agent)定期遍历所有的 Per-CPU 数据进行归并计算即可。这即是经典的“数据面无锁,控制面合并”架构。

    同类问题排查清单(Troubleshooting Checklist)

    1. XDP 性能影响定位:遇到网络收包延迟抖动,排查常规栈无果时,务必使用 bpftool prog showbpftool net show 检查是否被偷偷注入了 eBPF/XDP 程序。

    2. CPU 软中断被打满:使用 perf top 观察是否出现大量 bpf_prog_xxxhtab_map_xxx_raw_spin_lock 函数。如果是,大概率是 eBPF Map 滥用导致锁竞争或 Cache Miss 严重。

    3. 网卡底层静默丢包:关注 ethtool -S 中的 rx_missed_errorsrx_fifo_errors。该指标上涨通常意味着 CPU 处理 NAPI poll 的速度跟不上网卡硬件收包的速度。

    4. eBPF Map 选型红线:在 XDP/TC 等高频网络上下文中,只要涉及计数、累加等写入操作,绝对禁止使用全局 BPF_MAP_TYPE_HASHBPF_MAP_TYPE_ARRAY。必须使用对应的 PERCPU 版本变体,将并发冲突转嫁到用户态去异步合并。

  • 深入 eBPF 陷阱排查:BPF_MAP_TYPE_LRU_HASH 并发更新引发的 XDP 静默丢包与伪 LRU 性能实战

    结论先行:在 XDP 网络加速场景中使用 BPF_MAP_TYPE_LRU_HASH 管理高并发会话状态时,由于内核采用了基于 Per-CPU 的伪 LRU(Pseudo-LRU)淘汰机制,在局部 Hash 冲突或跨 CPU 流量漂移时,极易触发未过期表项被强行驱逐,导致静默丢包。根本解法是:要么将 Map 容量冗余放大 3 倍以上并绑定 BPF_F_NO_COMMON_LRU,要么改用标准 BPF_MAP_TYPE_HASH 配合 RingBuffer 由用户态异步执行精确 GC。

    排查过程中,我们遇到一个极其隐蔽的网络抖动问题。自研的基于 XDP(eBPF)的边缘四层负载均衡器在流量高峰期(单机 PPS 约 80万,TCP 新建连接 3万/秒),P99 延迟会偶发出现从 2ms 飙升至 1.2s 的毛刺,业务端反馈伴随少量 TCP RST

    硬件环境是 Mellanox ConnectX-6,内核版本为 5.15.0-88-generic。系统负载非常健康,Load Average 不超过单核的 50%,软中断也没有打满。常规的网络排查手段在这里全部失效:netstat -s 没看到明显丢包,nstat -az | grep drop 毫无波澜。原因很简单:XDP 挂载在网卡驱动层(Native Mode),处理时机早于 SKB 的分配,它的丢包内核网络栈根本看不见。

    抓取现场:追踪被隐形的 XDP_DROP

    既然内核网络栈无感,只能用 eBPF 来监控 eBPF。我们直接挂载 xdp:xdp_exception 追踪点,看看到底是不是 XDP 程序把包丢了。

    # 使用 bpftrace 快速抓取 XDP_DROP 行为
    bpftrace -e '
    tracepoint:xdp:xdp_exception {
        if (args->action == 1) { // 1 == XDP_DROP
            @[args->prog_id] = count();
        }
    }'
    

    输出结果清晰地指向了 ID 为 145 的 XDP 核心分发程序。通过 bpftool prog show id 145 确认,这正是处理连接追踪(Conntrack)逻辑的代码。

    进一步审查逻辑:当收到一个非 SYN 的 ESTABLISHED 状态报文时,XDP 会去查询 Conntrack Map,如果查不到,直接返回 XDP_DROP(为了防御伪造的 ACK 攻击)。问题来了:明明是活跃连接,为什么在 Map 里查不到?

    我们查看了这个 Map 的状态:

    bpftool map show name xdp_ct_map
    # 112: lru_hash  name xdp_ct_map  flags 0x0
    #        key 16B  value 32B  max_entries 1048576  memlock 134217728B
    

    最大条目数是 100万(1048576),但通过脚本统计当前存量条目,仅仅只有 40 万左右。Map 远没达到容量上限,但里面活跃连接的 Key 却“凭空蒸发”了。

    为什么 BPF_MAP_TYPE_LRU_HASH 会在未满容量时触发随机淘汰?

    这涉及 eBPF LRU_HASH 的底层实现陷阱。很多开发认为 LRU_HASH 就是一个严格按照时间顺序淘汰最老数据的结构,但在 Linux Kernel 中,为了在极高并发下(比如几千万 PPS)避免全局自旋锁(Spinlock)的严重争抢,内核实现了一个妥协版的伪 LRU(Pseudo-LRU)

    kernel/bpf/bpf_lru_list.c 中,LRU Map 的内存分配和淘汰逻辑被拆分成了两级:

    1. 全局 LRU 链表(Global LRU List)

    2. Per-CPU 局部空闲链表(Per-CPU Free List)

    当一个 CPU 需要在 LRU_HASH 中插入新 Key 时:

    1. 优先从当前 CPU 的 Local Free List 拿内存。

    2. 如果 Local List 空了,它不会立刻去全局拿,而是尝试从当前 CPU 的 Local LRU 淘汰数据。

    3. 如果还不行,再去 Global LRU 去“偷”内存(Steal),甚至去别的 CPU 节点“偷”。

    致命弱点在于 Hash 冲突与 RSS 漂移的结合: 网卡的 RSS(Receive Side Scaling)负责将流量打到不同 CPU 队列。如果短时间内某个特定的 5-Tuple(五元组)Hash 导致大量新建连接集中落在了 CPU 0CPU 0 的 Local List 会迅速耗尽。 此时,即使全局(或者其他 CPU)还有 60 万个空闲名额,CPU 0 为了效率,也会优先执行强制淘汰。它极有可能把当前仍在活跃的连接状态踢掉。后续该连接的报文到来时(不管是落在这个 CPU 还是漂移到了别的 CPU),查询必定失败,XDP 逻辑就会无情地将包 Drop 掉。

    破局之道:架构调整与代码重构

    明确了由于并发不均和伪 LRU 设计导致的“抢占式淘汰”,我们有两种重构路径。

    方案一:硬扛(Per-CPU 隔离 + 容量放大)

    如果不改 Map 类型,必须优化内存分配行为。在创建 Map 时传入 BPF_F_NO_COMMON_LRU 标志位。 这个标志会让内核为每个 CPU 创建独立的 LRU 结构,彻底隔离全局竞争,代价是内存碎片化严重,你必须把 max_entries 设为预期的 3 倍以上。

    // BPF 代码调整
    struct {
        __uint(type, BPF_MAP_TYPE_LRU_HASH);
        __uint(max_entries, 3145728); // 放大 3 倍
        __type(key, struct ct_key);
        __type(value, struct ct_val);
        __uint(map_flags, BPF_F_NO_COMMON_LRU); // 禁用全局 Common LRU
    } xdp_ct_map SEC(".maps");
    

    注:此方案仅适用于网卡 RSS 极为均衡,且业务五元组分布绝对均匀的场景。否则依然会有单核被打爆导致淘汰的风险。

    方案二:降维打击(改用标准 HASH + RingBuffer 异步 GC)—— 我们的最终选择

    放弃把复杂状态机交给内核黑盒处理。我们将 Map 类型退级为普通的 BPF_MAP_TYPE_HASH,不依赖内核的 LRU,而是由用户态 Go/Rust 程序掌控生命周期。

    如何处理过期的连接?依靠 XDP 侧通过 BPF_MAP_TYPE_RINGBUF 向用户态发送 TCP FIN/RST 状态机的事件,用户态程序收到事件后,主动调用 bpf_map_delete_elem 清理。对于异常断电等没有 FIN 的死连接,用户态维持一个低频的定时器进行兜底扫盘。

    // 1. 回退到基础的 BPF_MAP_TYPE_HASH
    struct {
        __uint(type, BPF_MAP_TYPE_HASH);
        __uint(max_entries, 1048576);
        __type(key, struct ct_key);
        __type(value, struct ct_val);
        // HASH 必须显式预分配以保证性能
        __uint(map_flags, BPF_F_NO_PREALLOC ? 0 : 0); 
    } xdp_ct_map SEC(".maps");
    
    // 2. 引入 RingBuffer 传输销毁事件
    struct {
        __uint(type, BPF_MAP_TYPE_RINGBUF);
        __uint(max_entries, 256 * 1024); // 256KB 环形缓冲区
    } ct_gc_events SEC(".maps");
    
    // XDP 主逻辑中处理连接结束
    SEC("xdp")
    int xdp_lb_prog(struct xdp_md *ctx) {
        // ... 报文解析逻辑 ...
        if (tcp->fin || tcp->rst) {
            struct gc_event *e = bpf_ringbuf_reserve(&ct_gc_events, sizeof(*e), 0);
            if (e) {
                e->key = ct_key;
                bpf_ringbuf_submit(e, 0); // 抛给用户态 GC
            }
        }
        // ...
    }
    

    切换到此架构后,内核不再背负沉重的 LRU 锁和节点淘汰逻辑,XDP DROP 数量彻底归零,单核软中断 CPU 消耗下降了 14%,P99 毛刺彻底消失。

    常见问题 (FAQ)

    Q1:如何确认服务器上的网卡 RSS 是否均衡?它对 eBPF LRU 有多大影响? 极度不均衡的 RSS 是触发 eBPF 局部 LRU 淘汰的罪魁祸首。可以通过 mpstat -P ALL 1 查看各个核的 %soft 使用率。如果只有少量核心很忙,说明 RSS 未能正确散列。检查网卡是否开启了多队列(ethtool -l eth0),并确认中断亲和性(irqbalance 或手动绑定 /proc/irq/X/smp_affinity)。

    Q2:使用 BPF_MAP_TYPE_HASH 时,为什么说 BPF_F_NO_PREALLOC 对性能影响很大? 标准 Hash Map 默认是预分配内存的(Preallocated)。如果不加 BPF_F_NO_PREALLOC,内核会在加载程序时一次性吃掉所需的内存(Memlock)。但在 5.x 版本内核中,如果在高频包处理场景(如 XDP)开启了 BPF_F_NO_PREALLOC,每次 Map 更新都会触发内核 kmalloc 的内存分配机制,不仅产生巨大的自旋锁开销,还破坏了 RCU 的无锁读取优势,直接导致 PPS 吞吐腰斩。

    Q3:bpftool 显示的 max_entries 是 100万,但实际只用了 40万就报错,怎么排查是 Hash 冲突还是 LRU 淘汰? 可以挂载 eBPF 探针去 trace 内核函数 bpf_lru_list_pop_free_to_localhtab_lru_map_update_elem 的返回值。如果看到 bpf_lru_list_pop_free_to_local 频繁触发且是从其他核 steal 内存,说明是伪 LRU 的坑。如果返回 -E2BIG 且未开启 LRU,则是纯粹的 Hash 容量满了。

    Q4:为什么不直接在 eBPF 中实现一个定时器(bpf_timer)来清理连接表? bpf_timer 是在 Linux 5.15 中引入的功能。理论上可以为每个连接起一个 timer,但对于 100 万级并发连接的四层 LB,内核中维护海量定时器的软中断开销依然非常昂贵。XDP 的设计哲学应当是 “Data plane in kernel, Control plane in user space”(数据面在内核,控制面在用户态),将海量状态的 GC 交给有庞大内存和 Go routine 调度的用户态,系统架构会更加鲁棒。

  • 深入 eBPF/XDP 陷阱排查:Generic 模式退化引发的 ksoftirqd 耗尽与软中断风暴实战

    XDP并非银弹。在开启大接收卸载(LRO)或巨型帧的网卡上挂载XDP程序,会导致其悄无声息地退化为 Generic XDP(SKB模式)。这完全丧失了 XDP_DROP 零拷贝优势,在高PPS下直接导致 ksoftirqd 软中断100%打满,引发严重丢包与P99延迟雪崩。破局之道:关闭网卡LRO/GRO,并在生产环境中强制使用 xdpdrv Native 模式挂载,拒绝静默降级。

    排查过程中,我们遇到了一个极其隐蔽的网络性能故障。某高并发入口网关集群(Kernel 5.15.0,Mellanox ConnectX-4 网卡),为了抵御 UDP 反射攻击和 SYN Flood,我们在网卡上挂载了基于 eBPF/XDP 的 DDoS 过滤程序。

    日常流量下系统风平浪静。但某次压测中,当突发流量仅达到 200万 PPS 时,网关节点的 Load Average 瞬间飙升至 80+,业务 P99 延迟从 3ms 直接雪崩至 2000ms 以上。

    现场勘探:看似“正常”的假象

    登录故障节点,第一感觉是 CPU 遭到了软中断屠杀:

    $ mpstat -P ALL 1
    CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest  %gnice   %idle
    ...
     12    0.00    0.00    0.00    0.00    0.00  100.00    0.00    0.00    0.00    0.00
     13    0.00    0.00    0.00    0.00    0.00  100.00    0.00    0.00    0.00    0.00
    

    大量 CPU 核心的 %soft 被打满,进程上下文中大量出现 ksoftirqd/N

    查看网卡底层丢包情况,硬件 Ring Buffer 出现了灾难性的溢出:

    $ ethtool -S eth0 | grep rx_missed_errors
         rx_missed_errors: 18459203
    

    按理说,XDP 程序的执行位置在网卡驱动层(DMA 之后,SKB 分配之前),直接返回 XDP_DROP 丢弃恶意包,单核处理能力应该在 10M PPS 以上。区区 2M PPS 怎么会把软中断彻底打爆?

    致命陷阱:静默退化的 Generic XDP

    习惯性地检查 XDP 程序的挂载状态,一条不显眼的 xdpgeneric 暴露了真凶:

    $ ip -details link show eth0
    2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP mode DEFAULT group default qlen 1000
        link/ether b8:59:9f:xx:xx:xx brd ff:ff:ff:ff:ff:ff promiscuity 0 minmtu 68 maxmtu 9000
        prog/xdp id 42 tag 3b185a8f47700000 jited xdpgeneric
    

    注意最后的 xdpgeneric。这意味着当前 XDP 程序并没有运行在 Native 模式,而是回退到了 Generic 模式。

    为什么 Native XDP 会悄无声息地退化为 Generic 模式?

    要理解这个致命陷阱,必须清楚 XDP 的三种运行模式:

    1. Offloaded XDP (xdpoffload):直接编译到智能网卡硬件中执行,CPU 0 消耗。

    2. Native XDP (xdpdrv):在网卡驱动层的 RX Ring 中执行。此时内存 DMA 刚完成,操作系统还未分配庞大臃肿的 sk_buff 结构体,是软件层面的最高性能模式。

    3. Generic XDP (xdpgeneric):内核网络协议栈的后备方案。挂载点位于 netif_receive_skb_core() 中。

    Generic 模式的灾难性在于:当数据包到达这个 Hook 点时,内核已经完成了 sk_buff 的内存分配、元数据初始化、甚至部分解析工作! 你本想用 XDP 在门口直接拒之门外,结果 Generic 模式是把人请进客厅,倒好茶水(分配 SKB),然后再把人赶出去。在高频 DDoS 攻击下,海量的 SKB 分配和释放直接把内存分配器(SLUB)和软中断处理(net_rx_action)干到崩溃。

    退化是如何发生的? 绝大多数网上的教程,教你挂载 XDP 程序时使用的命令都是:

    ip link set dev eth0 xdp obj ddos_filter.o sec xdp
    

    在这个命令中,iproute2 工具使用了一个极为“贴心”却在生产环境中极其有害的逻辑:它首先尝试 Native 模式;如果网卡驱动拒绝,它会静默地使用 Generic 模式挂载,并返回成功。

    网卡驱动为什么会拒绝 Native XDP?通常因为特性冲突。查看故障节点的网卡配置:

    $ ethtool -k eth0 | grep large-receive-offload
    large-receive-offload: on
    

    当前网卡开启了 LRO(Large Receive Offload)或者使用了超出 XDP 限制的 Jumbo Frame。在 Linux 内核驱动(如 mlx5ixgbe)实现中,如果开启了 LRO,驱动层函数(如 mlx5e_xdp_allowed)会直接返回 falseiproute2 接收到 -EOPNOTSUPP 错误后,立刻降级为 Generic 模式。

    修复与防御性编程实践

    第一步:环境清理与网卡调优 关闭 LRO/GRO 等与 Native XDP 冲突的硬件卸载特性:

    ethtool -K eth0 lro off gro off
    

    注:关闭 GRO 可能会增加正常大包传输时的 CPU 消耗,需根据业务场景权衡,但作为 DDoS 防御节点,这是必选项。

    第二步:强制 Native 模式挂载 永远不要在生产环境脚本中使用模糊的 xdp 参数,必须显式指定 xdpdrv。宁可挂载失败报错,也绝不接受静默降级。

    # 卸载原有的 generic xdp
    ip link set dev eth0 xdp off
    
    # 强制使用 Native 模式挂载
    ip link set dev eth0 xdpdrv obj ddos_filter.o sec xdp
    

    如果底层不支持,iproute2 会直接抛出异常,触发自动化运维流水线的告警,而不是埋下一颗定时炸弹。

    进阶陷阱:全局 BPF Map 带来的 Cache Line 伪共享

    解决了模式退化问题后,我们发现 10M PPS 下 P99 延迟依然存在偶发抖动。排查 eBPF 源码发现,开发同学为了统计恶意 IP 的丢包数,使用了如下数据结构:

    struct {
        __uint(type, BPF_MAP_TYPE_HASH);
        __uint(max_entries, 100000);
        __type(key, __u32);   // Source IP
        __type(value, __u64); // Drop Count
    } drop_stats SEC(".maps");
    
    // XDP 处理逻辑中:
    __u64 *count = bpf_map_lookup_elem(&drop_stats, &src_ip);
    if (count) {
        __sync_fetch_and_add(count, 1); // 致命瓶颈
    }
    

    在网卡多队列(RSS)架构下,多个 CPU 核心的软中断同时处理大量数据包。当这些核心通过 __sync_fetch_and_add 原语高频修改同一个全局 Map 中的同一个元素时,会引发极其严重的 Cache Line Bouncing(缓存行颠簸)。多核之间的 MESI 协议同步开销,足以将 XDP 的性能优势吞噬殆尽。

    正确姿势:使用 Per-CPU MapBPF_MAP_TYPE_HASH 改为 BPF_MAP_TYPE_PERCPU_HASH。每个 CPU 核心只在本地 L1/L2 Cache 中更新自己的统计值,用户态程序读取时再进行跨核汇总。

    struct {
        __uint(type, BPF_MAP_TYPE_PERCPU_HASH);
        __uint(max_entries, 100000);
        __type(key, __u32);
        __type(value, __u64);
    } drop_stats SEC(".maps");
    
    // XDP 逻辑:
    __u64 *count = bpf_map_lookup_elem(&drop_stats, &src_ip);
    if (count) {
        *count += 1; // 无需原子操作,因为是 Per-CPU 私有数据
    }
    

    修改后,10M PPS 攻击流量下,单核软中断 CPU 占用率从 85% 锐减至 15%,系统彻底回归平稳。

    常见问题 (FAQ)

    Q1:如何判断当前内核版本和网卡驱动是否支持 Native XDP? A:除了查阅官方文档,最直接的方式是使用 bpftool 工具查询网卡特性(需要内核 >= 5.14):

    bpftool net -p
    bpftool feature probe dev eth0
    

    或者尝试强制挂载 ip link set dev eth0 xdpdrv obj dummy.o,看内核 dmesg 输出的错误日志。

    Q2:使用了 XDP_DROP 丢弃的数据包,还能用 tcpdump 抓到吗? A:不能。 Native XDP 的执行点位于驱动层,早于 tc (Traffic Control) 子系统,更早于 AF_PACKET 抓包点。因此被 XDP_DROP 掉的包对于 tcpdump 是完全隐形的。如果需要调试丢弃情况,建议通过 eBPF Map 导出统计数据,或利用 bpf_trace_printk 查看(仅限调试环境)。

    Q3:网卡驱动报 XDP_SETUP_PROG failedOperation not supported,除了 LRO 还有什么原因? A:常见原因有三个:

    1. MTU 过大:由于 XDP 通常要求一帧数据必须位于连续的物理内存页中(不支持散页/Scatter-Gather),如果 MTU > 3900(因网卡而异),会导致驱动拒绝 XDP。

    2. RX 队列数量:某些老旧网卡驱动要求 XDP 的 TX 队列数必须等于 RX 队列数(用于 XDP_TX)。可通过 ethtool -L 调整。

    3. 驱动 Bug:部分虚拟化网卡(如早期版本的 virtio-netveth)对 Native XDP 支持有缺陷。

    Q4:为什么加载 eBPF 程序时会报 bpf verifier failed A:eBPF 验证器 (Verifier) 极其严苛,拒绝任何可能导致内核崩溃的代码。常见错误包括:死循环(未限定上限的 for 循环)、越界内存访问(没有在访问 packet data 前做 data + offset > data_end 的严格校验)、未初始化的变量等。请严格遵守“防御性编程”规范,确保包边界检查无懈可击。

  • 深入 eBPF/XDP 丢包雪崩排查:Hash Map 满载引发的 XDP_DROP 风暴与 ksoftirqd 饱和实战

    近期排查了一起极其诡异的边缘节点网络雪崩事故。业务表现为随机的 TCP 建连超时,API 网关 P99 延迟阶段性飙升至 3 秒以上(典型的 SYN 丢包重传)。经过链路排查,最终定位于一个新上线的基于 XDP (eXpress Data Path) 的防 DDoS 阻断程序。 核心结论:开发在编写 eBPF 代码时,错误地使用基础的 BPF_MAP_TYPE_HASH 来记录源 IP 访问频率,且未配置任何过期清理逻辑;当 Map 满载后 bpf_map_update_elem 调用失败,异常处理分支居然默认返回了 XDP_DROP。更致命的是,部署脚本未校验网卡驱动兼容性,在部分节点回退到了 Generic XDP (SKB 模式),不仅没起到加速作用,反而直接打爆了 ksoftirqd 软中断。

    这不仅仅是代码 Bug,更是对生产环境缺乏敬畏之心的体现。写底层网络逻辑,不带防御性编程思维,等同于在主干道上埋雷。

    案发现场:消失的 SYN 包与哀嚎的软中断

    监控告警最先在部分 BGP 边缘节点触发,现象非常割裂:

    1. 网络层面:外部监控探测大面积报 TCP Timeout。ss -s 发现节点 SYN-RECV 极少,但外部抓包显示 SYN 已经到达物理机网卡。

    2. 系统层面:出问题的节点 Load Average 飙高,top -1 发现个别 CPU 核心的 si(Soft Interrupt)使用率长时间顶在 100%,进程 ksoftirqd/x 霸榜。

    3. 传统排查失效:内核 dmesg 无任何报错,conntrack -S 表项未满,iptables/nftables 的 drop 计数器毫无波澜。

    包进来了,但在进入内核协议栈(Netfilter)之前就凭空消失了。结合软中断被打满的现象,直觉告诉我:有人在网卡底层动了手脚,极大概率是 tc 或者 XDP。

    现场拆解:用 bpftool 扒掉“黑盒”的底裤

    既然怀疑是底层 Hook,直接上 bpftool 查户口。

    执行 bpftool net show,果不其然,网卡 eth0 上挂着东西:

    # bpftool net show
    xdp:
    eth0(2) generic id 142 act XDP_DROP
    

    这里立刻暴露了两个致命问题:

    1. 模式不对:显示为 generic 而不是 driver。Native XDP 是在网卡驱动层(Ring Buffer 刚分配完)处理数据,性能极高;而 Generic XDP 是内核为了兼容不支持 XDP 的网卡做的妥协,它是在 sk_buff 已经分配,甚至包已经进入网络协议栈入口后才执行 eBPF 字节码。此时拦截毫无性能优势,反而因为额外的 BPF 执行逻辑增加了 NET_RX 软中断的开销,直接导致 ksoftirqd 饱和。

    2. 阻断风暴:当前挂载的程序 ID 是 142。

    接着查看具体挂载了什么程序和它的 Map 状态:

    # bpftool prog show id 142
    142: xdp  name xdp_ddos_block  tag 3b185187f1855c4c  gpl
            loaded_at 202X-XX-XXT10:00:00+0800  uid 0
            xlated 528B  jited 312B  memlock 4096B
            map_ids 45
    

    提取关联的 Map ID 45,查看 Map 容量与元素数量:

    # bpftool map show id 45
    45: hash  name ip_stat_map  flags 0x0
            key 4B  value 8B  max_entries 65536  memlock 5242880B
    # bpftool map dump id 45 | grep "Found"
    Found 65536 elements
    

    破案了。max_entries 是 65536,当前已经存了 65536 个元素。Map 被彻底打满了。

    源码处刑:无脑的 XDP_DROP 与缺失的驱逐机制

    把开发叫来,翻开 eBPF C 源码,看到如下逻辑片段时,我血压直接上来了:

    struct bpf_map_def SEC("maps") ip_stat_map = {
        .type = BPF_MAP_TYPE_HASH, // 致命错误1:普通的 Hash Map
        .key_size = sizeof(__u32),
        .value_size = sizeof(struct ip_stat),
        .max_entries = 65536,
    };
    
    SEC("xdp")
    int xdp_ddos_block(struct xdp_md *ctx) {
        // ... 解析 IP 头 ...
        __u32 src_ip = iph->saddr;
    
        struct ip_stat *stat = bpf_map_lookup_elem(&ip_stat_map, &src_ip);
        if (!stat) {
            struct ip_stat new_stat = { .count = 1, .last_time = bpf_ktime_get_ns() };
            // 致命错误2:未判断更新失败的情况,直接放任后续逻辑或采取错误假设
            int ret = bpf_map_update_elem(&ip_stat_map, &src_ip, &new_stat, BPF_ANY);
            if (ret != 0) {
                // 致命错误3:更新 Map 失败(如满了),直接当做异常流量 Drop 掉!
                return XDP_DROP; 
            }
        } else {
            // ... 频率检测逻辑 ...
        }
        return XDP_PASS;
    }
    

    灾难逻辑剖析: 开发者的本意是:“如果连记录状态都失败了,说明系统可能在被严重攻击,为了安全起见,宁可杀错不可放过,直接丢弃(XDP_DROP)”。 但他们忽略了网络世界的复杂性:互联网每天有大量的扫描器、僵尸网络发起一次性连接。使用 BPF_MAP_TYPE_HASH,这些单次访问的源 IP 会永远占据坑位。没有用户态进程去定时清理,也没有内核级的 LRU (Least Recently Used) 淘汰机制,不到几个小时,65536 的容量必然耗尽。 Map 满载后,后续所有正常用户的全新 IP 访问,在执行 bpf_map_update_elem 时都会返回 -E2BIG。代码捕获到这个错误,果断执行了 XDP_DROP。 最终结果就是:防 DDoS 的程序自己变成了一个完美的高性能 DDoS 攻击器,对所有新访客实施无差别静默丢包。

    技术结论与重构方案

    XDP 的极强性能来源于其极其底层的执行位置,但这也意味着它完全脱离了 Linux 协议栈成熟的异常处理、垃圾回收和可观测性体系。能力越大,越需要防御性编程。

    针对该故障,我们进行了彻底整改:

    1. 废弃标准 HASH,强制使用 LRU HASH: 将 Map 类型修改为 BPF_MAP_TYPE_LRU_HASH。当 Map 容量达到 max_entries 时,内核会自动淘汰最久未访问的元素,腾出空间给新连接。永远不要在没有外部 GC 守护进程的情况下,在网络数据面使用不具备自动淘汰机制的 Map。

    2. 修正 Fail-Open (容错放行) 逻辑: 监控程序自身的异常不应导致业务中断。如果 Map 更新失败,正确的做法是打印 BPF Trace 日志或增加异常统计 Counter,并返回 XDP_PASS 交给上层内核协议栈处理,而不是傲慢地返回 XDP_DROP

    3. 强制 Native 模式加载,彻底告别 Generic 软中断陷阱: 修改加载程序(或使用 ip link set dev eth0 xdp obj xxx.o sec xdp 时明确指定模式)。我们重写了加载工具,如果在给定的网卡上 XDP_FLAGS_DRV_MODE (Native 模式) 挂载失败,应当直接终止部署并告警,绝对不允许静默回退到 XDP_FLAGS_SKB_MODE

    同类问题速查排查清单 (eBPF/XDP 故障急救)

    1. 确认 XDP 是否介入及运行模式bpftool net showip link show。重点看接口后是否带有 xdp 标记,以及是 xdpgeneric 还是 xdpdrv。如果是 xdpgeneric 且系统软中断高,直接拔掉 XDP 恢复业务。

    2. 检查 eBPF Map 的满载情况: 使用 bpftool map show 获取所有 Map 的 max_entries,再用 bpftool map dump id | grep "Found" 检查当前元素量。接近或等于满载的,必定会引发 bpf_map_update_elem 返回 -E2BIG,需立即排查代码异常分支逻辑。

    3. 定位静默丢包(Drop)统计: XDP 丢包不会体现在 iptables 里。除了在代码里自建 BPF Perf Event 或 Ring Buffer 输出丢包日志外,可以通过 ethtool -S | grep xdp_drop (依赖具体网卡驱动支持)来观测底层拦截量。

    4. 内核 BPF 调试日志探测: 如果开发在代码中使用了 bpf_printk,可通过 cat /sys/kernel/debug/tracing/trace_pipe 查看实时内核 eBPF 打印的报错信息,往往能一针见血发现诸如 Map Update 失败的错误。

  • 深入 eBPF/XDP 网络雪崩排查:Netfilter 软中断打满引发的丢包与 XDP 内核级加速防御实战

    高并发下 Netfilter 必然成为性能瓶颈。排查某次网关节点大面积丢包时,确认系海量小包打满 ksoftirqdnf_conntrack 溢出导致。直接抛弃 iptables 方案,通过 eBPF 挂载 XDP 程序在网卡驱动层(SKB 分配前)进行拦截与转发,CPU 软中断开销骤降 80%,99线延迟从 200ms 恢复至 2ms,系统吞吐量提升三个数量级。

    故障现场:ksoftirqd 榨干 CPU 与 Conntrack 溢出

    某次生产环境的高并发突发流量下,K8S Ingress 节点(OS: Ubuntu 22.04, 内核 Linux 5.15)出现大面积请求超时。前端监控显示 99 线延迟飙升至 200ms 以上,甚至出现 502/504 错误。

    登录宿主机,第一眼看系统负载:

    $ uptime
     10:14:32 up 45 days, 14:20,  2 users,  load average: 84.12, 75.33, 60.10
    

    Load Average 极高,敲击键盘都有迟滞感。直接看 CPU 消耗,top 里的 si(Soft Interrupt)指标在多个核心上死死顶在 100%,相关的进程全是 ksoftirqd/n

    %Cpu(s):  1.5 us,  3.2 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi, 95.3 si,  0.0 st
      PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
       14 root      20   0       0      0      0 R  99.9   0.0  10:23.12 ksoftirqd/1
       20 root      20   0       0      0      0 R  99.9   0.0   9:14.05 ksoftirqd/2
    

    与此同时,dmesg 中正在疯狂刷屏经典报错:

    $ dmesg -T | tail -n 5
    [Thu Oct 12 10:15:01 2023] nf_conntrack: nf_conntrack: table full, dropping packet
    [Thu Oct 12 10:15:01 2023] nf_conntrack: nf_conntrack: table full, dropping packet
    

    典型的网络软中断风暴 + 连接跟踪表打满。虽然通过 sysctl -w net.netfilter.nf_conntrack_max=2097152 临时缓解了丢包,但这只是扬汤止沸,软中断依然居高不下,节点的网络栈已经处于半瘫痪状态。

    为什么传统的 iptables/Netfilter 在高并发下必然雪崩?

    要理解这场雪崩,必须拆解 Linux 传统的网络收包路径。

    当网卡收到一个数据包时,硬中断触发后,真正的重头戏在软中断 NET_RX_SOFTIRQ。此时,内核会为每个数据包调用 __alloc_skb() 分配一个 sk_buff 结构体。这个结构体极其庞大(通常包含数百个字段),高频的内存分配和释放本身就是巨大的开销。

    紧接着,包会进入内核协议栈,穿越 Netfilter 的重重关卡(PREROUTING, INPUT, FORWARD 等)。如果是 K8S 环境,kube-proxy 写入的数万条 iptables 规则会以线性或树状(ipset)进行匹配。最致命的是 Conntrack(连接跟踪) 机制。每次建连,内核都要加锁更新连接状态表。当 PPS(每秒包数)达到数十万级别时,nf_conntrack 的自旋锁竞争会导致 CPU 缓存命中率暴跌,最终表现为 ksoftirqd 吃满 CPU,后续的包连 sk_buff 都分配不到,直接在网卡 Ring Buffer 处被丢弃。

    可观测性介入:用 eBPF/bpftrace 精准定位丢包点

    在实施改造前,我们需要硬核的数据佐证。只看 dmesg 不够,到底包是在协议栈的哪一步被 Drop 的? 利用 bpftrace 编写一行脚本,直接 Hook 内核的 kfree_skb 函数(内核丢弃数据包时通常会调用它),并打印调用栈:

    # 依赖环境: bpftrace 0.14.0+
    $ bpftrace -e 'kprobe:kfree_skb /comm == "ksoftirqd/1"/ { @[kstack] = count(); }'
    

    运行 10 秒后 Ctrl+C 停止,输出的核心堆栈如下:

    @[
        kfree_skb+1
        nf_conntrack_in+1345
        ipv4_conntrack_in+28
        nf_hook_slow+66
        ip_rcv+165
        __netif_receive_skb_core+2180
        net_rx_action+354
        __do_softirq+215
        run_ksoftirqd+42
    ]: 45210
    

    数据确凿:短短 10 秒内,在 nf_conntrack_in 链路下触发了 4.5 万次 kfree_skb。传统的防御方案(如加机器、调大 sysctl 参数)在百万级 PPS 面前毫无招架之力。必须进行降维打击——绕过 sk_buff 和 Netfilter。

    降维打击:XDP (eXpress Data Path) 零拷贝拦截实战

    XDP 是基于 eBPF 的一项技术,它允许我们在网卡驱动层,即数据包刚通过 DMA 拷贝到内存,尚未分配 sk_buff 之前,执行我们自定义的 eBPF 程序。

    排查过程中,我们发现异常流量具有明显的端口和 IP 聚集特征。直接编写 XDP 程序,对恶意流量执行 XDP_DROP,对合法突发流量直接在驱动层打标或放行。

    以下是精简后的 XDP C 代码(xdp_filter.c),实现对特定目标端口(如 8080)的异常小包直接 Drop:

    #include <linux/bpf.h>
    #include <linux/if_ether.h>
    #include <linux/ip.h>
    #include <linux/tcp.h>
    #include <linux/in.h>
    #include <bpf/bpf_helpers.h>
    
    SEC("xdp")
    int xdp_drop_prog(struct xdp_md *ctx) {
        // 获取数据包的起止指针
        void *data_end = (void *)(long)ctx->data_end;
        void *data     = (void *)(long)ctx->data;
    
        // 解析以太网头部
        struct ethhdr *eth = data;
        if (data + sizeof(*eth) > data_end)
            return XDP_PASS;
    
        // 仅处理 IPv4
        if (eth->h_proto != bpf_htons(ETH_P_IP))
            return XDP_PASS;
    
        // 解析 IP 头部
        struct iphdr *iph = data + sizeof(*eth);
        if ((void *)iph + sizeof(*iph) > data_end)
            return XDP_PASS;
    
        // 解析 TCP 头部
        if (iph->protocol == IPPROTO_TCP) {
            struct tcphdr *tcph = (void *)iph + sizeof(*iph);
            if ((void *)tcph + sizeof(*tcph) > data_end)
                return XDP_PASS;
    
            // 如果目标端口是 8080,直接在网卡驱动层丢弃 (模拟黑洞)
            if (tcph->dest == bpf_htons(8080)) {
                // 可在此处加入 eBPF Map 统计丢包数量
                return XDP_DROP;
            }
        }
    
        // 其他数据包正常进入协议栈
        return XDP_PASS;
    }
    
    char _license[] SEC("license") = "GPL";
    

    编译与挂载: 利用 Clang 将 C 代码编译为 BPF 字节码,并通过 iproute2 工具直接挂载到宿主机物理网卡(如 eth0)。

    # 编译 (需安装 clang 12+ 和 linux-headers)
    $ clang -O2 -g -Wall -target bpf -c xdp_filter.c -o xdp_filter.o
    
    # 以 Native 模式挂载到 eth0
    $ ip link set dev eth0 xdp obj xdp_filter.o sec xdp
    
    # 查看挂载状态
    $ ip link show eth0
    2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 xdp/id:45 qdisc mq state UP mode DEFAULT group default qlen 1000
        link/ether 00:16:3e:xx:xx:xx brd ff:ff:ff:ff:ff:ff
        prog/xdp id 45 tag 8fxxxxxx
    

    效果对比: 挂载 XDP 后,恶意流量在网卡驱动层即被截断,根本不会触发 alloc_skb,更不会进入 Netfilter。

    • ksoftirqd 的 CPU 占用率从 100% 瞬间暴降至 15% 左右。

    • dmesgnf_conntrack 报错消失。

    • 合法业务流量的 99 线延迟恢复到健康的 2ms 范围内。

    常见问题 (FAQ)

    Q1:XDP 的 Generic 模式和 Native 模式有什么性能差异? Generic 模式(xdpgeneric)是内核网络栈模拟的 XDP,此时 sk_buff 已经分配,性能提升有限,主要用于测试或不支持 XDP 的网卡驱动。Native 模式(xdp)是在网卡驱动层实现,包刚放入内存就触发,零拷贝,性能是 Generic 模式的 4-5 倍。生产环境必须确保网卡驱动(如 ixgbe, mlx5)支持 Native XDP。

    Q2:eBPF Map 并发读写时如何保证数据一致性? 在多核并发场景下,统计包量等操作直接更新普通的 Array/Hash Map 会有竞态问题。应当使用 BPF_MAP_TYPE_PERCPU_ARRAYBPF_MAP_TYPE_PERCPU_HASH。这种 Map 会为每个 CPU 核心维护独立的数据副本,更新时无锁,用户态读取时再遍历所有 CPU 的值进行汇总。

    Q3:使用 Cilium 替换 kube-proxy 后,NodePort 流量依然有延迟,如何排查? Cilium 默认并不全量开启底层 XDP 加速。如果 NodePort 流量仍有延迟,需检查 Cilium Agent 配置是否启用了 bpf-node-portkube-proxy-replacement=strict。可以通过 cilium status 查看 XDP 加速状态,并使用 cilium bpf nat list 确认底层的 eBPF NAT 表是否正常接管了 iptables 规则。如果网卡不支持 Native XDP,Cilium 会退化到 TC (Traffic Control) 层的 eBPF hook,性能会打折扣。

  • 深入 eBPF/XDP 实战:从 Netfilter 软中断打满看 XDP 快速拦截与 kfree_skb 丢包追踪

    传统 iptables/Netfilter 在千万级 PPS 场景下必然成为软中断杀手,协议栈过深的遍历路径是高并发网关的性能毒药。本文直接给出基于 eBPF/XDP 的网络防刷与加速方案,在网卡驱动层(甚至硬件卸载)直接丢弃恶意包,将 CPU si 开销降低 80%,并结合 tracepoint:skb:kfree_skb 彻底终结内核丢包“黑盒”排查。

    案发现场:Netfilter 成为性能瓶颈

    某次生产环境流量突增,某业务 Ingress 网关(Ubuntu 22.04, Kernel 5.15.0-88-generic)QPS 并没有成倍放大,但 P99 延迟直接从 20ms 飙升到了 500ms,部分节点甚至出现 SSH 登录卡顿。

    第一反应看负载,直接上 mpstat -P ALL 1,发现网卡队列绑定的几个 CPU 核心 si(SoftIRQ)直接被打满到了 100%。

    抓取热点函数 perf top -a,霸榜的调用链异常清晰:

      18.52%  [kernel]  [k] nf_hook_slow
      15.21%  [kernel]  [k] ip_rcv
      12.33%  [kernel]  [k] kmem_cache_alloc
      10.14%  [kernel]  [k] __netif_receive_skb_core
    

    典型的 CC 攻击/恶意扫段特征。大量无效的小包涌入,虽然在 iptables/Netfilter 层面配置了 DROP 规则,但由于 iptables 挂载在 PREROUTING 等 Hook 点,数据包走到这里时,内核已经为每一个包分配了 sk_buff 结构体,并走完了复杂的 L2 和 L3 早期协议栈处理

    在动辄几百万 PPS 的冲击下,频繁的 kmem_cache_alloc 和 Netfilter 规则链遍历直接榨干了 CPU。我们需要在更底层“掐断”这些流量。

    为什么 XDP 能在千万级 PPS 下实现防刷降级?

    常规的数据包接收路径是:网卡 -> DMA 拷贝到 Ring Buffer -> 触发硬中断 -> NAPI 轮询拉取 -> 分配 sk_buff -> __netif_receive_skb_core -> 网络协议栈 (Netfilter/IP/TCP 等)。

    XDP(eXpress Data Path)之所以快,根本原因在于它的 Hook 点位于 网络驱动层分配 sk_buff 之前。 当网卡通过 DMA 将数据放入内存后,XDP BPF 程序直接读取这段连续的原始内存(xdp_md),如果是恶意包,直接返回 XDP_DROP,网卡驱动会原地回收页面。没有 skb 内存分配,没有协议栈解析,没有上下文切换。

    XDP 黑名单拦截实战代码

    我们使用 BPF Map 来维护一个高频攻击 IP 黑名单,在 XDP 层直接匹配并丢弃。 以下是精简后的核心 C 代码(xdp_drop.c):

    #include <linux/bpf.h>
    #include <linux/in.h>
    #include <linux/if_ether.h>
    #include <linux/if_packet.h>
    #include <linux/if_vlan.h>
    #include <linux/ip.h>
    #include <bpf/bpf_helpers.h>
    
    // 定义一个 BPF Hash Map 存储黑名单 IP
    struct {
        __uint(type, BPF_MAP_TYPE_HASH);
        __uint(max_entries, 10000);
        __type(key, __u32);   // IPv4 Address
        __type(value, __u32); // Drop counter
    } blacklist SEC(".maps");
    
    SEC("xdp")
    int xdp_drop_prog(struct xdp_md *ctx) {
        void *data_end = (void *)(long)ctx->data_end;
        void *data = (void *)(long)ctx->data;
    
        // 边界检查(必须,否则 eBPF 验证器会拒绝加载)
        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 *iph = data + sizeof(struct ethhdr);
        if ((void *)(iph + 1) > data_end)
            return XDP_PASS;
    
        __u32 src_ip = iph->saddr;
    
        // 查询黑名单 Map
        __u32 *value = bpf_map_lookup_elem(&blacklist, &src_ip);
        if (value) {
            __sync_fetch_and_add(value, 1); // 原子递增拦截计数
            return XDP_DROP; // 核心:在驱动层直接丢弃
        }
    
        return XDP_PASS;
    }
    
    char _license[] SEC("license") = "GPL";
    

    编译与挂载:

    # 使用 clang 编译成 BPF 字节码
    clang -O2 -target bpf -c xdp_drop.c -o xdp_drop.o
    
    # 将 XDP 程序挂载到网卡 eth0 (推荐 Native 模式,如果网卡驱动支持)
    ip link set dev eth0 xdp obj xdp_drop.o sec xdp
    
    # 查看挂载状态
    ip link show eth0
    # 输出会包含: prog/xdp id 123 tag xxxxxxx
    

    此时再用 bpftool map 动态向 blacklist 中写入恶意 IP,被拦截的流量完全不会在 CPU si 中泛起波澜,系统 Load 瞬间恢复。

    丢包排查:用 bpftrace 追踪 kfree_skb 黑盒

    在上述流量清洗的过程中,常会遇到业务方反馈:“我的包明明发过去了,为什么网关没收到?”。此时,如果是协议栈内部某处静默丢包(如 MTU 不匹配、TCP 状态机异常、连接跟踪满),用 tcpdump 是看不出所以然的。

    内核丢弃数据包最终都会调用 kfree_skbconsume_skb(正常释放)。利用 eBPF 追踪 kfree_skb 是降维打击。

    在 Kernel 5.15 下,可以直接使用 bpftrace 一行命令定位丢包的确切内核调用栈:

    # 捕获 10 秒内所有因非正常原因丢包的内核栈并统计次数
    bpftrace -e '
    tracepoint:skb:kfree_skb {
        // args->reason 在 5.1x 较新内核引入,可直接区分丢包原因
        @[kstack] = count();
    }
    '
    

    如果你的内核支持 skb_drop_reason(Kernel 5.17+ 完善),甚至可以直接打印出人类可读的丢包枚举值。 在我们的排查过程中,通过上述命令输出了如下聚合栈:

    @[
        kfree_skb+1
        tcp_v4_rcv+1452
        ip_protocol_deliver_rcu+54
        ip_local_deliver_finish+108
        __netif_receive_skb_one_core+138
        process_backlog+164
        __napi_poll+42
        net_rx_action+582
    ]: 2450
    

    一针见血,包是在 tcp_v4_rcv 中被丢弃的。结合代码和偏移量,立刻定位到是处于 TIME_WAIT 状态的 socket 堆积,导致 PAWS(Protect Against Wrapped Sequence numbers)校验失败,触发了静默丢包。调整 net.ipv4.tcp_tw_reuse 和时间戳设置后,问题迎刃而解。没有 eBPF,这个问题在海量流量下排查至少需要拔几根头发。

    常见问题 (FAQ)

    Q1:XDP 有 Native 和 Generic 两种模式,性能差异多大? Native 模式下,XDP BPF 代码直接嵌入在网卡驱动的 NAPI poll 循环中执行,性能极高(线速丢包可达 10M~20M PPS)。而 Generic 模式(xdpgeneric)是作为回退方案,挂载在 sk_buff 分配之后、协议栈处理之前,性能大打折扣,失去了 XDP “零分配”的核心优势。实战中,如果网卡驱动(如 ixgbe, i40e, mlx5)支持,务必使用 Native 模式(xdpdrv)。

    Q2:加载 XDP 字节码时报错 bpf verifier errors,提示越界访问,怎么解决? eBPF 内核验证器(Verifier)极其严格,采用“防御性加载”策略。如果你在 C 代码中解析 IP 头部,但没有在使用指针前做边界检查(例如 if ((void *)(iph + 1) > data_end) return XDP_PASS;),验证器会认为该程序可能引发 Kernel Panic 并拒绝加载。必须为每一次网络包头部偏移读取增加严格的 data_end 边界校验。

    Q3:网关已经部署了 Cilium (基于 eBPF/XDP),我自己挂载的 XDP 会冲突吗? 会冲突。一个网卡的 RX 队列在同一时间点通常只能挂载一个 XDP 程序。如果强制挂载,后者的会覆盖前者,导致 Cilium 的网络路由与策略失效。在较新的内核中可以使用 libxdp 提供的多程序链(Multi-prog dispatcher)机制,将多个 XDP 程序按优先级串联(如将你的防刷 XDP 作为优先级最高的程序执行,如果 XDP_PASS,再交由 Cilium 的 XDP 程序处理)。

    Q4:为什么不用 TC (Traffic Control) BPF 做拦截? TC BPF 也是极好的网络控制点(支持 Ingress 和 Egress 双向),且能获取完整的 skb 上下文,功能比 XDP 更丰富(比如修改包长、克隆重定向)。但 TC Hook 点位于 skb 分配之后。如果你的首要目标是应对 L3/L4 层的洪水攻击或极限压榨 CPU 性能,选 XDP;如果是做复杂的流量整形、七层之前的深度负载均衡,选 TC。