一、dpdk环境开启
这里使用了已经搭建好的dpdk环境，dpdk的搭建过程网上有很多教程可以参考，后面有空再做一篇dpdk环境搭建文章吧！ （1）检查网卡状态
代码语言：javascript复制ifconfigping一下网卡IP，确定网卡是可以连通的。 （2）查看是不是支持多队列网卡
代码语言：javascript复制cat /proc/interrupts | grep eth0多队列网卡是支持多队列中断的；只支持一个中断是无法使用dpdk的。 （3）导出dpdk环境变量
代码语言：javascript复制cd dpdk路径
# 如dpdk/dpdk-stable-19.08.2/
#切换root权限
sudo su
export RTE_SDK=dpdk路径
export RTE_TARGET=x86_64-native-linux-gcc可以做成shell脚本。 （4）配置dpdk
代码语言：javascript复制./usertools/dpdk-setup.sh依次执行： 43（加载DPDK UIO 模块，即插入driver） 44（加载VFIO模块，也是一种driver） 45（加载KNI模块，将一些数据写回内核） 46（设置巨页，可以不需要频繁页交换，512） 47（设置巨页，可512） 49（执行之前需要eth0 down掉，执行sudo ifconfig eth0 down，使绑定dpdk）pci地址=对应eth0的（如0000:03:00.0） 60（退出）
执行过程如下：
代码语言：javascript复制------------------------------------------------------------------------------
RTE_SDK exported as /home/king/share/dpdk/dpdk-stable-19.08.2
------------------------------------------------------------------------------
----------------------------------------------------------
Step 1: Select the DPDK environment to build
----------------------------------------------------------
[1] arm64-armada-linuxapp-gcc
[2] arm64-armada-linux-gcc
[3] arm64-armv8a-linuxapp-clang
[4] arm64-armv8a-linuxapp-gcc
[5] arm64-armv8a-linux-clang
[6] arm64-armv8a-linux-gcc
[7] arm64-bluefield-linuxapp-gcc
[8] arm64-bluefield-linux-gcc
[9] arm64-dpaa2-linuxapp-gcc
[10] arm64-dpaa2-linux-gcc
[11] arm64-dpaa-linuxapp-gcc
[12] arm64-dpaa-linux-gcc
[13] arm64-octeontx2-linuxapp-gcc
[14] arm64-octeontx2-linux-gcc
[15] arm64-stingray-linuxapp-gcc
[16] arm64-stingray-linux-gcc
[17] arm64-thunderx2-linuxapp-gcc
[18] arm64-thunderx2-linux-gcc
[19] arm64-thunderx-linuxapp-gcc
[20] arm64-thunderx-linux-gcc
[21] arm64-xgene1-linuxapp-gcc
[22] arm64-xgene1-linux-gcc
[23] arm-armv7a-linuxapp-gcc
[24] arm-armv7a-linux-gcc
[25] i686-native-linuxapp-gcc
[26] i686-native-linuxapp-icc
[27] i686-native-linux-gcc
[28] i686-native-linux-icc
[29] ppc_64-power8-linuxapp-gcc
[30] ppc_64-power8-linux-gcc
[31] x86_64-native-bsdapp-clang
[32] x86_64-native-bsdapp-gcc
[33] x86_64-native-freebsd-clang
[34] x86_64-native-freebsd-gcc
[35] x86_64-native-linuxapp-clang
[36] x86_64-native-linuxapp-gcc
[37] x86_64-native-linuxapp-icc
[38] x86_64-native-linux-clang
[39] x86_64-native-linux-gcc
[40] x86_64-native-linux-icc
[41] x86_x32-native-linuxapp-gcc
[42] x86_x32-native-linux-gcc
----------------------------------------------------------
Step 2: Setup linux environment
----------------------------------------------------------
[43] Insert IGB UIO module
[44] Insert VFIO module
[45] Insert KNI module
[46] Setup hugepage mappings for non-NUMA systems
[47] Setup hugepage mappings for NUMA systems
[48] Display current Ethernet/Baseband/Crypto device settings
[49] Bind Ethernet/Baseband/Crypto device to IGB UIO module
[50] Bind Ethernet/Baseband/Crypto device to VFIO module
[51] Setup VFIO permissions
----------------------------------------------------------
Step 3: Run test application for linux environment
----------------------------------------------------------
[52] Run test application ($RTE_TARGET/app/test)
[53] Run testpmd application in interactive mode ($RTE_TARGET/app/testpmd)
----------------------------------------------------------
Step 4: Other tools
----------------------------------------------------------
[54] List hugepage info from /proc/meminfo
----------------------------------------------------------
Step 5: Uninstall and system cleanup
----------------------------------------------------------
[55] Unbind devices from IGB UIO or VFIO driver
[56] Remove IGB UIO module
[57] Remove VFIO module
[58] Remove KNI module
[59] Remove hugepage mappings
[60] Exit Script
Option: 43
Unloading any existing DPDK UIO module
Loading uio module
Loading DPDK UIO module
Press enter to continue ...
......
Option: 44
Unloading any existing VFIO module
Loading VFIO module
chmod /dev/vfio
OK
Press enter to continue ...
......
Option: 45
Unloading any existing DPDK KNI module
Loading DPDK KNI module
Press enter to continue ...
......
Option: 46
Removing currently reserved hugepages
Unmounting /mnt/huge and removing directory
Input the number of 1048576kB hugepages
Example: to have 128MB of hugepages available in a 2MB huge page system,
enter '64' to reserve 64 * 2MB pages
Number of pages: 512
Reserving hugepages
Creating /mnt/huge and mounting as hugetlbfs
Press enter to continue ...
......
Option: 47
Removing currently reserved hugepages
Unmounting /mnt/huge and removing directory
Input the number of 1048576kB hugepages for each node
Example: to have 128MB of hugepages available per node in a 2MB huge page system,
enter '64' to reserve 64 * 2MB pages on each node
Number of pages for node0: 512
Reserving hugepages
Creating /mnt/huge and mounting as hugetlbfs
Press enter to continue ...
......
Option: 49
Network devices using kernel driver
===================================
0000:02:01.0 '82545EM Gigabit Ethernet Controller (Copper) 100f' if=eth2 drv=e1000 unused=igb_uio,vfio-pci *Active*
0000:02:06.0 '82545EM Gigabit Ethernet Controller (Copper) 100f' if=eth3 drv=e1000 unused=igb_uio,vfio-pci *Active*
0000:03:00.0 'VMXNET3 Ethernet Controller 07b0' if=eth0 drv=vmxnet3 unused=igb_uio,vfio-pci
0000:0b:00.0 'VMXNET3 Ethernet Controller 07b0' if=eth1 drv=vmxnet3 unused=igb_uio,vfio-pci *Active*
No 'Baseband' devices detected
==============================
No 'Crypto' devices detected
============================
No 'Eventdev' devices detected
==============================
No 'Mempool' devices detected
=============================
No 'Compress' devices detected
==============================
No 'Misc (rawdev)' devices detected
===================================
Enter PCI address of device to bind to IGB UIO driver: 0000:03:00.0
OK
Press enter to continue ...
......
Option: 60二、Windowe下配置静态IP表
需要管理员权限 （1）查看要加入的静态表接口
代码语言：javascript复制arp -a示例结果如下，可以看到0x13这个位置，后面步骤用到。
代码语言：javascript复制接口: 192.168.2.130 --- 0x13
Internet 地址 物理地址 类型
192.168.0.20 00-17-16-07-b1-14 动态
192.168.0.25 00-00-74-f8-0f-65 动态
192.168.0.60 00-1e-67-6e-d4-c8 动态
192.168.0.62 00-15-5d-00-29-01 动态
192.168.0.80 00-00-5e-00-01-82 动态
192.168.0.116 04-d4-c4-8f-03-d7 动态
192.168.0.120 90-09-d0-0a-39-8b 动态
192.168.0.128 18-c0-4d-5e-30-05 动态
192.168.0.150 90-23-b4-b8-62-63 动态
192.168.0.152 b8-cb-29-b1-82-5b 动态
192.168.0.180 0c-c4-7a-79-21-8a 动态
192.168.2.42 30-5a-3a-5a-63-cd 动态
192.168.2.154 00-0e-c6-5c-39-34 动态
192.168.2.227 18-c0-4d-de-e8-9d 动态
192.168.3.111 30-b4-9e-76-e6-60 动态
192.168.3.166 2c-56-dc-dc-d5-45 动态
192.168.4.191 d8-5e-d3-20-7a-53 动态
192.168.5.0 18-c0-4d-9b-65-fb 动态
192.168.7.31 fc-aa-14-a2-e7-4a 动态
192.168.7.98 18-c0-4d-de-dd-be 动态
192.168.7.146 00-0c-29-39-a8-c4 动态
192.168.7.234 18-c0-4d-cc-b7-da 动态
192.168.7.248 d4-5d-64-d2-b7-23 动态
192.168.7.253 50-81-40-f3-ed-90 动态
192.168.8.1 70-8c-b6-ee-02-12 动态
192.168.8.11 00-11-04-01-19-4d 动态
192.168.8.17 00-11-04-01-01-c5 动态
192.168.11.12 d4-5d-64-3c-5c-fa 动态
192.168.11.21 e0-70-ea-f1-0b-77 动态
192.168.11.45 0c-9d-92-85-52-d4 动态
192.168.11.92 40-8d-5c-a8-08-00 动态
192.168.11.95 04-42-1a-eb-b5-00 动态
192.168.11.138 00-0e-c6-80-04-fa 动态
192.168.11.202 98-29-a6-65-c9-2c 动态
192.168.11.225 18-c0-4d-57-59-58 动态
192.168.16.124 18-c0-4d-50-1e-da 动态
192.168.17.140 d8-5e-d3-2a-56-78 动态
192.168.17.174 70-5a-0f-4d-c7-e8 动态
192.168.17.196 00-24-1d-9c-f2-15 动态
192.168.17.199 38-d5-47-1c-5c-fb 动态
192.168.20.188 e4-e7-49-ff-f0-9c 动态
192.168.255.255 ff-ff-ff-ff-ff-ff 静态
224.0.0.2 01-00-5e-00-00-02 静态
224.0.0.22 01-00-5e-00-00-16 静态
224.0.0.251 01-00-5e-00-00-fb 静态
224.0.0.252 01-00-5e-00-00-fc 静态
224.0.1.60 01-00-5e-00-01-3c 静态
224.0.6.151 01-00-5e-00-06-97 静态
224.100.100.100 01-00-5e-64-64-64 静态
224.200.200.200 01-00-5e-48-c8-c8 静态
229.111.112.12 01-00-5e-6f-70-0c 静态
233.233.233.233 01-00-5e-69-e9-e9 静态
234.200.200.200 01-00-5e-48-c8-c8 静态
239.102.144.50 01-00-5e-66-90-32 静态
239.192.152.143 01-00-5e-40-98-8f 静态
239.193.3.64 01-00-5e-41-03-40 静态
239.193.4.69 01-00-5e-41-04-45 静态
239.193.5.133 01-00-5e-41-05-85 静态
239.193.21.194 01-00-5e-41-15-c2 静态
239.193.21.222 01-00-5e-41-15-de 静态
239.193.21.241 01-00-5e-41-15-f1 静态
239.255.102.18 01-00-5e-7f-66-12 静态
239.255.255.250 01-00-5e-7f-ff-fa 静态
239.255.255.251 01-00-5e-7f-ff-fb 静态
239.255.255.253 01-00-5e-7f-ff-fd 静态
239.255.255.254 01-00-5e-7f-ff-fe 静态（2）查看适配器
代码语言：javascript复制netsh i i show in示例结果如下：
代码语言：javascript复制Idx Met MTU 状态 名称
--- ---------- ---------- ------------ ---------------------------
1 75 4294967295 connected Loopback Pseudo-Interface 1
19 35 1500 connected 以太网 2
5 35 1500 connected VMware Network Adapter VMnet1
15 35 1500 connected VMware Network Adapter VMnet8
39 35 1500 connected VMware Network Adapter VMnet2可以看到，上面的0x13=19对应的网络接口是以太网。 （3）新添静态IP
代码语言：javascript复制netsh -c i i add neighbors 19 192.168.7.199 38-d5-47-1c-5c-fb注意要确定MAC地址的正确性。 （4）检查是否添加成功
代码语言：javascript复制arp -a（5）如果需要清除静态表，执行：
代码语言：javascript复制netsh i i delete neighbors 接口号
# 比如18就是接口号三、DPDK API介绍
dpdk提供丰富的api，具体的api介绍可以参考官网API文档。这里介绍一下部分常用的API。
3.1、struct rte_memzone结构体
原型：
代码语言：javascript复制#include <rte_memzone.h>
struct rte_memzone{
char name [RTE_MEMZONE_NAMESIZE]；
rte_iova_t iova；
size_t len；
uint64_t hugepage_sz；
int32_t socket_id；
uint32_t flags；
void * addr；
uint64_t addr_64；
};成员描述：
成员 | 含义 |
|---|---|
name | 内存分区名称。 |
iova | 开始的输入输出地址。 |
addr | 开始的虚拟地址。 |
addr_64 | 确保addr总是64 bits。 |
len | memzone的长度。 |
hugepage_sz | 底层内存的页大小。 |
socket_id | NUMA socket ID。 |
flags | memzone的标识 |
3.2、struct rte_mempool结构体
原型：
代码语言：javascript复制#include <rte_mempool.h>
struct rte_mempool{
char name [RTE_MEMPOOL_NAMESIZE];
void *pool_config;
const struct rte_memzone *mz;
unsigned int flags;
int socket_id;
uint32_t size;
uint32_t cache_size;
uint32_t elt_size;
uint32_t header_size;
uint32_t trailer_size;
unsigned private_data_size;
int32_t ops_index;
struct rte_mempool_cache *local_cache;
uint32_t populated_size;
struct rte_mempool_objhdr_list elt_list;
uint32_t nb_mem_chunks;
struct rte_mempool_memhdr_list mem_list;
void *pool_data;
uint64_t pool_id;
}成员描述：
成员 | 含义 |
|---|---|
name | 内存池的名称。 |
pool_data | 用于存储对象的环或池。 |
pool_id | 外部内存标识符。 |
pool_config | 可选参数。 |
mz | 分配池的Memzone。 |
flags | 内存池的标志。 |
socket_id | 创建时传递的套接字id。 |
size | 内存池的最大大小。 |
cache_size | 每内核默认本地缓存的大小。 |
elt_size | 元素大小。 |
header_size | 元素之前的头大小。 |
trailer_size | 元素之后的尾大小。 |
private_data_size | 私有数据的大小。 |
ops_index | 内存池操作结构的rte_mempool_ops_table数组的索引，该数组包含回调函数指针。在这里使用索引而不是回调函数的指针，以方便任何可能想要使用这个内存池的辅助进程。 |
local_cache | Per-lcore本地缓存 |
populated_size | 填充对象的数量。 |
elt_list | 池中的元素列表 |
nb_mem_chunks | 内存块数量 |
mem_list | 内存块列表 |
3.3、struct rte_eth_dev_info结构体
一种用于检索以太网设备上下文信息的结构，如设备的控制驱动程序等。 原型：
代码语言：javascript复制#include <rte_ethdev.h>
struct rte_eth_dev_info{
struct rte_device * device；
const char * driver_name；
unsigned int if_index；
uint16_t min_mtu;
uint16_t max_mtu；
const uint32_t * dev_flags;
uint32_t min_rx_bufsize;
uint32_t max_rx_pktlen;
uint32_t max_lro_pkt_size;
uint16_t max_rx_queues;
uint16_t max_tx_queues;
uint32_t max_mac_addrs;
uint32_t max_hash_mac_addrs;
uint16_t max_vfs;
uint16_t max_vmdq_pools;
struct rte_eth_rxseg_capa rx_seg_capa;
uint64_t rx_offload_capa;
uint64_t tx_offload_capa;
uint64_t rx_queue_offload_capa;
uint64_t tx_queue_offload_capa;
uint16_t reta_size;
uint8_t hash_key_size;
uint64_t flow_type_rss_offloads;
struct rte_eth_rxconf default_rxconf;
struct rte_eth_txconf default_txconf;
uint16_t vmdq_queue_base;
uint16_t vmdq_queue_num;
uint16_t vmdq_pool_base;
struct rte_eth_desc_lim rx_desc_lim;
struct rte_eth_desc_lim tx_desc_lim;
uint32_t speed_capa;
uint16_t nb_rx_queues;
uint16_t nb_tx_queues;
struct rte_eth_dev_portconf default_rxportconf;
struct rte_eth_dev_portconf default_txportconf;
uint64_t dev_capa;
struct rte_eth_switch_info switch_info;
uint64_t reserved_64s [2];
void * reserved_ptrs [2];
};3.4、struct rte_eth_conf结构体
用于配置以太网端口的结构。根据Rx多队列模式，可能需要额外的高级配置设置。
代码语言：javascript复制#include <rte_ethdev.h>
struct rte_eth_conf{
uint32_t link_speeds;
struct rte_eth_rxmode rxmode;
struct rte_eth_txmode txmode;
uint32_t lpbk_mode;
struct {
struct rte_eth_rss_conf rss_conf;
struct rte_eth_vmdq_dcb_conf vmdq_dcb_conf;
struct rte_eth_dcb_rx_conf dcb_rx_conf;
struct rte_eth_vmdq_rx_conf vmdq_rx_conf;
} rx_adv_conf;
union {
struct rte_eth_vmdq_dcb_tx_conf vmdq_dcb_tx_conf;
struct rte_eth_dcb_tx_conf dcb_tx_conf;
struct rte_eth_vmdq_tx_conf vmdq_tx_conf;
} tx_adv_conf;
uint32_t dcb_capability_en;
struct rte_eth_fdir_conf fdir_conf;
struct rte_eth_intr_conf intr_conf;
};3.5、struct rte_eth_rxconf结构体
用于配置以太网端口Rx环的结构。位置lib/ethdev/rte_ethdev.h。 原型：
代码语言：javascript复制#include <rte_ethdev.h>
rte_eth_rxconf{
struct rte_eth_thresh rx_thresh;// 接收环阈值寄存器
uint16_t rx_free_thresh;//驱动Rx描述符的释放
uint8_t rx_drop_en;//如果没有可用的描述符，则丢弃数据包
uint8_t rx_deferred_start;//不要使用 rte_eth_dev_start()开始排队
uint16_t rx_nseg;//数组中的rx_seg描述数
uint16_t share_group;//在 Rx 域和交换机域中共享组索引。非零值启用 ，零值禁用。
uint16_t share_qid;//组中的共享 Rx 队列 ID
uint64_t offloads;//卸载，每队列 Rx 卸载要使用 RTE_ETH_RX_OFFLOAD_* 标志进行设置。
union rte_eth_rxseg * rx_seg;//指向整个数据包的分段描述数组。数组元素是连续 Rx 段的属性。
uint64_t reserved_64s [2];//保留
void * reserved_ptrs [2];//保留
};3.6、struct rte_eth_txconf结构体
用于配置以太网端口的发送环的结构。 原型：
代码语言：javascript复制#include <rte_ethdev.h>
struct rte_eth_txconf{
struct rte_eth_thresh tx_thresh;//发送环阈值寄存器
uint16_t tx_rs_thresh;//驱动TXD上RS为的设置
uint16_t tx_free_thresh;//用于配置以太网端口的发送环的结构。
uint8_t tx_deferred_start;//不要使用 rte_eth_dev_start()开始排
uint64_t offloads;//卸载
uint64_t reserved_64s [2];//保留
void * reserved_ptrs [2];//保留
};3.7、rte_eal_init()
EAL配置API定义在rte_eal.h。 函数原型：
代码语言：javascript复制#include <rte_eal.h>
int rte_eal_init(int argc, char **argv);此函数是初始化环境抽象层 （EAL）。仅在 MAIN lcore 上执行，尽可能在应用程序的 main() 函数中执行；它将 WORKER lcore 置于 WAIT 状态。 成功则返回大于或等于0的值，即分析的参数数。失败则返回-1，并且rte_errno设置故障原因的值。在一些情况下，为清除部分问题，可能需要重启应用程序。 参数：
参数 | 含义 |
|---|---|
argc | 非负值。如果它大于 0，则 argv[0] 到 argv[argc]的数组成员应包含指向字符串的指针。 |
argv | 字符串数组。数组的内容以及数组所指向的字符串都可以由此函数修改。 |
rte_errno返回的错误码：
值 | 含义 |
|---|---|
EACCES | 表示存在权限问题。 |
EAGAIN | 指示总线或系统资源不可用，可以再次尝试设置。 |
EALREADY | 表示rte_eal_init函数已被调用，无法再次调用。 |
EFAULT | 指示在内存配置中找不到 tailq 配置名称。 |
EINVAL | 指示无效参数被传递为 argv/argc。 |
ENOMEM | 表示故障可能是由内存不足情况引起的。 |
ENODEV | 指示内存设置问题。 |
ENOTSUP | 指示 EAL 无法在此系统上初始化。 |
EPROTO | 指示 PCI 总线不存在，或者 eal 无法读取。 |
ENOEXEC | 表示服务核心未能成功启动。 |
3.8、rte_exit()
立即终止 应用程序，打印错误消息并将exit_code返回到 shell。此函数不会有返回。 函数原型：
代码语言：javascript复制#include <rte_common.h>
__rte_noreturn void rte_exit(int exit_code,const char * format,... );参数 | 含义 |
|---|---|
exit_code | 应用程序要返回的退出代码 |
format | 用于打印消息的格式字符串。这可以包括 printf 格式字符，这些字符将使用函数的任何其他参数进行扩展。 |
3.9、rte_memzone_reserve()
函数原型：
代码语言：javascript复制#include <rte_memzone.h>
const struct rte_memzone* rte_memzone_reserve (
const char * name,
size_t len,
int socket_id,
unsigned flags
);保留一部分物理内存。此函数保留一些内存，并返回指向正确填充的 memzone 描述符的指针。如果无法完成分配，则返回 NULL。
注意： len 设置为 0 的 memzone 将仅尝试从已可用的内存中分配 memzone。它不会触发任何新的分配。当保留len设置为0的memzones时，最好也设置一个有效的socket_id。支持将socket_id设置为SOCKET_ID_ANY，但可能不会产生预期的结果。具体来说，生成的 memzone 不一定是可用的最大 memzone，而是与调用预留的 lcore 相对应的套接字 ID 上可用的最大 memzone。 参数：
参数 | 含义 |
|---|---|
name | memzone的名称。如果它已经存在，则该函数将失败并返回 NULL。 |
len | 要保留的内存的大小。如果为 0，则将保留最大的连续区域。 |
socket_id | NUMA 情况下的套接字标识符。如果保留区域没有 NUMA 约束，则可以SOCKET_ID_ANY该值。 |
flags | 参数用于请求从特定大小的大页面中获取 memzone。 |
flags取值：
标识 | 含义 |
|---|---|
RTE_MEMZONE_2MB | 保留 2MB 页面 |
RTE_MEMZONE_1GB | 保留 1GB 页面 |
RTE_MEMZONE_16MB | 保留 16MB 页面 |
RTE_MEMZONE_16GB | 保留 16GB 页面 |
RTE_MEMZONE_256KB | 保留 256KB 页起 |
RTE_MEMZONE_256MB | 保留 256MB 页面 |
RTE_MEMZONE_512MB | 保留 512MB 页面 |
RTE_MEMZONE_4GB | 保留自 4GB 页面 |
RTE_MEMZONE_SIZE_HINT_ONLY | 如果请求的页面大小不可用，则允许使用备用页面大小。如果未设置此标志，则该函数将在大小不可用请求时返回错误。 |
RTE_MEMZONE_IOVA_CONTIG | 确保保留的 memzone 与 IOVA 相容。在分配用于硬件环等的内存时，应使用此选项。 |
成功则返回指向正确填充的只读 memzone 描述符的指针，如果失败时返回 NULL，并适当地设置rte_errno。 错误码：
错误码 | 含义 |
|---|---|
E_RTE_NO_CONFIG | 函数无法获取指向rte_config结构的指针 |
E_RTE_SECONDARY | 函数从辅助流程实例调用 |
EINVAL | 无效参数 |
ENOSPC | memzone的最大数量已经分配 |
EEXIST | 已存在同名的memzone |
ENOMEM | 没有找到合适的内存区域来创建memzone |
3.10、rte_mempool_create()
函数原型：
代码语言：javascript复制struct rte_mempool* rte_mempool_create ( const char * name,
unsigned n,
unsigned elt_size,
unsigned cache_size,
unsigned private_data_size,
rte_mempool_ctor_t *mp_init,
void *mp_init_arg,
rte_mempool_obj_cb_t *obj_init,
void *obj_init_arg,
int socket_id,
unsigned flags
);在内存中创建一个名为name的新内存池。这个函数使用rte_memzone_reserve()来分配内存。该池包含n个elt_size的元素。它的大小设为n。
参数 | 含义 |
|---|---|
name | 内存池的名称。 |
n | 内存池中的元素数。内存池的最佳大小（就内存使用而言）：n = （2^q - 1）。 |
elt_size | 每个元素的大小。 |
cache_size | 每核对象缓存的大小。如果cache_size不为零，则rte_mempool库将尝试通过维护每 lcore 对象缓存来限制对公共无锁池的访问。此参数必须低于或等于 RTE_MEMPOOL_CACHE_MAX_SIZE 和 n/1.5。建议选择cache_size，使其具有“n模cache_size == 0”：如果不是这种情况，则某些元素将始终留在池中，永远不会被使用。当然，对 per-lcore 表的访问速度比多生产者/使用者池更快。如果 cache_size 参数设置为 0，则可以禁用缓存;它可用于避免丢失缓存中的对象。 |
private_data_size | 内存池结构后附加的私有数据的大小。这对于在内存池结构之后存储一些私有数据非常有用，例如对于rte_mbuf_pool。 |
mp_init | 一个函数指针，用于在对象初始化之前初始化池。如果需要，用户可以在此函数中初始化私有数据。如果不需要，此参数可以为 NULL。 |
mp_init_arg | 指向可在内存池构造函数中使用的数据的不透明指针。 |
obj_init | 在池初始化时为每个对象调用的函数指针。如果需要，用户可以在对象中设置一些元数据。如果不需要，此参数可以为 NULL。obj_init（） 函数将 mempool 指针、init_arg、对象指针和对象编号作为参数。 |
obj_init_arg | 指向数据的不透明指针，可用作每次调用对象构造函数的参数。 |
socket_id | socket_id参数是 NUMA 情况下的套接字标识符。如果保留区域没有 NUMA 约束，则可以SOCKET_ID_ANY该值。 |
flags | 标记符 |
flags标记符说明：
标记符 | 含义 |
|---|---|
RTE_MEMPOOL_F_NO_SPREAD | 默认情况下，对象地址分布在 RAM 中的通道之间：池分配器将根据硬件配置在对象之间添加填充。有关详细信息，请参阅内存对齐约束。如果设置了此标志，则分配器将仅将它们与缓存行对齐。 |
RTE_MEMPOOL_F_NO_CACHE_ALIGN | 默认情况下，返回的对象是缓存对齐的。此标志将删除此约束，并且对象之间不会存在任何填充。此标志表示RTE_MEMPOOL_F_NO_SPREAD。 |
RTE_MEMPOOL_F_SP_PUT | 如果设置了此标志，则使用 rte_mempool_put（） 或 rte_mempool_put_bulk（） 时的默认行为为“单生产者”。否则，就是“多生产者”。 |
RTE_MEMPOOL_F_SC_GET | 如果设置了此标志，则使用 rte_mempool_get（） 或 rte_mempool_get_bulk（） 时的默认行为为“单使用者”。否则，就是“多消费者”。 |
RTE_MEMPOOL_F_NO_IOVA_CONTIG | 如果设置，分配的对象在 IO 内存中不一定是连续的。 |
成功时返回指向新分配的内存池的指针。错误时返回 NULL并设置rte_errno。 错误码：
错误码 | 含义 |
|---|---|
E_RTE_NO_CONFIG | 函数无法获取指向rte_config结构的指针 |
E_RTE_SECONDARY | 函数从辅助流程实例调用 |
EINVAL | 提供的缓存大小太大，或者priv_size未对齐。 |
ENOSPC | memzone的最大数量已经分配 |
EEXIST | 已存在同名的memzone |
ENOMEM | 没有找到合适的内存区域来创建memzone |
3.11、rte_pktmbuf_pool_create()
创建mbuf池。创建并初始化packet mbuf池；它是rte_mempool的封装器。
函数原型：
代码语言：javascript复制#include <rte_mbuf.h>
struct rte_mempool* rte_pktmbuf_pool_create (
const char *name,
unsigned n,
unsigned cache_size,
uint16_t priv_size,
uint16_t data_room_size,
int socket_id
);成功时，返回指向新分配的内存池的指针。错误时返回 NULL，并设置rte_errno值。
参数：
参数 | 含义 |
|---|---|
name | mbuf 池的名称。 |
n | mbuf 池中的元素数。内存池的最佳大小（就内存使用而言）：n = （2^q - 1）。 |
cache_size | 每核对象缓存的大小。有关详细信息，请参见 rte_mempool_create()。 |
priv_size | 应用程序私有的大小，介于rte_mbuf结构和数据缓冲区之间。此值必须与RTE_MBUF_PRIV_ALIGN对齐。 |
data_room_size | 每个 mbuf 中数据缓冲区的大小，包括RTE_PKTMBUF_HEADROOM。 |
socket_id | 应在其中分配内存的套接字标识符。如果保留区域没有 NUMA 约束，则可以SOCKET_ID_ANY该值。 |
错误码：
错误码 | 含义 |
|---|---|
E_RTE_NO_CONFIG | 函数无法获取指向rte_config结构的指针 |
E_RTE_SECONDARY | 函数从辅助流程实例调用 |
EINVAL | 提供的缓存大小太大，或者priv_size未对齐。 |
ENOSPC | memzone的最大数量已经分配 |
EEXIST | 已存在同名的memzone |
ENOMEM | 没有找到合适的内存区域来创建memzone |
3.12、rte_socket_id()
函数原型：
代码语言：javascript复制#include <rte_Icore.h>
unsigned int rte_socket_id(void);返回正在运行的逻辑核心的物理套接字的ID。 返回当前lcoreid的物理套接字的ID。
3.13、rte_eth_dev_count_avail()
获取应用程序可用的端口数量。 这些设备必须使用宏RTE_ETH_FOREACH_DEV或RTE_ETH_FOREACH_DEV_OWNED_BY来处理非连续范围的设备。 函数原型：
代码语言：javascript复制#include <rte_ethdev.h>
uint16_t rte_eth_dev_count_avail(void );返回可用的以太网设备的数量。
3.14、rte_eth_dev_info_get()
检索以太网设备的上下文信息。 函数原型：
代码语言：javascript复制#include <rte_ethdev.h>
int rte_eth_dev_info_get(uint16_t port_id, struct rte_eth_dev_info * dev_info);参数 | 含义 |
|---|---|
port_id | 以太网设备的端口标识符。 |
dev_info | 指向rte_eth_dev_info类型的结构的指针，以填充以太网设备的上下文信息。 |
返回值 | 含义 |
|---|---|
0 | 成功。 |
ENOTSUP | 设备不支持 dev_infos_get()。 |
ENODEV | port_id无效。 |
EINVAL | 参数错误。 |
3.15、rte_eth_dev_configure()
配置以太网设备。 必须先调用此函数，然后再调用以太网 API 中的任何其他函数。当设备处于停止状态时，也可以重新调用此函数。 函数原型：
代码语言：javascript复制#include <rte_ethdev.h>
int rte_eth_dev_configure(
uint16_t port_id,
uint16_t nb_rx_queue,
uint16_t nb_tx_queue,
const struct rte_eth_conf * eth_conf
);参数说明：
参数 | 含义 |
|---|---|
port_id | 要配置的以太网设备的端口标识符。 |
nb_rx_queue | 要为以太网设备设置的接收队列数。 |
nb_tx_queue | 要为以太网设备设置的传输队列数。 |
eth_conf | 指向要用于以太网设备的配置数据的指针。将所有配置信息嵌入到单个数据结构中是更灵活的方法，允许在不更改 API 语法的情况下添加新功能。 |
返回值：
返回 | 含义 |
|---|---|
0 | 成功，设备已配置。 |
<0 | 驱动程序配置函数返回的错误代码。 |
3.16、rte_eth_dev_socket_id()
函数原型： 返回以太网设备连接到的NUMA套接字。
代码语言：javascript复制#include <rte_ethdev.h>
int rte_eth_dev_socket_id ( uint16_t port_id ) - port_id：以太网设备的端口标识符。
- 返回：以太网设备连接到的NUMA套接字ID，如果无法确定套接字，则默认为零。当port_id值超出范围时返回-1。
3.17、rte_eth_rx_queue_setup()
分配并设置以太网设备的接收队列。 该函数为来自socket_id关联的内存区域的nb_rx_desc接收描述符分配一个连续的内存块，并使用从内存池mb_pool分配的网络缓冲区初始化每个接收描述符。
函数原型：
代码语言：javascript复制#include <rte_ethdev.h>
int rte_eth_rx_queue_setup (
uint16_t port_id,
uint16_t rx_queue_id,
uint16_t nb_rx_desc,
unsigned int socket_id,
const struct rte_eth_rxconf * rx_conf,
struct rte_mempool * mb_pool
);参数 | 含义 |
|---|---|
port_id | 以太网设备的端口标识符。 |
rx_queue_id | 要设置的接收队列的索引。该值必须在之前提供给 rte_eth_dev_configure() 的范围内 [0， nb_rx_queue - 1]。 |
nb_rx_desc | 要为接收环分配的接收描述符数。 |
socket_id | socket_id参数是 NUMA 情况下的套接字标识符。如果为环的接收描述符分配的 DMA 内存没有 NUMA 约束，则可以SOCKET_ID_ANY该值。 |
rx_conf | 指向要用于接收队列的配置数据的指针。允许空值，在这种情况下将使用默认的 Rx 配置。rx_conf结构包含一个rx_thresh结构，其中包含接收环的预取、主机和回写阈值寄存器的值。 |
mb_pool | 指向要从中分配rte_mbuf网络内存缓冲区以填充接收环的每个描述符的内存池的指针。有两个选项可用于提供 Rx 缓冲区配置：（1）mb_pool不为 NULL，rx_conf.rx_nseg 为 0（单个池）。（2）mb_pool为 NULL，rx_conf.rx_seg 不为 NULL，rx_conf.rx_nseg 不是 0（多段描述）。仅当在卸载中设置了标志RTE_ETH_RX_OFFLOAD_BUFFER_SPLIT时才采取。 |
返回值 | 含义 |
|---|---|
0 | 成功，接收队列设置正确。 |
EIO | 设备被移除。 |
ENODEV | port_id无效。 |
EINVAL | 内存池指针为 null，或者可从此内存池分配的网络缓冲区的大小不适合设备控制器允许的各种缓冲区大小。 |
ENOMEM | 初始化接收描述符时，无法分配接收环描述符或从内存池中分配网络内存缓冲区。 |
3.18、rte_eth_tx_queue_setup()
分配并设置以太网设备的传输队列。 函数原型：
代码语言：javascript复制#include <rte_ethdev.h>
int rte_eth_tx_queue_setup (
uint16_t port_id,
uint16_t tx_queue_id,
uint16_t nb_tx_desc,
unsigned int socket_id,
const struct rte_eth_txconf * tx_conf
);成功，返回0，发送队列正确建立。 失败，返回-ENOMEM，无法分配传输环描述符。
参数 | 含义 |
|---|---|
port_id | 以太网设备的端口标识符。 |
tx_queue_id | 要设置的传输队列的索引。该值必须在之前提供给 rte_eth_dev_configure（） 的范围内 [0， nb_tx_queue - 1]。 |
nb_tx_desc | 要为传输环分配的传输描述符的数量。 |
socket_id | socket_id参数是 NUMA 情况下的套接字标识符。如果为环的传输描述符分配的 DMA 内存没有 NUMA 约束，则可以SOCKET_ID_ANY其值。 |
tx_conf | 指向要用于传输队列的配置数据的指针。允许使用 NULL 值，在这种情况下，将使用默认的 Tx 配置。 |
3.19、rte_eth_dev_start()
启动以太网设备。 设备启动步骤是最后一个步骤，包括设置配置的卸载功能以及启动设备的发送和接收单元。 设备RTE_ETH_DEV_NOLIVE_MAC_ADDR标志会导致在调用 PMD 端口启动回调函数之前设置 MAC 地址。 成功后，可以调用以太网 API 导出的所有基本功能（链路状态、接收/传输等）。
函数原型：
代码语言：javascript复制#include <rte_ethdev.h>
int rte_eth_dev_start(uint16_t port_id);- 成功返回0；
- 失败返回负数。
3.20、rte_eth_macaddr_get()
获取以太网设备MAC地址。
代码语言：javascript复制#include <rte_ethdev.h>
int rte_eth_macaddr_get (uint16_t port_id, struct rte_ether_addr *mac_addr); - port_id：以太网设备的端口标识符。
- mac_addr：存放mac地址的地址指针。
返回值 | 含义 |
|---|---|
0 | 成功 |
ENODEV | port_id无效。 |
EINVAL | 无效参数 |
3.21、rte_eth_rx_burst()
返回实际检索到的数据包数，即有效提供给rx_pkts数组的rte_mbuf数据结构数。返回值等于 nb_pkts 表示 Rx 队列至少包含 rx_pkts 数据包，这可能表示其他接收的数据包仍保留在输入队列中。
函数不提供任何错误通知，以避免相应的开销。作为提示，一旦系统地返回给定尝试次数的 0 值，上层应用程序可能会检查设备链接的状态。
函数原型：
代码语言：javascript复制static uint16_t rte_eth_rx_burst (
uint16_t port_id,
uint16_t queue_id,
struct rte_mbuf ** rx_pkts,
const uint16_t nb_pkts
);参数 | 含义 |
|---|---|
port_id | 以太网设备的端口标识符。 |
queue_id | 要从中检索输入数据包的接收队列的索引。该值必须在之前提供给 rte_eth_dev_configure（） 的范围内 [0， nb_rx_queue - 1]。 |
rx_pkts | 指向rte_mbuf结构的指针数组的地址，这些结构必须足够大才能在其中存储nb_pkts指针。 |
nb_pkts | 要检索的最大数据包数。该值必须可被 8 整除才能与任何驱动程序一起使用。 |
返回实际检索到的数据包数，即指向有效提供给rx_pkts阵列rte_mbuf结构的指针数。
3.22、rte_pktmbuf_mtod_offset()
指向mbuf中数据偏移量的宏。 函数原型：
代码语言：javascript复制#include <rte_mbuf_core.h>
#define rte_pktmbuf_mtod_offset (m, t, o ) ((t)(void *)((char *)(m)->buf_addr (m)->data_off (o)))返回的指针被强制转换为t类型。在使用这个函数之前，用户必须确保第一个段足够大以容纳它的数据。
参数：
- m：mbuf数据结构包。
- t：要强制转换的类型。
- o：偏移位置。
3.23、rte_pktmbuf_mtod()
指向mbuf中数据开始的宏。 函数原型：
代码语言：javascript复制#include <rte_mbuf_core.h>
#define rte_pktmbuf_mtod (m,t ) rte_pktmbuf_mtod_offset(m, t, 0)- m：mbuf数据结构包。
- t：要强制转换的类型。
返回的指针被强制转换为t类型。在使用这个函数之前，用户必须确保第一个段足够大以容纳它的数据。
3.24、rte_cpu_to_be_16()
将一个16位的值从CPU顺序转换为大端序。 函数原型：
代码语言：javascript复制#include <rte_byteorder.h>
static rte_be16_t rte_cpu_to_be_16(uint16_t x);3.25、rte_memcpy()
将字节从一个位置复制到另一个位置，位置不能重叠。 返回指向目标数据的指针。 函数原型：
代码语言：javascript复制#include <rte_memcpy.h>
static void* rte_memcpy (
void * dst,
const void * src,
size_t n
);注意： （1）这是作为宏实现的，因此不应获取其地址，并且需要小心，因为参数表达式可能会被多次计算。 （2）对于要启用 AVX-512 memcpy 实现的 x86 平台，请在 CFLAGS 中设置 -DRTE_MEMCPY_AVX512 宏，或者在包含rte_memcpy头文件之前在源文件中显式定义RTE_MEMCPY_AVX512宏。
参数 | 含义 |
|---|---|
dst | 指向数据目标的指针。 |
src | 指向源数据的指针。 |
n | 要复制的字节数。 |
3.26、rte_pktmbuf_alloc()
从内存池分配一个新的mbuf。 这个新的mbuf包含一个长度为0的段。指向数据的指针被初始化为在缓冲区中有一些字节的净空空间(如果缓冲区大小允许)。
代码语言：javascript复制#include <rte_mbuf.h>
static struct rte_mbuf* rte_pktmbuf_alloc(struct rte_mempool * mp);- mp：分配mbuf的内存池。
- 成功返回新的mbuf指针。
- 失败返回NULL。
3.27、rte_eth_tx_burst()
在以太网设备的传输队列上发送突发输出数据包。
代码语言：javascript复制#include <rte_ethdev.h>
static uint16_t rte_eth_tx_burst(
uint16_t port_id,
uint16_t queue_id,
struct rte_mbuf ** tx_pkts,
uint16_t nb_pkts
);```
| 参数 | 含义 |
|--|--|
|port_id |以太网设备的端口标识符。
|queue_id |必须通过其发送输出数据包的传输队列的索引。该值必须在之前提供给 rte_eth_dev_configure（） 的范围内 [0， nb_tx_queue - 1]。
|tx_pkts |指向包含输出数据包的rte_mbuf结构的nb_pkts指针数组的地址。
|nb_pkts| 要传输的最大数据包数。
**返回实际存储在传输环的传输描述符中的输出数据包数。当传输环已满或已满时，返回值可以小于tx_pkts参数的值。**
## 3.28、rte_pktmbuf_free()
将数据包 mbuf 释放回其原始内存池。
释放 mbuf 及其所有段，以防出现链接缓冲区。每个段都会添加回其原始内存池中。
函数原型：
```c
#include <rte_mbuf.h>
static void rte_pktmbuf_free ( struct rte_mbuf * m ) m：要释放的数据包 mbuf。如果为 NULL，则该函数不执行任何操作。
3.29、DPDK定义的协议头
3.29.1、rte_ether_hdr
以太网报头:包含目的地址、源地址和帧类型。
代码语言：javascript复制#include <rte_ether.h>
#define RTE_ETHER_ADDR_LEN 6
typedef uint16_t rte_be16_t
struct rte_ether_addr{
uint8_t addr_bytes [RTE_ETHER_ADDR_LEN];
};
struct rte_ether_hdr{
struct rte_ether_addr dst_addr;
struct rte_ether_addr src_addr;
rte_be16_t ether_type;
};3.29.2、rte_ipv4_hdr
IPv4 Header
代码语言：javascript复制#include <rte_ip.h>
struct rte_ipv4_hdr {
__extension__
union {
uint8_t version_ihl;
struct {
#if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
uint8_t ihl:4;
uint8_t version:4;
#elif RTE_BYTE_ORDER == RTE_BIG_ENDIAN
uint8_t version:4;
uint8_t ihl:4;
#endif
};
};
uint8_t type_of_service;
rte_be16_t total_length;
rte_be16_t packet_id;
rte_be16_t fragment_offset;
uint8_t time_to_live;
uint8_t next_proto_id;
rte_be16_t hdr_checksum;
rte_be32_t src_addr;
rte_be32_t dst_addr;
} __rte_packed;3.29.3、rte_udp_hdr
UDP Header
代码语言：javascript复制#include <rte_udp.h>
struct rte_udp_hdr {
rte_be16_t src_port;
rte_be16_t dst_port;
rte_be16_t dgram_len;
rte_be16_t dgram_cksum;
} __rte_packed;3.29.4、rte_tcp_hdr
TCP Header
代码语言：javascript复制#include <rte_tcp.h>
struct rte_tcp_hdr {
rte_be16_t src_port;
rte_be16_t dst_port;
rte_be32_t sent_seq;
rte_be32_t recv_ack;
uint8_t data_off;
uint8_t tcp_flags;
rte_be16_t rx_win;
rte_be16_t cksum;
rte_be16_t tcp_urp;
} __rte_packed;四、代码实践：DPDK实现协议栈
以TCP/UDP为例，实现一个简单示例。 主要有如下实现步骤： （1）初始化EA。 （2）创建mbuf内存池 （3）配置以太网设备端口。 （4）设置以太网收发队列 （4）开启以太网设备 （5）收取网络数据包；协议解析。 （6）发送网络数据包；协议打包。 实现代码如下：
代码语言：javascript复制#include <rte_eal.h>
#include <rte_ethdev.h>
#include <rte_mbuf.h>
#include <stdio.h>
#include <arpa/inet.h>
#define ENABLE_SEND 1
#define ENABLE_ARP 1
#define ENABLE_TCP 1
#define TCP_MAX_SEQ 4294967295
#define NUM_MBUFS (4096-1)
#define BURST_SIZE 32
#if ENABLE_SEND
static uint32_t gSrcIp; //
static uint32_t gDstIp;
static uint8_t gSrcMac[RTE_ETHER_ADDR_LEN];
static uint8_t gDstMac[RTE_ETHER_ADDR_LEN];
static uint16_t gSrcPort;
static uint16_t gDstPort;
#endif
#if ENABLE_TCP
uint32_t seqnum;
uint32_t acknum = 0;
uint8_t flag;
#endif
int gDpdkPortId = 0;
static const struct rte_eth_conf port_conf_default = {
.rxmode = {.max_rx_pkt_len = RTE_ETHER_MAX_LEN }
};
static void ng_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 Supported eth foundn");
}
// 检索以太网设备的上下文信息
struct rte_eth_dev_info dev_info;
rte_eth_dev_info_get(gDpdkPortId, &dev_info); //
// 配置以太网设备
const int num_rx_queues = 1;
const int num_tx_queues = 1;
struct rte_eth_conf port_conf = port_conf_default;
rte_eth_dev_configure(gDpdkPortId, num_rx_queues, num_tx_queues, &port_conf);
//分配并设置以太网设备的接收队列。
if (rte_eth_rx_queue_setup(gDpdkPortId, 0 , 1024,
rte_eth_dev_socket_id(gDpdkPortId),NULL, mbuf_pool) < 0) {
rte_exit(EXIT_FAILURE, "Could not setup RX queuen");
}
#if ENABLE_SEND
// 分配并设置以太网设备的传输队列。
struct rte_eth_txconf txq_conf = dev_info.default_txconf;
txq_conf.offloads = port_conf.rxmode.offloads;
if (rte_eth_tx_queue_setup(gDpdkPortId, 0 , 1024,
rte_eth_dev_socket_id(gDpdkPortId), &txq_conf) < 0) {
rte_exit(EXIT_FAILURE, "Could not setup TX queuen");
}
#endif
//启动以太网设备
if (rte_eth_dev_start(gDpdkPortId) < 0 ) {
rte_exit(EXIT_FAILURE, "Could not startn");
}
}
static int ng_encode_udp_pkt(uint8_t *msg, unsigned char *data, uint16_t total_len) {
// encode
// 1 ethhdr
struct rte_ether_hdr *eth = (struct rte_ether_hdr *)msg;
rte_memcpy(eth->s_addr.addr_bytes, gSrcMac, RTE_ETHER_ADDR_LEN);
rte_memcpy(eth->d_addr.addr_bytes, gDstMac, RTE_ETHER_ADDR_LEN);
eth->ether_type = htons(RTE_ETHER_TYPE_IPV4);
// 2 iphdr
struct rte_ipv4_hdr *ip = (struct rte_ipv4_hdr *)(msg sizeof(struct rte_ether_hdr));
ip->version_ihl = 0x45;
ip->type_of_service = 0;
ip->total_length = htons(total_len - sizeof(struct rte_ether_hdr));
ip->packet_id = 0;
ip->fragment_offset = 0;
ip->time_to_live = 64; // ttl = 64
ip->next_proto_id = IPPROTO_UDP;
ip->src_addr = gSrcIp;
ip->dst_addr = gDstIp;
ip->hdr_checksum = 0;
ip->hdr_checksum = rte_ipv4_cksum(ip);
// 3 udphdr
struct rte_udp_hdr *udp = (struct rte_udp_hdr *)(msg sizeof(struct rte_ether_hdr) sizeof(struct rte_ipv4_hdr));
udp->src_port = gSrcPort;
udp->dst_port = gDstPort;
uint16_t udplen = total_len - sizeof(struct rte_ether_hdr) - sizeof(struct rte_ipv4_hdr);
udp->dgram_len = htons(udplen);
rte_memcpy((uint8_t*)(udp 1), data, udplen);
udp->dgram_cksum = 0;
udp->dgram_cksum = rte_ipv4_udptcp_cksum(ip, udp);
struct in_addr addr;
addr.s_addr = gSrcIp;
printf(" --> src: %s:%d, ", inet_ntoa(addr), ntohs(gSrcPort));
addr.s_addr = gDstIp;
printf("dst: %s:%dn", inet_ntoa(addr), ntohs(gDstPort));
return 0;
}
static struct rte_mbuf * ng_send(struct rte_mempool *mbuf_pool, uint8_t *data, uint16_t length) {
// mempool --> mbuf
const unsigned total_len = length 42;
// 从内存池分配一个新的mbuf。
struct rte_mbuf *mbuf = rte_pktmbuf_alloc(mbuf_pool);
if (!mbuf) {
rte_exit(EXIT_FAILURE, "rte_pktmbuf_allocn");
}
mbuf->pkt_len = total_len;
mbuf->data_len = total_len;
// 从mbuf中提取出pktdata
uint8_t *pktdata = rte_pktmbuf_mtod(mbuf, uint8_t*);
ng_encode_udp_pkt(pktdata, data, total_len);
return mbuf;
}
static int ng_encode_tcp_pkt(uint8_t *msg) {
// encode
// 1 ethhdr
struct rte_ether_hdr *eth = (struct rte_ether_hdr *)msg;
rte_memcpy(eth->s_addr.addr_bytes, gSrcMac, RTE_ETHER_ADDR_LEN);
rte_memcpy(eth->d_addr.addr_bytes, gDstMac, RTE_ETHER_ADDR_LEN);
eth->ether_type = htons(RTE_ETHER_TYPE_IPV4);
// 2 iphdr
struct rte_ipv4_hdr *ip = (struct rte_ipv4_hdr *)(msg sizeof(struct rte_ether_hdr));
ip->version_ihl = 0x45;
ip->type_of_service = 0;
ip->total_length = htons(sizeof(struct rte_ipv4_hdr) sizeof(struct rte_tcp_hdr));
ip->packet_id = 0;
ip->fragment_offset = 0;
ip->time_to_live = 64; // ttl = 64
ip->next_proto_id = IPPROTO_UDP;
ip->src_addr = gSrcIp;
ip->dst_addr = gDstIp;
ip->hdr_checksum = 0;
ip->hdr_checksum = rte_ipv4_cksum(ip);
// 3 tcphdr
struct rte_tcp_hdr *tcp = (struct rte_tcp_hdr *)(msg sizeof(struct rte_ether_hdr) sizeof(struct rte_ipv4_hdr));
tcp->src_port = gSrcPort;
tcp->dst_port = gDstPort;
//seqnum:代表对方发送数据的索引号
//acknum : 代表对方已收到我方数据的索引号。
uint32_t seed = time(NULL);
tcp->sent_seq = rand_r(&seed);//acknum表示我方应答字节序
tcp->recv_ack = seqnum;//seqnum表示应答对方的字节序
tcp->data_off = 0x50;
tcp->rx_win = 1024;
tcp->tcp_urp = 0;
tcp->tcp_flags = RTE_TCP_SYN_FLAG | RTE_TCP_ACK_FLAG;
tcp->cksum = 0;
tcp->cksum = rte_ipv4_udptcp_cksum(ip, tcp);
return 0;
}
static struct rte_mbuf * ng_send_tcp(struct rte_mempool *mbuf_pool) {
// mempool --> mbuf
const unsigned total_len = sizeof(struct rte_ether_hdr) sizeof(struct rte_ipv4_hdr) sizeof(struct rte_tcp_hdr);
// 从内存池分配一个新的mbuf。
struct rte_mbuf *mbuf = rte_pktmbuf_alloc(mbuf_pool);
if (!mbuf) {
rte_exit(EXIT_FAILURE, "rte_pktmbuf_allocn");
}
mbuf->pkt_len = total_len;
mbuf->data_len = total_len;
// 从mbuf中提取出pktdata
uint8_t *pktdata = rte_pktmbuf_mtod(mbuf, uint8_t*);
ng_encode_tcp_pkt(pktdata);
return mbuf;
}
int main(int argc, char *argv[]) {
//EAL初始化
if (rte_eal_init(argc, argv) < 0) {
rte_exit(EXIT_FAILURE, "Error with EAL initn");
}
//创建并初始化packet mbuf池
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 pooln");
}
ng_init_port(mbuf_pool);
//获取以太网设备的mac地址
rte_eth_macaddr_get(gDpdkPortId, (struct rte_ether_addr *)gSrcMac);
while (1) {
//从以太网设备的接收队列中检索突发的输入数据包。检索到的数据包存储在rte_mbuf结构中
struct rte_mbuf *mbufs[BURST_SIZE];
unsigned num_recvd = rte_eth_rx_burst(gDpdkPortId, 0, mbufs, BURST_SIZE);
if (num_recvd > BURST_SIZE) {
rte_exit(EXIT_FAILURE, "Error receiving from ethn");
}
unsigned i = 0;
for (i = 0;i < num_recvd;i ) {
// 将mbufs数据包中的以太网头提取出来
struct rte_ether_hdr *ehdr = rte_pktmbuf_mtod(mbufs[i], struct rte_ether_hdr*);
//将一个16位的值从CPU顺序转换为大端序
if (ehdr->ether_type != rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)) {
continue;
}
// 将mbufs数据包中的ipv4头提取出来
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);
#if ENABLE_SEND //
rte_memcpy(gDstMac, ehdr->s_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
rte_memcpy(&gSrcIp, &iphdr->dst_addr, sizeof(uint32_t));
rte_memcpy(&gDstIp, &iphdr->src_addr, sizeof(uint32_t));
rte_memcpy(&gSrcPort, &udphdr->dst_port, sizeof(uint16_t));
rte_memcpy(&gDstPort, &udphdr->src_port, sizeof(uint16_t));
#endif
uint16_t length = ntohs(udphdr->dgram_len);
*((char*)udphdr length) = ' ';
struct in_addr addr;
addr.s_addr = iphdr->src_addr;
printf("src: %s:%d, ", inet_ntoa(addr), ntohs(udphdr->src_port));
addr.s_addr = iphdr->dst_addr;
printf("dst: %s:%d, %sn", inet_ntoa(addr), ntohs(udphdr->dst_port),
(char *)(udphdr 1));
#if ENABLE_SEND
struct rte_mbuf *txbuf = ng_send(mbuf_pool, (uint8_t *)(udphdr 1), length);
rte_eth_tx_burst(gDpdkPortId, 0, &txbuf, 1);
rte_pktmbuf_free(txbuf);
#endif
rte_pktmbuf_free(mbufs[i]);
}
else if (iphdr->next_proto_id == IPPROTO_TCP)
{
struct rte_tcp_hdr *tcphdr = (struct rte_tcp_hdr *)(iphdr 1);
#if ENABLE_SEND //
rte_memcpy(gDstMac, ehdr->s_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
rte_memcpy(&gSrcIp, &iphdr->dst_addr, sizeof(uint32_t));
rte_memcpy(&gDstIp, &iphdr->src_addr, sizeof(uint32_t));
rte_memcpy(&gSrcPort, &tcphdr->dst_port, sizeof(uint16_t));
rte_memcpy(&gDstPort, &tcphdr->src_port, sizeof(uint16_t));
#endif
if (tcphdr->tcp_flags & RTE_TCP_SYN_FLAG)
{
//第一次握手
seqnum = ntohl(tcphdr->sent_seq) 1;
struct rte_mbuf *txbuf = ng_send_tcp(mbuf_pool);
rte_eth_tx_burst(gDpdkPortId, 0, &txbuf, 1);
rte_pktmbuf_free(txbuf);
rte_pktmbuf_free(mbufs[i]);
}else if(tcphdr->tcp_flags & RTE_TCP_ACK_FLAG)
{
// 处理第三次
}
struct in_addr addr;
addr.s_addr = iphdr->src_addr;
printf("tcp src: %s:%d, ", inet_ntoa(addr), ntohs(tcphdr->src_port));
addr.s_addr = iphdr->dst_addr;
printf("tcp dst: %s:%d,seqnum: %u, flag: %xn", inet_ntoa(addr), ntohs(tcphdr->dst_port),
seqnum, tcphdr->tcp_flags);
}
}
}
}总结
dpdk可以实现旁路获取网络数据包，获取到的原始数据可以用户实现协议栈，以太网协议的解析 --> IP协议解析–>TCP/UDP解析等等。 在进行协议栈调试时，可以使用wareshare工具抓包分析。 DPDK实现协议栈的框图如下：
图片
