1
// BPF 指令示例（手动编写极少，通常由 clang 编译 C 生成）
2
// r0 = r1 + 5
3
//   op = BPF_ALU64 | BPF_ADD | BPF_K  (0x07)
4
//   dst = r0, src = r1, off = 0, imm = 5
5

6
// if r1 > 10 goto +2
7
//   op = BPF_JMP | BPF_JGT | BPF_K  (0x25)
8
//   dst = r1, off = 2, imm = 10

1
对于每条执行路径：
2
  1. 维护寄存器状态（类型、范围、是否已初始化）
3
  2. 维护栈帧状态（每个栈槽的类型和值）
4
  3. 在分支点保存状态快照
5
  4. 合并汇聚点的状态（取交集）
6
  5. 检测不可达代码
7
  6. 限制总探索状态数（防止状态爆炸）

1
# 查看 JIT 编译状态
2
cat /proc/sys/net/core/bpf_jit_enable
3
# 0 = 禁用, 1 = 启用, 2 = 启用 + 添加调试跟踪
4

5
# 启用 JIT
6
sudo sysctl -w net.core.bpf_jit_enable=1
7

8
# 查看 JIT 编译后的指令（需要 bpf_jit_enable=2）
9
sudo cat /proc/sys/net/core/bpf_jit_kallsyms

1
// xdp_prog_kern.c — XDP 程序（运行在内核态）
2
#include <linux/bpf.h>
3
#include <bpf/bpf_helpers.h>
4

5
// 定义一个 BPF Map 用于统计
6
struct {
7
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
8
    __uint(max_entries, 5);  // 对应 5 种 XDP 动作
9
    __type(key, __u32);
10
    __type(value, __u64);
11
} xdp_stats_map SEC(".maps");
12

13
// XDP 程序入口
14
SEC("xdp")
15
int xdp_stats_func(struct xdp_md *ctx)
16
{
17
    void *data_end = (void *)(long)ctx->data_end;
18
    void *data     = (void *)(long)ctx->data;
19

20
    // 解析以太网头
21
    struct ethhdr *eth = data;
22
    if ((void *)(eth + 1) > data_end)
23
        return XDP_PASS;  // 包太短，交给协议栈
24

25
    // 只处理 IPv4
26
    if (eth->h_proto != __builtin_bswap16(0x0800))
27
        return XDP_PASS;
28

29
    // 解析 IP 头
30
    struct iphdr *iph = (void *)(eth + 1);
31
    if ((void *)(iph + 1) > data_end)
32
        return XDP_PASS;
33

34
    // 统计各动作计数
35
    __u32 action = XDP_PASS;  // 默认动作
36
    __u64 *count = bpf_map_lookup_elem(&xdp_stats_map, &action);
37
    if (count)
38
        (*count)++;
39

40
    return action;
41
}
42

43
char _license[] SEC("license") = "GPL";

1
// include/uapi/linux/bpf.h（简化）
2
struct xdp_md {
3
    __u32 data;           // 数据包起始地址（可读写）
4
    __u32 data_end;       // 数据包结束地址（只读）
5
    __u32 data_meta;      // 元数据区域起始
6
    __u32 ingress_ifindex; // 入接口索引
7
    __u32 rx_queue_index;  // 接收队列索引
8
};

1
// 修改数据包内容（原地修改）
2
static __always_inline void swap_mac(struct xdp_md *ctx)
3
{
4
    void *data_end = (void *)(long)ctx->data_end;
5
    void *data     = (void *)(long)ctx->data;
6

7
    struct ethhdr *eth = data;
8
    if ((void *)(eth + 1) > data_end)
9
        return;
10

11
    // 交换源 MAC 和目标 MAC（用于 XDP_TX 回包）
12
    __u8 tmp[6];
13
    __builtin_memcpy(tmp, eth->h_source, 6);
14
    __builtin_memcpy(eth->h_source, eth->h_dest, 6);
15
    __builtin_memcpy(eth->h_dest, tmp, 6);
16
}
17

18
// 调整数据包头部空间
19
// bpf_xdp_adjust_head() 增加或减少包头空间
20
SEC("xdp")
21
int xdp_add_header(struct xdp_md *ctx)
22
{
23
    // 在数据包前面增加 4 字节（用于封装 VLAN 等场景）
24
    if (bpf_xdp_adjust_head(ctx, -4))
25
        return XDP_DROP;
26

27
    // 调整后需要重新获取 data/data_end 指针
28
    void *data_end = (void *)(long)ctx->data_end;
29
    void *data     = (void *)(long)ctx->data;
30

31
    // 填充新增的 4 字节...
32
    return XDP_PASS;
33
}

1
// 查找
2
void *bpf_map_lookup_elem(struct bpf_map *map, const void *key);
3
// 返回值指针，不存在返回 NULL
4

5
// 更新/插入
6
long bpf_map_update_elem(struct bpf_map *map, const void *key,
7
                          const void *value, __u64 flags);
8
// flags: BPF_ANY (存在则更新，不存在则创建)
9
//        BPF_NOEXIST (仅不存在时创建)
10
//        BPF_EXIST (仅存在时更新)
11

12
// 删除
13
long bpf_map_delete_elem(struct bpf_map *map, const void *key);
14

15
// 遍历
16
long bpf_map_get_next_key(struct bpf_map *map, const void *key,
17
                           void *next_key);
18
// key=NULL 时返回第一个 key

1
// xdp_lb_kern.c — 基于 XDP 的 L3 负载均衡器
2
#include <linux/bpf.h>
3
#include <linux/in.h>
4
#include <bpf/bpf_helpers.h>
5
#include <bpf/bpf_endian.h>
6

7
// 后端服务器列表
8
struct backend {
9
    __u32 ip;       // 后端 IP（网络字节序）
10
    __u8 mac[6];    // 后端 MAC
11
};
12

13
// 后端服务器 Map（ARRAY 类型，索引即后端编号）
14
struct {
15
    __uint(type, BPF_MAP_TYPE_ARRAY);
16
    __uint(max_entries, 16);
17
    __type(key, __u32);
18
    __type(value, struct backend);
19
} backends SEC(".maps");
20

21
// 连接状态表（HASH 类型，五元组 → 后端编号）
22
struct conn_key {
23
    __u32 src_ip;
24
    __u32 dst_ip;
25
    __u16 src_port;
26
    __u16 dst_port;
27
    __u8 proto;
28
    __u8 pad[3];
29
};
30

31
struct {
32
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
33
    __uint(max_entries, 65536);
34
    __type(key, struct conn_key);
35
    __type(value, __u32);  // 后端索引
36
} conn_table SEC(".maps");
37

38
// 统计计数（PERCPU_ARRAY，无锁高效）
39
enum stats_idx {
40
    STAT_PACKETS,
41
    STAT_REDIRECTED,
42
    STAT_DROPPED,
43
    STAT_MAX
44
};
45

46
struct {
47
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
48
    __uint(max_entries, STAT_MAX);
49
    __type(key, __u32);
50
    __type(value, __u64);
51
} stats SEC(".maps");
52

53
static __always_inline void stats_inc(__u32 idx)
54
{
55
    __u64 *val = bpf_map_lookup_elem(&stats, &idx);
56
    if (val)
57
        (*val)++;
58
}
59

60
SEC("xdp")
61
int xdp_lb(struct xdp_md *ctx)
62
{
63
    void *data_end = (void *)(long)ctx->data_end;
64
    void *data     = (void *)(long)ctx->data;
65

66
    stats_inc(STAT_PACKETS);
67

68
    // 解析以太网头
69
    struct ethhdr *eth = data;
70
    if ((void *)(eth + 1) > data_end)
71
        return XDP_PASS;
72

73
    if (eth->h_proto != bpf_htons(ETH_P_IP))
74
        return XDP_PASS;
75

76
    // 解析 IP 头
77
    struct iphdr *iph = (void *)(eth + 1);
78
    if ((void *)(iph + 1) > data_end)
79
        return XDP_PASS;
80

81
    // 构造连接键
82
    struct conn_key key = {};
83
    key.src_ip  = iph->saddr;
84
    key.dst_ip  = iph->daddr;
85
    key.proto   = iph->protocol;
86

87
    // 查找已有连接
88
    __u32 *backend_idx = bpf_map_lookup_elem(&conn_table, &key);
89
    __u32 idx;
90

91
    if (backend_idx) {
92
        idx = *backend_idx;
93
    } else {
94
        // 新连接：简单哈希选择后端
95
        idx = (iph->saddr + iph->daddr) % 16;
96
        bpf_map_update_elem(&conn_table, &key, &idx, BPF_ANY);
97
    }
98

99
    // 查找后端信息
100
    struct backend *be = bpf_map_lookup_elem(&backends, &idx);
101
    if (!be) {
102
        stats_inc(STAT_DROPPED);
103
        return XDP_DROP;
104
    }
105

106
    // 修改目标 MAC 和 IP（DNAT）
107
    __builtin_memcpy(eth->h_dest, be->mac, 6);
108
    iph->daddr = be->ip;
109
    iph->check = 0;  // 简化，实际需重算校验和
110

111
    stats_inc(STAT_REDIRECTED);
112
    return XDP_TX;  // 从同一网卡发回
113
}
114

115
char _license[] SEC("license") = "GPL";

1
// cpumap_redirect_kern.c — CPUMAP 重定向示例
2
#include <linux/bpf.h>
3
#include <bpf/bpf_helpers.h>
4

5
// CPUMAP：key=目标 CPU 编号，value=队列大小
6
struct {
7
    __uint(type, BPF_MAP_TYPE_CPUMAP);
8
    __uint(max_entries, 64);
9
    __type(key, __u32);
10
    __type(value, __u32);
11
} cpu_map SEC(".maps");
12

13
// 统计
14
struct {
15
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
16
    __uint(max_entries, 1);
17
    __type(key, __u32);
18
    __type(value, __u64);
19
} redirect_cnt SEC(".maps");
20

21
SEC("xdp")
22
int xdp_cpumap_redirect(struct xdp_md *ctx)
23
{
24
    void *data_end = (void *)(long)ctx->data_end;
25
    void *data     = (void *)(long)ctx->data;
26

27
    struct ethhdr *eth = data;
28
    if ((void *)(eth + 1) > data_end)
29
        return XDP_PASS;
30

31
    // 简单策略：根据接收队列选择目标 CPU
32
    // 实际中可根据五元组哈希、协议类型等决定
33
    __u32 dest_cpu = ctx->rx_queue_index % 4;
34

35
    // 重定向到目标 CPU
36
    long ret = bpf_redirect_map(&cpu_map, dest_cpu, 0);
37
    if (ret == XDP_REDIRECT) {
38
        __u32 key = 0;
39
        __u64 *cnt = bpf_map_lookup_elem(&redirect_cnt, &key);
40
        if (cnt)
41
            (*cnt)++;
42
    }
43

44
    return ret;
45
}
46

47
// CPUMAP 附着程序：在目标 CPU 上执行
48
SEC("xdp/cpumap")
49
int xdp_cpumap_pass(struct xdp_md *ctx)
50
{
51
    // 在目标 CPU 上可以进一步处理包
52
    // 例如：修改包头、记录日志等
53
    return XDP_PASS;  // 最终交给协议栈
54
}
55

56
char _license[] SEC("license") = "GPL";

1
// devmap_redirect_kern.c — DEVMAP 重定向示例
2
#include <linux/bpf.h>
3
#include <bpf/bpf_helpers.h>
4

5
// DEVMAP：key=目标网卡 ifindex，value=转发配置
6
struct {
7
    __uint(type, BPF_MAP_TYPE_DEVMAP);
8
    __uint(max_entries, 64);
9
    __type(key, __u32);
10
    __type(value, __u32);  // 目标网卡 ifindex
11
} dev_map SEC(".maps");
12

13
SEC("xdp")
14
int xdp_devmap_redirect(struct xdp_md *ctx)
15
{
16
    void *data_end = (void *)(long)ctx->data_end;
17
    void *data     = (void *)(long)ctx->data;
18

19
    struct ethhdr *eth = data;
20
    if ((void *)(eth + 1) > data_end)
21
        return XDP_PASS;
22

23
    // 根据目标 MAC 查找转发端口
24
    // 简化：重定向到固定网卡
25
    __u32 dest_ifindex = 2;  // eth1 的 ifindex
26

27
    // 修改源 MAC 为当前网卡 MAC（避免 MAC 漂移）
28
    // 实际中需要查路由表获取正确的源 MAC
29

30
    return bpf_redirect_map(&dev_map, dest_ifindex, 0);
31
}
32

33
char _license[] SEC("license") = "GPL";

1
// UMEM 配置
2
struct xdp_umem_reg {
3
    __u64 addr;       // UMEM 起始地址
4
    __u64 len;        // UMEM 总长度
5
    __u32 chunk_size; // 帧大小（通常 4096）
6
    __u32 headroom;   // 每帧预留的头部空间
7
    __u32 flags;      // 标志位
8
};

1
1. 用户态在 Fill Ring 中放入空帧描述符（addr=帧偏移, len=帧大小）
2
2. 网卡收到数据包 → XDP 程序 → XSKMAP redirect
3
3. 内核从 Fill Ring 取出空帧描述符
4
4. 内核将数据包 DMA 写入 UMEM 对应帧
5
5. 内核在 RX Ring 中放入已填充帧的描述符
6
6. 用户态从 RX Ring 读取描述符，直接访问 UMEM 中的数据

1
1. 用户态在 UMEM 帧中构造数据包
2
2. 用户态在 TX Ring 中放入帧描述符
3
3. 内核从 TX Ring 取出描述符
4
4. 内核触发网卡 DMA 发送 UMEM 帧中的数据
5
5. 内核在 Completion Ring 中放入已发送帧的描述符
6
6. 用户态从 Completion Ring 回收帧，放回 Fill Ring 复用

1
# 查看网卡是否支持 AF_XDP 零拷贝
2
ethtool -i eth0
3
# 需要驱动支持 XDP_ZEROCOPY（如 i40e, ice, mlx5, virtio）

1
// af_xdp_rx.c — AF_XDP 收包示例
2
#include <linux/if_xdp.h>
3
#include <bpf/xsk.h>
4
#include <bpf/libbpf.h>
5
#include <net/if.h>
6
#include <stdlib.h>
7
#include <string.h>
8
#include <stdio.h>
9

10
#define NUM_FRAMES    4096
11
#define FRAME_SIZE    XSK_UMEM_DEFAULT_FRAME_SIZE  // 4096
12
#define RX_BATCH_SIZE 64
13

14
// UMEM 和 XSK 配置
15
struct xsk_socket_info {
16
    struct xsk_ring_cons rx;       // RX Ring 消费者
17
    struct xsk_ring_prod fill;     // Fill Ring 生产者
18
    struct xsk_ring_cons comp;     // Completion Ring 消费者
19
    struct xsk_ring_prod tx;       // TX Ring 生产者
20
    struct xsk_socket *xsk;
21
    struct xsk_umem *umem;
22
    void *buffer;                   // UMEM 缓冲区
23
};
24

25
static struct xsk_socket_info *
26
xsk_configure_socket(const char *ifname, __u32 queue_id)
27
{
28
    struct xsk_socket_info *xsk_info;
29
    struct xsk_umem_config umem_cfg = {
30
        .fill_size      = XSK_RING_PROD__DEFAULT_NUM_DESCS,
31
        .comp_size      = XSK_RING_CONS__DEFAULT_NUM_DESCS,
32
        .frame_size     = FRAME_SIZE,
33
        .frame_headroom = XSK_UMEM_DEFAULT_FRAME_HEADROOM,
34
        .flags          = 0,  // 0=自动选择（优先零拷贝）
35
    };
36
    struct xsk_socket_config xsk_cfg = {
37
        .rx_size = XSK_RING_CONS__DEFAULT_NUM_DESCS,
38
        .tx_size = XSK_RING_PROD__DEFAULT_NUM_DESCS,
39
        .libbpf_flags  = 0,
40
        .xdp_flags     = XDP_FLAGS_UPDATE_IF_NOEXIST,
41
        .bind_flags    = XDP_ZEROCOPY,  // 优先使用零拷贝
42
    };
43

44
    xsk_info = calloc(1, sizeof(*xsk_info));
45

46
    // 分配 UMEM 缓冲区
47
    xsk_info->buffer = aligned_alloc(getpagesize(),
48
                                      NUM_FRAMES * FRAME_SIZE);
49

50
    // 创建 UMEM
51
    xsk_umem__create(&xsk_info->umem, xsk_info->buffer,
52
                     NUM_FRAMES * FRAME_SIZE,
53
                     &xsk_info->fill, &xsk_info->comp,
54
                     &umem_cfg);
55

56
    // 创建 XSK 套接字
57
    xsk_socket__create(&xsk_info->xsk, ifname, queue_id,
58
                       xsk_info->umem,
59
                       &xsk_info->rx, &xsk_info->tx,
60
                       &xsk_cfg);
61

62
    // 预填充 Fill Ring（提供空帧给内核）
63
    __u32 idx;
64
    __u32 n = xsk_ring_prod__reserve(&xsk_info->fill,
65
                                      NUM_FRAMES, &idx);
66
    for (__u32 i = 0; i < n; i++) {
67
        *xsk_ring_prod__fill_addr(&xsk_info->fill, idx + i) =
68
            i * FRAME_SIZE;
69
    }
70
    xsk_ring_prod__submit(&xsk_info->fill, n);
71

72
    return xsk_info;
73
}
74

75
// 收包主循环
76
static void rx_and_process(struct xsk_socket_info *xsk_info)
77
{
78
    for (;;) {
79
        __u32 idx_rx = 0;
80
        __u32 rcvd = xsk_ring_cons__peek(&xsk_info->rx,
81
                                           RX_BATCH_SIZE,
82
                                           &idx_rx);
83
        if (!rcvd) {
84
            // 无数据，poll 等待
85
            struct pollfd fds = {
86
                .fd = xsk_socket__fd(xsk_info->xsk),
87
                .events = POLLIN,
88
            };
89
            poll(&fds, 1, -1);
90
            continue;
91
        }
92

93
        // 批量处理已接收的数据包
94
        for (__u32 i = 0; i < rcvd; i++) {
95
            __u64 addr = xsk_ring_cons__rx_desc(&xsk_info->rx,
96
                                                  idx_rx + i)->addr;
97
            __u32 len = xsk_ring_cons__rx_desc(&xsk_info->rx,
98
                                                 idx_rx + i)->len;
99

100
            // 直接访问 UMEM 中的数据包（零拷贝！）
101
            __u8 *pkt = xsk_umem__get_data(xsk_info->buffer, addr);
102

103
            // 处理数据包...
104
            printf("收到 %u 字节数据包，首字节: 0x%02x\n",
105
                   len, pkt[0]);
106

107
            // 处理完毕，将帧放回 Fill Ring 复用
108
            __u32 idx_fill;
109
            xsk_ring_prod__reserve(&xsk_info->fill, 1, &idx_fill);
110
            *xsk_ring_prod__fill_addr(&xsk_info->fill, idx_fill) = addr;
111
            xsk_ring_prod__submit(&xsk_info->fill, 1);
112
        }
113

114
        // 释放已处理的 RX 描述符
115
        xsk_ring_cons__release(&xsk_info->rx, rcvd);
116
    }
117
}
118

119
int main(int argc, char **argv)
120
{
121
    const char *ifname = argc > 1 ? argv[1] : "eth0";
122
    __u32 queue_id = argc > 2 ? atoi(argv[2]) : 0;
123

124
    struct xsk_socket_info *xsk_info =
125
        xsk_configure_socket(ifname, queue_id);
126

127
    printf("AF_XDP 套接字已绑定到 %s 队列 %u\n", ifname, queue_id);
128
    rx_and_process(xsk_info);
129

130
    return 0;
131
}

1
# 安装 libxdp 开发包
2
sudo apt install libxdp-dev
3

4
# 或从源码编译
5
git clone https://github.com/xdp-project/xdp-tools.git
6
cd xdp-tools
7
make lib/libxdp
8
sudo make install

1
                    ┌─────────────────────────┐
2
                    │      XDP 前置过滤       │
3
                    │  DDoS 防护 / 早期丢弃   │
4
                    └────────┬────────────────┘
5
                             │
6
                 ┌───────────┴───────────┐
7
                 │                       │
8
          XDP_DROP（攻击流量）    XDP_REDIRECT
9
                                       │
10
                              ┌────────┴────────┐
11
                              │                 │
12
                        XDP_PASS           AF_XDP
13
                     （协议栈处理）    （用户态高速处理）
14
                              │                 │
15
                        内核 TCP/IP          DPDK 应用
16
                        正常业务流量      深度包检测/转发

1
# 1. 安装依赖
2
sudo apt install clang llvm gcc-multilib libbpf-dev linux-headers-$(uname -r)
3

4
# 2. 编写 XDP 程序（使用上面的 xdp_stats_func 示例）
5
cat > xdp_stats.c << 'EOF'
6
#include <linux/bpf.h>
7
#include <bpf/bpf_helpers.h>
8

9
struct {
10
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
11
    __uint(max_entries, 5);
12
    __type(key, __u32);
13
    __type(value, __u64);
14
} xdp_stats_map SEC(".maps");
15

16
SEC("xdp")
17
int xdp_stats_func(struct xdp_md *ctx)
18
{
19
    __u32 key = XDP_PASS;
20
    __u64 *count = bpf_map_lookup_elem(&xdp_stats_map, &key);
21
    if (count)
22
        (*count)++;
23
    return XDP_PASS;
24
}
25

26
char _license[] SEC("license") = "GPL";
27
EOF
28

29
# 3. 编译为 BPF 字节码
30
clang -O2 -target bpf -c xdp_stats.c -o xdp_stats.o
31

32
# 4. 加载 XDP 程序到网卡（通用模式，无需驱动支持）
33
sudo ip link set dev eth0 xdpgeneric off   # 先卸载已有程序
34
sudo ip link set dev eth0 xdpgeneric obj xdp_stats.o sec xdp
35

36
# 5. 验证程序已加载
37
ip link show dev eth0 | grep xdp
38
# 输出类似：xdpgeneric/id 42
39

40
# 6. 卸载 XDP 程序
41
sudo ip link set dev eth0 xdpgeneric off

1
# 原生模式加载
2
sudo ip link set dev eth0 xdp obj xdp_stats.o sec xdp
3

4
# 或使用 libxdp 的 xdp-loader 工具（支持多程序链式挂载）
5
xdp-loader load eth0 xdp_stats.o
6

7
# 查看已加载的 XDP 程序
8
xdp-loader status
9

10
# 卸载
11
xdp-loader unload eth0 --all

1
# 列出所有已加载的 BPF 程序
2
sudo bpftool prog list
3
# 输出示例：
4
# 42: xdp  name xdp_stats_func  tag 57cd311f2c27e4cf  gpl
5
#     loaded_at 2026-04-21T10:00:00+0000  uid 0
6
#     xlated 48B  jited 57B  memlock 4096B  map_ids 43
7

8
# 查看特定程序的详细信息
9
sudo bpftool prog show id 42
10

11
# 查看程序的 BPF 指令（反汇编）
12
sudo bpftool prog dump xlated id 42
13
# 查看 JIT 编译后的原生指令
14
sudo bpftool prog dump jited id 42
15

16
# 列出所有 BPF Map
17
sudo bpftool map list
18
# 输出示例：
19
# 43: percpu_array  name xdp_stats_map  flags 0x0
20
#     key 4B  value 8B  max_entries 5  memlock 4096B
21

22
# 查看 Map 内容
23
sudo bpftool map dump id 43
24
# 输出每个 key 对应的值（percpu map 会显示每个 CPU 的值）
25

26
# 查询特定 key
27
sudo bpftool map lookup id 43 key 0 0 0 0
28
# key = 0 (XDP_PASS) 的计数值
29

30
# 实时跟踪 Map 变化
31
sudo bpftool map event id 43

1
# 1. 安装 libxdp 和 libbpf
2
sudo apt install libxdp-dev libbpf-dev
3

4
# 2. 编译 AF_XDP 收包示例（使用上面的 af_xdp_rx.c）
5
gcc -O2 -o af_xdp_rx af_xdp_rx.c -lxdp -lbpf
6

7
# 3. 编译配套的 XDP 程序（XSKMAP redirect）
8
clang -O2 -target bpf -c xskmap_redirect.c -o xskmap_redirect.o
9

10
# 4. 运行 AF_XDP 程序
11
sudo ./af_xdp_rx eth0 0
12
# 输出：AF_XDP 套接字已绑定到 eth0 队列 0
13
# 收到 64 字节数据包，首字节: 0x00
14

15
# 5. 使用 xdp-bench 工具测试 AF_XDP 性能
16
# xdp-bench 是 xdp-tools 的一部分
17
git clone https://github.com/xdp-project/xdp-tools.git
18
cd xdp-tools && make
19

20
# 运行 AF_XDP 吞吐量测试
21
sudo ./xdp-bench rx eth0 -a  # 所有队列
22
sudo ./xdp-bench rx eth0 -q 0  # 指定队列
23

24
# 6. 使用 testpmd（DPDK 自带）对比 DPDK 性能
25
# 需要 VFIO 和大页配置，参考第 2 章的 DPDK 实践

1
# 1. 编写 XDP_DROP 程序
2
cat > xdp_drop_all.c << 'EOF'
3
#include <linux/bpf.h>
4
#include <bpf/bpf_helpers.h>
5

6
SEC("xdp")
7
int xdp_drop_all(struct xdp_md *ctx)
8
{
9
    return XDP_DROP;  // 丢弃所有包
10
}
11

12
char _license[] SEC("license") = "GPL";
13
EOF
14

15
clang -O2 -target bpf -c xdp_drop_all.c -o xdp_drop_all.o
16

17
# 2. 加载 XDP_DROP 程序
18
sudo ip link set dev eth0 xdpgeneric obj xdp_drop_all.o sec xdp
19

20
# 3. 使用 pktgen 或外部流量发生器发送高速流量
21
# 方法 A：使用内核 pktgen 模块
22
sudo modprobe pktgen
23
echo "add_device eth0" | sudo tee /proc/net/pktgen/kpktgend_0
24
echo "pkt_size 64" | sudo tee /proc/net/pktgen/eth0
25
echo "count 0" | sudo tee /proc/net/pktgen/eth0
26
echo "start" | sudo tee /proc/net/pktgen/pgctrl
27

28
# 方法 B：使用 MoonGen/TrafficGen 等外部工具
29

30
# 4. 观察 XDP 丢包统计
31
sudo bpftool prog show  # 查看 XDP 程序
32
cat /proc/net/dev       # 查看网卡统计（rx packets vs dropped）
33
ethtool -S eth0         # 查看网卡详细统计
34

35
# 5. 对比：卸载 XDP，使用 iptables/nftables 丢包
36
sudo ip link set dev eth0 xdpgeneric off
37
sudo iptables -A INPUT -j DROP
38

39
# 6. 再次发送流量，对比性能
40
# XDP_DROP 通常比 iptables DROP 快 5-10 倍
41

42
# 7. 清理
43
sudo iptables -D INPUT -j DROP