第26周：XDP 程序开发入门

字数统计: 2.5k字   |   阅读时长≈ 12分

第26周：XDP 程序开发入门

目标：理解 XDP（eXpress Data Path）的挂载点和处理模型，能够编写 XDP 程序实现包过滤和转发。

1. XDP 概述

1.1 什么是 XDP？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
XDP（eXpress Data Path）：

  - 驱动级别的数据包处理
  - 在内核协议栈之前执行
  - 由网卡驱动通过 NAPI 钩子调用
  - 比 iptables/nftables 早得多

数据流向（无 XDP）：
  网卡 → DMA → driver → 内核协议栈 → 用户态

数据流向（有 XDP）：
  网卡 → DMA → driver → XDP 程序 → 内核协议栈 → 用户态
                          ↓
                       XDP_DROP（丢弃）
                       XDP_TX（直接返回）
                       XDP_REDIRECT（重定向）

1.2 XDP 性能优势

1
2
3
4
5
6
7
8
9
10
11
12
性能对比（典型 10GbE 小包）：

  iptables:  1-3 Mpps
  TC:        3-5 Mpps
  XDP (driver): 12-14 Mpps（线速）
  XDP (generic): 6-9 Mpps（回退到 TC 路径）

原因：
  - 在 DMA 后立即执行（零拷贝）
  - 无协议栈开销
  - 跳过 skb 分配（XDP_PASS 仍需分配）
  - 单条指令路径，无锁

2. XDP 挂载点

2.1 三种挂载模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
┌────────────────────────────────────────────────────────┐
│                  Linux 内核网络栈                        │
│                                                        │
│  ┌─────────┐   ┌─────────┐   ┌─────────┐             │
│  │ Native  │   │  Off-   │   │ Generic │             │
│  │  XDP    │   │  loaded │   │  XDP    │             │
│  │ (driver)│   │(driver) │   │ (kernel)│             │
│  └────┬────┘   └────┬────┘   └────┬────┘             │
│       │             │             │                  │
│       ▼             ▼             ▼                  │
│   最快(线速)    中等         通用(任意网卡)              │
│                                                        │
└────────────────────────────────────────────────────────┘

1. Native XDP（驱动级）
   - 速度最快
   - 需要网卡驱动支持
   - 由 NAPI poll 钩子调用
   - 支持的驱动：ixgbe, i40e, mlx5, bnxt 等

2. Offloaded XDP（卸载到网卡）
   - 由网卡硬件执行
   - 不消耗 CPU
   - 需要 SmartNIC 支持
   - Netronome NFP 等

3. Generic XDP（通用）
   - 默认回退路径
   - 性能最差但兼容性最好
   - 在 skb 分配后执行

2.2 挂载方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# === iproute2 加载 XDP ===

# Native XDP
sudo ip link set dev eth0 xdp obj xdp_prog.o sec xdp

# Generic XDP（兼容性回退）
sudo ip link set dev eth0 xdpdrv
sudo ip link set dev eth0 xdpgeneric obj xdp_prog.o sec xdp

# 卸载
sudo ip link set dev eth0 xdp off

# 查看
ip link show dev eth0
# 输出: xdp id=42
# 或:   xdpgeneric id=42

# === bpftool 加载 ===
sudo bpftool prog load xdp_prog.o /sys/fs/bpf/xdp_prog
sudo bpftool prog show

# 挂载到接口
sudo bpftool net attach xdp name xdp_prog dev eth0
sudo bpftool net detach xdp name xdp_prog dev eth0

3. XDP 动作

3.1 五种动作

1
2
3
4
5
6
7
8
9
10
11
12
13
// <linux/bpf.h>
enum xdp_action {
    XDP_ABORTED = 0,    // 异常终止（丢弃 + 触发 trace）
    XDP_DROP,           // 丢弃
    XDP_PASS,           // 传递给内核协议栈
    XDP_TX,             // 原路返回（从同一网卡发送）
    XDP_REDIRECT,       // 重定向到其他网卡/CPU/AF_XDP socket
};

// 返回值
// > 0: 动作码（如 XDP_DROP）
// == 0: XDP_ABORTED
// < 0: 错误

3.2 动作详细说明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
XDP_DROP（最快）：
  - 立即丢弃包
  - 不通知对端
  - 比 iptables DROP 快（无需走协议栈）
  - 用途：DDoS 防护、黑名单、过滤

XDP_TX：
  - 把包从原路返回（从同一 NIC 发送回去）
  - 适合做 L2 reflector（负载测试）
  - 注意：需要修改 MAC 地址
  - 用途：流量镜像、负载生成

XDP_PASS：
  - 继续走内核协议栈
  - 用途：包计数、监控

XDP_REDIRECT：
  - 重定向到另一个网卡
  - 重定向到 CPU（CPUMAP）
  - 重定向到 AF_XDP socket（用户态）
  - 用途：转发、负载均衡

XDP_ABORTED：
  - 异常终止（不应该使用）
  - 验证器会报警

4. XDP 程序基础

4.1 第一个 XDP 程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// drop_all.bpf.c
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

// 统计丢弃数量
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 1);
    __type(key, u32);
    __type(value, u64);
} drop_count SEC(".maps");

// XDP 程序
SEC("xdp")
int xdp_drop_all(struct xdp_md *ctx) {
    u32 key = 0;
    u64 *count = bpf_map_lookup_elem(&drop_count, &key);
    if (count)
        (*count)++;

    return XDP_DROP;  // 丢弃所有包
}

char LICENSE[] SEC("license") = "GPL";

4.2 XDP 上下文

1
2
3
4
5
6
7
8
9
// <linux/bpf.h>
struct xdp_md {
    __u32 data;       // 包数据起始地址（虚拟）
    __u32 data_end;   // 包数据结束地址
    __u32 data_meta;  // 元数据起始（可选）
    __u32 ingress_ifindex;  // 接收网卡 index
    __u32 rx_queue_index;   // 接收队列 index
    __u32 egress_ifindex;  // 出口网卡 index（仅 XDP_TX）
};

4.3 包数据访问辅助

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 直接访问包头（必须先检查边界）

// 访问以太网头
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;  // 越界
}

// 访问 IP 头（跳过以太网头）
struct iphdr *ip = (void *)(eth + 1);
if ((void *)(ip + 1) > data_end) {
    return XDP_PASS;
}

// 也可以使用 BPF helper（更优雅）
int bpf_xdp_adjust_head(struct xdp_md *ctx, int delta);  // 调整头
int bpf_xdp_adjust_tail(struct xdp_md *ctx, int delta);  // 调整尾
int bpf_xdp_adjust_meta(struct xdp_md *ctx, int delta);  // 调整元数据

4.4 内置 XDP 头（vmlinux.h）

1
2
3
4
5
// <linux/if_ether.h> — 但 BPF 程序要用 bpf helper
#include <linux/if_ether.h>   // struct ethhdr
#include <linux/ip.h>          // struct iphdr
#include <linux/tcp.h>         // struct tcphdr
#include <linux/udp.h>         // struct udphdr

5. 实践：丢弃所有 UDP 8080 端口包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// drop_udp_8080.bpf.c
#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_endian.h>

// 统计
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 4);
    __type(key, u32);
    __type(value, u64);
} stats SEC(".maps");

// enum 索引
enum {
    STAT_TOTAL = 0,
    STAT_UDP_8080 = 1,
    STAT_DROPPED = 2,
    STAT_PASSED = 3,
};

SEC("xdp")
int xdp_drop_udp_8080(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;

    // 只处理 IPv4
    if (eth->h_proto != bpf_htons(ETH_P_IP))
        return XDP_PASS;

    // 边界检查：IP 头
    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end)
        return XDP_PASS;

    // 边界检查：UDP 头
    if (ip->protocol != IPPROTO_UDP)
        return XDP_PASS;

    struct udphdr *udp = (void *)ip + (ip->ihl * 4);
    if ((void *)(udp + 1) > data_end)
        return XDP_PASS;

    // 统计总包
    u32 key = STAT_TOTAL;
    u64 *count = bpf_map_lookup_elem(&stats, &key);
    if (count) (*count)++;

    // 检查 UDP 8080
    if (udp->dest == bpf_htons(8080)) {
        key = STAT_UDP_8080;
        count = bpf_map_lookup_elem(&stats, &key);
        if (count) (*count)++;

        key = STAT_DROPPED;
        count = bpf_map_lookup_elem(&stats, &key);
        if (count) (*count)++;

        return XDP_DROP;
    }

    // 透传
    key = STAT_PASSED;
    count = bpf_map_lookup_elem(&stats, &key);
    if (count) (*count)++;

    return XDP_PASS;
}

char LICENSE[] SEC("license") = "GPL";

5.1 编译

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 编译为 BPF 字节码
clang -O2 -g -target bpf \
    -D__TARGET_ARCH_x86 \
    -I/usr/include/x86_64-linux-gnu \
    -c drop_udp_8080.bpf.c \
    -o drop_udp_8080.bpf.o

# 检查程序
bpftool prog show
bpftool prog dump xlated pinned /sys/fs/bpf/drop_udp_8080

# 加载
sudo ip link set dev eth0 xdp obj drop_udp_8080.bpf.o sec xdp

# 卸载
sudo ip link set dev eth0 xdp off

5.2 测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 1. 启动服务
nc -ul 8080

# 2. 验证 XDP 工作
echo "test" | nc -u 192.168.1.100 8080 -w 1

# 检查 dmesg（如果用 printk）
dmesg -w

# 查看统计
cat /sys/kernel/debug/tracing/trace_pipe

# 3. 测试其他端口（应正常）
echo "test" | nc -u 192.168.1.100 9999 -w 1

6. 数据包检查模式（重要）

6.1 严格边界检查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
SEC("xdp")
int xdp_check(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    // === 1. 检查以太网头 ===
    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)  // 必须用 > 而不是 >=
        return XDP_PASS;

    // === 2. 检查 VLAN 标签（如果存在）===
    if (eth->h_proto == bpf_htons(ETH_P_8021Q)) {
        struct vlan_hdr *vh = (void *)(eth + 1);
        if ((void *)(vh + 1) > data_end)
            return XDP_PASS;
        // 跳过 VLAN 头
        // ...
    }

    // === 3. 检查 IP 头 ===
    if (eth->h_proto != bpf_htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end)
        return XDP_PASS;

    // === 4. 检查 IHL 字段 ===
    if (ip->ihl < 5)
        return XDP_PASS;

    // === 5. 检查 L4 头 ===
    if (ip->protocol == IPPROTO_TCP) {
        struct tcphdr *tcp = (void *)ip + (ip->ihl * 4);
        if ((void *)(tcp + 1) > data_end)
            return XDP_PASS;
        // ... TCP 处理
    }

    return XDP_PASS;
}

6.2 辅助：使用 helper 进行解析

1
2
3
4
5
6
7
8
9
10
// BPF 提供了一些便利函数解析常见头

// 解析 IPv4 头（已做边界检查）
int bpf_parse_header(struct sk_buff *skb, u32 offset, u32 hdr, u32 *value);
// 不直接用，更好的方式是手动解析

// XDP 中可以调用：
// - bpf_xdp_adjust_head()：前移 data 指针
// - bpf_xdp_adjust_tail()：后移 data_end
// - bpf_xdp_adjust_meta()：调整元数据区

7. 调整数据包（修改包内容）

7.1 调整头部（剥离/添加包头）

1
2
3
4
5
6
7
8
9
10
SEC("xdp")
int xdp_modify(struct xdp_md *ctx) {
    // 剥离 VLAN 标签
    bpf_xdp_adjust_head(ctx, 4);  // data 指针 +4 字节
    // 现在 ctx->data 指向 VLAN 头之后的位置

    // 添加包头（vlan tag）
    // bpf_xdp_adjust_head(ctx, -4);  // data 指针 -4（需要确认有空间）
    return XDP_PASS;
}

7.2 修改包内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 直接修改（可写）
SEC("xdp")
int xdp_modify_dst(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;

    // 修改目的 MAC（XDP_TX 需要）
    if (eth->h_proto == bpf_htons(ETH_P_ARP)) {
        // ARP 包特殊处理
    }

    return XDP_PASS;
}

7.3 XDP_TX 实现（反射器）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
SEC("xdp")
int xdp_reflect(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;

    // 交换源/目的 MAC
    unsigned char tmp_mac[ETH_ALEN];
    memcpy(tmp_mac, eth->h_source, ETH_ALEN);
    memcpy(eth->h_source, eth->h_dest, ETH_ALEN);
    memcpy(eth->h_dest, tmp_mac, ETH_ALEN);

    return XDP_TX;  // 从原网卡发回
}

8. 调试与验证

8.1 trace_pipe

1
2
3
4
5
6
7
// BPF 程序中使用
bpf_printk("DEBUG: tcp_connect from pid=%d\\n", pid);

// 用户态查看
sudo cat /sys/kernel/debug/tracing/trace_pipe
# 或
sudo tail -f /sys/kernel/debug/tracing/trace_pipe

8.2 bpftool 检查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 列出所有 BPF 程序
sudo bpftool prog list

# 输出示例：
# 42: xdp  tag ...  gpl
#      loaded_at ...  uid 0
#      xlated 32B  jited 50B  memlock 4096B  map_ids 10,11
#      pids test_prog(1234)

# 查看程序详情
sudo bpftool prog show id 42

# 反汇编（xlated 字节码）
sudo bpftool prog dump xlated id 42

# 反汇编（JIT 后机器码）
sudo bpftool prog dump jited id 42

# 列出所有 BPF map
sudo bpftool map list

# 查看 map 内容
sudo bpftool map dump id 10

# 统计
sudo bpftool prog profile id 42

8.3 内核日志

1
2
3
4
5
6
7
8
# 在 BPF 程序中
bpf_printk("Got packet: src=%pI4 dst=%pI4\\n",
           &ip->saddr, &ip->daddr);

# 用户态查看
sudo dmesg -w
# 或
sudo cat /sys/kernel/debug/tracing/trace_pipe

9. 高级 XDP 特性

9.1 多程序链（tail call）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 跳转到另一个 BPF 程序
SEC("xdp")
int xdp_prog1(struct xdp_md *ctx) {
    // ... 处理

    // 跳转到 prog2（program array map）
    bpf_tail_call(ctx, &progs_array, 0);
    return XDP_PASS;
}

// prog2
SEC("xdp")
int xdp_prog2(struct xdp_md *ctx) {
    // ... 处理
    return XDP_DROP;
}

// tail call map
struct {
    __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
    __uint(max_entries, 1);
    __type(key, u32);
    __type(value, u32);
} progs_array SEC(".maps");

9.2 CPU 重定向（CPUMAP）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 重定向到其他 CPU 处理
struct {
    __uint(type, BPF_MAP_TYPE_CPUMAP);
    __uint(max_entries, 8);
    __type(key, u32);
    __type(value, struct bpf_cpumap_val);
} cpu_map SEC(".maps";

// 重定向
SEC("xdp")
int xdp_redirect_cpu(struct xdp_md *ctx) {
    u32 cpu_id = bpf_get_smp_processor_id();
    cpu_id = (cpu_id + 1) % 8;  // 下一个 CPU

    return bpf_redirect_map(&cpu_map, cpu_id, 0);
}

9.3 设备重定向（DEVMAP）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 重定向到其他网卡
struct {
    __uint(type, BPF_MAP_TYPE_DEVMAP);
    __uint(max_entries, 4);
    __type(key, u32);
    __type(value, struct bpf_devmap_val);
} dev_map SEC(".maps");

SEC("xdp")
int xdp_redirect_dev(struct xdp_md *ctx) {
    u32 out_port = 1;  // 目标网卡

    // 通过 DEVMAP 转发
    return bpf_redirect_map(&dev_map, out_port, 0);
}

10. XDP 与 AF_XDP 配合

1
2
3
4
5
6
7
8
9
10
11
AF_XDP（用户态网络）：

  XDP 程序将包重定向到 AF_XDP socket
  用户态程序（如 DPDK）直接读取
  零拷贝，极低延迟

  ┌─────────┐    XDP_REDIRECT    ┌──────────┐
  │  网卡    │ ────────────────▶ │ AF_XDP   │
  │         │                    │ socket   │
  │  XDP    │                    │ 用户态   │
  └─────────┘                    └──────────┘
1
2
# 启用 AF_XDP 零拷贝
sudo ethtool --set-priv-flags <interface> rx-zero-copy enable
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870