第28章 eBPF深度实践

学习目标

深入理解eBPF技术原理和应用
掌握XDP、AF_XDP等eBPF网络技术
了解eBPF在网络加速中的应用
能够开发eBPF网络程序

前置知识

28.1 eBPF技术概述

28.1.1 什么是eBPF

eBPF（extended Berkeley Packet Filter）是Linux内核的虚拟机，允许用户态程序在内核态安全地执行，提供高性能的网络处理能力。

核心特性：

内核态执行：在内核空间运行
安全沙箱：通过验证器保证安全
高性能：接近内核性能
可编程：支持复杂逻辑

28.1.2 eBPF架构

┌─────────────────────────────────────────────────────────────┐
│                    eBPF Architecture                       │
├─────────────────────────────────────────────────────────────┤
│  User Space                                                │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐    │
│  │ eBPF Program│    │ eBPF Loader │    │ eBPF Maps   │    │
│  └─────────────┘    └─────────────┘    └─────────────┘    │
├─────────────────────────────────────────────────────────────┤
│  Kernel Space                                              │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐    │
│  │ eBPF VM     │    │ eBPF Maps   │    │ eBPF Hooks  │    │
│  └─────────────┘    └─────────────┘    └─────────────┘    │
└─────────────────────────────────────────────────────────────┘

28.1.3 eBPF应用场景

1. 网络处理

数据包过滤
负载均衡
流量控制
安全防护

2. 系统监控

性能分析
故障诊断
资源监控
行为分析

3. 安全防护

入侵检测
恶意软件检测
访问控制
审计日志

28.2 XDP技术

28.2.1 XDP概述

XDP（eXpress Data Path）是eBPF在网络数据包处理中的应用，提供高性能的数据包处理能力。

特点：

最早处理点：在网卡驱动层处理
高性能：接近硬件性能
零拷贝：避免数据拷贝
可编程：支持复杂逻辑

28.2.2 XDP工作模式

1. Native模式

// 在网卡驱动中处理
// 性能最高
// 需要修改驱动

2. Offload模式

// 在网卡硬件中处理
// 性能最高
// 需要硬件支持

3. Generic模式

// 在协议栈中处理
// 兼容性最好
// 性能较低

28.2.3 XDP程序开发

1. 基本XDP程序

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

SEC("xdp")
int xdp_prog(struct xdp_md *ctx)
{
    void *data_end = (void *)(long)ctx->data_end;
    void *data = (void *)(long)ctx->data;
    
    // 获取以太网头部
    struct ethhdr *eth = data;
    if ((void *)eth + sizeof(*eth) > data_end)
        return XDP_ABORTED;
    
    // 检查协议类型
    if (eth->h_proto != htons(ETH_P_IP))
        return XDP_PASS;
    
    // 获取IP头部
    struct iphdr *iph = data + sizeof(*eth);
    if ((void *)iph + sizeof(*iph) > data_end)
        return XDP_ABORTED;
    
    // 检查IP协议
    if (iph->protocol != IPPROTO_TCP)
        return XDP_PASS;
    
    // 获取TCP头部
    struct tcphdr *tcph = data + sizeof(*eth) + (iph->ihl * 4);
    if ((void *)tcph + sizeof(*tcph) > data_end)
        return XDP_ABORTED;
    
    // 检查端口
    if (tcph->dest != htons(80))
        return XDP_PASS;
    
    // 丢弃HTTP流量
    return XDP_DROP;
}

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

2. 编译XDP程序

# 使用clang编译
clang -O2 -target bpf -c xdp_prog.c -o xdp_prog.o

# 使用llvm-objdump查看
llvm-objdump -h xdp_prog.o

3. 加载XDP程序

#include <linux/bpf.h>
#include <bpf/libbpf.h>

int main()
{
    struct bpf_object *obj;
    struct bpf_program *prog;
    int prog_fd;
    
    // 加载eBPF程序
    obj = bpf_object__open_file("xdp_prog.o", NULL);
    if (!obj) {
        fprintf(stderr, "Failed to load eBPF program\n");
        return 1;
    }
    
    // 加载到内核
    if (bpf_object__load(obj)) {
        fprintf(stderr, "Failed to load eBPF program to kernel\n");
        return 1;
    }
    
    // 获取程序
    prog = bpf_object__find_program_by_name(obj, "xdp_prog");
    if (!prog) {
        fprintf(stderr, "Failed to find eBPF program\n");
        return 1;
    }
    
    // 获取文件描述符
    prog_fd = bpf_program__fd(prog);
    if (prog_fd < 0) {
        fprintf(stderr, "Failed to get eBPF program fd\n");
        return 1;
    }
    
    // 附加到网络接口
    if (bpf_set_link_xdp_fd(0, prog_fd, XDP_FLAGS_UPDATE_IF_NOEXIST) < 0) {
        fprintf(stderr, "Failed to attach eBPF program to interface\n");
        return 1;
    }
    
    printf("XDP program loaded successfully\n");
    
    // 清理
    bpf_object__close(obj);
    return 0;
}

28.3 AF_XDP技术

28.3.1 AF_XDP概述

AF_XDP是Linux内核的套接字类型，提供高性能的用户态网络数据包处理能力。

特点：

零拷贝：避免内核态和用户态数据拷贝
高性能：接近硬件性能
可编程：支持复杂逻辑
灵活：支持多种处理模式

28.3.2 AF_XDP工作流程

1. 创建AF_XDP套接字

#include <linux/if_xdp.h>
#include <sys/socket.h>

int main()
{
    int sock_fd;
    struct sockaddr_xdp sxdp;
    
    // 创建AF_XDP套接字
    sock_fd = socket(AF_XDP, SOCK_RAW, 0);
    if (sock_fd < 0) {
        perror("socket");
        return 1;
    }
    
    // 绑定到网络接口
    memset(&sxdp, 0, sizeof(sxdp));
    sxdp.sxdp_family = AF_XDP;
    sxdp.sxdp_ifindex = if_nametoindex("eth0");
    sxdp.sxdp_queue_id = 0;
    
    if (bind(sock_fd, (struct sockaddr *)&sxdp, sizeof(sxdp)) < 0) {
        perror("bind");
        return 1;
    }
    
    printf("AF_XDP socket created successfully\n");
    
    close(sock_fd);
    return 0;
}

2. 数据包处理

#include <linux/if_xdp.h>
#include <sys/socket.h>
#include <sys/mman.h>

#define NUM_FRAMES 1024
#define FRAME_SIZE 2048

int main()
{
    int sock_fd;
    struct sockaddr_xdp sxdp;
    void *umem;
    struct xdp_ring *rx_ring, *tx_ring;
    struct xdp_desc *rx_desc, *tx_desc;
    char *frames;
    int i;
    
    // 创建AF_XDP套接字
    sock_fd = socket(AF_XDP, SOCK_RAW, 0);
    
    // 分配内存
    umem = mmap(NULL, NUM_FRAMES * FRAME_SIZE, PROT_READ | PROT_WRITE,
                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    
    // 设置内存
    if (setsockopt(sock_fd, SOL_XDP, XDP_UMEM_REG, &umem, sizeof(umem)) < 0) {
        perror("setsockopt XDP_UMEM_REG");
        return 1;
    }
    
    // 设置帧大小
    int frame_size = FRAME_SIZE;
    if (setsockopt(sock_fd, SOL_XDP, XDP_UMEM_FRAME_SIZE, &frame_size, sizeof(frame_size)) < 0) {
        perror("setsockopt XDP_UMEM_FRAME_SIZE");
        return 1;
    }
    
    // 设置队列大小
    int queue_size = NUM_FRAMES;
    if (setsockopt(sock_fd, SOL_XDP, XDP_RX_RING, &queue_size, sizeof(queue_size)) < 0) {
        perror("setsockopt XDP_RX_RING");
        return 1;
    }
    
    if (setsockopt(sock_fd, SOL_XDP, XDP_TX_RING, &queue_size, sizeof(queue_size)) < 0) {
        perror("setsockopt XDP_TX_RING");
        return 1;
    }
    
    // 绑定到网络接口
    memset(&sxdp, 0, sizeof(sxdp));
    sxdp.sxdp_family = AF_XDP;
    sxdp.sxdp_ifindex = if_nametoindex("eth0");
    sxdp.sxdp_queue_id = 0;
    
    if (bind(sock_fd, (struct sockaddr *)&sxdp, sizeof(sxdp)) < 0) {
        perror("bind");
        return 1;
    }
    
    // 处理数据包
    while (1) {
        // 接收数据包
        struct xdp_desc desc;
        if (recv(sock_fd, &desc, sizeof(desc), 0) < 0) {
            perror("recv");
            continue;
        }
        
        // 处理数据包
        char *data = umem + desc.addr;
        process_packet(data, desc.len);
        
        // 发送数据包
        if (send(sock_fd, &desc, sizeof(desc), 0) < 0) {
            perror("send");
            continue;
        }
    }
    
    close(sock_fd);
    return 0;
}

28.4 eBPF网络加速

28.4.1 负载均衡

1. 基于eBPF的负载均衡

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 1024);
    __type(key, __u32);
    __type(value, __u32);
} backend_map SEC(".maps");

struct {
    __uint(type, BPF_MAP_TYPE_ARRAY);
    __uint(max_entries, 1);
    __type(key, __u32);
    __type(value, __u32);
} backend_count SEC(".maps");

SEC("xdp")
int xdp_load_balancer(struct xdp_md *ctx)
{
    void *data_end = (void *)(long)ctx->data_end;
    void *data = (void *)(long)ctx->data;
    
    // 获取以太网头部
    struct ethhdr *eth = data;
    if ((void *)eth + sizeof(*eth) > data_end)
        return XDP_ABORTED;
    
    // 检查协议类型
    if (eth->h_proto != htons(ETH_P_IP))
        return XDP_PASS;
    
    // 获取IP头部
    struct iphdr *iph = data + sizeof(*eth);
    if ((void *)iph + sizeof(*iph) > data_end)
        return XDP_ABORTED;
    
    // 检查IP协议
    if (iph->protocol != IPPROTO_TCP)
        return XDP_PASS;
    
    // 获取TCP头部
    struct tcphdr *tcph = data + sizeof(*eth) + (iph->ihl * 4);
    if ((void *)tcph + sizeof(*tcph) > data_end)
        return XDP_ABORTED;
    
    // 检查端口
    if (tcph->dest != htons(80))
        return XDP_PASS;
    
    // 负载均衡逻辑
    __u32 key = 0;
    __u32 *count = bpf_map_lookup_elem(&backend_count, &key);
    if (!count)
        return XDP_PASS;
    
    __u32 backend_id = bpf_get_prandom_u32() % (*count);
    __u32 *backend_ip = bpf_map_lookup_elem(&backend_map, &backend_id);
    if (!backend_ip)
        return XDP_PASS;
    
    // 修改目标IP
    iph->daddr = *backend_ip;
    
    // 重新计算校验和
    iph->check = 0;
    iph->check = ip_fast_csum(iph, iph->ihl);
    
    return XDP_TX;
}

28.4.2 流量控制

1. 基于eBPF的流量控制

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 1024);
    __type(key, __u32);
    __type(value, __u64);
} rate_limit_map SEC(".maps");

SEC("xdp")
int xdp_rate_limiter(struct xdp_md *ctx)
{
    void *data_end = (void *)(long)ctx->data_end;
    void *data = (void *)(long)ctx->data;
    
    // 获取以太网头部
    struct ethhdr *eth = data;
    if ((void *)eth + sizeof(*eth) > data_end)
        return XDP_ABORTED;
    
    // 检查协议类型
    if (eth->h_proto != htons(ETH_P_IP))
        return XDP_PASS;
    
    // 获取IP头部
    struct iphdr *iph = data + sizeof(*eth);
    if ((void *)iph + sizeof(*iph) > data_end)
        return XDP_ABORTED;
    
    // 获取源IP
    __u32 src_ip = iph->saddr;
    
    // 获取当前时间
    __u64 now = bpf_ktime_get_ns();
    
    // 检查速率限制
    __u64 *last_time = bpf_map_lookup_elem(&rate_limit_map, &src_ip);
    if (last_time) {
        if (now - *last_time < 1000000000) { // 1秒
            return XDP_DROP;
        }
    }
    
    // 更新最后时间
    bpf_map_update_elem(&rate_limit_map, &src_ip, &now, BPF_ANY);
    
    return XDP_PASS;
}

28.5 实验：eBPF网络程序开发

28.5.1 实验环境

环境要求：

Linux 5.4+内核
支持eBPF
安装bcc工具
安装libbpf

安装依赖：

# 安装bcc工具
apt-get install bpfcc-tools

# 安装libbpf
apt-get install libbpf-dev

# 安装clang
apt-get install clang llvm

28.5.2 实验1：XDP程序开发

步骤1：创建XDP程序

// xdp_drop.c
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

SEC("xdp")
int xdp_drop_prog(struct xdp_md *ctx)
{
    return XDP_DROP;
}

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

步骤2：编译程序

# 编译XDP程序
clang -O2 -target bpf -c xdp_drop.c -o xdp_drop.o

# 查看程序信息
llvm-objdump -h xdp_drop.o

步骤3：加载程序

# 使用ip命令加载
ip link set dev eth0 xdp obj xdp_drop.o

# 查看加载状态
ip link show dev eth0

# 卸载程序
ip link set dev eth0 xdp off

28.5.3 实验2：AF_XDP程序开发

步骤1：创建AF_XDP程序

// af_xdp_test.c
#include <linux/if_xdp.h>
#include <sys/socket.h>
#include <sys/mman.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>

int main()
{
    int sock_fd;
    struct sockaddr_xdp sxdp;
    
    // 创建AF_XDP套接字
    sock_fd = socket(AF_XDP, SOCK_RAW, 0);
    if (sock_fd < 0) {
        perror("socket");
        return 1;
    }
    
    // 绑定到网络接口
    memset(&sxdp, 0, sizeof(sxdp));
    sxdp.sxdp_family = AF_XDP;
    sxdp.sxdp_ifindex = if_nametoindex("eth0");
    sxdp.sxdp_queue_id = 0;
    
    if (bind(sock_fd, (struct sockaddr *)&sxdp, sizeof(sxdp)) < 0) {
        perror("bind");
        return 1;
    }
    
    printf("AF_XDP socket created successfully\n");
    
    // 处理数据包
    while (1) {
        char buffer[2048];
        int len = recv(sock_fd, buffer, sizeof(buffer), 0);
        if (len > 0) {
            printf("Received packet: %d bytes\n", len);
        }
    }
    
    close(sock_fd);
    return 0;
}

步骤2：编译运行

# 编译程序
gcc -o af_xdp_test af_xdp_test.c

# 运行程序
sudo ./af_xdp_test

28.6 性能优化

28.6.1 eBPF程序优化

1. 减少分支

// 避免复杂分支
if (condition) {
    // 简单处理
} else {
    // 简单处理
}

2. 使用内联函数

// 使用内联函数
static inline __u32 hash(__u32 key)
{
    return key * 0x9e3779b9;
}

3. 优化内存访问

// 减少内存访问
struct ethhdr *eth = data;
struct iphdr *iph = data + sizeof(*eth);

28.6.2 系统优化

1. CPU亲和性

# 设置CPU亲和性
taskset -c 0-3 ./program

2. 内存优化

# 设置内存页大小
echo 2048 > /proc/sys/vm/nr_hugepages

3. 网络优化

# 优化网络参数
echo 'net.core.rmem_max = 134217728' >> /etc/sysctl.conf
echo 'net.core.wmem_max = 134217728' >> /etc/sysctl.conf
sysctl -p

28.7 故障排查

28.7.1 常见问题诊断

问题1：eBPF程序加载失败

# 检查内核版本
uname -r

# 检查eBPF支持
cat /proc/sys/kernel/unprivileged_bpf_disabled

# 检查程序语法
clang -O2 -target bpf -c program.c -o program.o

问题2：XDP程序不生效

# 检查程序加载
ip link show dev eth0

# 检查程序状态
bpftool prog list

# 检查程序日志
dmesg | grep xdp

问题3：AF_XDP程序错误

# 检查套接字创建
strace -e socket,bind ./af_xdp_test

# 检查内存映射
cat /proc/maps | grep xdp

28.7.2 调试工具

# 使用bpftool调试
bpftool prog list
bpftool prog dump xlated id 1
bpftool prog dump jited id 1

# 使用bcc工具调试
trace -p $(pgrep program)
argdist -p $(pgrep program)

28.8 排错清单

28.8.1 eBPF程序检查

[ ] 内核版本是否支持eBPF
[ ] 程序语法是否正确
[ ] 程序是否通过验证器
[ ] 程序是否正确加载
[ ] 程序是否正确执行

28.8.2 性能检查

[ ] 程序性能是否满足要求
[ ] 内存使用是否正常
[ ] CPU使用率是否正常
[ ] 网络延迟是否正常
[ ] 吞吐量是否满足要求

28.9 延伸阅读

下一章：第29章 ServiceMesh

返回目录：README