1
// DPDK 初始化
2
int rte_eal_init(int argc, char **argv);
3

4
// EAL 参数示例
5
// dpdk-app -c 0x3 -n 4 -- -p 0x01
6
// -c: CPU 核心掩码
7
// -n: 内存通道数
8
// --: 应用参数分隔

1
#include <rte_mempool.h>
2
#include <rte_mbuf.h>
3

4
// 创建内存池
5
struct rte_mempool *pool = rte_pktmbuf_pool_create(
6
    "mbuf_pool",     // 池名称
7
    8192,            // 对象数量
8
    256,              // 每核缓存数量
9
    0,                // 私有数据大小
10
    512,              // 数据区域大小
11
    rte_socket_id()    // NUMA 节点
12
);
13

14
// 申请 mbuf
15
struct rte_mbuf *mbuf = rte_pktmbuf_alloc(pool);
16

17
// 释放 mbuf
18
rte_pktmbuf_free(mbuf);

1
#include <rte_ring.h>
2

3
// 创建无锁环形队列
4
struct rte_ring *ring = rte_ring_create(
5
    "packet_ring",
6
    1024,              // 队列容量（必须 2 的幂）
7
    rte_socket_id(),
8
    RING_F_SP_ENQ | RING_F_SC_DEQ  // 单生产者/消费者标志
9
);
10

11
// 入队
12
rte_ring_sp_enqueue(ring, mbuf);  // 单生产者
13
rte_ring_mp_enqueue(ring, mbuf); // 多生产者
14

15
// 出队
16
rte_ring_sc_dequeue(ring, &mbuf);  // 单消费者
17
rte_ring_mc_dequeue(ring, &mbuf);  // 多消费者

1
# 配置 2MB 大页
2
echo 1024 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
3

4
# 配置 1GB 大页（需要支持）
5
echo 4 > /sys/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages
6

7
# 查看大页配置
8
cat /proc/meminfo | grep Huge

1
#include <rte_eal.h>
2
#include <rte_memzone.h>
3

4
// 分配大页内存
5
const struct rte_memzone *mz = rte_memzone_reserve(
6
    "dma_buffer",
7
    1024 * 1024,      // 1MB
8
    rte_socket_id(),
9
    RTE_MEMZONE_1GB | RTE_MEMZONE_SIZE_FIXED,
10
    0
11
);
12

13
// 获取大页物理地址（用于 DMA）
14
uint64_t phys_addr = mz->phys_addr;
15
void *virt_addr = mz->addr;

1
#include <rte_ethdev.h>
2

3
// 网卡初始化
4
int rte_eth_dev_configure(
5
    port_id,
6
    nb_rx_queues,  // 接收队列数
7
    nb_tx_queues,  // 发送队列数
8
    &port_conf     // 端口配置
9
);
10

11
// 分配 RX/TX 队列
12
rte_eth_rx_queue_setup(port_id, queue_id, nb_rx_desc,
13
    rte_eth_dev_socket_id(port_id),
14
    NULL,  // RX 回调参数
15
    mbuf_pool);
16

17
rte_eth_tx_queue_setup(port_id, queue_id, nb_tx_desc,
18
    rte_socket_id(),
19
    NULL);
20

21
// 启动端口
22
rte_eth_dev_start(port_id);

1
// 接收数据包
2
#define NB_PKTS 32
3
struct rte_mbuf *pkts[NB_PKTS];
4

5
uint16_t nb_rx = rte_eth_rx_burst(
6
    port_id,
7
    queue_id,
8
    pkts,
9
    NB_PKTS
10
);
11

12
for (int i = 0; i < nb_rx; i++) {
13
    process_packet(pkts[i]);
14
    rte_pktmbuf_free(pkts[i]);
15
}
16

17
// 发送数据包
18
uint16_t nb_tx = rte_eth_tx_burst(
19
    port_id,
20
    queue_id,
21
    pkts,
22
    nb_pkts
23
);

1
#include <rte_lcore.h>
2

3
// 获取当前 lcore
4
unsigned lcore_id = rte_lcore_id();
5

6
// 获取 lcore 对应的 CPU ID
7
unsigned socket_id = rte_lcore_to_socket_id(lcore_id);
8

9
// DPDK 线程绑定到指定 lcore
10
struct rte_mbuf *pkts[MAX_PKT_BURST];
11

12
RTE_LCORE_FOREACH_WORKER(lcore_id) {
13
    // 每个 worker lcore 处理一个队列
14
    rte_eal_remote_launch(
15
        lcore_loop,       // 处理函数
16
        &queue_id,        // 参数
17
        lcore_id
18
    );
19
}

1
// NUMA 感知内存分配
2
struct rte_mempool *pool_by_socket[SOCKET_MAX];
3
for (int socket = 0; socket < RTE_MAX_NUMA_NODES; socket++) {
4
    if (rte_numa_node_available(socket) == 0) {
5
        pool_by_socket[socket] = rte_pktmbuf_pool_create(
6
            "pool_socket",
7
            8192,
8
            256,
9
            0,
10
            2048,  // 数据区域大小
11
            socket
12
        );
13
    }
14
}
15

16
// 使用本地 socket 的内存池
17
struct rte_mempool *pool = pool_by_socket[socket_id];

1
// 防火墙数据包处理流水线
2
int firewall_process(struct rte_mbuf *pkt) {
3
    // 1. 解析 Ethernet 头
4
    struct rte_ether_hdr *eth = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
5

6
    // 2. 解析 IP 头
7
    struct rte_ipv4_hdr *ip = (struct rte_ipv4_hdr *)((char *)eth + sizeof(struct rte_ether_hdr));
8

9
    // 3. 安全检查
10
    if (is_blocked_ip(ip->src_ip)) {
11
        return FIREWALL_DROP;
12
    }
13

14
    // 4. 状态跟踪
15
    if (is_new_connection(ip)) {
16
        if (!check_policy(ip)) {
17
            return FIREWALL_DROP;
18
        }
19
        add_connection(ip);
20
    }
21

22
    // 5. NAT 转换
23
    nat_translate(ip);
24

25
    return FIREWALL_ACCEPT;
26
}

1
// Snort 风格规则匹配
2
int ids_check(struct rte_mbuf *pkt) {
3
    struct rte_ipv4_hdr *ip = get_ip_header(pkt);
4

5
    // 遍历规则链
6
    for (int i = 0; i < rule_count; i++) {
7
        if (rule_match(&rules[i], ip)) {
8
            log_alert("Rule %d matched", rules[i].id);
9
            return IDS_ALERT;
10
        }
11
    }
12
    return IDS_OK;
13
}

1
// 批量接收提高缓存命中率
2
#define BURST_SIZE 32
3

4
uint16_t nb_rx = rte_eth_rx_burst(port_id, queue_id, pkts, BURST_SIZE);
5

6
// 处理一批数据包比分批处理更高效
7
for (int i = 0; i < nb_rx; i++) {
8
    process_packet(pkts[i]);
9
}

1
// 预取即将使用的数据
2
for (int i = 0; i < BURST_SIZE; i++) {
3
    // 预取 mbuf 头部
4
    rte_prefetch0(pkts[i]);
5
    // 预取数据区域
6
    rte_prefetch0(rte_pktmbuf_mtod(pkts[i], void *));
7
}

1
// 使用 flow table 加速转发
2
struct flow_entry {
3
    uint32_t src_ip;
4
    uint32_t dst_ip;
5
    uint16_t src_port;
6
    uint16_t dst_port;
7
    uint8_t protocol;
8
    uint8_t action;  // DROP/ACCEPT/NAT
9
};
10

11
struct flow_table {
12
    struct flow_entry *entries[65536];
13
    pthread_rwlock_t lock;
14
};