简介
本系列记录了我学习dpdk的学习笔记，文章内容会参考dpdk的官方文档，同时也会用ai辅助自己理解代码。选用的dpdk版本是24.11.4。
目录
[static void l2fwd_main_loop(void)](#static void l2fwd_main_loop(void))
[配置转发目标端口（l2fwd_dst_ports 数组）：](#配置转发目标端口（l2fwd_dst_ports 数组）：)
二层转发应用例功能介绍
该程序的功能是将数据包在成对的端口间转发，默认情况下是端口0和端口1、端口2和端口3.....以此类推。如果启用了MAC地址修改功能的话会将数据包的源MAC地址修改成接受到数据包的端口的MAC地址，目的地址修改成02:00:00:00:00:xx，其中xx为目的端口的端口号。
代码路径为dpdk源码中的 /examples/l2fwd 完整代码如下：
cpp
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2010-2016 Intel Corporation
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/queue.h>
#include <setjmp.h>
#include <stdarg.h>
#include <ctype.h>
#include <errno.h>
#include <getopt.h>
#include <signal.h>
#include <stdbool.h>
#include <rte_common.h>
#include <rte_log.h>
#include <rte_malloc.h>
#include <rte_memory.h>
#include <rte_memcpy.h>
#include <rte_eal.h>
#include <rte_launch.h>
#include <rte_cycles.h>
#include <rte_prefetch.h>
#include <rte_lcore.h>
#include <rte_per_lcore.h>
#include <rte_branch_prediction.h>
#include <rte_interrupts.h>
#include <rte_random.h>
#include <rte_debug.h>
#include <rte_ether.h>
#include <rte_ethdev.h>
#include <rte_mempool.h>
#include <rte_mbuf.h>
#include <rte_string_fns.h>
static volatile bool force_quit;
/* MAC updating enabled by default */
static int mac_updating = 1;
/* Ports set in promiscuous mode off by default. */
static int promiscuous_on;
#define RTE_LOGTYPE_L2FWD RTE_LOGTYPE_USER1
#define MAX_PKT_BURST 32
#define BURST_TX_DRAIN_US 100 /* TX drain every ~100us */
#define MEMPOOL_CACHE_SIZE 256
/*
* Configurable number of RX/TX ring descriptors
*/
#define RX_DESC_DEFAULT 1024
#define TX_DESC_DEFAULT 1024
static uint16_t nb_rxd = RX_DESC_DEFAULT;
static uint16_t nb_txd = TX_DESC_DEFAULT;
/* ethernet addresses of ports */
static struct rte_ether_addr l2fwd_ports_eth_addr[RTE_MAX_ETHPORTS];
/* mask of enabled ports */
static uint32_t l2fwd_enabled_port_mask = 0;
/* list of enabled ports */
static uint32_t l2fwd_dst_ports[RTE_MAX_ETHPORTS];
struct __rte_cache_aligned port_pair_params {
#define NUM_PORTS 2
uint16_t port[NUM_PORTS];
};
static struct port_pair_params port_pair_params_array[RTE_MAX_ETHPORTS / 2];
static struct port_pair_params *port_pair_params;
static uint16_t nb_port_pair_params;
static unsigned int l2fwd_rx_queue_per_lcore = 1;
#define MAX_RX_QUEUE_PER_LCORE 16
#define MAX_TX_QUEUE_PER_PORT 16
/* List of queues to be polled for a given lcore. 8< */
struct __rte_cache_aligned lcore_queue_conf {
unsigned n_rx_port;
unsigned rx_port_list[MAX_RX_QUEUE_PER_LCORE];
};
struct lcore_queue_conf lcore_queue_conf[RTE_MAX_LCORE];
/* >8 End of list of queues to be polled for a given lcore. */
static struct rte_eth_dev_tx_buffer *tx_buffer[RTE_MAX_ETHPORTS];
static struct rte_eth_conf port_conf = {
.txmode = {
.mq_mode = RTE_ETH_MQ_TX_NONE,
},
};
struct rte_mempool * l2fwd_pktmbuf_pool = NULL;
/* Per-port statistics struct */
struct __rte_cache_aligned l2fwd_port_statistics {
uint64_t tx;
uint64_t rx;
uint64_t dropped;
};
struct l2fwd_port_statistics port_statistics[RTE_MAX_ETHPORTS];
#define MAX_TIMER_PERIOD 86400 /* 1 day max */
/* A tsc-based timer responsible for triggering statistics printout */
static uint64_t timer_period = 10; /* default period is 10 seconds */
/* Print out statistics on packets dropped */
static void
print_stats(void)
{
uint64_t total_packets_dropped, total_packets_tx, total_packets_rx;
unsigned portid;
total_packets_dropped = 0;
total_packets_tx = 0;
total_packets_rx = 0;
const char clr[] = { 27, '[', '2', 'J', '\0' };
const char topLeft[] = { 27, '[', '1', ';', '1', 'H','\0' };
/* Clear screen and move to top left */
printf("%s%s", clr, topLeft);
printf("\nPort statistics ====================================");
for (portid = 0; portid < RTE_MAX_ETHPORTS; portid++) {
/* skip disabled ports */
if ((l2fwd_enabled_port_mask & (1 << portid)) == 0)
continue;
printf("\nStatistics for port %u ------------------------------"
"\nPackets sent: %24"PRIu64
"\nPackets received: %20"PRIu64
"\nPackets dropped: %21"PRIu64,
portid,
port_statistics[portid].tx,
port_statistics[portid].rx,
port_statistics[portid].dropped);
total_packets_dropped += port_statistics[portid].dropped;
total_packets_tx += port_statistics[portid].tx;
total_packets_rx += port_statistics[portid].rx;
}
printf("\nAggregate statistics ==============================="
"\nTotal packets sent: %18"PRIu64
"\nTotal packets received: %14"PRIu64
"\nTotal packets dropped: %15"PRIu64,
total_packets_tx,
total_packets_rx,
total_packets_dropped);
printf("\n====================================================\n");
fflush(stdout);
}
static void
l2fwd_mac_updating(struct rte_mbuf *m, unsigned dest_portid)
{
struct rte_ether_hdr *eth;
void *tmp;
eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
/* 02:00:00:00:00:xx */
tmp = ð->dst_addr.addr_bytes[0];
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dest_portid << 40);
/* src addr */
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dest_portid], ð->src_addr);
}
/* Simple forward. 8< */
static void
l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
{
unsigned dst_port;
int sent;
struct rte_eth_dev_tx_buffer *buffer;
dst_port = l2fwd_dst_ports[portid];
if (mac_updating)
l2fwd_mac_updating(m, dst_port);
buffer = tx_buffer[dst_port];
sent = rte_eth_tx_buffer(dst_port, 0, buffer, m);
if (sent)
port_statistics[dst_port].tx += sent;
}
/* >8 End of simple forward. */
/* main processing loop */
static void
l2fwd_main_loop(void)
{
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
struct rte_mbuf *m;
int sent;
unsigned lcore_id;
uint64_t prev_tsc, diff_tsc, cur_tsc, timer_tsc;
unsigned i, j, portid, nb_rx;
struct lcore_queue_conf *qconf;
const uint64_t drain_tsc = (rte_get_tsc_hz() + US_PER_S - 1) / US_PER_S *
BURST_TX_DRAIN_US;
struct rte_eth_dev_tx_buffer *buffer;
prev_tsc = 0;
timer_tsc = 0;
lcore_id = rte_lcore_id();
qconf = &lcore_queue_conf[lcore_id];
if (qconf->n_rx_port == 0) {
RTE_LOG(INFO, L2FWD, "lcore %u has nothing to do\n", lcore_id);
return;
}
RTE_LOG(INFO, L2FWD, "entering main loop on lcore %u\n", lcore_id);
for (i = 0; i < qconf->n_rx_port; i++) {
portid = qconf->rx_port_list[i];
RTE_LOG(INFO, L2FWD, " -- lcoreid=%u portid=%u\n", lcore_id,
portid);
}
while (!force_quit) {
/* Drains TX queue in its main loop. 8< */
cur_tsc = rte_rdtsc();
/*
* TX burst queue drain
*/
diff_tsc = cur_tsc - prev_tsc;
if (unlikely(diff_tsc > drain_tsc)) {
for (i = 0; i < qconf->n_rx_port; i++) {
portid = l2fwd_dst_ports[qconf->rx_port_list[i]];
buffer = tx_buffer[portid];
sent = rte_eth_tx_buffer_flush(portid, 0, buffer);
if (sent)
port_statistics[portid].tx += sent;
}
/* if timer is enabled */
if (timer_period > 0) {
/* advance the timer */
timer_tsc += diff_tsc;
/* if timer has reached its timeout */
if (unlikely(timer_tsc >= timer_period)) {
/* do this only on main core */
if (lcore_id == rte_get_main_lcore()) {
print_stats();
/* reset the timer */
timer_tsc = 0;
}
}
}
prev_tsc = cur_tsc;
}
/* >8 End of draining TX queue. */
/* Read packet from RX queues. 8< */
for (i = 0; i < qconf->n_rx_port; i++) {
portid = qconf->rx_port_list[i];
nb_rx = rte_eth_rx_burst(portid, 0,
pkts_burst, MAX_PKT_BURST);
if (unlikely(nb_rx == 0))
continue;
port_statistics[portid].rx += nb_rx;
for (j = 0; j < nb_rx; j++) {
m = pkts_burst[j];
rte_prefetch0(rte_pktmbuf_mtod(m, void *));
l2fwd_simple_forward(m, portid);
}
}
/* >8 End of read packet from RX queues. */
}
}
static int
l2fwd_launch_one_lcore(__rte_unused void *dummy)
{
l2fwd_main_loop();
return 0;
}
/* display usage */
static void
l2fwd_usage(const char *prgname)
{
printf("%s [EAL options] -- -p PORTMASK [-P] [-q NQ]\n"
" -p PORTMASK: hexadecimal bitmask of ports to configure\n"
" -P : Enable promiscuous mode\n"
" -q NQ: number of queue (=ports) per lcore (default is 1)\n"
" -T PERIOD: statistics will be refreshed each PERIOD seconds (0 to disable, 10 default, 86400 maximum)\n"
" --no-mac-updating: Disable MAC addresses updating (enabled by default)\n"
" When enabled:\n"
" - The source MAC address is replaced by the TX port MAC address\n"
" - The destination MAC address is replaced by 02:00:00:00:00:TX_PORT_ID\n"
" --portmap: Configure forwarding port pair mapping\n"
" Default: alternate port pairs\n\n",
prgname);
}
static int
l2fwd_parse_portmask(const char *portmask)
{
char *end = NULL;
unsigned long pm;
/* parse hexadecimal string */
pm = strtoul(portmask, &end, 16);
if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
return 0;
return pm;
}
static int
l2fwd_parse_port_pair_config(const char *q_arg)
{
enum fieldnames {
FLD_PORT1 = 0,
FLD_PORT2,
_NUM_FLD
};
unsigned long int_fld[_NUM_FLD];
const char *p, *p0 = q_arg;
char *str_fld[_NUM_FLD];
unsigned int size;
char s[256];
char *end;
int i;
nb_port_pair_params = 0;
while ((p = strchr(p0, '(')) != NULL) {
++p;
p0 = strchr(p, ')');
if (p0 == NULL)
return -1;
size = p0 - p;
if (size >= sizeof(s))
return -1;
memcpy(s, p, size);
s[size] = '\0';
if (rte_strsplit(s, sizeof(s), str_fld,
_NUM_FLD, ',') != _NUM_FLD)
return -1;
for (i = 0; i < _NUM_FLD; i++) {
errno = 0;
int_fld[i] = strtoul(str_fld[i], &end, 0);
if (errno != 0 || end == str_fld[i] ||
int_fld[i] >= RTE_MAX_ETHPORTS)
return -1;
}
if (nb_port_pair_params >= RTE_MAX_ETHPORTS/2) {
printf("exceeded max number of port pair params: %hu\n",
nb_port_pair_params);
return -1;
}
port_pair_params_array[nb_port_pair_params].port[0] =
(uint16_t)int_fld[FLD_PORT1];
port_pair_params_array[nb_port_pair_params].port[1] =
(uint16_t)int_fld[FLD_PORT2];
++nb_port_pair_params;
}
port_pair_params = port_pair_params_array;
return 0;
}
static unsigned int
l2fwd_parse_nqueue(const char *q_arg)
{
char *end = NULL;
unsigned long n;
/* parse hexadecimal string */
n = strtoul(q_arg, &end, 10);
if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0'))
return 0;
if (n == 0)
return 0;
if (n >= MAX_RX_QUEUE_PER_LCORE)
return 0;
return n;
}
static int
l2fwd_parse_timer_period(const char *q_arg)
{
char *end = NULL;
int n;
/* parse number string */
n = strtol(q_arg, &end, 10);
if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0'))
return -1;
if (n >= MAX_TIMER_PERIOD)
return -1;
return n;
}
static const char short_options[] =
"p:" /* portmask */
"P" /* promiscuous */
"q:" /* number of queues */
"T:" /* timer period */
;
#define CMD_LINE_OPT_NO_MAC_UPDATING "no-mac-updating"
#define CMD_LINE_OPT_PORTMAP_CONFIG "portmap"
enum {
/* long options mapped to a short option */
/* first long only option value must be >= 256, so that we won't
* conflict with short options */
CMD_LINE_OPT_NO_MAC_UPDATING_NUM = 256,
CMD_LINE_OPT_PORTMAP_NUM,
};
static const struct option lgopts[] = {
{ CMD_LINE_OPT_NO_MAC_UPDATING, no_argument, 0,
CMD_LINE_OPT_NO_MAC_UPDATING_NUM},
{ CMD_LINE_OPT_PORTMAP_CONFIG, 1, 0, CMD_LINE_OPT_PORTMAP_NUM},
{NULL, 0, 0, 0}
};
/* Parse the argument given in the command line of the application */
static int
l2fwd_parse_args(int argc, char **argv)
{
int opt, ret, timer_secs;
char **argvopt;
int option_index;
char *prgname = argv[0];
argvopt = argv;
port_pair_params = NULL;
while ((opt = getopt_long(argc, argvopt, short_options,
lgopts, &option_index)) != EOF) {
switch (opt) {
/* portmask */
case 'p':
l2fwd_enabled_port_mask = l2fwd_parse_portmask(optarg);
if (l2fwd_enabled_port_mask == 0) {
printf("invalid portmask\n");
l2fwd_usage(prgname);
return -1;
}
break;
case 'P':
promiscuous_on = 1;
break;
/* nqueue */
case 'q':
l2fwd_rx_queue_per_lcore = l2fwd_parse_nqueue(optarg);
if (l2fwd_rx_queue_per_lcore == 0) {
printf("invalid queue number\n");
l2fwd_usage(prgname);
return -1;
}
break;
/* timer period */
case 'T':
timer_secs = l2fwd_parse_timer_period(optarg);
if (timer_secs < 0) {
printf("invalid timer period\n");
l2fwd_usage(prgname);
return -1;
}
timer_period = timer_secs;
break;
/* long options */
case CMD_LINE_OPT_PORTMAP_NUM:
ret = l2fwd_parse_port_pair_config(optarg);
if (ret) {
fprintf(stderr, "Invalid config\n");
l2fwd_usage(prgname);
return -1;
}
break;
case CMD_LINE_OPT_NO_MAC_UPDATING_NUM:
mac_updating = 0;
break;
default:
l2fwd_usage(prgname);
return -1;
}
}
if (optind >= 0)
argv[optind-1] = prgname;
ret = optind-1;
optind = 1; /* reset getopt lib */
return ret;
}
/*
* Check port pair config with enabled port mask,
* and for valid port pair combinations.
*/
static int
check_port_pair_config(void)
{
uint32_t port_pair_config_mask = 0;
uint32_t port_pair_mask = 0;
uint16_t index, i, portid;
for (index = 0; index < nb_port_pair_params; index++) {
port_pair_mask = 0;
for (i = 0; i < NUM_PORTS; i++) {
portid = port_pair_params[index].port[i];
if ((l2fwd_enabled_port_mask & (1 << portid)) == 0) {
printf("port %u is not enabled in port mask\n",
portid);
return -1;
}
if (!rte_eth_dev_is_valid_port(portid)) {
printf("port %u is not present on the board\n",
portid);
return -1;
}
port_pair_mask |= 1 << portid;
}
if (port_pair_config_mask & port_pair_mask) {
printf("port %u is used in other port pairs\n", portid);
return -1;
}
port_pair_config_mask |= port_pair_mask;
}
l2fwd_enabled_port_mask &= port_pair_config_mask;
return 0;
}
/* Check the link status of all ports in up to 9s, and print them finally */
static void
check_all_ports_link_status(uint32_t port_mask)
{
#define CHECK_INTERVAL 100 /* 100ms */
#define MAX_CHECK_TIME 90 /* 9s (90 * 100ms) in total */
uint16_t portid;
uint8_t count, all_ports_up, print_flag = 0;
struct rte_eth_link link;
int ret;
char link_status_text[RTE_ETH_LINK_MAX_STR_LEN];
printf("\nChecking link status");
fflush(stdout);
for (count = 0; count <= MAX_CHECK_TIME; count++) {
if (force_quit)
return;
all_ports_up = 1;
RTE_ETH_FOREACH_DEV(portid) {
if (force_quit)
return;
if ((port_mask & (1 << portid)) == 0)
continue;
memset(&link, 0, sizeof(link));
ret = rte_eth_link_get_nowait(portid, &link);
if (ret < 0) {
all_ports_up = 0;
if (print_flag == 1)
printf("Port %u link get failed: %s\n",
portid, rte_strerror(-ret));
continue;
}
/* print link status if flag set */
if (print_flag == 1) {
rte_eth_link_to_str(link_status_text,
sizeof(link_status_text), &link);
printf("Port %d %s\n", portid,
link_status_text);
continue;
}
/* clear all_ports_up flag if any link down */
if (link.link_status == RTE_ETH_LINK_DOWN) {
all_ports_up = 0;
break;
}
}
/* after finally printing all link status, get out */
if (print_flag == 1)
break;
if (all_ports_up == 0) {
printf(".");
fflush(stdout);
rte_delay_ms(CHECK_INTERVAL);
}
/* set the print_flag if all ports up or timeout */
if (all_ports_up == 1 || count == (MAX_CHECK_TIME - 1)) {
print_flag = 1;
printf("done\n");
}
}
}
static void
signal_handler(int signum)
{
if (signum == SIGINT || signum == SIGTERM) {
printf("\n\nSignal %d received, preparing to exit...\n",
signum);
force_quit = true;
}
}
int
main(int argc, char **argv)
{
struct lcore_queue_conf *qconf;
int ret;
uint16_t nb_ports;
uint16_t nb_ports_available = 0;
uint16_t portid, last_port;
unsigned lcore_id, rx_lcore_id;
unsigned nb_ports_in_mask = 0;
unsigned int nb_lcores = 0;
unsigned int nb_mbufs;
/* Init EAL. 8< */
ret = rte_eal_init(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Invalid EAL arguments\n");
argc -= ret;
argv += ret;
force_quit = false;
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
/* parse application arguments (after the EAL ones) */
ret = l2fwd_parse_args(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Invalid L2FWD arguments\n");
/* >8 End of init EAL. */
printf("MAC updating %s\n", mac_updating ? "enabled" : "disabled");
/* convert to number of cycles */
timer_period *= rte_get_timer_hz();
nb_ports = rte_eth_dev_count_avail();
if (nb_ports == 0)
rte_exit(EXIT_FAILURE, "No Ethernet ports - bye\n");
if (port_pair_params != NULL) {
if (check_port_pair_config() < 0)
rte_exit(EXIT_FAILURE, "Invalid port pair config\n");
}
/* check port mask to possible port mask */
if (l2fwd_enabled_port_mask & ~((1 << nb_ports) - 1))
rte_exit(EXIT_FAILURE, "Invalid portmask; possible (0x%x)\n",
(1 << nb_ports) - 1);
/* Initialization of the driver. 8< */
/* reset l2fwd_dst_ports */
for (portid = 0; portid < RTE_MAX_ETHPORTS; portid++)
l2fwd_dst_ports[portid] = 0;
last_port = 0;
/* populate destination port details */
if (port_pair_params != NULL) {
uint16_t idx, p;
for (idx = 0; idx < (nb_port_pair_params << 1); idx++) {
p = idx & 1;
portid = port_pair_params[idx >> 1].port[p];
l2fwd_dst_ports[portid] =
port_pair_params[idx >> 1].port[p ^ 1];
}
} else {
RTE_ETH_FOREACH_DEV(portid) {
/* skip ports that are not enabled */
if ((l2fwd_enabled_port_mask & (1 << portid)) == 0)
continue;
if (nb_ports_in_mask % 2) {
l2fwd_dst_ports[portid] = last_port;
l2fwd_dst_ports[last_port] = portid;
} else {
last_port = portid;
}
nb_ports_in_mask++;
}
if (nb_ports_in_mask % 2) {
printf("Notice: odd number of ports in portmask.\n");
l2fwd_dst_ports[last_port] = last_port;
}
}
/* >8 End of initialization of the driver. */
rx_lcore_id = 0;
qconf = NULL;
/* Initialize the port/queue configuration of each logical core */
RTE_ETH_FOREACH_DEV(portid) {
/* skip ports that are not enabled */
if ((l2fwd_enabled_port_mask & (1 << portid)) == 0)
continue;
/* get the lcore_id for this port */
while (rte_lcore_is_enabled(rx_lcore_id) == 0 ||
lcore_queue_conf[rx_lcore_id].n_rx_port ==
l2fwd_rx_queue_per_lcore) {
rx_lcore_id++;
if (rx_lcore_id >= RTE_MAX_LCORE)
rte_exit(EXIT_FAILURE, "Not enough cores\n");
}
if (qconf != &lcore_queue_conf[rx_lcore_id]) {
/* Assigned a new logical core in the loop above. */
qconf = &lcore_queue_conf[rx_lcore_id];
nb_lcores++;
}
qconf->rx_port_list[qconf->n_rx_port] = portid;
qconf->n_rx_port++;
printf("Lcore %u: RX port %u TX port %u\n", rx_lcore_id,
portid, l2fwd_dst_ports[portid]);
}
nb_mbufs = RTE_MAX(nb_ports * (nb_rxd + nb_txd + MAX_PKT_BURST +
nb_lcores * MEMPOOL_CACHE_SIZE), 8192U);
/* Create the mbuf pool. 8< */
l2fwd_pktmbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", nb_mbufs,
MEMPOOL_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE,
rte_socket_id());
if (l2fwd_pktmbuf_pool == NULL)
rte_exit(EXIT_FAILURE, "Cannot init mbuf pool\n");
/* >8 End of create the mbuf pool. */
/* Initialise each port */
RTE_ETH_FOREACH_DEV(portid) {
struct rte_eth_rxconf rxq_conf;
struct rte_eth_txconf txq_conf;
struct rte_eth_conf local_port_conf = port_conf;
struct rte_eth_dev_info dev_info;
/* skip ports that are not enabled */
if ((l2fwd_enabled_port_mask & (1 << portid)) == 0) {
printf("Skipping disabled port %u\n", portid);
continue;
}
nb_ports_available++;
/* init port */
printf("Initializing port %u... ", portid);
fflush(stdout);
ret = rte_eth_dev_info_get(portid, &dev_info);
if (ret != 0)
rte_exit(EXIT_FAILURE,
"Error during getting device (port %u) info: %s\n",
portid, strerror(-ret));
if (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE)
local_port_conf.txmode.offloads |=
RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE;
/* Configure the number of queues for a port. */
ret = rte_eth_dev_configure(portid, 1, 1, &local_port_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Cannot configure device: err=%d, port=%u\n",
ret, portid);
/* >8 End of configuration of the number of queues for a port. */
ret = rte_eth_dev_adjust_nb_rx_tx_desc(portid, &nb_rxd,
&nb_txd);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"Cannot adjust number of descriptors: err=%d, port=%u\n",
ret, portid);
ret = rte_eth_macaddr_get(portid,
&l2fwd_ports_eth_addr[portid]);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"Cannot get MAC address: err=%d, port=%u\n",
ret, portid);
/* init one RX queue */
fflush(stdout);
rxq_conf = dev_info.default_rxconf;
rxq_conf.offloads = local_port_conf.rxmode.offloads;
/* RX queue setup. 8< */
ret = rte_eth_rx_queue_setup(portid, 0, nb_rxd,
rte_eth_dev_socket_id(portid),
&rxq_conf,
l2fwd_pktmbuf_pool);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_rx_queue_setup:err=%d, port=%u\n",
ret, portid);
/* >8 End of RX queue setup. */
/* Init one TX queue on each port. 8< */
fflush(stdout);
txq_conf = dev_info.default_txconf;
txq_conf.offloads = local_port_conf.txmode.offloads;
ret = rte_eth_tx_queue_setup(portid, 0, nb_txd,
rte_eth_dev_socket_id(portid),
&txq_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_tx_queue_setup:err=%d, port=%u\n",
ret, portid);
/* >8 End of init one TX queue on each port. */
/* Initialize TX buffers */
tx_buffer[portid] = rte_zmalloc_socket("tx_buffer",
RTE_ETH_TX_BUFFER_SIZE(MAX_PKT_BURST), 0,
rte_eth_dev_socket_id(portid));
if (tx_buffer[portid] == NULL)
rte_exit(EXIT_FAILURE, "Cannot allocate buffer for tx on port %u\n",
portid);
rte_eth_tx_buffer_init(tx_buffer[portid], MAX_PKT_BURST);
ret = rte_eth_tx_buffer_set_err_callback(tx_buffer[portid],
rte_eth_tx_buffer_count_callback,
&port_statistics[portid].dropped);
if (ret < 0)
rte_exit(EXIT_FAILURE,
"Cannot set error callback for tx buffer on port %u\n",
portid);
ret = rte_eth_dev_set_ptypes(portid, RTE_PTYPE_UNKNOWN, NULL,
0);
if (ret < 0)
printf("Port %u, Failed to disable Ptype parsing\n",
portid);
/* Start device */
ret = rte_eth_dev_start(portid);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_dev_start:err=%d, port=%u\n",
ret, portid);
printf("done: \n");
if (promiscuous_on) {
ret = rte_eth_promiscuous_enable(portid);
if (ret != 0)
rte_exit(EXIT_FAILURE,
"rte_eth_promiscuous_enable:err=%s, port=%u\n",
rte_strerror(-ret), portid);
}
printf("Port %u, MAC address: " RTE_ETHER_ADDR_PRT_FMT "\n\n",
portid,
RTE_ETHER_ADDR_BYTES(&l2fwd_ports_eth_addr[portid]));
/* initialize port stats */
memset(&port_statistics, 0, sizeof(port_statistics));
}
if (!nb_ports_available) {
rte_exit(EXIT_FAILURE,
"All available ports are disabled. Please set portmask.\n");
}
check_all_ports_link_status(l2fwd_enabled_port_mask);
ret = 0;
/* launch per-lcore init on every lcore */
rte_eal_mp_remote_launch(l2fwd_launch_one_lcore, NULL, CALL_MAIN);
RTE_LCORE_FOREACH_WORKER(lcore_id) {
if (rte_eal_wait_lcore(lcore_id) < 0) {
ret = -1;
break;
}
}
RTE_ETH_FOREACH_DEV(portid) {
if ((l2fwd_enabled_port_mask & (1 << portid)) == 0)
continue;
printf("Closing port %d...", portid);
ret = rte_eth_dev_stop(portid);
if (ret != 0)
printf("rte_eth_dev_stop: err=%d, port=%d\n",
ret, portid);
rte_eth_dev_close(portid);
printf(" Done\n");
}
/* clean up the EAL */
rte_eal_cleanup();
printf("Bye...\n");
return ret;
}函数讲解
static void l2fwd_main_loop(void)
static void
l2fwd_main_loop(void)
{
/* 定义用于接收数据包的 mbuf 数组指针，大小为 MAX_PKT_BURST (32) */
struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
struct rte_mbuf *m;
int sent;
unsigned lcore_id;
/* 时间戳相关变量，用于定时任务 */
uint64_t prev_tsc, diff_tsc, cur_tsc, timer_tsc;
unsigned i, j, portid, nb_rx;
struct lcore_queue_conf *qconf;
/* 计算 TX 缓冲区刷新的时间阈值（基于 CPU 频率），这里约等于 100 微秒 */
const uint64_t drain_tsc = (rte_get_tsc_hz() + US_PER_S - 1) / US_PER_S *
BURST_TX_DRAIN_US;
struct rte_eth_dev_tx_buffer *buffer;
prev_tsc = 0;
timer_tsc = 0;
/* 获取当前逻辑核的 ID */
lcore_id = rte_lcore_id();
/* 获取该逻辑核的配置（负责哪些端口） */
qconf = &lcore_queue_conf[lcore_id];
/* 如果该逻辑核没有分配到任何 RX 端口，则直接返回，不参与循环 */
if (qconf->n_rx_port == 0) {
RTE_LOG(INFO, L2FWD, "lcore %u has nothing to do\n", lcore_id);
return;
}
RTE_LOG(INFO, L2FWD, "entering main loop on lcore %u\n", lcore_id);
/* 打印该逻辑核负责的所有 RX 端口 */
for (i = 0; i < qconf->n_rx_port; i++) {
portid = qconf->rx_port_list[i];
RTE_LOG(INFO, L2FWD, " -- lcoreid=%u portid=%u\n", lcore_id,
portid);
}
/* 主循环：只要没收到退出信号（force_quit），就一直运行 */
while (!force_quit) {
/* Drains TX queue in its main loop. 8< */
/* 获取当前的 TSC (Time Stamp Counter) 周期数 */
cur_tsc = rte_rdtsc();
/*
* TX burst queue drain
* 检查是否需要刷新 TX 缓冲区
*/
diff_tsc = cur_tsc - prev_tsc;
/* 如果距离上次检查的时间超过了 drain_tsc (约 100us) */
if (unlikely(diff_tsc > drain_tsc)) {
/* 遍历该核心负责的所有端口 */
for (i = 0; i < qconf->n_rx_port; i++) {
/* 获取接收端口对应的目的端口（发送端口） */
portid = l2fwd_dst_ports[qconf->rx_port_list[i]];
buffer = tx_buffer[portid];
/* 强制刷新 TX 缓冲区，将缓存的包发送出去 */
sent = rte_eth_tx_buffer_flush(portid, 0, buffer);
if (sent)
port_statistics[portid].tx += sent;
}
/* if timer is enabled */
/* 统计信息打印定时器 */
if (timer_period > 0) {
/* advance the timer */
timer_tsc += diff_tsc;
/* if timer has reached its timeout */
/* 如果累计时间超过了设定的打印周期（默认 10 秒） */
if (unlikely(timer_tsc >= timer_period)) {
/* do this only on main core */
/* 只有主核负责打印统计信息，避免输出混乱 */
if (lcore_id == rte_get_main_lcore()) {
print_stats();
/* reset the timer */
timer_tsc = 0;
}
}
}
/* 更新上次检查的时间戳 */
prev_tsc = cur_tsc;
}
/* >8 End of draining TX queue. */
/* Read packet from RX queues. 8< */
/* 遍历该核心负责的所有 RX 端口，进行收包 */
for (i = 0; i < qconf->n_rx_port; i++) {
portid = qconf->rx_port_list[i];
/* 从端口接收一批数据包，最大为 MAX_PKT_BURST */
nb_rx = rte_eth_rx_burst(portid, 0,
pkts_burst, MAX_PKT_BURST);
/* 如果没有收到包，继续下一个端口 */
if (unlikely(nb_rx == 0))
continue;
/* 更新接收统计 */
port_statistics[portid].rx += nb_rx;
/* 处理接收到的每一个数据包 */
for (j = 0; j < nb_rx; j++) {
m = pkts_burst[j];
/* 预取数据包头部到 CPU 缓存，提高后续处理速度 */
rte_prefetch0(rte_pktmbuf_mtod(m, void *));
/* 调用转发函数进行处理和发送 */
l2fwd_simple_forward(m, portid);
}
}
/* >8 End of read packet from RX queues. */
}
}
这个函数是二层转发最核心的函数，主要任务是从 RX 队列批量读取入口包，大小为 MAX_PKT_BURST，rte_eth_rx_burst()函数将 mbuf 指针写入本地表，并返回表中可用的 mbuf 数量。然后，表中的每个 mbuf 由 l2fwd_simple_forward() 函数处理。l2fwd_simple_forward() 函数处理过程非常简单：先从接收端口处理 TX 端口，然后如果启用 MAC 地址更新，替换源和目的 MAC 地址。
参数解析
l2fwd_usage(const char *prgname)：打印程序的使用帮助信息。
l2fwd_parse_portmask(const char *portmask)：解析 -p 参数，使用 strtoul 将十六进制字符串转换为 unsigned long 类型的位掩码。
l2fwd_parse_nqueue(const char *q_arg)：解析 -q 参数（每个核的队列数）。
l2fwd_parse_timer_period(const char *q_arg)：解析 -T 参数（统计刷新周期）。
l2fwd_parse_port_pair_config(const char *q_arg)：解析 --portmap 参数，允许用户手动指定转发关系。
l2fwd_parse_args(int argc, char **argv)：命令行参数解析的主入口，使用标准的 getopt_long 函数库来处理短选项（如 -p ）和长选项（如 --portmap ）。
check_port_pair_config(void)：在参数解析完成后，验证用户指定的端口对配置是否合法，如：配置的端口必须在 -p 指定的端口掩码中开启、端口必须是 DPDK 能够识别的有效端口、一个端口不能被重复使用在多个配对中。
程序执行流程
EAL初始化：
// 初始化EAL，解析EAL参数（如-l指定lcore、-n指定内存通道数）
ret = rte_eal_init(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Invalid EAL arguments\n");
argc -= ret; // 调整参数个数，跳过已解析的EAL参数
argv += ret; // 调整参数指针，指向后续的应用层参数
// 初始化退出标记，绑定信号处理函数（Ctrl+C/SIGINT、SIGTERM）
force_quit = false;
signal(SIGINT, signal_handler); // Ctrl+C触发signal_handler，置force_quit=1
signal(SIGTERM, signal_handler); // 进程终止信号触发
// 解析L2FWD应用层参数（如--portmask、--promiscuous、--mac-updating）
ret = l2fwd_parse_args(argc, argv);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Invalid L2FWD arguments\n");
基础检查与端口转发配对配置：
printf("MAC updating %s\n", mac_updating ? "enabled" : "disabled");
// 转换定时器周期为CPU周期数（用于后续统计/定时，本文未实际使用）
timer_period *= rte_get_timer_hz();
// 获取DPDK识别的所有可用物理端口数
nb_ports = rte_eth_dev_count_avail();
if (nb_ports == 0)
rte_exit(EXIT_FAILURE, "No Ethernet ports - bye\n");
// 若用户自定义了端口配对（port_pair_params），检查配置合法性
if (port_pair_params != NULL) {
if (check_port_pair_config() < 0)
rte_exit(EXIT_FAILURE, "Invalid port pair config\n");
}
// 检查端口掩码是否合法：掩码不能包含超出可用端口数的端口
if (l2fwd_enabled_port_mask & ~((1 << nb_ports) - 1))
rte_exit(EXIT_FAILURE, "Invalid portmask; possible (0x%x)\n", (1 << nb_ports) - 1);
配置转发目标端口（l2fwd_dst_ports 数组）：
// 重置转发目标端口数组，初始值为0
for (portid = 0; portid < RTE_MAX_ETHPORTS; portid++)
l2fwd_dst_ports[portid] = 0;
last_port = 0;
// 模式1：用户自定义端口配对（如指定0→2、1→3）
if (port_pair_params != NULL) {
uint16_t idx, p;
for (idx = 0; idx < (nb_port_pair_params << 1); idx++) {
p = idx & 1; // 0或1，代表配对的两个端口
portid = port_pair_params[idx >> 1].port[p];
// 配对端口互指：port[p]的目标是port[p^1]，port[p^1]的目标是port[p]
l2fwd_dst_ports[portid] = port_pair_params[idx >> 1].port[p ^ 1];
}
}
// 模式2：默认自动奇偶配对（无自定义时，0↔1、2↔3，奇数个端口则最后一个自环）
else {
RTE_ETH_FOREACH_DEV(portid) {
if ((l2fwd_enabled_port_mask & (1 << portid)) == 0)
continue; // 跳过未启用的端口
if (nb_ports_in_mask % 2) { // 奇数个已启用端口：和上一个端口配对
l2fwd_dst_ports[portid] = last_port; // 当前端口→上一个端口
l2fwd_dst_ports[last_port] = portid; // 上一个端口→当前端口
} else { // 偶数个已启用端口：暂存为last_port，等待下一个端口配对
last_port = portid;
}
nb_ports_in_mask++;
}
// 若总启用端口数为奇数：最后一个端口自环（自己转发给自己）
if (nb_ports_in_mask % 2) {
printf("Notice: odd number of ports in portmask.\n");
l2fwd_dst_ports[last_port] = last_port;
}
}
lcore与端口绑定:
rx_lcore_id = 0; // 从lcore 0开始分配
qconf = NULL; // 指向当前lcore的配置结构体
// 遍历所有端口，为每个启用的端口分配lcore
RTE_ETH_FOREACH_DEV(portid) {
if ((l2fwd_enabled_port_mask & (1 << portid)) == 0)
continue;
// 找到可用的lcore：必须是启用的，且未达到每lcore最大RX端口数
while (rte_lcore_is_enabled(rx_lcore_id) == 0 ||
lcore_queue_conf[rx_lcore_id].n_rx_port == l2fwd_rx_queue_per_lcore) {
rx_lcore_id++;
if (rx_lcore_id >= RTE_MAX_LCORE)
rte_exit(EXIT_FAILURE, "Not enough cores\n");
}
// 为当前端口分配了新的lcore，更新配置指针并统计lcore数
if (qconf != &lcore_queue_conf[rx_lcore_id]) {
qconf = &lcore_queue_conf[rx_lcore_id];
nb_lcores++; // 实际用到的lcore数
}
// 将当前端口加入该lcore的RX端口列表
qconf->rx_port_list[qconf->n_rx_port] = portid;
qconf->n_rx_port++;
// 打印绑定关系：lcore X 负责 RX端口Y → TX端口Z
printf("Lcore %u: RX port %u TX port %u\n", rx_lcore_id,
portid, l2fwd_dst_ports[portid]);
}
mbuf池创建:
// 计算需要的mbuf数量：结合端口数、描述符数、lcore缓存，最小8192
nb_mbufs = RTE_MAX(nb_ports * (nb_rxd + nb_txd + MAX_PKT_BURST + nb_lcores * MEMPOOL_CACHE_SIZE), 8192U);
// 创建mbuf内存池
l2fwd_pktmbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", nb_mbufs,
MEMPOOL_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE,
rte_socket_id());
if (l2fwd_pktmbuf_pool == NULL)
rte_exit(EXIT_FAILURE, "Cannot init mbuf pool\n");
网卡端口初始化:
RTE_ETH_FOREACH_DEV(portid) {
struct rte_eth_rxconf rxq_conf;
struct rte_eth_txconf txq_conf;
struct rte_eth_conf local_port_conf = port_conf; // 端口核心配置
struct rte_eth_dev_info dev_info; // 网卡设备信息
if ((l2fwd_enabled_port_mask & (1 << portid)) == 0) {
printf("Skipping disabled port %u\n", portid);
continue;
}
nb_ports_available++; // 统计实际启用并初始化的端口数
printf("Initializing port %u... ", portid);
fflush(stdout);
// 步骤1：获取网卡设备信息（支持的卸载能力、默认队列配置等）
ret = rte_eth_dev_info_get(portid, &dev_info);
if (ret != 0)
rte_exit(EXIT_FAILURE, "Error during getting device info: %s\n", portid, strerror(-ret));
// 步骤2：启用TX MBUF快速释放卸载（硬件加速，提升发包性能）
if (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE)
local_port_conf.txmode.offloads |= RTE_ETH_TX_OFFLOAD_MBUF_FAST_FREE;
// 步骤3：配置端口：1个RX队列、1个TX队列，使用自定义配置
ret = rte_eth_dev_configure(portid, 1, 1, &local_port_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Cannot configure device: err=%d, port=%u\n", ret, portid);
// 步骤4：调整RX/TX描述符数（适配硬件限制，如必须是2的幂）
ret = rte_eth_dev_adjust_nb_rx_tx_desc(portid, &nb_rxd, &nb_txd);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Cannot adjust number of descriptors: err=%d, port=%u\n", ret, portid);
// 步骤5：获取端口MAC地址，存入全局数组（后续二层转发替换源MAC用）
ret = rte_eth_macaddr_get(portid, &l2fwd_ports_eth_addr[portid]);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Cannot get MAC address: err=%d, port=%u\n", ret, portid);
// 步骤6：初始化RX队列（1个）：绑定mbuf池、NUMA本地化
rxq_conf = dev_info.default_rxconf;
rxq_conf.offloads = local_port_conf.rxmode.offloads;
ret = rte_eth_rx_queue_setup(portid, 0, nb_rxd,
rte_eth_dev_socket_id(portid), &rxq_conf, l2fwd_pktmbuf_pool);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_rx_queue_setup:err=%d, port=%u\n", ret, portid);
// 步骤7：初始化TX队列（1个）：启用硬件卸载、NUMA本地化
txq_conf = dev_info.default_txconf;
txq_conf.offloads = local_port_conf.txmode.offloads;
ret = rte_eth_tx_queue_setup(portid, 0, nb_txd,
rte_eth_dev_socket_id(portid), &txq_conf);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_tx_queue_setup:err=%d, port=%u\n", ret, portid);
// 步骤8：创建并初始化TX缓冲区（批量发包优化，减少硬件交互）
tx_buffer[portid] = rte_zmalloc_socket("tx_buffer",
RTE_ETH_TX_BUFFER_SIZE(MAX_PKT_BURST), 0,
rte_eth_dev_socket_id(portid));
if (tx_buffer[portid] == NULL)
rte_exit(EXIT_FAILURE, "Cannot allocate buffer for tx on port %u\n", portid);
rte_eth_tx_buffer_init(tx_buffer[portid], MAX_PKT_BURST);
// 为TX缓冲区设置错误回调（统计发包失败的丢包数）
ret = rte_eth_tx_buffer_set_err_callback(tx_buffer[portid],
rte_eth_tx_buffer_count_callback, &port_statistics[portid].dropped);
if (ret < 0)
rte_exit(EXIT_FAILURE, "Cannot set error callback for tx buffer on port %u\n", portid);
// 步骤9：禁用Ptype解析（减少网卡硬件开销，无需解析数据包类型）
ret = rte_eth_dev_set_ptypes(portid, RTE_PTYPE_UNKNOWN, NULL, 0);
if (ret < 0)
printf("Port %u, Failed to disable Ptype parsing\n", portid);
// 步骤10：启动网卡端口（所有配置生效，端口进入就绪状态）
ret = rte_eth_dev_start(portid);
if (ret < 0)
rte_exit(EXIT_FAILURE, "rte_eth_dev_start:err=%d, port=%u\n", ret, portid);
printf("done: \n");
// 步骤11：启用混杂模式（接收所有数据包，二层转发必做）
if (promiscuous_on) {
ret = rte_eth_promiscuous_enable(portid);
if (ret != 0)
rte_exit(EXIT_FAILURE, "rte_eth_promiscuous_enable:err=%s, port=%u\n", rte_strerror(-ret), portid);
}
// 打印端口MAC地址
printf("Port %u, MAC address: " RTE_ETHER_ADDR_PRT_FMT "\n\n",
portid, RTE_ETHER_ADDR_BYTES(&l2fwd_ports_eth_addr[portid]));
// 步骤12：初始化端口统计信息（收包、发包、丢包数置0）
memset(&port_statistics, 0, sizeof(port_statistics));
}
// 检查是否有可用的端口，无则退出
if (!nb_ports_available) {
rte_exit(EXIT_FAILURE, "All available ports are disabled. Please set portmask.\n");
}
链路状态检查:
// 检查所有启用端口的链路状态，最长9秒，打印最终结果
check_all_ports_link_status(l2fwd_enabled_port_mask)
启动多lcore转发线程:
ret = 0;
// 向所有启用的worker lcore分发转发函数 l2fwd_launch_one_lcore
rte_eal_mp_remote_launch(l2fwd_launch_one_lcore, NULL, CALL_MAIN);
// 等待所有worker lcore执行完成，检查返回值
RTE_LCORE_FOREACH_WORKER(lcore_id) {
if (rte_eal_wait_lcore(lcore_id) < 0) {
ret = -1;
break;
}
}
等待执行，然后关闭端口和EAL清理:
// 遍历所有启用的端口，停止并关闭网卡
RTE_ETH_FOREACH_DEV(portid) {
if ((l2fwd_enabled_port_mask & (1 << portid)) == 0)
continue;
printf("Closing port %d...", portid);
ret = rte_eth_dev_stop(portid); // 停止端口（停止收发包）
if (ret != 0)
printf("rte_eth_dev_stop: err=%d, port=%d\n", ret, portid);
rte_eth_dev_close(portid); // 关闭端口（释放硬件资源）
printf(" Done\n");
}
// 清理EAL环境，释放所有底层资源（大页内存、PCIe设备、lcore等）
rte_eal_cleanup();
printf("Bye...\n");
return ret;
程序运行结果
我的程序是在Ubuntu22.04的虚拟机上运行的
./<build_dir>/examples/dpdk-l2fwd [EAL options] -- -p PORTMASK [-P] [-q NQ] --[no-]mac-updating [--portmap="(port, port)[,(port, port)]"]
EAL options 为环境抽象层（EAL）选项的一般信息，具体配置方法可以看这篇文档：9. EAL 参数 --- 数据平面开发套件 25.11.0 文档 --- 9. EAL parameters --- Data Plane Development Kit 25.11.0 documentation
p PORTMASK：用于配置端口的十六进制比特掩码
P：可选，将所有端口设置为混杂模式，使数据包无论 MAC 目的地址如何都能被接受。如果没有该选项，只有 MAC 目标地址设置为该端口以太网地址的数据包才被接受。
q NQ：每个核心的最大队列数（默认为 1）
--[no-]mac-updating ：启用或禁用 MAC 地址更新（默认启用）
--portmap="（port，port）[，（port，port）]"：决定转发端口映射。
dpdk二层转发机配置：
虚拟机设置：
查看网卡驱动（使用dpdk的usertools中的dpdk-devbind.py脚本）：
bash
yy@yy:~/dpdk/dpdk-stable-24.11.4/usertools$ ./dpdk-devbind.py -s
Network devices using DPDK-compatible driver
============================================
0000:02:05.0 '82545EM Gigabit Ethernet Controller (Copper) 100f' drv=vfio-pci unused=e1000
0000:02:06.0 '82545EM Gigabit Ethernet Controller (Copper) 100f' drv=vfio-pci unused=e1000
0000:02:07.0 '82545EM Gigabit Ethernet Controller (Copper) 100f' drv=vfio-pci unused=e1000
0000:02:08.0 '82545EM Gigabit Ethernet Controller (Copper) 100f' drv=vfio-pci unused=e1000
Network devices using kernel driver
===================================
0000:02:01.0 '82545EM Gigabit Ethernet Controller (Copper) 100f' if=ens33 drv=e1000 unused=vfio-pci *Active*
No 'Baseband' devices detected
==============================
No 'Crypto' devices detected
============================
No 'DMA' devices detected
=========================
No 'Eventdev' devices detected
==============================
No 'Mempool' devices detected
=============================
No 'Compress' devices detected
==============================
No 'Misc (rawdev)' devices detected
===================================
No 'Regex' devices detected
===========================
No 'ML' devices detected
========================绑定网卡驱动同样也是使用dpdk-devbind.py脚本（其中vfio-pci为dpdk程序运行网卡时所需要的驱动，0000:02:05.0为我需要绑定的网卡的编号）
bash
./dpdk-devbind.py -b vfio-pci 0000:02:05.0编译与运行:
在这个路径下执行make可以编译dpdk二层转发应用示例：
bash
root@yy:/home/yy/dpdk/dpdk-stable-24.11.4/examples/l2fwd# make运行dpdk二层转发应用示例，-l指定运行的逻辑和为lcore0和lcore1，-q指定每个逻辑核有两个队列，-p指定端口掩码，3在二进制下为11，表示端口0和端口1：
bash
root@yy:/home/yy/dpdk/dpdk-stable-24.11.4/examples/l2fwd# ./build/l2fwd -l 0-1 -- -q 2 -p 3运行后可以看到这个结果:
bash
root@yy:/home/yy/dpdk/dpdk-stable-24.11.4/examples/l2fwd# ./build/l2fwd -l 0-1 -- -q 2 -p 3
EAL: Detected CPU lcores: 4
EAL: Detected NUMA nodes: 1
EAL: Detected shared linkage of DPDK
EAL: Multi-process socket /var/run/dpdk/rte/mp_socket
EAL: Selected IOVA mode 'PA'
EAL: VFIO support initialized
EAL: Using IOMMU type 8 (No-IOMMU)
MAC updating enabled
Lcore 0: RX port 0 TX port 1
Lcore 0: RX port 1 TX port 0
Initializing port 0... EAL: Error enabling MSI-X interrupts for fd 22
done:
Port 0, MAC address: 00:0C:29:FB:49:F3
Initializing port 1... EAL: Error enabling MSI-X interrupts for fd 26
done:
Port 1, MAC address: 00:0C:29:FB:49:FD
Skipping disabled port 2
Skipping disabled port 3
Checking link statusdone
Port 0 Link up at 1 Gbps FDX Autoneg
Port 1 Link up at 1 Gbps FDX Autoneg
L2FWD: lcore 1 has nothing to do
L2FWD: entering main loop on lcore 0
L2FWD: -- lcoreid=0 portid=0
L2FWD: -- lcoreid=0 portid=1
Port statistics ====================================
Statistics for port 0 ------------------------------
Packets sent: 0
Packets received: 0
Packets dropped: 0
Statistics for port 1 ------------------------------
Packets sent: 0
Packets received: 0
Packets dropped: 0
Aggregate statistics ===============================
Total packets sent: 0
Total packets received: 0
Total packets dropped: 0
====================================================发包机配置：
虚拟机设置：
ip地址配置：
bash
root@yy:~# ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 00:0c:29:38:40:42 brd ff:ff:ff:ff:ff:ff
altname enp2s1
inet 192.168.1.125/24 metric 100 brd 192.168.1.255 scope global dynamic ens33
valid_lft 245801sec preferred_lft 245801sec
inet6 2409:8a62:2115:8800:20c:29ff:fe38:4042/64 scope global dynamic mngtmpaddr noprefixroute
valid_lft 259072sec preferred_lft 172672sec
inet6 fe80::20c:29ff:fe38:4042/64 scope link
valid_lft forever preferred_lft forever
3: ens37: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 00:0c:29:38:40:4c brd ff:ff:ff:ff:ff:ff
altname enp2s5
inet 1.1.1.1/24 scope global ens37
valid_lft forever preferred_lft forever
inet6 fe80::20c:29ff:fe38:404c/64 scope link
valid_lft forever preferred_lft forever抓包机配置：
虚拟机设置：
ip地址配置：
bash
root@yy:~# ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 00:0c:29:21:a9:e4 brd ff:ff:ff:ff:ff:ff
altname enp2s1
inet 192.168.1.126/24 metric 100 brd 192.168.1.255 scope global dynamic ens33
valid_lft 245766sec preferred_lft 245766sec
inet6 2409:8a62:2115:8800:20c:29ff:fe21:a9e4/64 scope global dynamic mngtmpaddr noprefixroute
valid_lft 259037sec preferred_lft 172637sec
inet6 fe80::20c:29ff:fe21:a9e4/64 scope link
valid_lft forever preferred_lft forever
3: ens37: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 00:0c:29:21:a9:ee brd ff:ff:ff:ff:ff:ff
altname enp2s5
inet 1.1.1.2/24 scope global ens37
valid_lft forever preferred_lft forever
inet6 fe80::20c:29ff:fe21:a9ee/64 scope link
valid_lft forever preferred_lft forever运行结果：
二层转发机：
bash
Port statistics ====================================
Statistics for port 0 ------------------------------
Packets sent: 3
Packets received: 0
Packets dropped: 0
Statistics for port 1 ------------------------------
Packets sent: 0
Packets received: 3
Packets dropped: 0
Aggregate statistics ===============================
Total packets sent: 3
Total packets received: 3
Total packets dropped: 0
====================================================可以看到端口1收到了3个包，并且将这三个包从端口0发送了出去，符合预期。
发包机：
bash
root@yy:~# hping3 -I ens37 -c 1 1.1.1.1
HPING 1.1.1.1 (ens37 1.1.1.1): NO FLAGS are set, 40 headers + 0 data bytes
--- 1.1.1.1 hping statistic ---
1 packets transmitted, 0 packets received, 100% packet loss
round-trip min/avg/max = 0.0/0.0/0.0 ms发包机从ens37端口向1.1.1.1（抓包机的ip地址）发送了一个数据包。
抓包机：
bash
root@yy:~# tcpdump -i ens37 -nnv
tcpdump: listening on ens37, link-type EN10MB (Ethernet), snapshot length 262144 bytes
11:48:39.721636 ARP, Ethernet (len 6), IPv4 (len 4), Request who-has 1.1.1.1 tell 1.1.1.2, length 46
11:48:40.736572 ARP, Ethernet (len 6), IPv4 (len 4), Request who-has 1.1.1.1 tell 1.1.1.2, length 46
11:48:41.761196 ARP, Ethernet (len 6), IPv4 (len 4), Request who-has 1.1.1.1 tell 1.1.1.2, length 抓包机收到3个ARP请求包，询问1.1.1.1的MAC，但抓包机没有响应ARP，所以发包机无法获得目标MAC，无法发送真正的数据包。不过l2fwd程序是正常运行了的。
解决方案：
相关参考文档
dpdk优质教学视频：【全程干货-实战的DPDK入门视频】https://www.bilibili.com/video/BV1obshzcEUV?vd_source=93b8e5bd54bce5ce350bfa7725b6b58e