f2fc83b40f
There is a common macro __rte_unused, avoiding warnings, which is now used where appropriate for consistency. Signed-off-by: Thomas Monjalon <thomas@monjalon.net>
822 lines
20 KiB
C
822 lines
20 KiB
C
/* 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 <netinet/in.h>
|
|
#include <setjmp.h>
|
|
#include <stdarg.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <getopt.h>
|
|
#include <signal.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_atomic.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_timer.h>
|
|
#include <rte_keepalive.h>
|
|
|
|
#include "shm.h"
|
|
|
|
#define RTE_LOGTYPE_L2FWD RTE_LOGTYPE_USER1
|
|
|
|
#define NB_MBUF 8192
|
|
|
|
#define MAX_PKT_BURST 32
|
|
#define BURST_TX_DRAIN_US 100 /* TX drain every ~100us */
|
|
|
|
/*
|
|
* Configurable number of RX/TX ring descriptors
|
|
*/
|
|
#define RTE_TEST_RX_DESC_DEFAULT 1024
|
|
#define RTE_TEST_TX_DESC_DEFAULT 1024
|
|
static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT;
|
|
static uint16_t nb_txd = RTE_TEST_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;
|
|
|
|
/* list of enabled ports */
|
|
static uint32_t l2fwd_dst_ports[RTE_MAX_ETHPORTS];
|
|
|
|
static unsigned int l2fwd_rx_queue_per_lcore = 1;
|
|
|
|
#define MAX_RX_QUEUE_PER_LCORE 16
|
|
#define MAX_TX_QUEUE_PER_PORT 16
|
|
struct lcore_queue_conf {
|
|
unsigned n_rx_port;
|
|
unsigned rx_port_list[MAX_RX_QUEUE_PER_LCORE];
|
|
} __rte_cache_aligned;
|
|
struct lcore_queue_conf lcore_queue_conf[RTE_MAX_LCORE];
|
|
|
|
struct rte_eth_dev_tx_buffer *tx_buffer[RTE_MAX_ETHPORTS];
|
|
|
|
static struct rte_eth_conf port_conf = {
|
|
.rxmode = {
|
|
.split_hdr_size = 0,
|
|
},
|
|
.txmode = {
|
|
.mq_mode = ETH_MQ_TX_NONE,
|
|
},
|
|
};
|
|
|
|
struct rte_mempool *l2fwd_pktmbuf_pool = NULL;
|
|
|
|
/* Per-port statistics struct */
|
|
struct l2fwd_port_statistics {
|
|
uint64_t tx;
|
|
uint64_t rx;
|
|
uint64_t dropped;
|
|
} __rte_cache_aligned;
|
|
struct l2fwd_port_statistics port_statistics[RTE_MAX_ETHPORTS];
|
|
|
|
/* A tsc-based timer responsible for triggering statistics printout */
|
|
#define TIMER_MILLISECOND 1
|
|
#define MAX_TIMER_PERIOD 86400 /* 1 day max */
|
|
static int64_t timer_period = 10 * TIMER_MILLISECOND * 1000; /* 10 seconds */
|
|
static int64_t check_period = 5; /* default check cycle is 5ms */
|
|
|
|
/* Keepalive structure */
|
|
struct rte_keepalive *rte_global_keepalive_info;
|
|
|
|
/* Termination signalling */
|
|
static int terminate_signal_received;
|
|
|
|
/* Termination signal handler */
|
|
static void handle_sigterm(__rte_unused int value)
|
|
{
|
|
terminate_signal_received = 1;
|
|
}
|
|
|
|
/* Print out statistics on packets dropped */
|
|
static void
|
|
print_stats(__rte_unused struct rte_timer *ptr_timer,
|
|
__rte_unused void *ptr_data)
|
|
{
|
|
uint64_t total_packets_dropped, total_packets_tx, total_packets_rx;
|
|
uint16_t 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");
|
|
}
|
|
|
|
static void
|
|
l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid)
|
|
{
|
|
struct rte_ether_hdr *eth;
|
|
void *tmp;
|
|
int sent;
|
|
unsigned dst_port;
|
|
struct rte_eth_dev_tx_buffer *buffer;
|
|
|
|
dst_port = l2fwd_dst_ports[portid];
|
|
eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
|
|
|
|
/* 02:00:00:00:00:xx */
|
|
tmp = ð->d_addr.addr_bytes[0];
|
|
*((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40);
|
|
|
|
/* src addr */
|
|
rte_ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], ð->s_addr);
|
|
|
|
buffer = tx_buffer[dst_port];
|
|
sent = rte_eth_tx_buffer(dst_port, 0, buffer, m);
|
|
if (sent)
|
|
port_statistics[dst_port].tx += sent;
|
|
}
|
|
|
|
/* 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;
|
|
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;
|
|
|
|
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);
|
|
}
|
|
|
|
uint64_t tsc_initial = rte_rdtsc();
|
|
uint64_t tsc_lifetime = (rand()&0x07) * rte_get_tsc_hz();
|
|
|
|
while (!terminate_signal_received) {
|
|
/* Keepalive heartbeat */
|
|
rte_keepalive_mark_alive(rte_global_keepalive_info);
|
|
|
|
cur_tsc = rte_rdtsc();
|
|
|
|
/*
|
|
* Die randomly within 7 secs for demo purposes if
|
|
* keepalive enabled
|
|
*/
|
|
if (check_period > 0 && cur_tsc - tsc_initial > tsc_lifetime)
|
|
break;
|
|
|
|
/*
|
|
* 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;
|
|
|
|
}
|
|
|
|
prev_tsc = cur_tsc;
|
|
}
|
|
|
|
/*
|
|
* Read packet from RX queues
|
|
*/
|
|
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);
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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 [-q NQ]\n"
|
|
" -p PORTMASK: hexadecimal bitmask of ports to configure\n"
|
|
" -q NQ: number of queue (=ports) per lcore (default is 1)\n"
|
|
" -K PERIOD: Keepalive check period (5 default; 86400 max)\n"
|
|
" -T PERIOD: statistics will be refreshed each PERIOD seconds (0 to disable, 10 default, 86400 maximum)\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 -1;
|
|
|
|
if (pm == 0)
|
|
return -1;
|
|
|
|
return pm;
|
|
}
|
|
|
|
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 int
|
|
l2fwd_parse_check_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;
|
|
}
|
|
|
|
/* Parse the argument given in the command line of the application */
|
|
static int
|
|
l2fwd_parse_args(int argc, char **argv)
|
|
{
|
|
int opt, ret;
|
|
char **argvopt;
|
|
int option_index;
|
|
char *prgname = argv[0];
|
|
static struct option lgopts[] = {
|
|
{NULL, 0, 0, 0}
|
|
};
|
|
|
|
argvopt = argv;
|
|
|
|
while ((opt = getopt_long(argc, argvopt, "p:q:T:K:",
|
|
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;
|
|
|
|
/* 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_period = l2fwd_parse_timer_period(optarg)
|
|
* (int64_t)(1000 * TIMER_MILLISECOND);
|
|
if (timer_period < 0) {
|
|
printf("invalid timer period\n");
|
|
l2fwd_usage(prgname);
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
/* Check period */
|
|
case 'K':
|
|
check_period = l2fwd_parse_check_period(optarg);
|
|
if (check_period < 0) {
|
|
printf("invalid check period\n");
|
|
l2fwd_usage(prgname);
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
/* long options */
|
|
case 0:
|
|
l2fwd_usage(prgname);
|
|
return -1;
|
|
|
|
default:
|
|
l2fwd_usage(prgname);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (optind >= 0)
|
|
argv[optind-1] = prgname;
|
|
|
|
ret = optind-1;
|
|
optind = 1; /* reset getopt lib */
|
|
return ret;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
printf("\nChecking link status");
|
|
fflush(stdout);
|
|
for (count = 0; count <= MAX_CHECK_TIME; count++) {
|
|
all_ports_up = 1;
|
|
RTE_ETH_FOREACH_DEV(portid) {
|
|
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) {
|
|
if (link.link_status)
|
|
printf(
|
|
"Port%d Link Up. Speed %u Mbps - %s\n",
|
|
portid, link.link_speed,
|
|
(link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
|
|
("full-duplex") : ("half-duplex\n"));
|
|
else
|
|
printf("Port %d Link Down\n", portid);
|
|
continue;
|
|
}
|
|
/* clear all_ports_up flag if any link down */
|
|
if (link.link_status == 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
|
|
dead_core(__rte_unused void *ptr_data, const int id_core)
|
|
{
|
|
if (terminate_signal_received)
|
|
return;
|
|
printf("Dead core %i - restarting..\n", id_core);
|
|
if (rte_eal_get_lcore_state(id_core) == FINISHED) {
|
|
rte_eal_wait_lcore(id_core);
|
|
rte_eal_remote_launch(l2fwd_launch_one_lcore, NULL, id_core);
|
|
} else {
|
|
printf("..false positive!\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
relay_core_state(void *ptr_data, const int id_core,
|
|
const enum rte_keepalive_state core_state, uint64_t last_alive)
|
|
{
|
|
rte_keepalive_relayed_state((struct rte_keepalive_shm *)ptr_data,
|
|
id_core, core_state, last_alive);
|
|
}
|
|
|
|
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;
|
|
struct sigaction signal_handler;
|
|
struct rte_keepalive_shm *ka_shm;
|
|
|
|
memset(&signal_handler, 0, sizeof(signal_handler));
|
|
terminate_signal_received = 0;
|
|
signal_handler.sa_handler = &handle_sigterm;
|
|
if (sigaction(SIGINT, &signal_handler, NULL) == -1 ||
|
|
sigaction(SIGTERM, &signal_handler, NULL) == -1)
|
|
rte_exit(EXIT_FAILURE, "SIGNAL\n");
|
|
|
|
|
|
/* init EAL */
|
|
ret = rte_eal_init(argc, argv);
|
|
if (ret < 0)
|
|
rte_exit(EXIT_FAILURE, "Invalid EAL arguments\n");
|
|
argc -= ret;
|
|
argv += ret;
|
|
|
|
l2fwd_enabled_port_mask = 0;
|
|
|
|
/* parse application arguments (after the EAL ones) */
|
|
ret = l2fwd_parse_args(argc, argv);
|
|
if (ret < 0)
|
|
rte_exit(EXIT_FAILURE, "Invalid L2FWD arguments\n");
|
|
|
|
/* create the mbuf pool */
|
|
l2fwd_pktmbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", NB_MBUF, 32,
|
|
0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
|
|
if (l2fwd_pktmbuf_pool == NULL)
|
|
rte_exit(EXIT_FAILURE, "Cannot init mbuf pool\n");
|
|
|
|
nb_ports = rte_eth_dev_count_avail();
|
|
if (nb_ports == 0)
|
|
rte_exit(EXIT_FAILURE, "No Ethernet ports - bye\n");
|
|
|
|
/* reset l2fwd_dst_ports */
|
|
for (portid = 0; portid < RTE_MAX_ETHPORTS; portid++)
|
|
l2fwd_dst_ports[portid] = 0;
|
|
last_port = 0;
|
|
|
|
/*
|
|
* Each logical core is assigned a dedicated TX queue on each port.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
rx_lcore_id = 1;
|
|
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];
|
|
|
|
qconf->rx_port_list[qconf->n_rx_port] = portid;
|
|
qconf->n_rx_port++;
|
|
printf("Lcore %u: RX port %u\n",
|
|
rx_lcore_id, portid);
|
|
}
|
|
|
|
/* Initialise each port */
|
|
RTE_ETH_FOREACH_DEV(portid) {
|
|
struct rte_eth_dev_info dev_info;
|
|
struct rte_eth_rxconf rxq_conf;
|
|
struct rte_eth_txconf txq_conf;
|
|
struct rte_eth_conf local_port_conf = port_conf;
|
|
|
|
/* 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 & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
|
|
local_port_conf.txmode.offloads |=
|
|
DEV_TX_OFFLOAD_MBUF_FAST_FREE;
|
|
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);
|
|
|
|
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 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;
|
|
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);
|
|
|
|
/* init one TX queue on each port */
|
|
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);
|
|
|
|
/* 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);
|
|
|
|
/* 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);
|
|
|
|
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: "
|
|
"%02X:%02X:%02X:%02X:%02X:%02X\n\n",
|
|
portid,
|
|
l2fwd_ports_eth_addr[portid].addr_bytes[0],
|
|
l2fwd_ports_eth_addr[portid].addr_bytes[1],
|
|
l2fwd_ports_eth_addr[portid].addr_bytes[2],
|
|
l2fwd_ports_eth_addr[portid].addr_bytes[3],
|
|
l2fwd_ports_eth_addr[portid].addr_bytes[4],
|
|
l2fwd_ports_eth_addr[portid].addr_bytes[5]);
|
|
|
|
/* 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);
|
|
|
|
struct rte_timer hb_timer, stats_timer;
|
|
|
|
rte_timer_subsystem_init();
|
|
rte_timer_init(&stats_timer);
|
|
|
|
ka_shm = NULL;
|
|
if (check_period > 0) {
|
|
ka_shm = rte_keepalive_shm_create();
|
|
if (ka_shm == NULL)
|
|
rte_exit(EXIT_FAILURE,
|
|
"rte_keepalive_shm_create() failed");
|
|
rte_global_keepalive_info =
|
|
rte_keepalive_create(&dead_core, ka_shm);
|
|
if (rte_global_keepalive_info == NULL)
|
|
rte_exit(EXIT_FAILURE, "init_keep_alive() failed");
|
|
rte_keepalive_register_relay_callback(rte_global_keepalive_info,
|
|
relay_core_state, ka_shm);
|
|
rte_timer_init(&hb_timer);
|
|
if (rte_timer_reset(&hb_timer,
|
|
(check_period * rte_get_timer_hz()) / 1000,
|
|
PERIODICAL,
|
|
rte_lcore_id(),
|
|
(void(*)(struct rte_timer*, void*))
|
|
&rte_keepalive_dispatch_pings,
|
|
rte_global_keepalive_info
|
|
) != 0 )
|
|
rte_exit(EXIT_FAILURE, "Keepalive setup failure.\n");
|
|
}
|
|
if (timer_period > 0) {
|
|
if (rte_timer_reset(&stats_timer,
|
|
(timer_period * rte_get_timer_hz()) / 1000,
|
|
PERIODICAL,
|
|
rte_lcore_id(),
|
|
&print_stats, NULL
|
|
) != 0 )
|
|
rte_exit(EXIT_FAILURE, "Stats setup failure.\n");
|
|
}
|
|
/* launch per-lcore init on every slave lcore */
|
|
RTE_LCORE_FOREACH_SLAVE(lcore_id) {
|
|
struct lcore_queue_conf *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
|
|
);
|
|
else {
|
|
rte_eal_remote_launch(
|
|
l2fwd_launch_one_lcore,
|
|
NULL,
|
|
lcore_id
|
|
);
|
|
rte_keepalive_register_core(rte_global_keepalive_info,
|
|
lcore_id);
|
|
}
|
|
}
|
|
while (!terminate_signal_received) {
|
|
rte_timer_manage();
|
|
rte_delay_ms(5);
|
|
}
|
|
|
|
RTE_LCORE_FOREACH_SLAVE(lcore_id) {
|
|
if (rte_eal_wait_lcore(lcore_id) < 0)
|
|
return -1;
|
|
}
|
|
|
|
if (ka_shm != NULL)
|
|
rte_keepalive_shm_cleanup(ka_shm);
|
|
return 0;
|
|
}
|