1
// 启用 RX 中断（DPDK 22.11+）
2
// 将特定队列设置为中断模式
3
rte_eth_dev_rx_intr_enable(port_id, queue_id);
4

5
// 在 epoll 中等待中断
6
struct epoll_event ev;
7
ev.events = EPOLLIN;
8
ev.data.fd = rx_intr_fd;
9
epoll_ctl(epfd, EPOLL_CTL_ADD, rx_intr_fd, &ev);
10

11
// 中断触发后，切换回轮询模式处理数据包
12
int n = epoll_wait(epfd, &ev, 1, timeout);
13
if (n > 0) {
14
    rte_eth_dev_rx_intr_disable(port_id, queue_id);
15
    // 进入轮询模式批量收包
16
    while (1) {
17
        nb_rx = rte_eth_rx_burst(port_id, queue_id, bufs, BURST_SIZE);
18
        if (nb_rx == 0) break;
19
        // 处理数据包...
20
    }
21
    rte_eth_dev_rx_intr_enable(port_id, queue_id);
22
}

1
#include <rte_ethdev.h>
2

3
#define RX_RING_SIZE  1024
4
#define TX_RING_SIZE  1024
5
#define NUM_MBUFS     8191
6
#define MBUF_CACHE_SIZE  250
7
#define BURST_SIZE    32
8

9
int port_init(uint16_t port, struct rte_mempool *mbuf_pool)
10
{
11
    struct rte_eth_conf port_conf = {
12
        .rxmode = {
13
            .max_rx_pkt_len = RTE_ETHER_MAX_LEN,
14
            .offloads = 0,
15
        },
16
        .txmode = {
17
            .offloads = 0,
18
        },
19
    };
20
    struct rte_eth_dev_info dev_info;
21
    int ret;
22

23
    // 获取设备信息（能力、支持的 offload 等）
24
    ret = rte_eth_dev_info_get(port, &dev_info);
25
    if (ret != 0)
26
        return ret;
27

28
    // 配置设备：1 个 RX 队列 + 1 个 TX 队列
29
    ret = rte_eth_dev_configure(port, 1, 1, &port_conf);
30
    if (ret != 0)
31
        return ret;
32

33
    // ... 后续队列配置
34
    return 0;
35
}

1
// 配置 RX 队列
2
ret = rte_eth_rx_queue_setup(port, 0, RX_RING_SIZE,
3
    rte_eth_dev_socket_id(port), NULL, mbuf_pool);
4
if (ret < 0)
5
    rte_exit(EXIT_FAILURE, "rte_eth_rx_queue_setup: err=%d\n", ret);

1
// 配置 TX 队列
2
ret = rte_eth_tx_queue_setup(port, 0, TX_RING_SIZE,
3
    rte_eth_dev_socket_id(port), NULL);
4
if (ret < 0)
5
    rte_exit(EXIT_FAILURE, "rte_eth_tx_queue_setup: err=%d\n", ret);

1
// 从 port_id 的 queue_id 批量接收最多 BURST_SIZE 个包
2
struct rte_mbuf *bufs[BURST_SIZE];
3
uint16_t nb_rx;
4

5
nb_rx = rte_eth_rx_burst(port_id, queue_id, bufs, BURST_SIZE);
6

7
// 处理接收到的包
8
for (i = 0; i < nb_rx; i++) {
9
    // bufs[i] 即为一个完整的以太网帧
10
    struct rte_ether_hdr *eth = rte_pktmbuf_mtod(bufs[i], struct rte_ether_hdr *);
11
    // ... 业务逻辑处理
12
}
13

14
// 处理完毕后释放 mbuf
15
for (i = 0; i < nb_rx; i++)
16
    rte_pktmbuf_free(bufs[i]);

1
// 批量发送数据包
2
struct rte_mbuf *tx_bufs[BURST_SIZE];
3
uint16_t nb_tx;
4

5
// 准备要发送的 mbuf（从 mempool 分配并填充数据）
6
for (i = 0; i < nb_pkts_to_send; i++) {
7
    tx_bufs[i] = rte_pktmbuf_alloc(mbuf_pool);
8
    // 填充以太网帧数据...
9
}
10

11
nb_tx = rte_eth_tx_burst(port_id, queue_id, tx_bufs, nb_pkts_to_send);
12

13
// 发送未成功的包需要释放
14
if (unlikely(nb_tx < nb_pkts_to_send)) {
15
    for (i = nb_tx; i < nb_pkts_to_send; i++)
16
        rte_pktmbuf_free(tx_bufs[i]);
17
}

1
#include <rte_eal.h>
2
#include <rte_ethdev.h>
3
#include <rte_mbuf.h>
4

5
#define RX_RING_SIZE  1024
6
#define TX_RING_SIZE  1024
7
#define NUM_MBUFS     8191
8
#define MBUF_CACHE_SIZE  250
9
#define BURST_SIZE    32
10

11
static const struct rte_eth_conf port_conf_default = {
12
    .rxmode = {
13
        .max_rx_pkt_len = RTE_ETHER_MAX_LEN,
14
    },
15
};
16

17
/* 初始化端口 */
18
static inline int
19
port_init(uint16_t port, struct rte_mempool *mbuf_pool)
20
{
21
    struct rte_eth_conf port_conf = port_conf_default;
22
    const uint16_t rx_rings = 1, tx_rings = 1;
23
    uint16_t nb_rxd = RX_RING_SIZE;
24
    uint16_t nb_txd = TX_RING_SIZE;
25
    int retval;
26
    uint16_t q;
27
    struct rte_eth_dev_info dev_info;
28
    struct rte_eth_txconf txconf;
29

30
    if (!rte_eth_dev_is_valid_port(port))
31
        return -1;
32

33
    retval = rte_eth_dev_info_get(port, &dev_info);
34
    if (retval != 0) {
35
        printf("Error during getting device (port %u) info: %s\n",
36
                port, strerror(-retval));
37
        return retval;
38
    }
39

40
    // 配置以太网设备
41
    retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
42
    if (retval != 0)
43
        return retval;
44

45
    // 调整描述符数量为设备支持的合法值
46
    retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &nb_rxd, &nb_txd);
47
    if (retval != 0)
48
        return retval;
49

50
    // 配置每个 RX 队列
51
    for (q = 0; q < rx_rings; q++) {
52
        retval = rte_eth_rx_queue_setup(port, q, nb_rxd,
53
                rte_eth_dev_socket_id(port), NULL, mbuf_pool);
54
        if (retval < 0)
55
            return retval;
56
    }
57

58
    // 配置每个 TX 队列
59
    txconf = dev_info.default_txconf;
60
    txconf.offloads = port_conf.txmode.offloads;
61
    for (q = 0; q < tx_rings; q++) {
62
        retval = rte_eth_tx_queue_setup(port, q, nb_txd,
63
                rte_eth_dev_socket_id(port), &txconf);
64
        if (retval < 0)
65
            return retval;
66
    }
67

68
    // 启动设备
69
    retval = rte_eth_dev_start(port);
70
    if (retval < 0)
71
        return retval;
72

73
    // 启用混杂模式（可选，根据需求）
74
    retval = rte_eth_promiscuous_enable(port);
75
    if (retval != 0)
76
        return retval;
77

78
    return 0;
79
}

1
// TX 描述符环的回收逻辑（简化版）
2
// 在每次 tx_burst 之前，检查已发送的描述符并释放 mbuf
3
static inline void
4
tx_free_bufs(struct tx_queue *txq)
5
{
6
    uint16_t nb_tx = txq->nb_tx;
7
    uint16_t nb_free = 0;
8

9
    // 检查已发送描述符的 DD 位
10
    while (nb_free < txq->free_thresh &&
11
           (txq->tx_desc[nb_tx].status & DD_BIT)) {
12
        // 释放已发送的 mbuf
13
        rte_pktmbuf_free(txq->tx_bufs[nb_tx]);
14
        txq->tx_bufs[nb_tx] = NULL;
15
        nb_tx = (nb_tx + 1) % txq->nb_desc;
16
        nb_free++;
17
    }
18
    txq->nb_tx = nb_tx;
19
}

1
// 批量收包 + 预取优化
2
nb_rx = rte_eth_rx_burst(port_id, queue_id, bufs, BURST_SIZE);
3

4
for (i = 0; i < nb_rx; i++) {
5
    // 预取下一个 mbuf 的数据到缓存
6
    rte_prefetch0(rte_pktmbuf_mtod(bufs[i], void *));
7
}
8

9
for (i = 0; i < nb_rx; i++) {
10
    // 此时 mbuf 数据已在缓存中，处理延迟极低
11
    process_packet(bufs[i]);
12
}

1
// 向量化 RX 的核心思想（简化）
2
// 一次检查 4 个或 8 个描述符的 DD 位
3
__m256i desc_vals = _mm256_loadu_si256((__m256i *)desc_ptr);
4
__m256i dd_mask = _mm256_set1_epi32(DD_BIT);
5
__m256i cmp = _mm256_and_si256(desc_vals, dd_mask);
6
// 一次比较得到 8 个描述符的状态

1
# 编译时查看向量化支持
2
meson configure build | grep vector
3

4
# 运行时查看当前使用的向量化路径
5
# 在 testpmd 中：
6
# show config rxtx
7
# Rx mode: vectorized (AVX2)

1
# 加载 UIO 驱动
2
sudo modprobe uio_pci_generic
3

4
# 绑定网卡到 UIO
5
sudo dpdk-devbind.py --bind=uio_pci_generic 0000:01:00.0

1
# 启用 IOMMU（在内核启动参数中添加）
2
# Intel: intel_iommu=on
3
# AMD:   amd_iommu=on
4

5
# 加载 VFIO 驱动
6
sudo modprobe vfio-pci
7

8
# 绑定网卡到 VFIO
9
sudo dpdk-devbind.py --bind=vfio-pci 0000:01:00.0
10

11
# 验证绑定
12
dpdk-devbind.py --status

1
# 查看设备的 IOMMU Group
2
ls -la /sys/bus/pci/devices/0000:01:00.0/iommu_group/devices/
3

4
# 查看 IOMMU Group 编号
5
readlink /sys/bus/pci/devices/0000:01:00.0/iommu_group
6
# 输出类似: ../../kernel/iommu_groups/1
7

8
# 如果 Group 中有多个设备，必须全部绑定到 VFIO 或全部不绑定

1
# 第一步：查看当前网卡状态
2
dpdk-devbind.py --status
3

4
# 输出示例：
5
# 0000:01:00.0 '82599ES 10-Gigabit' if=eth0 drv=ixgbe unused=vfio-pci
6
# 0000:01:00.1 '82599ES 10-Gigabit' if=eth1 drv=ixgbe unused=vfio-pci
7

8
# 第二步：卸载当前内核驱动
9
sudo rmmod ixgbe
10

11
# 第三步：加载 VFIO 驱动
12
sudo modprobe vfio-pci
13

14
# 第四步：绑定到 VFIO
15
sudo dpdk-devbind.py --bind=vfio-pci 0000:01:00.0
16
sudo dpdk-devbind.py --bind=vfio-pci 0000:01:00.1
17

18
# 第五步：验证绑定
19
dpdk-devbind.py --status
20

21
# 输出示例：
22
# 0000:01:00.0 '82599ES 10-Gigabit' drv=vfio-pci unused=ixgbe
23
# 0000:01:00.1 '82599ES 10-Gigabit' drv=vfio-pci unused=ixgbe
24

25
# 第六步：设置 VFIO 权限（非 root 用户需要）
26
sudo chmod 666 /dev/vfio/1
27
# 或者将用户加入 vfio 组
28
sudo usermod -aG vfio $USER

1
// DPDK EAL 内部的 VFIO DMA 映射（简化）
2
// 将大页内存映射到 IOMMU
3
int vfio_dma_map(uint64_t vaddr, uint64_t iova, uint64_t size)
4
{
5
    struct vfio_iommu_type1_dma_map dma_map = {
6
        .argsz = sizeof(dma_map),
7
        .flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE,
8
        .vaddr = vaddr,    // 虚拟地址
9
        .iova = iova,      // I/O 虚拟地址
10
        .size = size,      // 映射大小
11
    };
12

13
    return ioctl(vfio_container_fd, VFIO_IOMMU_MAP_DMA, &dma_map);
14
}

1
# 第一步：启用 SR-IOV（创建 VF）
2
# 在 PF 上创建 4 个 VF
3
echo 4 | sudo tee /sys/class/net/eth0/device/sriov_numvfs
4

5
# 验证 VF 创建
6
lspci | grep -i virtual
7
# 输出示例：
8
# 01:10.0 Ethernet controller: Intel 82599 Virtual Function
9
# 01:10.1 Ethernet controller: Intel 82599 Virtual Function
10
# 01:10.2 Ethernet controller: Intel 82599 Virtual Function
11
# 01:10.3 Ethernet controller: Intel 82599 Virtual Function
12

13
# 第二步：设置 VF 的 MAC 地址（可选，由 PF 管理）
14
sudo ip link set eth0 vf 0 mac 00:11:22:33:44:55
15
sudo ip link set eth0 vf 1 mac 00:11:22:33:44:66
16

17
# 第三步：设置 VF 的 VLAN（可选）
18
sudo ip link set eth0 vf 0 vlan 100
19
sudo ip link set eth0 vf 1 vlan 200
20

21
# 第四步：查看 VF 状态
22
ip link show eth0
23
# 输出包含 VF 信息：
24
# vf 0 MAC 00:11:22:33:44:55, vlan 100
25
# vf 1 MAC 00:11:22:33:44:66, vlan 200
26
# vf 2 MAC 00:00:00:00:00:00
27
# vf 3 MAC 00:00:00:00:00:00
28

29
# 第五步：将 VF 分配给虚拟机（libvirt 示例）
30
# 在 VM XML 中添加：
31
# <interface type='hostdev'>
32
#   <source>
33
#     <address type='pci' domain='0x0000' bus='0x01' slot='0x10' function='0x0'/>
34
#   </source>
35
# </interface>

1
# 将 VF 绑定到 VFIO
2
sudo dpdk-devbind.py --bind=vfio-pci 0000:01:10.0
3
sudo dpdk-devbind.py --bind=vfio-pci 0000:01:10.1
4

5
# 使用 testpmd 测试 VF 收发包
6
dpdk-testpmd -l 0-3 -n 4 -- -i
7

8
# 在 testpmd 中查看 VF 端口
9
show port info all

1
# PF 保持内核驱动（ixgbe）
2
# VF 绑定到 VFIO 供 DPDK 使用
3
sudo dpdk-devbind.py --bind=vfio-pci 0000:01:10.0

1
// 创建 LACP Bond 设备
2
#include <rte_eth_bond.h>
3

4
// 创建 bond 设备
5
uint16_t bond_port_id;
6
bond_port_id = rte_eth_bond_create("bond0", BONDING_MODE_8023AD, socket_id);
7

8
// 添加从端口
9
rte_eth_bond_slave_add(bond_port_id, port0);
10
rte_eth_bond_slave_add(bond_port_id, port1);
11

12
// 配置 LACP 参数
13
struct rte_eth_bond_8023ad_conf lacp_conf;
14
rte_eth_bond_8023ad_conf_get(bond_port_id, &lacp_conf);
15
lacp_conf.fast_periodic_ms = 500;    // 快速周期
16
lacp_conf.slow_periodic_ms = 30000;  // 慢速周期
17
lacp_conf.aggregate_wait_timeout_ms = 500;
18
rte_eth_bond_8023ad_conf_set(bond_port_id, &lacp_conf);

1
// 完整的 Bond 设备初始化流程
2
int bond_init(struct rte_mempool *mbuf_pool)
3
{
4
    uint16_t bond_port_id;
5
    int ret;
6

7
    // 1. 创建 bond 设备（Mode 4: LACP）
8
    bond_port_id = rte_eth_bond_create("net_bonding0",
9
        BONDING_MODE_8023AD, rte_socket_id());
10
    if (bond_port_id < 0)
11
        rte_exit(EXIT_FAILURE, "Failed to create bond device\n");
12

13
    // 2. 添加从端口
14
    ret = rte_eth_bond_slave_add(bond_port_id, 0);  // port 0
15
    if (ret < 0)
16
        rte_exit(EXIT_FAILURE, "Failed to add slave 0\n");
17

18
    ret = rte_eth_bond_slave_add(bond_port_id, 1);  // port 1
19
    if (ret < 0)
20
        rte_exit(EXIT_FAILURE, "Failed to add slave 1\n");
21

22
    // 3. 配置 bond 设备（与普通端口相同）
23
    ret = port_init(bond_port_id, mbuf_pool);
24
    if (ret < 0)
25
        rte_exit(EXIT_FAILURE, "Failed to configure bond port\n");
26

27
    // 4. 启动 bond 设备
28
    ret = rte_eth_dev_start(bond_port_id);
29
    if (ret < 0)
30
        rte_exit(EXIT_FAILURE, "Failed to start bond port\n");
31

32
    return 0;
33
}

1
rte_flow 规则 = Pattern + Actions
2
Pattern = 一组匹配项（item），从外层到内层
3
Actions = 一组动作（action），按顺序执行

1
// 定义匹配模式
2
struct rte_flow_attr attr = {
3
    .ingress = 1,  // 入方向规则
4
};
5

6
struct rte_flow_item pattern[4];  // 最后一项必须是 END
7

8
// Item 0: 以太网层
9
struct rte_flow_item_eth eth_spec = {
10
    .type = RTE_BE16(RTE_ETHER_TYPE_IPV4),
11
};
12
struct rte_flow_item_eth eth_mask = {
13
    .type = 0xFFFF,  // 匹配 EtherType
14
};
15
pattern[0].type = RTE_FLOW_ITEM_TYPE_ETH;
16
pattern[0].spec = &eth_spec;
17
pattern[0].mask = &eth_mask;
18

19
// Item 1: IPv4 层
20
struct rte_flow_item_ipv4 ipv4_spec = {0};
21
struct rte_flow_item_ipv4 ipv4_mask = {0};
22
pattern[1].type = RTE_FLOW_ITEM_TYPE_IPV4;
23
pattern[1].spec = &ipv4_spec;
24
pattern[1].mask = &ipv4_mask;
25

26
// Item 2: TCP 层，匹配目的端口 80
27
struct rte_flow_item_tcp tcp_spec = {
28
    .hdr.dst_port = RTE_BE16(80),
29
};
30
struct rte_flow_item_tcp tcp_mask = {
31
    .hdr.dst_port = 0xFFFF,  // 完全匹配目的端口
32
};
33
pattern[2].type = RTE_FLOW_ITEM_TYPE_TCP;
34
pattern[2].spec = &tcp_spec;
35
pattern[2].mask = &tcp_mask;
36

37
// Item 3: 结束标记
38
pattern[3].type = RTE_FLOW_ITEM_TYPE_END;

1
// 定义动作列表
2
struct rte_flow_action actions[2];
3

4
// Action 0: 送到队列 0
5
struct rte_flow_action_queue queue_action = {
6
    .index = 0,
7
};
8
actions[0].type = RTE_FLOW_ACTION_TYPE_QUEUE;
9
actions[0].conf = &queue_action;
10

11
// Action 1: 结束标记
12
actions[1].type = RTE_FLOW_ACTION_TYPE_END;

1
struct rte_flow_error error;
2

3
// 验证规则是否被硬件支持
4
int ret = rte_flow_validate(port_id, &attr, pattern, actions, &error);
5
if (ret < 0) {
6
    printf("Flow rule validation failed: %s\n", error.message);
7
    return -1;
8
}
9

10
// 创建流规则
11
struct rte_flow *flow = rte_flow_create(port_id, &attr, pattern, actions, &error);
12
if (flow == NULL) {
13
    printf("Flow rule creation failed: %s\n", error.message);
14
    return -1;
15
}
16

17
// 销毁流规则（不再需要时）
18
rte_flow_destroy(port_id, flow, &error);
19

20
// 销毁端口上的所有流规则
21
rte_flow_flush(port_id, &error);

1
// 配置 RSS：基于 IPv4 + TCP 四元组哈希
2
struct rte_eth_rss_conf rss_conf = {
3
    .rss_key = NULL,  // 使用默认 RSS key
4
    .rss_key_len = 0,
5
    .rss_hf = RTE_ETH_RSS_IP | RTE_ETH_RSS_TCP,  // 哈希字段
6
};
7

8
// 在 port_conf 中配置 RSS
9
struct rte_eth_conf port_conf = {
10
    .rxmode = {
11
        .mq_mode = RTE_ETH_MQ_RX_RSS,
12
        .offloads = 0,
13
    },
14
    .rx_adv_conf = {
15
        .rss_conf = rss_conf,
16
    },
17
};

1
// 使用 rte_flow 实现 Flow Director 功能
2
// 匹配：源 IP = 192.168.1.100，目的端口 = 443
3
// 动作：送到队列 2，并打标记 0x1234
4

5
struct rte_flow_item_ipv4 ipv4_spec = {
6
    .hdr.src_addr = RTE_BE32(0xC0A80164),  // 192.168.1.100
7
};
8
struct rte_flow_item_ipv4 ipv4_mask = {
9
    .hdr.src_addr = 0xFFFFFFFF,  // 完全匹配源 IP
10
};
11

12
struct rte_flow_item_tcp tcp_spec = {
13
    .hdr.dst_port = RTE_BE16(443),
14
};
15
struct rte_flow_item_tcp tcp_mask = {
16
    .hdr.dst_port = 0xFFFF,
17
};
18

19
struct rte_flow_action_queue queue_action = { .index = 2 };
20
struct rte_flow_action_mark mark_action = { .id = 0x1234 };
21

22
struct rte_flow_action actions[] = {
23
    { .type = RTE_FLOW_ACTION_TYPE_MARK, .conf = &mark_action },
24
    { .type = RTE_FLOW_ACTION_TYPE_QUEUE, .conf = &queue_action },
25
    { .type = RTE_FLOW_ACTION_TYPE_END },
26
};

1
# 1. 确认网卡 PCI 地址
2
lspci | grep -i ethernet
3
# 示例输出：
4
# 01:00.0 Ethernet controller: Intel 82599ES 10-Gigabit
5

6
# 2. 查看当前驱动
7
dpdk-devbind.py --status
8

9
# 3. 加载 VFIO 驱动
10
sudo modprobe vfio-pci
11

12
# 4. 绑定网卡到 VFIO
13
sudo dpdk-devbind.py --bind=vfio-pci 0000:01:00.0
14

15
# 5. 验证绑定成功
16
dpdk-devbind.py --status | grep -A2 "0000:01:00.0"
17
# 期望输出：drv=vfio-pci
18

19
# 6. 配置大页
20
echo 1024 | sudo tee /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
21

22
# 7. 验证大页可用
23
cat /proc/meminfo | grep HugePages
24
# HugePages_Total:    1024
25
# HugePages_Free:     1024

1
# 启动 testpmd
2
# -l 0-3: 使用 lcore 0~3
3
# -n 4: 4 个内存通道
4
# -- -i: 交互模式
5
dpdk-testpmd -l 0-3 -n 4 -- -i
6

7
# 在 testpmd 交互界面中：
8

9
# 查看端口信息
10
show port info all
11

12
# 启动转发
13
start
14

15
# 查看收发包统计（每秒刷新）
16
show port stats all
17

18
# 典型输出：
19
#   RX-packets: 12345678  RX-missed: 0       RX-bytes:  876543210
20
#   RX-errors:  0         RX-nombuf:  0
21
#   TX-packets: 12345678  TX-errors:  0       TX-bytes:  876543210
22

23
# 查看 RX/TX 队列统计
24
show port xstats all
25

26
# 停止转发
27
stop
28

29
# 退出
30
quit

1
# 1. 确认网卡支持 SR-IOV
2
lspci -vvv -s 0000:01:00.0 | grep -i "SR-IOV"
3
# 期望输出：Capabilities: [xxx] SR-IOV
4

5
# 2. 查看最大 VF 数量
6
cat /sys/class/net/eth0/device/sriov_totalvfs
7
# 输出：64（取决于网卡型号）
8

9
# 3. 创建 4 个 VF
10
echo 4 | sudo tee /sys/class/net/eth0/device/sriov_numvfs
11

12
# 4. 验证 VF 创建
13
lspci | grep -i "virtual function"
14

15
# 5. 查看 VF 状态
16
ip link show eth0 | grep vf
17

18
# 6. 设置 VF MAC 地址
19
sudo ip link set eth0 vf 0 mac 52:54:00:00:01:01
20
sudo ip link set eth0 vf 1 mac 52:54:00:00:01:02
21

22
# 7. 设置 VF VLAN
23
sudo ip link set eth0 vf 0 vlan 100
24

25
# 8. 将 VF 绑定到 VFIO 供 DPDK 使用
26
sudo dpdk-devbind.py --bind=vfio-pci 0000:01:10.0
27

28
# 9. 用 testpmd 测试 VF
29
dpdk-testpmd -l 0-1 -n 4 -- -i
30
show port info all

1
# 启动 testpmd
2
dpdk-testpmd -l 0-3 -n 4 -- -i
3

4
# 创建流规则：将目的端口为 80 的 TCP 包送到队列 0
5
flow create 0 ingress pattern eth / ipv4 / tcp dst is 80 / end actions queue index 0 / end
6

7
# 创建流规则：丢弃来自 192.168.1.100 的所有包
8
flow create 0 ingress pattern eth / ipv4 src is 192.168.1.100 / end actions drop / end
9

10
# 创建流规则：将 TCP 443 流量标记为 0x1234 并送到队列 1
11
flow create 0 ingress pattern eth / ipv4 / tcp dst is 443 / end actions mark id 0x1234 / queue index 1 / end
12

13
# 查看所有流规则
14
flow list 0
15

16
# 查看流规则统计
17
flow query 0 0 count
18
# 输出：hits: 12345
19

20
# 销毁特定流规则
21
flow destroy 0 rule 0
22

23
# 销毁所有流规则
24
flow flush 0