apt update
apt install -y build-essential meson ninja-build libnuma-dev python3-pyelftools pkg-config
wget https://fast.dpdk.org/rel/dpdk-24.11.1.tar.xz
tar xf dpdk-24.11.1.tar.xz
cd dpdk-24.11.1
# 编译安装
meson setup build
cd build
ninja
ninja install
ldconfig

# 分配 1GB 的大页内存，挂载文件系统类型hugetlbfs并禁止设备文件（nodev，类似于 nosuid 禁止特殊权限、noexec 禁止执行程序）
echo 512 | sudo tee /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
mkdir -p /mnt/huge
mount -t hugetlbfs nodev /mnt/huge

lspci | grep -i ether // 查找有线网卡的PCI地址，如00:1f.6
ip link set dev enp0s31f6 down

# 加载通用的 UIO 驱动
sudo modprobe uio_pci_generic
# 用 dpdk-devbind 强行绑定到这个驱动
sudo dpdk-devbind.py --bind=uio_pci_generic 00:1f.6
# 查看状态，确认进入了 "Network devices using DPDK-compatible driver"
sudo dpdk-devbind.py --status

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <rte_eal.h>
#include <rte_ethdev.h>
#include <rte_mbuf.h>

#define RX_RING_SIZE 1024
#define TX_RING_SIZE 1024
#define NUM_MBUFS 8191
#define MBUF_CACHE_SIZE 250
#define BURST_SIZE 32

// 极简网卡初始化函数
static inline int port_init(uint16_t port, struct rte_mempool *mbuf_pool) {
    struct rte_eth_dev_info dev_info;
    struct rte_eth_rxconf rx_conf;

    // struct rte_eth_conf port_conf = {
    //     .rxmode = {
    //         .max_lro_pkt_size = RTE_ETHER_MAX_LEN,
    //         // 显式关闭可能导致板载网卡丢包的硬件卸载功能
    //         .offloads = 0, 
    //     },
    //     .txmode = {
    //         .offloads = 0,
    //     }
    // };
    struct rte_eth_conf port_conf = {
        .rxmode = {
            .max_lro_pkt_size = RTE_ETHER_MAX_LEN,
            .mq_mode = RTE_ETH_MQ_RX_NONE, // 关键：彻底关闭多队列模式 (No Multi-Queue)
            .offloads = 0,
        },
        .txmode = {
            .mq_mode = RTE_ETH_MQ_TX_NONE, // 关键：关闭发送多队列
            .offloads = 0,
        },
        // 显式将 rx_adv_conf.rss_conf 置空，彻底废除哈希分流
        .rx_adv_conf = {
            .rss_conf = {
                .rss_key = NULL,
                .rss_hf = 0, // 核心：哈希函数设为0，不参与任何分流
            },
        },
    };
    const uint16_t rx_rings = 1, tx_rings = 1;
    int retval;
    uint16_t q;

    if (!rte_eth_dev_is_valid_port(port)) return -1;

    // 配置网卡，1个收包队列，1个发包队列
    retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
    if (retval != 0) return retval;

    retval = rte_eth_dev_info_get(port, &dev_info);
    if (retval != 0) return retval;

    rx_conf = dev_info.default_rxconf; // 获取网卡硬件默认的队列配置
    rx_conf.offloads = port_conf.rxmode.offloads; // 保持offload一致

    // 分配并初始化收包队列
    for (q = 0; q < rx_rings; q++) {
        retval = rte_eth_rx_queue_setup(port, q, RX_RING_SIZE,
                rte_eth_dev_socket_id(port), &rx_conf, mbuf_pool);
        if (retval < 0) return retval;
    }

    // 分配并初始化发包队列（虽然单向抓包用不上，但必须初始化）
    for (q = 0; q < tx_rings; q++) {
        retval = rte_eth_tx_queue_setup(port, q, TX_RING_SIZE,
                rte_eth_dev_socket_id(port), NULL);
        if (retval < 0) return retval;
    }

    // 启动物理网卡
    retval = rte_eth_dev_start(port);
    if (retval < 0) return retval;

    // 开启混杂模式（重要：确保能抓到非本地MAC的镜像包）
    rte_eth_promiscuous_enable(port);

    struct rte_eth_link link;
    printf("正在等待网卡链路建立...\n");
    do {
        int ret = rte_eth_link_get_nowait(port, &link);
        if (ret < 0) {
            // 推荐的做法：在这里处理错误日志或返回
            printf("Error getting link status for port %u\n", port);
        }
        rte_delay_ms(500);
    } while (link.link_status == RTE_ETH_LINK_DOWN);
    
    printf("网卡已成功 Up！速率: %u Mbps, 模式: %s\n", 
           link.link_speed, (link.link_duplex == RTE_ETH_LINK_FULL_DUPLEX) ? "全双工" : "半双工");
    return 0;
}

// 核心收包与实时打印线程
static __rte_noreturn void lcore_main(void) {
    uint16_t port = 0; // 我们的板载网卡是 port 0
    uint64_t loop_count = 0; // 增加计数器
    printf("\n[DPDK Sniffer] 核心 %u 正在实时监听 Port %u 流量...\n", rte_lcore_id(), port);

    while (1) {
        struct rte_mbuf *bufs[BURST_SIZE];
        // 核心API：无阻塞批量收包
        const uint16_t nb_rx = rte_eth_rx_burst(port, 0, bufs, BURST_SIZE);

        // 每循环 1 亿次打印一行提示，证明主循环没卡死，且确实在尝试收包
        if (unlikely(loop_count++ % 100000000 == 0)) {
            printf("[Debug] 正在死守网卡收包... 当前收包返回值: %u\n", nb_rx);
        }

        if (unlikely(nb_rx == 0)) {
            continue; // 没有包时空转，死守网卡线速
        }

        // 实时处理收到的每一个报文
        for (uint16_t i = 0; i < nb_rx; i++) {
            struct rte_mbuf *m = bufs[i];
            
            // 转换为以太网头部结构体指针（指针零拷贝移位）
            struct rte_ether_hdr *eth_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
            
            // 实时打印报文基础信息（你可以自由扩展解析 IP/TCP/HTTP）
            printf("实时捕获 -> 源MAC: %02X:%02X:%02X:%02X:%02X:%02X "
                   "| 目的MAC: %02X:%02X:%02X:%02X:%02X:%02X "
                   "| 长度: %u 字节\n",
                   eth_hdr->src_addr.addr_bytes[0], eth_hdr->src_addr.addr_bytes[1],
                   eth_hdr->src_addr.addr_bytes[2], eth_hdr->src_addr.addr_bytes[3],
                   eth_hdr->src_addr.addr_bytes[4], eth_hdr->src_addr.addr_bytes[5],
                   eth_hdr->dst_addr.addr_bytes[0], eth_hdr->dst_addr.addr_bytes[1],
                   eth_hdr->dst_addr.addr_bytes[2], eth_hdr->dst_addr.addr_bytes[3],
                   eth_hdr->dst_addr.addr_bytes[4], eth_hdr->dst_addr.addr_bytes[5],
                   rte_pktmbuf_pkt_len(m));
            
            // 如果你想看全量十六进制，甚至可以解开下面这行（高吞吐流量下慎用，会刷屏卡死终端）
            // rte_pktmbuf_dump(stdout, m, 64); 

            // 旁路监听模式下，处理完必须手动释放 mbuf，防止内存泄漏
            rte_pktmbuf_free(m);
        }
    }
}

int main(int argc, char *argv[]) {
    struct rte_mempool *mbuf_pool;
    uint16_t portid = 0;

    // 1. 初始化基础环境（EAL），解析 -l, -n, --iova-mode 等参数
    int ret = rte_eal_init(argc, argv);
    if (ret < 0) rte_exit(EXIT_FAILURE, "EAL 初始化失败\n");

    // 2. 创建内存池（大页内存分配）
    mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", NUM_MBUFS,
        MBUF_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
    if (mbuf_pool == NULL) rte_exit(EXIT_FAILURE, "无法创建内存池\n");

    // 3. 初始化我们的 0 号物理网卡
    if (port_init(portid, mbuf_pool) != 0)
        rte_exit(EXIT_FAILURE, "网卡 Port %u 初始化失败\n", portid);

    // 4. 在当前核心上直接启动主循环（Demo单核运行即可）
    lcore_main();

    rte_eal_cleanup();
    return 0;
}

# 让 meson 扫描工程并生成 build 构建目录
meson setup build

# 进入构建目录并用 ninja 编译
cd build
ninja

# 如需重编，彻底删除之前的旧 build 缓存
rm -rf build

# -l 4：强行把主收包循环焊死在 4 号 CPU 核心上。
# --iova-mode=pa：指定物理地址模式，完美适配 UIO 驱动。
./dpdk_sniffer -l 4 -n 4 --iova-mode=pa