【DPDK实战】编写一个高性能 UDP 抓包程序

在高性能网络编程领域，DPDK (Data Plane Development Kit) 是绕不开的一座大山。它通过绕过操作系统内核（Kernel Bypass），直接在用户态接管网卡，实现了极高的数据包处理效率。

很多初学者配置好环境后，面对复杂的 API 无从下手。今天这篇文章，我们将从零开始，编写一个基于 DPDK 的 用户态协议栈雏形（ustack）。

本文目标： 实现一个程序，能够从网卡捕获 IPv4 下的 UDP 数据包，并解析打印出 Payload 内容。

核心概念：为什么 DPDK 这么快？

在看代码之前，我们需要理解 DPDK 的三个核心，这也是我们代码中各个模块存在的意义：

代码全解析

我们将代码分为三个部分：环境初始化、网卡配置、业务循环。

1. 头文件与宏定义

#include <stdio.h> // 标准输入输出库，用于 printf
#include <rte_eal.h> // DPDK 核心库：EAL (Environment Abstraction Layer) 环境抽象层
#include <rte_ethdev.h> // DPDK 网卡设备库：提供网卡配置、收发包 API
#include <arpa/inet.h> // 提供网络字节序转换等函数 (如 htons)

// 指定我们要使用的网卡端口 ID，0 代表系统识别到的第一个 DPDK 网卡
int global_portid = 0;

// 内存池大小：申请 4096 个 mbuf (内存块)
// 如果包处理得慢，或者收包太快，这个池子可能会枯竭，导致丢包
#define NUM_MBUFS 4096

// 批量处理大小：每次从网卡“抢” 128 个包
#define BURST_SIZE 128

注意：BURST_SIZE 设置为 128 或 32 是常见做法。批量处理可以分摊函数调用的开销（类似批发比零售便宜）。

2. 网卡初始化函数 (ustack_init_port)

这个函数负责告诉网卡：“我要怎么用你”。

// 网卡的基础配置结构体
static const struct rte_eth_conf port_conf_default = {
// 设置接收模式：最大包长度为以太网标准最大长度 (1518字节)
// 注意：旧版本是用 RTE_ETH_MAX_PKT_LEN，新版本用 RTE_ETHER_MAX_LEN
.rxmode = { .max_rx_pkt_len = RTE_ETHER_MAX_LEN }
};

// [函数：初始化网卡端口]
// static 关键字：表示这是内部函数，防止对外暴露符号，避免命名冲突
static int ustack_init_port(struct rte_mempool *mbuf_pool){

// 1. 查询系统里有几个可用的 DPDK 网卡
uint16_t nb_sys_ports = rte_eth_dev_count_avail();
if(nb_sys_ports == 0){
rte_exit(EXIT_FAILURE, "No available ports\\n"); // 如果没有网卡，直接报错退出
}

// 2. 配置网卡参数
const int num_rx_queues = 1; // 启用 1 个接收队列 (收货口)
const int num_tx_queues = 0; // 启用 0 个发送队列 (只收不发，做抓包工具)

// 下发配置给 global_portid 号网卡
rte_eth_dev_configure(global_portid, num_rx_queues, num_tx_queues, &port_conf_default);

// 3. 绑定接收队列 (RX Queue) 和 内存池 (Mempool)
// 意思：0 号网卡的 0 号队列，你以后收到的包，都往 mbuf_pool 里的空箱子里装
// 参数 128 是指接收描述符的数量 (Ring Size)，即网卡硬件缓冲区的大小
if(rte_eth_rx_queue_setup(global_portid, 0, 128, rte_eth_dev_socket_id(global_portid), NULL, mbuf_pool) < 0){
rte_exit(EXIT_FAILURE, "Could not setup RX queue\\n");
}

// 4. 正式启动网卡 (Link Up)
// 这一步之后，网卡指示灯通常会亮起，开始工作
if(rte_eth_dev_start(global_portid) < 0) {
rte_exit(EXIT_FAILURE,"Could not start\\n");
}

return 0; // 初始化成功
}

3. Main 函数：EAL 初始化与内存池

int main(int argc, char *argv[]){

// [Step 1] EAL 初始化 (Environment Abstraction Layer)
// 这是 DPDK 的入口，负责接管 CPU、内存和网卡硬件
// 如果这一步失败，说明环境没配好 (比如没有大页内存，或者没加载 vfio-pci 驱动)
if(rte_eal_init(argc,argv) < 0){
rte_exit(EXIT_FAILURE, "EAL initialization failed\\n");
}

// [Step 2] 创建内存池 (Mempool)
// 名字叫 "mbuf pool"，一共有 NUM_MBUFS (4096) 个块
// 这是为了避免频繁 malloc/free，提升性能
struct rte_mempool *mbuf_pool = rte_pktmbuf_pool_create("mbuf pool", NUM_MBUFS,0,0,RTE_MBUF_DEFAULT_BUF_SIZE,rte_socket_id());
if(mbuf_pool == NULL){
rte_exit(EXIT_FAILURE, "Could not create mbuf pool\\n");
}

// [Step 3] 调用上面的辅助函数，初始化端口
ustack_init_port(mbuf_pool);

// … 进入核心循环 …
}

4. 核心循环：收包、解析、释放（重点！）

这是程序最繁忙的地方，也是最容易出错（比如内存泄漏）的地方。

// [Step 4] 进入死循环，开始“干苦力” (收包-处理-释放)
while(1){

// 定义一个指针数组，用来存放收到的一批包
struct rte_mbuf *mbufs[BURST_SIZE] = {0};

// A. [核心收包 API]
// 从 global_portid 的 0 号队列，尝试“抢”最多 BURST_SIZE (128) 个包
// num_recvd 是实际抢到的包数量 (可能为 0，也可能为 128)
uint16_t num_recvd = rte_eth_rx_burst(global_portid, 0, mbufs, BURST_SIZE);

// 理论上不应该超过 BURST_SIZE
if(num_recvd > BURST_SIZE){
rte_exit(EXIT_FAILURE, "Received more packets than burst size\\n");
}

// B. 遍历处理抢到的每一个包
int i = 0;
for(i = 0; i < num_recvd; i++){

// [零拷贝解析 – 第 1 层：以太网头]
// rte_pktmbuf_mtod (Message to Data): 把 mbuf 转成以太网头结构体指针
struct rte_ether_hdr *eth_hdr = rte_pktmbuf_mtod(mbufs[i], struct rte_ether_hdr *);

// 过滤：检查以太网类型是否为 IPv4 (0x0800)
// rte_cpu_to_be_16: 因为网络协议是大端序 (Big Endian)，x86 CPU 是小端序，需要转换
if(eth_hdr->ether_type != rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)){
// 如果不是 IPv4 (比如是 ARP 或 IPv6)，就不处理
rte_pktmbuf_free(mbufs[i]); // 释放内存，把箱子还给池子
continue; // 跳过，看下一个包
}

// [零拷贝解析 – 第 2 层：IP 头]
// mtod_offset: 在开头的基础上，向后偏移 sizeof(ether_hdr) 长度，找到 IP 头
struct rte_ipv4_hdr *iphdr = rte_pktmbuf_mtod_offset(mbufs[i], struct rte_ipv4_hdr *, sizeof(struct rte_ether_hdr));

// 过滤：检查 IP 协议号是否为 UDP (17)
if(iphdr->next_proto_id == IPPROTO_UDP){

// [零拷贝解析 – 第 3 层：UDP 头]
// 这里的指针加法 (iphdr + 1) 实际上是地址向后移动 sizeof(struct rte_ipv4_hdr)
struct rte_udp_hdr *udphdr = (struct rte_udp_hdr *)(iphdr + 1);

// [打印数据]
// (char*)(udphdr + 1) 指向 UDP 头后面的数据部分 (Payload)
// 注意：如果 Payload 不是以 \\0 结尾的字符串，这里可能会打印乱码
printf("udp : %s\\n", (char*)(udphdr + 1));
}

// [释放内存]
// 无论刚才是否打印了 UDP，处理完当前包后，必须手动归还内存
// 如果忘了这行，4096 个箱子很快用完，程序就会无法再收包 (内存泄漏)
rte_pktmbuf_free(mbufs[i]);
}

}

完整可运行代码

#include <stdio.h>
#include <rte_eal.h>
#include <rte_ethdev.h>
#include <arpa/inet.h>

int global_portid = 0;

#define NUM_MBUFS 4096
#define BURST_SIZE 128

static const struct rte_eth_conf port_conf_default = {
.rxmode = { .max_rx_pkt_len = RTE_ETHER_MAX_LEN }
};

static int ustack_init_port(struct rte_mempool *mbuf_pool) {
uint16_t nb_sys_ports = rte_eth_dev_count_avail();
if (nb_sys_ports == 0) {
rte_exit(EXIT_FAILURE, "No available ports\\n");
}

const int num_rx_queues = 1;
const int num_tx_queues = 0;
rte_eth_dev_configure(global_portid, num_rx_queues, num_tx_queues, &port_conf_default);

if (rte_eth_rx_queue_setup(global_portid, 0, 128, rte_eth_dev_socket_id(global_portid), NULL, mbuf_pool) < 0) {
rte_exit(EXIT_FAILURE, "Could not setup RX queue\\n");
}

if (rte_eth_dev_start(global_portid) < 0) {
rte_exit(EXIT_FAILURE, "Could not start\\n");
}

return 0;
}

int main(int argc, char *argv[]) {
if (rte_eal_init(argc, argv) < 0) {
rte_exit(EXIT_FAILURE, "EAL initialization failed\\n");
}

struct rte_mempool *mbuf_pool = rte_pktmbuf_pool_create("mbuf pool", NUM_MBUFS, 0, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
if (mbuf_pool == NULL) {
rte_exit(EXIT_FAILURE, "Could not create mbuf pool\\n");
}

ustack_init_port(mbuf_pool);

while (1) {
struct rte_mbuf *mbufs[BURST_SIZE] = {0};

uint16_t num_recvd = rte_eth_rx_burst(global_portid, 0, mbufs, BURST_SIZE);
if (num_recvd > BURST_SIZE) {
rte_exit(EXIT_FAILURE, "Received more packets than burst size\\n");
}

int i = 0;
for (i = 0; i < num_recvd; i++) {
struct rte_ether_hdr *eth_hdr = rte_pktmbuf_mtod(mbufs[i], struct rte_ether_hdr *);

if (eth_hdr->ether_type != rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)) {
rte_pktmbuf_free(mbufs[i]);
continue;
}

struct rte_ipv4_hdr *iphdr = rte_pktmbuf_mtod_offset(mbufs[i], struct rte_ipv4_hdr *, sizeof(struct rte_ether_hdr));
if (iphdr->next_proto_id == IPPROTO_UDP) {
struct rte_udp_hdr *udphdr = (struct rte_udp_hdr *)(iphdr + 1);
// 建议：实际项目中请使用 HexDump 打印二进制数据
printf("udp payload : %s\\n", (char*)(udphdr + 1));
}

// 务必释放 mbuf
rte_pktmbuf_free(mbufs[i]);
}
}

printf("hello world\\n");
return 0;
}

总结

通过这个简单的 Demo，我们完成了从网卡抓包到解析 UDP 的全过程。虽然代码短，但它包含了 DPDK 最精髓的思想：EAL 初始化环境、Mempool 管理内存、Rx Burst 批量收包、Zero Copy 指针解析。

0voice · GitHub