一些示例
基于dpdk-22.11
udp
udp_resv.c
#include <stdint.h>
#include <stdlib.h>
#include <inttypes.h>
#include <rte_eal.h>
#include <rte_ethdev.h>
#include <rte_cycles.h>
#include <rte_lcore.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 const struct rte_eth_conf port_conf_default ;
int
main(int argc, char *argv[])
{
struct rte_mempool *mbuf_pool;
unsigned nb_ports;
uint16_t portid = 0;
uint16_t nb_rx_q = 1;
uint16_t nb_tx_q = 0;
int ret = rte_eal_init(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
nb_ports = rte_eth_dev_count_avail();
// if (nb_ports < 2 || (nb_ports & 1))
// rte_exit(EXIT_FAILURE, "Error: number of ports must be even\n");
mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", NUM_MBUFS * nb_ports,
MBUF_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
if (mbuf_pool == NULL)
rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
int retval = rte_eth_dev_configure(portid, nb_rx_q, nb_tx_q, &port_conf_default);
if (retval != 0)
rte_exit(EXIT_FAILURE, "Error with eth dev configure\n");
retval = rte_eth_rx_queue_setup(portid, 0, 128,
rte_eth_dev_socket_id(portid), NULL, mbuf_pool);
if (retval < 0)
rte_exit(EXIT_FAILURE, "Error with rx queue setup\n");
retval = rte_eth_dev_start(portid);
if (retval < 0)
rte_exit(EXIT_FAILURE, "Error with eth dev start\n");
retval = rte_eth_promiscuous_enable(portid);
if (retval != 0)
rte_exit(EXIT_FAILURE, "Error with eth promiscuous enable\n");
for (;;) {
struct rte_mbuf *bufs[BURST_SIZE];
const uint16_t nb_rx = rte_eth_rx_burst(portid, 0,
bufs, BURST_SIZE);
if (unlikely(nb_rx == 0))
continue;
if (nb_rx > BURST_SIZE)
rte_exit(EXIT_FAILURE, "Error with rte_eth_rx_burst\n");
uint16_t i = 0;
for ( i = 0; i < nb_rx; i++)
{
struct rte_ether_hdr *ehdr = rte_pktmbuf_mtod(bufs[i], struct rte_ether_hdr *);
if (ehdr->ether_type != rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4))
{
continue;
}
struct rte_ipv4_hdr * iphdr = rte_pktmbuf_mtod_offset(bufs[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);
uint16_t length = udphdr->dgram_len;
*(char *)(udphdr + length-1) = '\0';
printf("udp: %s\n", (char *)(udphdr+1));
}
}
}
if (rte_lcore_count() > 1)
printf("\nWARNING: Too many lcores enabled. Only 1 used.\n");
rte_eal_cleanup();
return 0;
}
udp_resv2.c
// ****************************************************************************
// This example shows how to recv some packets.
// ****************************************************************************
// Check it works by sending some packets from another machine, eg:
// ping <destination address>
// DPDK headers
#include <rte_eal.h>
#include <rte_ethdev.h>
#include <rte_mbuf.h>
// Standard headers
#include <stdio.h>
// ****************************************************************************
// Tweak these values if you want.
// ****************************************************************************
// I believe that when packets arrive at the NIC, they are put into the RX ring
// and remain there until rte_eth_rx_burst() is called. So the size of the ring
// must be calculated based on the max time between calls to rte_eth_rx_burst()
// and the max packets per second you expect to handle.
#define RX_RING_SIZE 128
// DPDK has a pool allocator. Every "mbuf" holds one packets. This specifies
// how many packets are in the pool. I think this includes all those in the TX
// and RX rings, plus any that are currently in the hands of the application.
#define NUM_MBUFS 8191
// This value is probably irrelevant in this single threaded app. See
// the docs for the cache_size param of rte_mempool_create().
#define MBUF_CACHE_SIZE 0
// Everyone seems to use 32. Nobody seems to know why.
#define BURST_SIZE 32
// ****************************************************************************
// Do not tweak these values.
// ****************************************************************************
// DPDK supports many queues per port. Simple apps only need one TX queue and
// one RX queue. You only need more than one if you are doing something like
// scatter/gather.
#define DPDK_QUEUE_ID_RX 0
// In DPDK, a "port" is a NIC. We will use the first NIC DPDK finds.
int g_dpdkPortId = -1;
static const struct rte_eth_conf port_conf_default;
static void port_init(struct rte_mempool *mbuf_pool) {
// Find the first free DPDK enabled network interface. When running on
// Azure, the TAP PMD and MLX4 PMD will both advertise a port. We must not
// use them directly. Instead we want the fail-safe PMD which sits on top
// of them. The fail-safe will already have taken ownership of the TAP and
// MLX4 PMDs, so we won't see them as available in this loop.
g_dpdkPortId = 0;
// Configure the Ethernet device.
const int num_rx_queues = 1;
const int num_tx_queues = 0;
struct rte_eth_conf port_conf = port_conf_default;
if (rte_eth_dev_configure(g_dpdkPortId, num_rx_queues, num_tx_queues, &port_conf)) {
rte_exit(EXIT_FAILURE, "rte_eth_dev_configure() failed.\n");
}
// Set up RX queue.
if (rte_eth_rx_queue_setup(g_dpdkPortId, DPDK_QUEUE_ID_RX, RX_RING_SIZE,
rte_eth_dev_socket_id(g_dpdkPortId), NULL, mbuf_pool) < 0) {
rte_exit(EXIT_FAILURE, "Couldn't setup RX queue.\n");
}
// Start the Ethernet port.
if (rte_eth_dev_start(g_dpdkPortId) < 0) {
rte_exit(EXIT_FAILURE, "Device start failed.\n");
}
// Enable RX in promiscuous mode for the Ethernet device.
rte_eth_promiscuous_enable(g_dpdkPortId);
}
int main(int argc, char *argv[]) {
// Initialize the Environment Abstraction Layer. All DPDK apps must do this.
if (rte_eal_init(argc, argv) < 0) {
rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
}
// Creates a new mempool in memory to hold the mbufs.
struct rte_mempool *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) {
rte_exit(EXIT_FAILURE, "Couldn't create mbuf pool\n");
}
port_init(mbuf_pool);
while (1) {
struct rte_mbuf *mbufs[BURST_SIZE];
unsigned num_recvd = rte_eth_rx_burst(g_dpdkPortId, DPDK_QUEUE_ID_RX, mbufs, BURST_SIZE);
for (unsigned i = 0; i < num_recvd; i++) {
printf("Received packet: ");
// Print 10 bytes of UDP payload (without checking the packet is UDP).
char const *pack_data = rte_pktmbuf_mtod(mbufs[i], char const *);
for (int j = 42; j < 52; j++) {
putchar(pack_data[j]);
}
putchar('\n');
rte_pktmbuf_free(mbufs[i]);
}
}
return 0;
}
udp_send.c
// 标准C库头文件
#include <stdio.h> // 标准输入输出库
#include <stdlib.h> // 标准库，包含内存分配、进程控制等
#include <stdint.h> // 定义固定大小的整数类型
#include <inttypes.h> // 提供用于格式化固定大小整数类型的宏
#include <string.h> // 字符串处理函数库
#include <stdarg.h> // 用于处理变长参数的宏
#include <errno.h> // 错误号处理
#include <stdbool.h> // 布尔类型定义
#include <time.h> // 时间处理函数
#include <sys/types.h> // 定义数据类型，如`size_t`，`ssize_t`
#include <linux/if_ether.h> // 以太网常量
// Linux系统库头文件
#include <sys/queue.h> // 定义队列和链表的宏和类型
#include <getopt.h> // 命令行选项解析
#include <signal.h> // 信号处理库
#include <sys/time.h> // 获取时间的库函数（用于高精度时间）
// DPDK 核心库头文件
#include <rte_common.h> // DPDK中的通用定义
#include <rte_log.h> // DPDK日志系统
#include <rte_memory.h> // DPDK内存管理相关函数
#include <rte_memcpy.h> // 高效的内存拷贝函数
#include <rte_memzone.h> // DPDK内存区域管理
#include <rte_malloc.h> // DPDK内存分配函数
#include <rte_ring.h> // DPDK环形缓冲区
#include <rte_mempool.h> // DPDK内存池管理
#include <rte_mbuf.h> // DPDK数据包缓冲区结构和操作
// DPDK 环境初始化库头文件
#include <rte_eal.h> // DPDK环境抽象层（EAL）初始化
#include <rte_per_lcore.h> // DPDK每核特定变量
#include <rte_launch.h> // 启动函数
#include <rte_atomic.h> // 原子操作
#include <rte_spinlock.h> // 自旋锁
#include <rte_cycles.h> // CPU周期数函数
#include <rte_prefetch.h> // 缓存预取函数
#include <rte_lcore.h> // 核心绑定函数
#include <rte_branch_prediction.h> // 分支预测优化
#include <rte_interrupts.h> // 中断处理
#include <rte_pci.h> // PCI设备管理
#include <rte_random.h> // 随机数生成
#include <rte_debug.h> // 调试相关功能
// DPDK 网络相关头文件
#include <rte_ether.h> // 以太网帧的定义和处理
#include <rte_ethdev.h> // DPDK中的以太网设备驱动
// DPDK IP、TCP、UDP协议栈相关头文件
#include <rte_ip.h> // IP协议处理
#include <rte_tcp.h> // TCP协议处理
#include <rte_udp.h> // UDP协议处理
// DPDK 字符串操作头文件
#include <rte_string_fns.h> // 字符串处理函数库
// IP地址 UDP端口
#define IP_SRC_ADDR ((192U << 24) | (168 << 16) | (131 << 8) | 152)
#define IP_DST_ADDR ((192U << 24) | (168 << 16) | (131 << 8) | 130)
#define UDP_SRC_PORT 1024
#define UDP_DST_PORT 1024
#define MAX_PKT_BURST 32
#define RX_RING_SIZE 128 //发送环形缓冲区
#define NUM_MBUFS 8191 //数据包缓冲池
#define MBUF_CACHE_SIZE 256 //内存池中每个缓存的大小(以数据包为单位)
#define BURST_SIZE 32 //批量处理的大小
#define SEND_TOTAL 1 //发送
#define IP_DEFTTL 64
#define IP_VERSION 0x40
#define IP_HDRLEN 0x05 //默认头部为20字节
static volatile bool force_quit;//程序强制退出标识符
struct rte_mempool *pktmbuf_pool;
struct rte_mbuf *mbuf_list[MAX_PKT_BURST];//对应的rte_mbuf结构指针数组。32
static struct rte_ipv4_hdr pkt_ip_hdr;
static struct rte_udp_hdr pkt_udp_hdr;
struct rte_ether_addr des_eth_addrs;//目的mac
struct rte_ether_addr src_eth_addrs;//源mac
struct rte_ether_addr eth_addrs;
unsigned socket_id;
unsigned port_id;
unsigned lcore_id;
unsigned rx_queue_id;
unsigned tx_queue_id;
uint32_t send_total = 0;
rte_spinlock_t spinlock_conf = RTE_SPINLOCK_INITIALIZER; //自旋锁，来保证对一个网口竞争访问；
static const struct rte_eth_conf port_conf_default;
char buf[64]="Partial string initialization";
static void signal_handler(int signum)
{
if (signum == SIGINT || signum == SIGTERM) {
printf("\n\nSignal %d received, preparing to exit...\n",
signum);
force_quit = true;
}
}
static void print_ethaddr(const char *name, const struct ether_addr *eth_addr)
{
char buf[48];
rte_ether_format_addr(buf, 48, eth_addr);
printf("%s%s \n", name, buf);
}
// 设置并初始化 IPv4 和 UDP 的头部信息
static void setup_pkt_udp_ip_headers(struct rte_ipv4_hdr *ip_hdr,
struct rte_udp_hdr *udp_hdr,uint16_t pkt_data_len)
{
uint16_t pkt_len;
// 初始化UDP头部
pkt_len = (uint16_t)(pkt_data_len + sizeof(struct rte_udp_hdr));
udp_hdr->src_port = rte_cpu_to_be_16(UDP_SRC_PORT);
udp_hdr->dst_port = rte_cpu_to_be_16(UDP_DST_PORT);
udp_hdr->dgram_len = rte_cpu_to_be_16(pkt_len);
udp_hdr->dgram_cksum = 0; // 不使用UDP校验
// 初始化IP头部
pkt_len = (uint16_t) (pkt_len + sizeof(struct rte_ipv4_hdr));
ip_hdr->version_ihl =IP_VERSION|IP_HDRLEN;
ip_hdr->type_of_service = 0;
ip_hdr->fragment_offset = 0;
ip_hdr->time_to_live = IP_DEFTTL;
ip_hdr->next_proto_id = IPPROTO_UDP;
ip_hdr->packet_id = 0;
ip_hdr->total_length = rte_cpu_to_be_16(pkt_len);
ip_hdr->src_addr = rte_cpu_to_be_32(IP_SRC_ADDR); // 换为网络字节序
ip_hdr->dst_addr = rte_cpu_to_be_32(IP_DST_ADDR);
// IP 首部校验和
ip_hdr->hdr_checksum = 0;
uint32_t ip_cksum = 0;
// 将 IP 头部作为 16 位无符号整数数组处理
uint16_t *ptr16 = (uint16_t *)ip_hdr;
for (int i = 0; i < sizeof(struct rte_ipv4_hdr) / 2; i++) {
if (i != 5) { // 校验和字段需要跳过
ip_cksum += ptr16[i];
}
}
// 循环进位，将结果压缩为 16 位并处理溢出。
while (ip_cksum >> 16) {
ip_cksum = (ip_cksum & 0xFFFF) + (ip_cksum >> 16);
}
ip_hdr->hdr_checksum = (uint16_t)(~ip_cksum & 0xFFFF);
}
// 将一个内存缓冲区的内容（buf）拷贝到一个 DPDK 的数据包缓冲区中的多个片段中
static void copy_buf_to_pkt_segs(void *buf, unsigned len,
struct rte_mbuf *pkt, unsigned offset)
{
struct rte_mbuf *seg = pkt;
unsigned copy_len;
void *seg_buf;
// 定位到正确的片段
while (offset >= seg->data_len) {
offset -= seg->data_len;
seg = seg->next;
}
// 从当前片段开始拷贝数据
while (len > 0) {
// 计算当前片段中需要拷贝的数据长度
copy_len = seg->data_len - offset;
if (len < copy_len) {
copy_len = len;
}
seg_buf = rte_pktmbuf_mtod_offset(seg, char *, offset);
rte_memcpy(seg_buf, buf, copy_len);
len -= copy_len;
buf = (char *)buf + copy_len;
offset = 0;
if (len > 0) {
seg = seg->next;
if (seg == NULL) {
break; // 防止访问空片段
}
}
}
}
static inline void copy_buf_to_pkt(void* buf, unsigned len,
struct rte_mbuf *pkt, unsigned offset)
{
if (offset + len <= pkt->data_len) {
rte_memcpy(rte_pktmbuf_mtod_offset(pkt, char *, offset),buf, (size_t) len);
return;
}
// 处理跨多个片段的拷贝操作
copy_buf_to_pkt_segs(buf, len, pkt, offset);
}
// 创建一组数据包缓冲区
static void create_pkt_mbuf_array(){
struct rte_mbuf *pkt;
struct rte_ether_hdr eth_hdr;
unsigned pkt_data_len = sizeof(struct rte_ether_hdr) +
sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + sizeof(buf);
for (uint16_t i = 0; i <MAX_PKT_BURST ; i++)
{
// 分配一个buf
pkt = rte_mbuf_raw_alloc(pktmbuf_pool);
if (pkt == NULL) {
printf("error: no enough pool!\n");
continue; // 处理分配失败情况，继续下一个循环
}
// 重置pkt头部空间
rte_pktmbuf_reset_headroom(pkt);
pkt->data_len = pkt_data_len;
pkt->next = NULL;
// 设置以太网头部
rte_ether_addr_copy(&des_eth_addrs, ð_hdr.dst_addr);
rte_ether_addr_copy(&src_eth_addrs, ð_hdr.src_addr);
eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
// copy 这里优化可以使用dpdk的函数
copy_buf_to_pkt(ð_hdr, sizeof(eth_hdr), pkt, 0); // Eth
copy_buf_to_pkt(&pkt_ip_hdr, sizeof(pkt_ip_hdr), pkt, sizeof(struct rte_ether_hdr)); // IP header
copy_buf_to_pkt(&pkt_udp_hdr, sizeof(pkt_udp_hdr), pkt, sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr)); // UDP header
copy_buf_to_pkt(&buf, sizeof(buf), pkt, sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr)); // Data
/* dpdk优化版
struct rte_ether_hdr* eth_hdr;
struct rte_ipv4_hdr *ip_hdr;
struct rte_udp_hdr *udp_hdr;
ip_hdr = (struct rte_ipv4_hdr *)(eth_hdr + 1);
*ip_hdr = pkt_ip_hdr;
ip_hdr->total_length = rte_cpu_to_be_16(pkt_data_len - sizeof(struct rte_ether_hdr));
udp_hdr = (struct rte_udp_hdr *)(ip_hdr + 1);
*udp_hdr = pkt_udp_hdr;
udp_hdr->dgram_len = rte_cpu_to_be_16(pkt_data_len - sizeof(struct rte_ether_hdr) - sizeof(struct rte_ipv4_hdr));
void *pkt_data = (void *)(udp_hdr + 1);
rte_memcpy(pkt_data, buf, sizeof(buf));
*/
// 设置 rte_mbuf 参数：
pkt->nb_segs = 1;
pkt->pkt_len = pkt->data_len;
pkt->ol_flags = 0;
pkt->vlan_tci = 0;
pkt->vlan_tci_outer = 0;
pkt->l2_len = sizeof(struct rte_ether_hdr);
pkt->l3_len = sizeof(struct rte_ipv4_hdr);
pkt->l4_len = sizeof(struct rte_udp_hdr);
mbuf_list[i] = pkt;
}
}
// 在一个网口发送数据包
static inline int
send_burst(uint8_t portid, uint8_t queueid)
{
uint16_t send;
// 上锁，防止多线程同时访问发送队列
rte_spinlock_lock(&spinlock_conf);
// 发送数据包，send 是实际发送的数据包数量
send = rte_eth_tx_burst(portid, queueid, mbuf_list, MAX_PKT_BURST);
printf("-------- Data sent: %d packets\n", send);
// 解锁
rte_spinlock_unlock(&spinlock_conf);
// 如果未能全部发送，释放未发送的数据包
if (unlikely(send < MAX_PKT_BURST)) {
for (uint16_t i = send; i < MAX_PKT_BURST; i++) {
rte_pktmbuf_free(mbuf_list[i]);
}
}
// 统计已发送数据包总数
send_total += send;
return send;
}
static int app_lcore_main_loop(__attribute__((unused)) void *arg)
{
unsigned lcoreid;
uint32_t count = 0; // 记录发送的包数
uint32_t num = 0; // 记录发送的包总数
uint16_t ret; // 记录每次发送成功的包数
uint16_t pkt_data_len = sizeof(buf); // 数据包的总长度
struct rte_eth_stats port_stats; // 记录端口统计数据
struct timeval tv; // 用于计算时间
lcoreid = rte_lcore_id(); // 获取当前核心 ID
if (lcoreid == lcore_id)
{
printf("------- Sending from core %u\n", lcore_id);
// 重置端口统计数据
rte_eth_stats_reset(port_id);
// 打印初始的统计数据
if (rte_eth_stats_get(port_id, &port_stats) == 0)
{
printf("Initial stats:\n");
printf("Received packets: %ld Sent packets: %ld\n", port_stats.ipackets, port_stats.opackets);
printf("Received bytes: %ld Sent bytes: %ld\n", port_stats.ibytes, port_stats.obytes);
printf("Receive errors: %ld Send errors: %ld\n", port_stats.ierrors, port_stats.oerrors);
printf("Missed packets: %ld RX no buffer: %ld\n", port_stats.imissed, port_stats.rx_nombuf);
}
// 开始计时
gettimeofday(&tv, NULL);
int starttime = tv.tv_sec * 1000000 + tv.tv_usec; // 转换为微秒
// 设置数据包的 IP 和 UDP 头部
setup_pkt_udp_ip_headers(&pkt_ip_hdr, &pkt_udp_hdr, pkt_data_len);
printf("setup_pkt_udp_ip_headers\n");
while (num < SEND_TOTAL)
{
if (force_quit) // 检查是否需要退出
break;
// 准备数据包并发送
create_pkt_mbuf_array(); // 组装数据包
ret = send_burst(port_id, tx_queue_id); // 发送数据包
rte_eth_tx_done_cleanup(port_id, tx_queue_id, 0); // 清理已发送的包
count += ret; // 累加成功发送的包数
num++; // 累加总发送包数
}
// 结束计时
gettimeofday(&tv, NULL);
int endtime = tv.tv_sec * 1000000 + tv.tv_usec; // 转换为微秒
int time = endtime - starttime; // 计算总耗时
// 打印发送后的统计数据
if (rte_eth_stats_get(port_id, &port_stats) == 0)
{
printf("Final stats:\n");
printf("Received packets: %ld Sent packets: %ld\n", port_stats.ipackets, port_stats.opackets);
printf("Received bytes: %ld Sent bytes: %ld\n", port_stats.ibytes, port_stats.obytes);
printf("Receive errors: %ld Send errors: %ld\n", port_stats.ierrors, port_stats.oerrors);
printf("Missed packets: %ld RX no buffer: %ld\n", port_stats.imissed, port_stats.rx_nombuf);
}
// 打印发送的总包数和耗时
printf("------- Total sent: %d Count: %d Time: %d microseconds\n", send_total, count, time);
}
return 0;
}
int
main(int argc, char **argv)
{
int ret;
uint32_t nb_lcores;
uint32_t nb_ports;
unsigned lcoreid;
uint8_t nb_rx_queue, nb_tx_queue;
uint16_t nb_rx_desc, nb_tx_desc;
struct rte_eth_dev_info default_eth_dev_info_before;
struct rte_eth_dev_info default_eth_dev_info_after;
struct rte_eth_rxconf default_rxconf;
struct rte_eth_txconf default_txconf;
struct rte_eth_desc_lim rx_desc_lim;
struct rte_eth_desc_lim tx_desc_lim;
nb_rx_queue = 1; //端口接收队列数量
nb_tx_queue = 1; //端口传输队列数量
nb_rx_desc = 128; //端口接收队列描述符数量
nb_tx_desc = 512; //端口传输队列描述符数量
rx_queue_id = 0; //仅使用接收队列 0
tx_queue_id = 0; //仅使用传输队列 0
port_id = 0; //仅使用端口 0
lcore_id = 1; //仅使用的逻辑核 1
force_quit = false;
ret = rte_eal_init(argc, argv);
if (ret < 0)
rte_panic("Cannot init EAL\n");
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
//端口数量
nb_ports = rte_eth_dev_count_total();
if (nb_ports > RTE_MAX_ETHPORTS)
nb_ports = RTE_MAX_ETHPORTS;
//逻辑核数量
nb_lcores = rte_lcore_count();
printf("number of lcores: %d number of ports: %d\n", nb_lcores, nb_ports);
//主逻辑核 CPU 插槽编号
socket_id = rte_lcore_to_socket_id(rte_get_main_lcore());
//创建内存池
char s[64];//内存池名称
snprintf(s, sizeof(s), "mbuf_pool_%d", socket_id);
pktmbuf_pool = rte_pktmbuf_pool_create(s,NUM_MBUFS, MBUF_CACHE_SIZE, 0,RTE_MBUF_DEFAULT_BUF_SIZE, socket_id);
if (pktmbuf_pool == NULL)
rte_exit(EXIT_FAILURE, "Cannot init mbuf pool on socket %d\n", socket_id);
else
printf("Allocated mbuf pool on socket %d\n", socket_id);
//获取端口mac 地址
rte_eth_macaddr_get(port_id, &src_eth_addrs);
print_ethaddr("SRC1 Mac Address:", &src_eth_addrs);
rte_eth_macaddr_get(port_id + 1, ð_addrs);
print_ethaddr("SRC2 Mac Address:", ð_addrs);
//目的mac 地址
void *tmp;
tmp = &des_eth_addrs.addr_bytes[0];
//*((uint64_t *)tmp) = (((uint64_t)0x59 << 40) | ((uint64_t)0x41 << 32) | ((uint64_t)0x02 << 24) | ((uint64_t)0x4A << 16) | ((uint64_t)0x53 << 8) | (uint64_t)0x2C);
//*((uint64_t *)tmp) = (((uint64_t)0x30 << 40) | ((uint64_t)0x05 << 32) | ((uint64_t)0x05 << 24) | ((uint64_t)0x0A << 16) | ((uint64_t)0x11 << 8) | (uint64_t)0x00);
*((uint64_t *)tmp) = (((uint64_t)0xFF << 40) | ((uint64_t)0xFF << 32) | ((uint64_t)0xFF << 24) | ((uint64_t)0xFF << 16) | ((uint64_t)0xFF << 8) | (uint64_t)0xFF);
print_ethaddr("DES Mac Address:", &des_eth_addrs);
//端口配置
ret = rte_eth_dev_configure(port_id, nb_rx_queue, nb_tx_queue, &port_conf_default);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Cannot configure device: err=%d, port=%d\n",ret, port_id);
//检查Rx和Tx描述符的数量是否满足来自以太网设备信息的描述符限制，否则将其调整为边界 nb_rx_desc =128,nb_tx_desc=128
ret = rte_eth_dev_adjust_nb_rx_tx_desc(port_id, &nb_rx_desc,&nb_tx_desc);
//获取端口默认配置信息
rte_eth_dev_info_get(port_id, &default_eth_dev_info_before);
//端口 TX 队列配置
fflush(stdout);
default_txconf = default_eth_dev_info_before.default_txconf;
tx_desc_lim = default_eth_dev_info_before.tx_desc_lim;
printf("config before ---- tx_free_thresh : %d ,desc_max ：%d ,desc_min : %d \n",default_txconf.tx_free_thresh, tx_desc_lim.nb_max, tx_desc_lim.nb_min);
default_txconf.tx_free_thresh = (uint16_t) MAX_PKT_BURST;
ret = rte_eth_tx_queue_setup(port_id, tx_queue_id, nb_tx_desc, socket_id, NULL);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_tx_queue_setup: err=%d, port=%d\n", ret, port_id);
//端口 RX 队列配置
fflush(stdout);
default_rxconf = default_eth_dev_info_before.default_rxconf;
rx_desc_lim = default_eth_dev_info_before.rx_desc_lim;
printf("config before ---- rx_free_thresh : %d ,desc_max ：%d ,desc_min : %d \n",default_rxconf.rx_free_thresh, rx_desc_lim.nb_max, rx_desc_lim.nb_min);
default_rxconf.rx_free_thresh = (uint16_t) MAX_PKT_BURST;
ret = rte_eth_rx_queue_setup(port_id, rx_queue_id, nb_rx_desc, socket_id, NULL, pktmbuf_pool);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_rx_queue_setup: err=%d,port=%d\n", ret, port_id);
rte_delay_ms(5000);//延迟5秒
memset(&default_txconf, 0, sizeof(default_txconf));
memset(&default_rxconf, 0, sizeof(default_rxconf));
memset(&tx_desc_lim, 0, sizeof(tx_desc_lim));
memset(&rx_desc_lim, 0, sizeof(rx_desc_lim));
//获取端口默认配置信息
rte_eth_dev_info_get(port_id, &default_eth_dev_info_after);
default_txconf = default_eth_dev_info_after.default_txconf;
tx_desc_lim = default_eth_dev_info_after.tx_desc_lim;
printf("config after ---- tx_free_thresh : %d ,desc_max ：%d ,desc_min : %d \n",default_txconf.tx_free_thresh, tx_desc_lim.nb_max, tx_desc_lim.nb_min);
default_rxconf = default_eth_dev_info_after.default_rxconf;
rx_desc_lim = default_eth_dev_info_after.rx_desc_lim;
printf("config after ---- rx_free_thresh : %d ,desc_max ：%d ,desc_min : %d \n",default_rxconf.rx_free_thresh, rx_desc_lim.nb_max, rx_desc_lim.nb_min);
/*开启端口网卡 */
ret = rte_eth_dev_start(port_id);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_dev_start: err=%d, port=%d\n",ret, port_id);
printf("started: Port %d\n", port_id);
/* 设置端口网卡混杂模式 */
rte_eth_promiscuous_enable(port_id);
/*等待网卡启动成功*/
#define CHECK_INTERVAL 100 /* 100ms */
#define MAX_CHECK_TIME 50 /* 5s (50 * 100ms) in total */
uint8_t count;
struct rte_eth_link link;
for (count = 0; count <= MAX_CHECK_TIME; count++) {
if (force_quit)
return 0;
memset(&link, 0, sizeof(link));
rte_eth_link_get_nowait(port_id, &link);
if (link.link_status)
printf("Port %d Link Up - speed %u Mbps - %s\n", (uint8_t)port_id,(unsigned)link.link_speed,
(link.link_duplex == RTE_ETH_LINK_FULL_DUPLEX) ?
("full-duplex") : ("half-duplex\n"));
else
printf("Port %d Link Down\n",(uint8_t)port_id);
rte_delay_ms(CHECK_INTERVAL);
}
printf("调用逻辑核执行任务\n");
/*调用逻辑核执行任务*/
rte_eal_mp_remote_launch(app_lcore_main_loop, NULL, CALL_MAIN);
/*等待逻辑核退出*/
RTE_LCORE_FOREACH_WORKER(lcoreid) {
if (rte_eal_wait_lcore(lcoreid) < 0) {
return -1;
}
}
printf("Bye...\n");
printf("Closing port %d...\n", port_id);
/*停止端口网卡*/
rte_eth_dev_stop(port_id);
/*关闭端口网卡*/
rte_eth_dev_close(port_id);
return 0;
}
udp_send2.c
这个发送了，收不到。
// ****************************************************************************
// This example shows how to send some simple UDP packets.
// ****************************************************************************
// Build it with:
// ./build.sh
//
// Check it works by running this on the receiving machine:
// sudo tshark -i <interface> udp port 1234
// DPDK headers
#include <rte_eal.h>
#include <rte_ethdev.h>
#include <rte_mbuf.h>
// Platform headers
#include <linux/if_ether.h>
#include <netinet/ip.h>
#include <netinet/udp.h>
// Standard headers
#include <stdint.h>
#include <stdio.h>
// ****************************************************************************
// Set these to the correct values of the machine you want to send to / from.
// ****************************************************************************
#define MAKE_IPV4_ADDR(a, b, c, d) (a + (b<<8) + (c<<16) + (d<<24))
static uint32_t g_src_ip = MAKE_IPV4_ADDR(10, 0, 0, 4);
static uint32_t g_dest_ip = MAKE_IPV4_ADDR(10, 0, 0, 5);
static uint8_t g_dest_mac_addr[ETH_ALEN] = { 0x00, 0x0d, 0x3a, 0xf4, 0x56, 0x28 };
// ****************************************************************************
// Tweak these values if you want.
// ****************************************************************************
// I believe packets you write using rte_eth_tx_burst() are put in the TX ring.
// The hardware moves them out of the ring when it can. The timing of when the
// hardware does that move depends on the rate at which it can put packets on
// the wire, on the performance of the interface between the NIC and the system
// RAM (typically DMA over PCIe) and on how much buffer space there is on the
// NIC. If your app calls rte_eth_tx_burst() repeatedly without doing anything
// else, you could fill this ring before the hardware has had time to move any
// packets out.
#define TX_RING_SIZE 128
// DPDK has a pool allocator. This specifies how many packets are in the pool.
// I think this includes all those in the TX and RX rings, plus any that are
// currently in the hands of the application.
#define NUM_MBUFS 8191
// This value is probably irrelevant in this single threaded app. See
// the docs for the cache_size param of rte_mempool_create().
#define MBUF_CACHE_SIZE 0
// Everyone seems to use 32. Nobody seems to know why.
#define BURST_SIZE 32
// ****************************************************************************
// Do not tweak these values.
// ****************************************************************************
static uint8_t g_src_mac_addr[ETH_ALEN]; // This will be set automatically at run time.
// DPDK supports many queues per port. Most simple apps only need one TX queue
// and one RX queue. You only need more than one if you are doing something
// like scatter/gather.
#define DPDK_QUEUE_ID_TX 0
// In DPDK, a "port" is a NIC. We will use the first NIC DPDK finds.
int g_dpdkPortId = -1;
static const struct rte_eth_conf port_conf_default = {
.rxmode = { .max_rx_pkt_len = ETHER_MAX_LEN }
};
static void port_init(struct rte_mempool *mbuf_pool) {
// Find the first free DPDK enabled network interface. When running on
// Azure, the TAP PMD and MLX4 PMD will both advertise a port. We must not
// use them directly. Instead we want the fail-safe PMD which sits on top
// of them. The fail-safe will already have taken ownership of the TAP and
// MLX4 PMDs, so we won't see them as available in this loop.
g_dpdkPortId = 0;
while (g_dpdkPortId < RTE_MAX_ETHPORTS &&
rte_eth_devices[g_dpdkPortId].data->owner.id != RTE_ETH_DEV_NO_OWNER) {
g_dpdkPortId++;
}
if (g_dpdkPortId == RTE_MAX_ETHPORTS) {
rte_exit(EXIT_FAILURE, "There were no DPDK ports free.\n");
}
// Configure the Ethernet device.
const int num_rx_queues = 0;
const int num_tx_queues = 1;
struct rte_eth_conf port_conf = port_conf_default;
if (rte_eth_dev_configure(g_dpdkPortId, num_rx_queues, num_tx_queues, &port_conf)) {
rte_exit(EXIT_FAILURE, "rte_eth_dev_configure() failed.\n");
}
// Set up TX queue.
if (rte_eth_tx_queue_setup(g_dpdkPortId, DPDK_QUEUE_ID_TX, TX_RING_SIZE,
rte_eth_dev_socket_id(g_dpdkPortId), NULL) < 0) {
rte_exit(EXIT_FAILURE, "Couldn't setup TX queue.\n");
}
// Start the Ethernet port.
if (rte_eth_dev_start(g_dpdkPortId) < 0) {
rte_exit(EXIT_FAILURE, "Device start failed.\n");
}
}
static uint16_t gen_checksum(const char *buf, int num_bytes) {
const uint16_t *half_words = (const uint16_t *)buf;
unsigned sum = 0;
for (int i = 0; i < num_bytes / 2; i++)
sum += half_words[i];
if (num_bytes & 1)
sum += buf[num_bytes - 1];
sum = (sum & 0xffff) + (sum >> 16);
sum += (sum & 0xff0000) >> 16;
sum = ~sum & 0xffff;
return sum;
}
static void create_eth_ip_udp(uint8_t *msg, size_t total_len, uint8_t dst_mac[ETH_ALEN],
uint32_t src_ip, uint32_t dst_ip, uint16_t udp_src_port, uint16_t udp_dst_port) {
// Packet looks like this:
// Eth | IP | UDP | <payload>
// We will fill out each section in order.
struct ethhdr *eth = (struct ethhdr *)msg;
memcpy(eth->h_dest, dst_mac, ETH_ALEN);
memcpy(eth->h_source, g_src_mac_addr, ETH_ALEN);
eth->h_proto = htons(ETH_P_IP);
struct iphdr *ip = (struct iphdr *)(eth + 1);
size_t ip_len = total_len - sizeof(struct ethhdr);
ip->ihl = 5;
ip->version = 4;
ip->tos = 0;
ip->tot_len = htons((uint16_t)ip_len);
ip->id = 0;
ip->frag_off = 0;
ip->ttl = 64;
ip->protocol = IPPROTO_UDP;
ip->check = 0;
ip->saddr = src_ip;
ip->daddr = dst_ip;
ip->check = gen_checksum((char *)ip, sizeof(struct iphdr));
struct udphdr *udp = (struct udphdr *)(ip + 1);
size_t udp_len = ip_len - sizeof(struct iphdr);
udp->source = htons(udp_src_port);
udp->dest = htons(udp_dst_port);
udp->len = htons((uint16_t)udp_len);
// Set the UDP checksum to zero for simplicity. This is perfectly legal. It
// just tells the the receiver not to check the checksum.
udp->check = 0;
// Use the packet count as the payload.
uint32_t *payload = (uint32_t *)(udp + 1);
static uint32_t seq_num = 0;
*payload = htonl(seq_num++);
}
// Send the specified number of packets, using as many bursts as necessary.
static void do_send(struct rte_mempool *mbuf_pool, int num_to_send) {
// The smallest packet allowed by Ethernet.
const unsigned eth_total_len = 64;
struct rte_mbuf *mbufs[BURST_SIZE];
for (int i = 0; i < BURST_SIZE; i++) {
mbufs[i] = rte_pktmbuf_alloc(mbuf_pool);
if (!mbufs[i]) {
rte_exit(EXIT_FAILURE, "Cannot alloc mbuf\n");
}
mbufs[i]->pkt_len = eth_total_len;
mbufs[i]->data_len = eth_total_len;
}
for (int num_packets_left = num_to_send; num_packets_left > 0;) {
int num_to_send_this_burst = BURST_SIZE;
if (num_packets_left < BURST_SIZE) {
num_to_send_this_burst = num_packets_left;
}
for (int i = 0; i < num_to_send_this_burst; i++) {
uint8_t *packet_data = rte_pktmbuf_mtod(mbufs[i], uint8_t *);
const int UDP_PORT = 1234;
create_eth_ip_udp(packet_data, eth_total_len, g_dest_mac_addr,
g_src_ip, g_dest_ip, UDP_PORT, UDP_PORT);
}
// Send as many packets as will fit in the TX ring.
int num_sent = rte_eth_tx_burst(g_dpdkPortId, DPDK_QUEUE_ID_TX, mbufs, num_to_send_this_burst);
printf("Sent %i packets\n", num_sent);
num_packets_left -= num_sent;
}
}
int main(int argc, char *argv[]) {
// Initialize the Environment Abstraction Layer. All DPDK apps must do this.
if (rte_eal_init(argc, argv) < 0) {
rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
}
// Creates a new mempool in memory to hold the mbufs.
struct rte_mempool *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) {
rte_exit(EXIT_FAILURE, "Couldn't create mbuf pool\n");
}
port_init(mbuf_pool);
rte_eth_macaddr_get(g_dpdkPortId, (struct ether_addr *)g_src_mac_addr);
printf("Our MAC: %02x %02x %02x %02x %02x %02x\n",
g_src_mac_addr[0], g_src_mac_addr[1],
g_src_mac_addr[2], g_src_mac_addr[3],
g_src_mac_addr[4], g_src_mac_addr[5]);
do_send(mbuf_pool, 1);
return 0;
}
mini tx rx
mini tx
// Minimal DPDK TX
// Just send one packet from one port
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <rte_memory.h>
#include <rte_launch.h>
#include <rte_eal.h>
#include <rte_per_lcore.h>
#include <rte_lcore.h>
#include <rte_ethdev.h>
#include <rte_udp.h>
#include <rte_ip.h>
#define RX_RING_SIZE 0
#define TX_RING_SIZE 1024
#define NUM_MBUFS 8191
#define MBUF_CACHE_SIZE 250
#define BURST_SIZE 32
#define UDP_SRC_PORT 6666
#define UDP_DST_PORT 6666
#define IP_DEFTTL 64 /* from RFC 1340. */
#define IP_VERSION 0x40
#define IP_HDRLEN 0x05 /* default IP header length == five 32-bits words. */
#define IP_VHL_DEF (IP_VERSION | IP_HDRLEN)
#define TX_PACKET_LENGTH 862
#if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
#define RTE_BE_TO_CPU_16(be_16_v) (be_16_v)
#define RTE_CPU_TO_BE_16(cpu_16_v) (cpu_16_v)
#else
#define RTE_BE_TO_CPU_16(be_16_v) \
(uint16_t) ((((be_16_v) & 0xFF) << 8) | ((be_16_v) >> 8))
#define RTE_CPU_TO_BE_16(cpu_16_v) \
(uint16_t) ((((cpu_16_v) & 0xFF) << 8) | ((cpu_16_v) >> 8))
#endif
uint64_t DST_MAC;
uint32_t IP_SRC_ADDR,IP_DST_ADDR;
static const struct rte_eth_conf port_conf_default = {
.rxmode = { .max_rx_pkt_len = RTE_ETHER_MAX_LEN }
};
static struct rte_ipv4_hdr pkt_ip_hdr; /**< IP header of transmitted packets. */
static struct rte_udp_hdr pkt_udp_hdr; /**< UDP header of transmitted packets. */
struct rte_ether_addr my_addr; // SRC MAC address of NIC
struct rte_mempool *mbuf_pool;
uint32_t string_to_ip(char *);
uint64_t string_to_mac(char *);
static void send_packet(void);
static void exit_stats(int);
static uint64_t packet_count = 0;
static time_t t1;
// convert a quad-dot IP string to uint32_t IP address
uint32_t string_to_ip(char *s) {
unsigned char a[4];
int rc = sscanf(s, "%hhd.%hhd.%hhd.%hhd",a+0,a+1,a+2,a+3);
if(rc != 4){
fprintf(stderr, "bad source IP address format. Use like: -s 198.19.111.179\n");
exit(1);
}
return
(uint32_t)(a[0]) << 24 |
(uint32_t)(a[1]) << 16 |
(uint32_t)(a[2]) << 8 |
(uint32_t)(a[3]);
}
// convert six colon separated hex bytes string to uint64_t Ethernet MAC address
uint64_t string_to_mac(char *s) {
unsigned char a[6];
int rc = sscanf(s, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
a + 0, a + 1, a + 2, a + 3, a + 4, a + 5);
if(rc !=6 ){
fprintf(stderr, "bad MAC address format. Use like: -m 0a:38:ca:f6:f3:20\n");
exit(1);
}
return
(uint64_t)(a[0]) << 40 |
(uint64_t)(a[1]) << 32 |
(uint64_t)(a[2]) << 24 |
(uint64_t)(a[3]) << 16 |
(uint64_t)(a[4]) << 8 |
(uint64_t)(a[5]);
}
// setup packet UDP & IP headers
static void setup_pkt_udp_ip_headers(struct rte_ipv4_hdr *ip_hdr,
struct rte_udp_hdr *udp_hdr,
uint16_t pkt_data_len)
{
uint16_t *ptr16;
uint32_t ip_cksum;
uint16_t pkt_len;
//Initialize UDP header.
pkt_len = (uint16_t) (pkt_data_len + sizeof(struct rte_udp_hdr));
udp_hdr->src_port = rte_cpu_to_be_16(UDP_SRC_PORT);
udp_hdr->dst_port = rte_cpu_to_be_16(UDP_DST_PORT);
udp_hdr->dgram_len = RTE_CPU_TO_BE_16(pkt_len);
udp_hdr->dgram_cksum = 0; /* No UDP checksum. */
//Initialize IP header.
pkt_len = (uint16_t) (pkt_len + sizeof(struct rte_ipv4_hdr));
ip_hdr->version_ihl = IP_VHL_DEF;
ip_hdr->type_of_service = 0;
ip_hdr->fragment_offset = 0;
ip_hdr->time_to_live = IP_DEFTTL;
ip_hdr->next_proto_id = IPPROTO_UDP;
ip_hdr->packet_id = 0;
ip_hdr->total_length = RTE_CPU_TO_BE_16(pkt_len);
ip_hdr->src_addr = rte_cpu_to_be_32(IP_SRC_ADDR);
ip_hdr->dst_addr = rte_cpu_to_be_32(IP_DST_ADDR);
//Compute IP header checksum.
ptr16 = (unaligned_uint16_t*) ip_hdr;
ip_cksum = 0;
ip_cksum += ptr16[0]; ip_cksum += ptr16[1];
ip_cksum += ptr16[2]; ip_cksum += ptr16[3];
ip_cksum += ptr16[4];
ip_cksum += ptr16[6]; ip_cksum += ptr16[7];
ip_cksum += ptr16[8]; ip_cksum += ptr16[9];
//Reduce 32 bit checksum to 16 bits and complement it.
ip_cksum = ((ip_cksum & 0xFFFF0000) >> 16) +
(ip_cksum & 0x0000FFFF);
if (ip_cksum > 65535)
ip_cksum -= 65535;
ip_cksum = (~ip_cksum) & 0x0000FFFF;
if (ip_cksum == 0)
ip_cksum = 0xFFFF;
ip_hdr->hdr_checksum = (uint16_t) ip_cksum;
}
// actually send the packet
static void send_packet(void)
{
struct rte_mbuf *pkt;
union {
uint64_t as_int;
struct rte_ether_addr as_addr;
} dst_eth_addr;
struct rte_ether_hdr eth_hdr;
struct rte_mbuf *pkts_burst[1];
pkt = rte_mbuf_raw_alloc(mbuf_pool);
if(pkt == NULL) {printf("trouble at rte_mbuf_raw_alloc\n"); return;}
rte_pktmbuf_reset_headroom(pkt);
pkt->data_len = TX_PACKET_LENGTH;
// set up addresses
dst_eth_addr.as_int=rte_cpu_to_be_64(DST_MAC);
rte_ether_addr_copy(&dst_eth_addr.as_addr,ð_hdr.d_addr);
rte_ether_addr_copy(&my_addr, ð_hdr.s_addr);
eth_hdr.ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
// copy header to packet in mbuf
rte_memcpy(rte_pktmbuf_mtod_offset(pkt,char *,0),
ð_hdr,(size_t)sizeof(eth_hdr));
rte_memcpy(rte_pktmbuf_mtod_offset(pkt,char *,sizeof(struct rte_ether_hdr)),
&pkt_ip_hdr,(size_t)sizeof(pkt_ip_hdr));
rte_memcpy(rte_pktmbuf_mtod_offset(pkt,char *,
sizeof(struct rte_ether_hdr)+sizeof(struct rte_ipv4_hdr)),
&pkt_udp_hdr,(size_t)sizeof(pkt_udp_hdr));
// Add some pkt fields
pkt->nb_segs = 1;
pkt->pkt_len = pkt->data_len;
pkt->ol_flags = 0;
// Actually send the packet
pkts_burst[0] = pkt;
const uint16_t nb_tx = rte_eth_tx_burst(0, 0, pkts_burst, 1);
packet_count += nb_tx;
rte_mbuf_raw_free(pkt);
}
// Initialize Port
static inline int
port_init(uint16_t port)
{
struct rte_eth_conf port_conf = port_conf_default;
const uint16_t rx_rings = 0, tx_rings = 1;
uint16_t nb_rxd = RX_RING_SIZE;
uint16_t nb_txd = TX_RING_SIZE;
int retval;
uint16_t q;
struct rte_eth_dev_info dev_info;
struct rte_eth_txconf txconf;
if (!rte_eth_dev_is_valid_port(port))
return -1;
rte_eth_dev_info_get(port, &dev_info);
if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
port_conf.txmode.offloads |=
DEV_TX_OFFLOAD_MBUF_FAST_FREE;
/* Configure the Ethernet device. */
retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
if (retval != 0)
return retval;
retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &nb_rxd, &nb_txd);
if (retval != 0)
return retval;
txconf = dev_info.default_txconf;
txconf.offloads = port_conf.txmode.offloads;
//Allocate and set up 1 TX queue
for (q = 0; q < tx_rings; q++) {
retval = rte_eth_tx_queue_setup(port, q, nb_txd,
rte_eth_dev_socket_id(port), &txconf);
if (retval < 0)
return retval;
}
/* Start the Ethernet port. */
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
/* get the port MAC address. */
rte_eth_macaddr_get(port, &my_addr);
printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
" %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
port,
my_addr.addr_bytes[0], my_addr.addr_bytes[1],
my_addr.addr_bytes[2], my_addr.addr_bytes[3],
my_addr.addr_bytes[4], my_addr.addr_bytes[5]);
return 0;
}
static void exit_stats(int sig)
{
time_t total_time;
total_time = time(NULL) - t1;
printf("Caught signal %d\n", sig);
printf("\n=============== Stats =================\n");
printf("Total packets: %lu\n", packet_count);
printf("Total transmission time: %ld seconds\n", total_time);
printf("Average transmission rate: %lu pps\n", packet_count / total_time);
printf(" %lu Mbps\n", ((packet_count * TX_PACKET_LENGTH * 8) / total_time) / 1000000);
printf("=======================================\n");
exit(0);
}
int main(int argc, char **argv)
{
int ret,c;
uint16_t pkt_data_len;
int mac_flag=0,ip_src_flag=0,ip_dst_flag=0;
int counter = 0;
ret = rte_eal_init(argc, argv);
if (ret < 0)
rte_panic("Cannot init EAL\n");
argc -= ret;
argv += ret;
signal (SIGINT, exit_stats);
while ((c = getopt(argc, argv, "m:s:d:h")) != -1)
switch(c) {
case 'm':
// note, not quite sure why last two bytes are zero, but that is how DPDK likes it
DST_MAC=0ULL;
DST_MAC=string_to_mac(optarg)<<16;
mac_flag=1;
break;
case 's':
IP_SRC_ADDR=string_to_ip(optarg);
ip_src_flag=1;
break;
case 'd':
IP_DST_ADDR=string_to_ip(optarg);
ip_dst_flag=1;
break;
case 'h':
printf("usage -- -m [dst MAC] -s [src IP] -d [dst IP]\n");
exit(0);
break;
}
if(mac_flag==0) {
fprintf(stderr, "missing -m for destination MAC adress\n");
exit(1);
}
if(ip_src_flag==0) {
fprintf(stderr, "missing -s for IP source adress\n");
exit(1);
}
if(ip_dst_flag==0) {
fprintf(stderr, "missing -d for IP destination adress\n");
exit(1);
}
/* Creates a new mempool in memory to hold the mbufs. */
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, "Cannot create mbuf pool\n");
// initialize port 0
if (port_init(0) != 0)
rte_exit(EXIT_FAILURE, "Cannot init port 0\n");
printf("Sending packets ... [Press Ctrl+C to exit]\n");
pkt_data_len = (uint16_t) (TX_PACKET_LENGTH - (sizeof(struct rte_ether_hdr) +
sizeof(struct rte_ipv4_hdr) +
sizeof(struct rte_udp_hdr)));
setup_pkt_udp_ip_headers(&pkt_ip_hdr, &pkt_udp_hdr, pkt_data_len);
t1 = time(NULL);
while (true) {
counter++;
if (counter % 35 == 0) {
usleep(1);
}
send_packet();
}
return(0);
}
描述
Sends a single UDP packet from DPDK port 0 to designated destination.
Usage:
minimal_tx -- -m [dst MAC] -s [src IP] -d [dst IP]
For example:
./build/minimal_tx -- -m 0f:70:4a:e1:dd:34 -s 172.30.50.73 -d 172.30.50.194
As per usual, put DPDK EAL options ahead of -- if needed. For example:
./build/minimal_tx -v -- -m 0f:70:4a:e1:dd:34 -s 172.30.50.73 -d 172.30.50.194
mini rx
// Adapted from: https://github.com/DPDK/dpdk/blob/master/examples/skeleton/basicfwd.c
// by Thomas Edwards, Walt Disney Television
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <signal.h>
#include <rte_eal.h>
#include <rte_ethdev.h>
#include <rte_cycles.h>
#include <rte_lcore.h>
#include <rte_mbuf.h>
#define RX_RING_SIZE 1024
#define TX_RING_SIZE 0
#define NUM_MBUFS 8191
#define MBUF_CACHE_SIZE 250
#define BURST_SIZE 32
void DumpHex(const void*, size_t);
void rx_packets(void);
void exit_stats(int);
uint64_t packet_count = 0;
static const struct rte_eth_conf port_conf_default = {
.rxmode = {
.max_rx_pkt_len = RTE_ETHER_MAX_LEN,
},
};
void DumpHex(const void* data, size_t size) {
char ascii[17];
size_t i, j;
ascii[16] = '\0';
for (i = 0; i < size; ++i) {
printf("%02X ", ((const unsigned char*)data)[i]);
if (((const unsigned char*)data)[i] >= ' ' && ((const unsigned char*)data)[i] <= '~') {
ascii[i % 16] = ((const unsigned char*)data)[i];
} else {
ascii[i % 16] = '.';
}
if ((i+1) % 8 == 0 || i+1 == size) {
printf(" ");
if ((i+1) % 16 == 0) {
printf("| %s \n", ascii);
} else if (i+1 == size) {
ascii[(i+1) % 16] = '\0';
if ((i+1) % 16 <= 8) {
printf(" ");
}
for (j = (i+1) % 16; j < 16; ++j) {
printf(" ");
}
printf("| %s \n", ascii);
}
}
}
}
/*
* Initializes a given port using global settings and with the RX buffers
* coming from the mbuf_pool passed as a parameter.
*/
static inline int
port_init(uint16_t port, struct rte_mempool *mbuf_pool)
{
struct rte_eth_conf port_conf = port_conf_default;
const uint16_t rx_rings = 1, tx_rings = 0;
uint16_t nb_rxd = RX_RING_SIZE;
uint16_t nb_txd = TX_RING_SIZE;
int retval;
uint16_t q;
if (!rte_eth_dev_is_valid_port(port))
return -1;
/* Configure the Ethernet device. */
retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
if (retval != 0)
return retval;
retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &nb_rxd, &nb_txd);
if (retval != 0)
return retval;
/* Allocate and set up 1 RX queue per Ethernet port. */
for (q = 0; q < rx_rings; q++) {
retval = rte_eth_rx_queue_setup(port, q, nb_rxd,
rte_eth_dev_socket_id(port), NULL, mbuf_pool);
if (retval < 0)
return retval;
}
/* Start the Ethernet port. */
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
/* Display the port MAC address. */
struct rte_ether_addr addr;
rte_eth_macaddr_get(port, &addr);
printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
" %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
port,
addr.addr_bytes[0], addr.addr_bytes[1],
addr.addr_bytes[2], addr.addr_bytes[3],
addr.addr_bytes[4], addr.addr_bytes[5]);
/* Enable RX in promiscuous mode for the Ethernet device. */
rte_eth_promiscuous_enable(port);
return 0;
}
// recieve packets
void rx_packets(void)
{
uint16_t port;
int i;
printf("\nCore %u receiving packets. [Ctrl+C to quit]\n",
rte_lcore_id());
/* Run until the application is quit or killed. */
for (;;) {
RTE_ETH_FOREACH_DEV(port) {
struct rte_mbuf *bufs[BURST_SIZE];
const uint16_t nb_rx = rte_eth_rx_burst(port, 0,
bufs, BURST_SIZE);
if (unlikely(nb_rx == 0))
continue;
packet_count += nb_rx;
//printf("received %d packets:\n",nb_rx);
for(i=0;i<nb_rx;++i){
printf("----->processing packet %d\n",i);
printf("----->pkt_len=%d\n",bufs[i]->pkt_len);
DumpHex(rte_pktmbuf_mtod(bufs[i],char *),bufs[i]->pkt_len);
rte_pktmbuf_free(bufs[i]);
}
}
}
}
void exit_stats(int sig)
{
printf("Caught signal %d\n", sig);
printf("Total received packets: %lu\n", packet_count);
exit(0);
}
int main(int argc, char *argv[])
{
struct rte_mempool *mbuf_pool;
unsigned nb_ports;
uint16_t portid;
/* Initialize the Environment Abstraction Layer (EAL). */
int ret = rte_eal_init(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
argc -= ret;
argv += ret;
nb_ports = rte_eth_dev_count_avail();
printf("rte_eth_dev_count_avail()=%d\n",nb_ports);
/* Creates a new mempool in memory to hold the mbufs. */
mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL", NUM_MBUFS * nb_ports,
MBUF_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
if (mbuf_pool == NULL)
rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
/* Initialize all ports. */
RTE_ETH_FOREACH_DEV(portid)
if (port_init(portid, mbuf_pool) != 0)
rte_exit(EXIT_FAILURE, "Cannot init port %"PRIu16 "\n",
portid);
signal(SIGINT, exit_stats);
rx_packets();
return 0;
}
描述
This program will receive packets endlessly on all DPDK enable interfaces. Usage:
./build/minimal_rx