加载到网卡：

# 编译
clang -O2 -g -target bpf -c xdp_syn_flood_kern.c -o xdp_syn_flood_kern.o

# 加载（driver mode 性能最佳，需网卡支持）
ip link set eth0 xdp obj xdp_syn_flood_kern.o sec xdp

# 验证
ip link show eth0 | grep xdp
bpftool prog show

XDP 三种执行模式对比：

七、AF_XDP：用户态直通通道

7.1 架构模型

AF_XDP 提供了一条从网卡直接将 DMA 缓冲区映射到用户态的通道，绕过内核协议栈。核心数据结构是 UMEM（用户态内存池）和四个环形缓冲区：

用户态                             内核/XDP程序
  │                                    │
  │  [UMEM: 4096个 4KB frame]          │
  │  ┌──────────────────────┐          │
  │  │ FILL RING      ──────┼──────→  网卡 RX (driver)
  │  │ RX RING     ←────────┼───────  网卡 RX (driver)  
  │  │ TX RING     ──────→  │
  │  │ COMP RING  ←─────────┼───────  网卡 TX (driver)
  │  └──────────────────────┘          │

零拷贝循环：

1. 应用程序向 FILL ring 提交空闲帧地址
2. 网卡 RX 将这些地址对应的 DMA 内存填充帧
3. 帧出现在 RX ring，应用程序直接读写
4. 应用程序收到 COMP ring 释放的帧后，再次提交到 FILL ring

7.2 AF_XDP 最小转发程序骨架

#include <xdp/xsk.h>
#include <linux/if_link.h>
#include <linux/if_ether.h>
#include <net/if.h>
#include <poll.h>
#include <stdlib.h>
#include <stdio.h>

#define NUM_FRAMES 4096
#define FRAME_SIZE XSK_UMEM__DEFAULT_FRAME_SIZE
#define RX_BATCH_SIZE 64

struct xsk_umem_info {
    struct xsk_ring_prod fq;
    struct xsk_ring_cons cq;
    struct xsk_umem *umem;
    void *buffer;
};

struct xsk_socket_info {
    struct xsk_ring_cons rx;
    struct xsk_ring_prod tx;
    struct xsk_umem_info *umem;
    struct xsk_socket *xsk;
    uint32_t tx_npkts;
};

// 关键：转发循环（批量-零拷贝）
static void receive_forward(struct xsk_socket_info *xsk) {
    struct pollfd fds = {
        .fd = xsk_socket__fd(xsk->xsk),
        .events = POLLIN,
    };
    
    while (1) {
        int ret = poll(&fds, 1, 1000);
        if (ret <= 0) continue;
        
        // 1. 从 RX ring 出队一批帧
        uint32_t idx_rx = 0;
        uint32_t rcvd = xsk_ring_cons__peek(&xsk->rx, RX_BATCH_SIZE, &idx_rx);
        if (!rcvd) continue;
        
        // 2. 处理每帧（这里直接 echo）
        for (uint32_t i = 0; i < rcvd; i++) {
            uint64_t addr   = xsk_ring_cons__rx_desc(&xsk->rx, idx_rx + i)->addr;
            uint32_t len    = xsk_ring_cons__rx_desc(&xsk->rx, idx_rx + i)->len;
            uint8_t *pkt    = xsk_umem__get_data(xsk->umem->buffer, addr);
            
            // 直接修改帧（零拷贝）
            // 交换 MAC 地址做 echo
            struct ethhdr *eth = (struct ethhdr *)pkt;
            uint8_t tmp[ETH_ALEN];
            memcpy(tmp, eth->h_source, ETH_ALEN);
            memcpy(eth->h_source, eth->h_dest, ETH_ALEN);
            memcpy(eth->h_dest, tmp, ETH_ALEN);
            
            // 提交到 TX ring
            *xsk_ring_prod__tx_desc(&xsk->tx, xsk->tx_npkts++) = 
                (struct xdp_desc){ .addr = addr, .len = len };
        }
        
        xsk_ring_cons__release(&xsk->rx, rcvd);
        xsk_ring_prod__submit(&xsk->tx, xsk->tx_npkts);
        xsk->tx_npkts = 0;
        
        // 3. kick TX（通知内核发送）
        sendto(xsk_socket__fd(xsk->xsk), NULL, 0, MSG_DONTWAIT, NULL, 0);
    }
}

int main(int argc, char **argv) {
    // UMEM 分配与 ring 初始化...
    // xsk_socket__create() ...
    receive_forward(xsk);
    return 0;
}

AF_XDP vs DPDK vs 原始套接字：

八、Socket 层与零拷贝系统调用

8.1 sendfile 与 splice

在内核网络中，sendfile() 和 splice() 可以将数据完全在内核态转发，避免用户态拷贝：

// 文件 → socket 零拷贝
int fd = open("large.bin", O_RDONLY);
struct stat st;
fstat(fd, &st);

// 数据路径: 磁盘缓冲区 → socket 缓冲区（全程无用户空间拷贝）
sendfile(client_fd, fd, NULL, st.st_size);
close(fd);

注意：sendfile 无法用于"处理后再发送"的场景。如果必须修改数据，仍需要 mmap + write，并接受一次内核拷贝。

8.2 MSG_ZEROCOPY

Linux 4.14+ 的 MSG_ZEROCOPY 允许用户空间将页所有权临时"借"给内核，绕过发送方向的拷贝：

// 启用 zero-copy 发送
int one = 1;
setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &one, sizeof(one));

// 发送时标记
ssize_t n = send(fd, buf, len, MSG_ZEROCOPY);

// 等待完成通知（通过 socket error queue）
struct msghdr msg = {0};
char buf[CMSG_SPACE(sizeof(struct scm_timestamping))];
msg.msg_control = buf;
msg.msg_controllen = sizeof(buf);
recvmsg(fd, &msg, MSG_ERRQUEUE); // 获取 completion status

适用场景：大文件传输、对象存储（如 MinIO）、CDN 回源。不适用：小数据包（低于 4KB）时 completion 通知的开销反而更高。

九、生产环境调优清单

基于前文分析，给出 2026 年的 Linux 网络调优标准操作程序（SOP）：

9.1 系统级参数（/etc/sysctl.d/99-network.conf）

# === 接收路径 ===
net.core.netdev_max_backlog = 250000        # 内核处理队列长度
net.core.netdev_budget = 600                # NAPI 单次处理包数
net.core.netdev_budget_usecs = 8000         # NAPI 单次最大时延(μs)
net.core.rmem_max = 134217728               # 最大 TCP receive buffer
net.core.rmem_default = 16777216            # 默认 TCP receive buffer

# === 发送路径 ===
net.core.wmem_max = 134217728               # 最大 TCP send buffer
net.core.wmem_default = 16777216

# === Socket 层 ===
net.core.somaxconn = 65535                  # listen backlog 上限
net.ipv4.tcp_max_syn_backlog = 65535

# === TCP 行为 ===
net.ipv4.tcp_tw_reuse = 1                  # TIME_WAIT 复用
net.ipv4.tcp_slow_start_after_idle = 0      # 空闲后不重置 cwnd
net.ipv4.tcp_mtu_probing = 1                # 自动 MTU 探测
net.ipv4.tcp_congestion_control = bbr       # BBR v3 拥塞控制

# === === IRQ Affinity ===
# irqbalance 服务必须关闭，手动绑定网卡中断到隔离核
systemctl stop irqbalance
systemctl disable irqbalance

# 将中断绑定到物理核（避开 HT 逻辑核）
echo "f" > /proc/irq/IRQ_NUMBER/smp_affinity  # CPU 0-3

9.2 网卡硬件卸载

# 查看支持的卸载
ethtool -k eth0 | grep -E "scatter|segmentation|checksum|rx-gro|lro"

# 开启所有标准卸载
ethtool -K eth0 gro on gso on tso on sg on \
         rxhash on rx-vlan-filter off tx-vlan-hw-insert on

# 对于 DPDK/AF_XDP 场景，关闭所有内核卸载（避免冲突）
# ethtool -K eth0 gro off gso off tso off sg off

# ring buffer 大小调整
ethtool -G eth0 rx 8192 tx 8192

# 中断合并（Coalescing）- 高吞吐优先
ethtool -C eth0 rx-usecs 50 tx-usecs 50 rx-frames 64
# 低延迟优先
# ethtool -C eth0 rx-usecs 0 tx-usecs 0 rx-frames 1

9.3 依赖中断合并 vs 低延迟模式

十、一个完整的实战案例：400Gbps 路由器的 XDP 实现

背景：某 CDN 厂商需要在白盒交换机（Mellanox ConnectX-7 400GbE）上实现 L3 LRU 路由缓存，要求 100Mpps 转发能力、控制平面通过 BPF Map 下发路由条目。

架构：

// BPFTool: 路由缓存 map (LPM trie)
struct bpf_lpm_trip_key {
    __u32 prefixlen;
    __u8  addr[16];  // IPv4/IPv6 通吃
};

struct {
    __uint(type, BPF_MAP_TYPE_LPM_TRIE);
    __type(key, struct bpf_lpm_trip_key);
    __type(value, struct next_hop);  // 下一跳 MAC + ifindex
    __uint(max_entries, 1000000);
    __uint(map_flags, BPF_F_NO_PREALLOC);
} route_map SEC(".maps");

SEC("xdp")
int xdp_router(struct xdp_md *ctx) {
    // 1. 解析以太网 + IP
    // 2. 查 LPM trie（~50ns）
    // 3. 重写 DMAC 并递减 TTL
    // 4. 通过 bpf_redirect_map() 直接转发到出接口
    //    如果找不到则 XDP_PASS 给内核慢路径
    return bpf_redirect_map(&tx_port_map, entry->ifindex, XDP_DROP);
}

性能结果：

XDP 方案的 CPU 效率提升了 7 倍以上。这一代性能差异的核心来源是：XDP 跳过了 SKB 分配、协议栈软中断分发、以及 netfilter 的多个 hook 链。

十一、总结：选择合适的用户态通道方案

2026 年的 Linux 内核网络子系统已经进化出一个分层的加速栈：

┌─────────────────────────────────────────────────────────┐
│ 用户态应用程序                                           │
│                                                         │
│   ┌──────────┬──────────────┬────────────┐             │
│   │ AF_XDP   │ DPDK (PMD)   │ 标准 socket│             │
│   └────┬─────┴──────┬───────┴─────┬──────┘             │
├────────┼────────────┼─────────────┼────────────────────┤
│ 内核   │ XDP (eBPF) │             │ 完整 TCP/IP       │
│ 协议栈 │            │             │                    │
├────────┴────────────┴─────────────┴────────────────────┤
│ NAPI 轮询层 → GRO/GSO → 中断合并 → 硬件 Ring Buffer    │
├────────────────────────────────────────────────────────┤
│ 网卡硬件 (TSO/LRO/RSS/LSO/Checksum Offload)           │
└─────────────────────────────────────────────────────────┘

决策树：

• 只需要更高 QPS？ → 先调 sysctl + ring buffer + coalescing（零代码变更，收益通常 30%）
• 需要自定义转发/过滤逻辑？ → XDP（生态完整，无需旁路内核协议栈）
• 需要完整自定义协议栈？ → AF_XDP（复杂度适中，保留内核网络协议）
• 需要裸金属性能？ → DPDK（独占 CPU + 独占网卡，无可比拟的性能上限）

最后给出一句原则：能不下沉到用户态就不下沉的。内核协议栈承载了 30 年的 TCP 优化、QoS 算法和拥塞控制实现——绕开它意味着你要重新实现这一切，且不可能做得更好。只有在确认瓶颈在内核协议栈本身时，才应考虑 XDP 或 AF_XDP 方案。