【Linux 网络子系统深度拆解】XDP 内核实现：在驱动层重编程网络栈

// include/net/xdp.h
struct xdp_buff {
    void *data;            // 包数据起始（L2 头）
    void *data_end;        // 包数据结束
    void *data_meta;       // 元数据区域（data 之前）
    void *data_hard_start; // 帧缓冲区物理起始（含 headroom）
    struct xdp_rxq_info *rxq; // 接收队列信息
    struct xdp_txq_info *txq; // 发送队列信息（可选）
    u32 frame_sz;          // 帧总大小
    u32 flags;             // XDP_FLAGS_HAS_FRAGS 等
};

// include/net/xdp.h
struct xdp_frame {
    void *data;               // 数据指针
    u16 len;                  // 数据长度
    u16 headroom;             // headroom 大小
    u32 metasize;             // 元数据大小（低 8 位）
    struct xdp_mem_info mem;  // 内存模型（page pool/UMEM 等）
    struct net_device *dev_rx; // 原始接收设备
    u32 frame_sz;             // 帧大小
    u32 flags;                // 标志
};

// include/net/xdp.h
struct xdp_rxq_info {
    struct net_device *dev;    // 接收设备
    u32 queue_index;           // 队列编号
    u32 reg_state;             // 注册状态
    struct xdp_mem_info mem;   // 内存模型
    unsigned int napi_id;      // NAPI 实例 ID
    u32 frag_size;             // fragment 大小
} ____cacheline_aligned;       // cache line 对齐（性能关键）

// include/net/xdp.h
enum xdp_mem_type {
    MEM_TYPE_PAGE_SHARED = 0, // 页引用计数模型
    MEM_TYPE_PAGE_ORDER0,     // 独占 order-0 页
    MEM_TYPE_PAGE_POOL,       // page pool 管理
    MEM_TYPE_XSK_BUFF_POOL,   // AF_XDP UMEM
};

// include/linux/netdevice.h
struct net_device_ops {
    // ...
    int (*ndo_bpf)(struct net_device *dev, struct netdev_bpf *bpf);
    // ...
};

// 驱动 NAPI poll（概念性，以 ixgbe 风格为例）
static int driver_napi_poll(struct napi_struct *napi, int budget)
{
    while (budget > 0) {
        // 1. 从 ring buffer 取出 DMA 完成的帧
        struct xdp_buff xdp;
        xdp.data = page_address(page) + offset;
        xdp.data_end = xdp.data + len;
        xdp.data_hard_start = page_address(page);
        xdp.rxq = &rx_ring->xdp_rxq;
        xdp.frame_sz = PAGE_SIZE;

        // 2. 执行 XDP 程序
        u32 act = bpf_prog_run_xdp(xdp_prog, &xdp);

        // 3. 根据返回值处理
        switch (act) {
        case XDP_DROP:
            // 直接回收页到 page pool
            page_pool_recycle_direct(pool, page);
            break;
        case XDP_PASS:
            // 分配 sk_buff，走正常协议栈
            skb = xdp_build_skb_from_frame(...);
            napi_gro_receive(napi, skb);
            break;
        case XDP_TX:
            // 从同一设备发出
            driver_xdp_xmit(dev, &xdp);
            break;
        case XDP_REDIRECT:
            // 队列化重定向
            xdp_do_redirect(dev, &xdp, xdp_prog);
            break;
        case XDP_ABORTED:
            trace_xdp_exception(dev, xdp_prog, act);
            page_pool_recycle_direct(pool, page);
            break;
        }
        budget--;
    }

    // NAPI 轮询结束时 flush 重定向批次
    xdp_do_flush();
    return processed;
}

// include/net/xdp.h
static __always_inline u32
bpf_prog_run_xdp(const struct bpf_prog *prog, struct xdp_buff *xdp)
{
    u32 act = __bpf_prog_run(prog, xdp, BPF_DISPATCHER_FUNC(xdp));

    // 特殊处理：bonding 设备的 XDP_TX
    if (static_branch_unlikely(&bpf_master_redirect_enabled_key)) {
        if (act == XDP_TX && netif_is_bond_slave(xdp->rxq->dev))
            act = xdp_master_redirect(xdp);
    }
    return act;
}

// net/core/dev.c (概念性)
static int netif_receive_skb_internal(struct sk_buff *skb)
{
    // ... 已分配 sk_buff ...

    // Generic XDP 执行点
    if (static_branch_unlikely(&generic_xdp_needed_key)) {
        struct bpf_prog *xdp_prog = rcu_dereference(skb->dev->xdp_prog);
        if (xdp_prog) {
            // 从 sk_buff 构建临时 xdp_buff
            // 执行 XDP 程序
            // 根据返回值决定继续或丢弃
        }
    }
    // ... 继续正常路径 ...
}

case XDP_DROP:
    page_pool_recycle_direct(pool, page);
    // 或 page_frag_free(data);

case XDP_PASS:
    // xdp_buff → xdp_frame → sk_buff
    struct sk_buff *skb = xdp_build_skb_from_frame(xdpf, dev);
    if (skb)
        napi_gro_receive(napi, skb);

case XDP_TX:
    // 从同一网卡的 TX 队列发出
    xdp_convert_buff_to_frame(&xdp);  // 转换为 xdp_frame
    driver_xdp_xmit(dev, 1, &xdpf, 0);

case XDP_REDIRECT:
    xdp_do_redirect(dev, &xdp, xdp_prog);
    // 帧暂存在 per-CPU 批次队列中
    // NAPI 结束时 xdp_do_flush() 批量发送

case XDP_ABORTED:
    trace_xdp_exception(dev, xdp_prog, act);
    // 触发 tracepoint，便于调试
    page_pool_recycle_direct(pool, page);

// include/net/xdp.h
#define XDP_BULK_QUEUE_SIZE 16

struct xdp_frame_bulk {
    int count;
    void *xa;                         // 当前目标设备
    void *q[XDP_BULK_QUEUE_SIZE];     // 帧缓冲区
};

// BPF 程序中
SEC("xdp")
int xdp_redirect_prog(struct xdp_md *ctx)
{
    // 查找目标设备
    return bpf_redirect_map(&devmap, ctx->rx_queue_index, 0);
}

// 用户态创建 devmap
struct bpf_map_def devmap = {
    .type = BPF_MAP_TYPE_DEVMAP,
    .key_size = sizeof(u32),
    .value_size = sizeof(u32),  // 目标 ifindex
    .max_entries = 64,
};

// CPUMAP 内部使用 per-CPU FIFO 队列
// 源 CPU：xdp_do_redirect() → 放入目标 CPU 的队列
// 目标 CPU：kthread 或 NAPI 轮询 → 从队列取帧
//   → 可选：执行附加的 XDP 程序
//   → xdp_build_skb_from_frame() → 进入协议栈

// include/net/xdp_sock.h
struct xsk_map {
    struct bpf_map map;
    spinlock_t lock;
    atomic_t count;
    struct xdp_sock __rcu *xsk_map[];
};

// include/net/xdp_sock.h
struct xdp_sock {
    struct sock sk;              // 内嵌 socket
    struct xsk_queue *rx;        // 接收描述符环
    struct net_device *dev;      // 绑定设备
    struct xdp_umem *umem;       // 用户内存区域
    struct xsk_buff_pool *pool;  // 缓冲区池
    u16 queue_id;                // 绑定队列
    bool zc;                     // 零拷贝模式
    bool sg;                     // 散列聚集
    struct xsk_queue *tx;        // 发送描述符环
    u64 rx_dropped;              // 丢包计数
    u64 rx_queue_full;           // 队列满计数
};

// include/net/xdp_sock.h
struct xdp_umem {
    void *addrs;          // 内存映射地址
    u64 size;             // 总大小
    u32 headroom;         // 每帧预留 headroom
    u32 chunk_size;       // 每帧大小（通常 4096 或 2048）
    u32 chunks;           // 帧总数
    u32 npgs;             // 页数
    bool zc;              // 零拷贝标志
    struct page **pgs;    // 物理页数组
};

// 零拷贝模式
// 驱动直接 DMA 到 UMEM 页面
// 用户态读取时无数据拷贝
// 要求：驱动实现 ndo_xsk_wakeup
// 性能：100+ Mpps

// 拷贝模式
// 驱动 DMA 到普通页，内核拷贝到 UMEM
// 兼容所有设备
// 性能：20-50 Mpps

// include/uapi/linux/if_xdp.h
#define XDP_SHARED_UMEM     (1 << 0)  // 多 socket 共享 UMEM
#define XDP_COPY            (1 << 1)  // 强制拷贝模式
#define XDP_ZEROCOPY        (1 << 2)  // 强制零拷贝
#define XDP_USE_NEED_WAKEUP (1 << 3)  // 唤醒标志优化
#define XDP_USE_SG          (1 << 4)  // 散列聚集（多缓冲区）

// include/net/xdp.h
// 通过 flags 标志启用
#define XDP_FLAGS_HAS_FRAGS  BIT(0)

// 检测多缓冲区
static inline bool xdp_buff_has_frags(struct xdp_buff *xdp)
{
    return !!(xdp->flags & XDP_FLAGS_HAS_FRAGS);
}

// 获取完整长度（含 fragment）
static inline u32 xdp_get_buff_len(struct xdp_buff *xdp)
{
    u32 len = xdp->data_end - xdp->data;
    if (xdp_buff_has_frags(xdp)) {
        struct skb_shared_info *sinfo = xdp_get_shared_info_from_buff(xdp);
        len += sinfo->xdp_frags_size;
    }
    return len;
}

// fragment 存储在帧尾部的 skb_shared_info 中
#define xdp_data_hard_end(xdp) \
    ((xdp)->data_hard_start + (xdp)->frame_sz - \
     SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))

// 驱动设置元数据
xdp.data_meta = xdp.data - sizeof(struct my_metadata);
struct my_metadata *meta = xdp.data_meta;
meta->rx_timestamp = hw_timestamp;
meta->rx_hash = hw_rss_hash;

// BPF 程序读取
SEC("xdp")
int prog(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *meta = (void *)(long)ctx->data_meta;
    if (meta + sizeof(struct my_metadata) > data)
        return XDP_PASS;
    struct my_metadata *m = meta;
    // 使用 m->rx_timestamp, m->rx_hash
}

// include/net/xdp.h
struct xdp_metadata_ops {
    int (*xmo_rx_timestamp)(const struct xdp_md *ctx, u64 *timestamp);
    int (*xmo_rx_hash)(const struct xdp_md *ctx, u32 *hash,
                       enum xdp_rss_hash_type *rss_type);
    int (*xmo_rx_vlan_tag)(const struct xdp_md *ctx, __be16 *vlan_proto,
                           u16 *vlan_tci);
};

// XDP 程序可以调整包头部和元数据区域
bpf_xdp_adjust_head(xdp, delta);  // 扩展/收缩头部
bpf_xdp_adjust_meta(xdp, delta);  // 扩展/收缩元数据
bpf_xdp_adjust_tail(xdp, delta);  // 扩展/收缩尾部

# 追踪 XDP 动作分布
bpftrace -e '
tracepoint:xdp:xdp_redirect* {
    @redirect[probe] = count();
}
tracepoint:xdp:xdp_exception {
    @exception[args->act] = count();
}
interval:s:5 {
    print(@redirect);
    print(@exception);
    clear(@redirect);
    clear(@exception);
}
'

# 测量 XDP 程序的执行延迟
bpftrace -e '
kprobe:bpf_prog_run_xdp {
    @start[tid] = nsecs;
}
kretprobe:bpf_prog_run_xdp /@start[tid]/ {
    @xdp_latency_ns = hist(nsecs - @start[tid]);
    delete(@start[tid]);
}
interval:s:10 { print(@xdp_latency_ns); clear(@xdp_latency_ns); }
'

# 查看 AF_XDP socket 统计
cat /proc/net/xsk

# 追踪 AF_XDP 丢包
bpftrace -e '
kprobe:xsk_rcv_check {
    @xsk_check = count();
}
kprobe:xsk_drop {
    @xsk_drop = count();
}
interval:s:5 {
    print(@xsk_check);
    print(@xsk_drop);
}
'

# 追踪 XDP_ABORTED（程序错误）
bpftrace -e '
tracepoint:xdp:xdp_exception {
    printf("XDP exception: dev=%s act=%d prog_id=%d\n",
           str(args->dev->name), args->act, args->prog_id);
    @exceptions = count();
}
'

# 查看 XDP 程序信息
bpftool prog show type xdp
bpftool net show

# XDP 与协议栈的 CPU 对比
perf record -g -C 0 -- sleep 10
perf report --no-children | head -30
# 观察 bpf_prog_run_xdp 与 netif_receive_skb 的比例

# 1. 确保 native 模式
ip link show dev eth0 | grep xdp
# 应显示 xdp 而非 xdpgeneric

# 2. 绑定 XDP 处理到正确 CPU
# 通过 RSS/IRQ affinity 控制

# 3. 确保 page pool 启用
ethtool -S eth0 | grep page_pool

# 4. AF_XDP 零拷贝确认
# 创建 socket 时指定 XDP_ZEROCOPY
# 如果失败检查驱动支持

# 5. 批量大小优化
# 调整 NAPI weight 和 AF_XDP batch