3f47c017ee
The --txpkts command line parameter was silently ignored due to
application was unable to check the Tx queue ring sizes for non
configured ports.
The "set txpkts <len0[,len1]*>" was also rejected if there
was some stopped or /unconfigured port.
This provides the following:
- If fails to get ring size from the port, this can be because port is
not initialized yet, ignore the check and just be sure segment size
won't cause an out of bound access. The port descriptor check will
be done during Tx setup.
- The capability to send single packet is supposed to be very basic
and always supported, the setting segment number to 1 is always
allowed, no check performed
- At the moment of Tx queue setup the descriptor number is checked
against configured segment number
Bugzilla ID: 584
Fixes: 8dae835d88
("app/testpmd: remove restriction on Tx segments set")
Cc: stable@dpdk.org
Signed-off-by: Viacheslav Ovsiienko <viacheslavo@nvidia.com>
Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
Acked-by: Xiaoyun Li <xiaoyun.li@intel.com>
5139 lines
130 KiB
C
5139 lines
130 KiB
C
/* SPDX-License-Identifier: BSD-3-Clause
|
|
* Copyright(c) 2010-2016 Intel Corporation.
|
|
* Copyright 2013-2014 6WIND S.A.
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <inttypes.h>
|
|
|
|
#include <sys/queue.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
|
|
#include <rte_common.h>
|
|
#include <rte_byteorder.h>
|
|
#include <rte_debug.h>
|
|
#include <rte_log.h>
|
|
#include <rte_memory.h>
|
|
#include <rte_memcpy.h>
|
|
#include <rte_memzone.h>
|
|
#include <rte_launch.h>
|
|
#include <rte_eal.h>
|
|
#include <rte_per_lcore.h>
|
|
#include <rte_lcore.h>
|
|
#include <rte_atomic.h>
|
|
#include <rte_branch_prediction.h>
|
|
#include <rte_mempool.h>
|
|
#include <rte_mbuf.h>
|
|
#include <rte_interrupts.h>
|
|
#include <rte_pci.h>
|
|
#include <rte_ether.h>
|
|
#include <rte_ethdev.h>
|
|
#include <rte_string_fns.h>
|
|
#include <rte_cycles.h>
|
|
#include <rte_flow.h>
|
|
#include <rte_mtr.h>
|
|
#include <rte_errno.h>
|
|
#ifdef RTE_NET_IXGBE
|
|
#include <rte_pmd_ixgbe.h>
|
|
#endif
|
|
#ifdef RTE_NET_I40E
|
|
#include <rte_pmd_i40e.h>
|
|
#endif
|
|
#ifdef RTE_NET_BNXT
|
|
#include <rte_pmd_bnxt.h>
|
|
#endif
|
|
#include <rte_gro.h>
|
|
#include <rte_hexdump.h>
|
|
|
|
#include "testpmd.h"
|
|
#include "cmdline_mtr.h"
|
|
|
|
#define ETHDEV_FWVERS_LEN 32
|
|
|
|
#ifdef CLOCK_MONOTONIC_RAW /* Defined in glibc bits/time.h */
|
|
#define CLOCK_TYPE_ID CLOCK_MONOTONIC_RAW
|
|
#else
|
|
#define CLOCK_TYPE_ID CLOCK_MONOTONIC
|
|
#endif
|
|
|
|
#define NS_PER_SEC 1E9
|
|
|
|
static char *flowtype_to_str(uint16_t flow_type);
|
|
|
|
static const struct {
|
|
enum tx_pkt_split split;
|
|
const char *name;
|
|
} tx_split_name[] = {
|
|
{
|
|
.split = TX_PKT_SPLIT_OFF,
|
|
.name = "off",
|
|
},
|
|
{
|
|
.split = TX_PKT_SPLIT_ON,
|
|
.name = "on",
|
|
},
|
|
{
|
|
.split = TX_PKT_SPLIT_RND,
|
|
.name = "rand",
|
|
},
|
|
};
|
|
|
|
const struct rss_type_info rss_type_table[] = {
|
|
{ "all", ETH_RSS_ETH | ETH_RSS_VLAN | ETH_RSS_IP | ETH_RSS_TCP |
|
|
ETH_RSS_UDP | ETH_RSS_SCTP | ETH_RSS_L2_PAYLOAD |
|
|
ETH_RSS_L2TPV3 | ETH_RSS_ESP | ETH_RSS_AH | ETH_RSS_PFCP |
|
|
ETH_RSS_GTPU | ETH_RSS_ECPRI | ETH_RSS_MPLS},
|
|
{ "none", 0 },
|
|
{ "eth", ETH_RSS_ETH },
|
|
{ "l2-src-only", ETH_RSS_L2_SRC_ONLY },
|
|
{ "l2-dst-only", ETH_RSS_L2_DST_ONLY },
|
|
{ "vlan", ETH_RSS_VLAN },
|
|
{ "s-vlan", ETH_RSS_S_VLAN },
|
|
{ "c-vlan", ETH_RSS_C_VLAN },
|
|
{ "ipv4", ETH_RSS_IPV4 },
|
|
{ "ipv4-frag", ETH_RSS_FRAG_IPV4 },
|
|
{ "ipv4-tcp", ETH_RSS_NONFRAG_IPV4_TCP },
|
|
{ "ipv4-udp", ETH_RSS_NONFRAG_IPV4_UDP },
|
|
{ "ipv4-sctp", ETH_RSS_NONFRAG_IPV4_SCTP },
|
|
{ "ipv4-other", ETH_RSS_NONFRAG_IPV4_OTHER },
|
|
{ "ipv6", ETH_RSS_IPV6 },
|
|
{ "ipv6-frag", ETH_RSS_FRAG_IPV6 },
|
|
{ "ipv6-tcp", ETH_RSS_NONFRAG_IPV6_TCP },
|
|
{ "ipv6-udp", ETH_RSS_NONFRAG_IPV6_UDP },
|
|
{ "ipv6-sctp", ETH_RSS_NONFRAG_IPV6_SCTP },
|
|
{ "ipv6-other", ETH_RSS_NONFRAG_IPV6_OTHER },
|
|
{ "l2-payload", ETH_RSS_L2_PAYLOAD },
|
|
{ "ipv6-ex", ETH_RSS_IPV6_EX },
|
|
{ "ipv6-tcp-ex", ETH_RSS_IPV6_TCP_EX },
|
|
{ "ipv6-udp-ex", ETH_RSS_IPV6_UDP_EX },
|
|
{ "port", ETH_RSS_PORT },
|
|
{ "vxlan", ETH_RSS_VXLAN },
|
|
{ "geneve", ETH_RSS_GENEVE },
|
|
{ "nvgre", ETH_RSS_NVGRE },
|
|
{ "ip", ETH_RSS_IP },
|
|
{ "udp", ETH_RSS_UDP },
|
|
{ "tcp", ETH_RSS_TCP },
|
|
{ "sctp", ETH_RSS_SCTP },
|
|
{ "tunnel", ETH_RSS_TUNNEL },
|
|
{ "l3-pre32", RTE_ETH_RSS_L3_PRE32 },
|
|
{ "l3-pre40", RTE_ETH_RSS_L3_PRE40 },
|
|
{ "l3-pre48", RTE_ETH_RSS_L3_PRE48 },
|
|
{ "l3-pre56", RTE_ETH_RSS_L3_PRE56 },
|
|
{ "l3-pre64", RTE_ETH_RSS_L3_PRE64 },
|
|
{ "l3-pre96", RTE_ETH_RSS_L3_PRE96 },
|
|
{ "l3-src-only", ETH_RSS_L3_SRC_ONLY },
|
|
{ "l3-dst-only", ETH_RSS_L3_DST_ONLY },
|
|
{ "l4-src-only", ETH_RSS_L4_SRC_ONLY },
|
|
{ "l4-dst-only", ETH_RSS_L4_DST_ONLY },
|
|
{ "esp", ETH_RSS_ESP },
|
|
{ "ah", ETH_RSS_AH },
|
|
{ "l2tpv3", ETH_RSS_L2TPV3 },
|
|
{ "pfcp", ETH_RSS_PFCP },
|
|
{ "pppoe", ETH_RSS_PPPOE },
|
|
{ "gtpu", ETH_RSS_GTPU },
|
|
{ "ecpri", ETH_RSS_ECPRI },
|
|
{ "mpls", ETH_RSS_MPLS },
|
|
{ NULL, 0 },
|
|
};
|
|
|
|
static const struct {
|
|
enum rte_eth_fec_mode mode;
|
|
const char *name;
|
|
} fec_mode_name[] = {
|
|
{
|
|
.mode = RTE_ETH_FEC_NOFEC,
|
|
.name = "off",
|
|
},
|
|
{
|
|
.mode = RTE_ETH_FEC_AUTO,
|
|
.name = "auto",
|
|
},
|
|
{
|
|
.mode = RTE_ETH_FEC_BASER,
|
|
.name = "baser",
|
|
},
|
|
{
|
|
.mode = RTE_ETH_FEC_RS,
|
|
.name = "rs",
|
|
},
|
|
};
|
|
|
|
static void
|
|
print_ethaddr(const char *name, struct rte_ether_addr *eth_addr)
|
|
{
|
|
char buf[RTE_ETHER_ADDR_FMT_SIZE];
|
|
rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, eth_addr);
|
|
printf("%s%s", name, buf);
|
|
}
|
|
|
|
void
|
|
nic_stats_display(portid_t port_id)
|
|
{
|
|
static uint64_t prev_pkts_rx[RTE_MAX_ETHPORTS];
|
|
static uint64_t prev_pkts_tx[RTE_MAX_ETHPORTS];
|
|
static uint64_t prev_bytes_rx[RTE_MAX_ETHPORTS];
|
|
static uint64_t prev_bytes_tx[RTE_MAX_ETHPORTS];
|
|
static uint64_t prev_ns[RTE_MAX_ETHPORTS];
|
|
struct timespec cur_time;
|
|
uint64_t diff_pkts_rx, diff_pkts_tx, diff_bytes_rx, diff_bytes_tx,
|
|
diff_ns;
|
|
uint64_t mpps_rx, mpps_tx, mbps_rx, mbps_tx;
|
|
struct rte_eth_stats stats;
|
|
|
|
static const char *nic_stats_border = "########################";
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN)) {
|
|
print_valid_ports();
|
|
return;
|
|
}
|
|
rte_eth_stats_get(port_id, &stats);
|
|
printf("\n %s NIC statistics for port %-2d %s\n",
|
|
nic_stats_border, port_id, nic_stats_border);
|
|
|
|
printf(" RX-packets: %-10"PRIu64" RX-missed: %-10"PRIu64" RX-bytes: "
|
|
"%-"PRIu64"\n", stats.ipackets, stats.imissed, stats.ibytes);
|
|
printf(" RX-errors: %-"PRIu64"\n", stats.ierrors);
|
|
printf(" RX-nombuf: %-10"PRIu64"\n", stats.rx_nombuf);
|
|
printf(" TX-packets: %-10"PRIu64" TX-errors: %-10"PRIu64" TX-bytes: "
|
|
"%-"PRIu64"\n", stats.opackets, stats.oerrors, stats.obytes);
|
|
|
|
diff_ns = 0;
|
|
if (clock_gettime(CLOCK_TYPE_ID, &cur_time) == 0) {
|
|
uint64_t ns;
|
|
|
|
ns = cur_time.tv_sec * NS_PER_SEC;
|
|
ns += cur_time.tv_nsec;
|
|
|
|
if (prev_ns[port_id] != 0)
|
|
diff_ns = ns - prev_ns[port_id];
|
|
prev_ns[port_id] = ns;
|
|
}
|
|
|
|
diff_pkts_rx = (stats.ipackets > prev_pkts_rx[port_id]) ?
|
|
(stats.ipackets - prev_pkts_rx[port_id]) : 0;
|
|
diff_pkts_tx = (stats.opackets > prev_pkts_tx[port_id]) ?
|
|
(stats.opackets - prev_pkts_tx[port_id]) : 0;
|
|
prev_pkts_rx[port_id] = stats.ipackets;
|
|
prev_pkts_tx[port_id] = stats.opackets;
|
|
mpps_rx = diff_ns > 0 ?
|
|
(double)diff_pkts_rx / diff_ns * NS_PER_SEC : 0;
|
|
mpps_tx = diff_ns > 0 ?
|
|
(double)diff_pkts_tx / diff_ns * NS_PER_SEC : 0;
|
|
|
|
diff_bytes_rx = (stats.ibytes > prev_bytes_rx[port_id]) ?
|
|
(stats.ibytes - prev_bytes_rx[port_id]) : 0;
|
|
diff_bytes_tx = (stats.obytes > prev_bytes_tx[port_id]) ?
|
|
(stats.obytes - prev_bytes_tx[port_id]) : 0;
|
|
prev_bytes_rx[port_id] = stats.ibytes;
|
|
prev_bytes_tx[port_id] = stats.obytes;
|
|
mbps_rx = diff_ns > 0 ?
|
|
(double)diff_bytes_rx / diff_ns * NS_PER_SEC : 0;
|
|
mbps_tx = diff_ns > 0 ?
|
|
(double)diff_bytes_tx / diff_ns * NS_PER_SEC : 0;
|
|
|
|
printf("\n Throughput (since last show)\n");
|
|
printf(" Rx-pps: %12"PRIu64" Rx-bps: %12"PRIu64"\n Tx-pps: %12"
|
|
PRIu64" Tx-bps: %12"PRIu64"\n", mpps_rx, mbps_rx * 8,
|
|
mpps_tx, mbps_tx * 8);
|
|
|
|
printf(" %s############################%s\n",
|
|
nic_stats_border, nic_stats_border);
|
|
}
|
|
|
|
void
|
|
nic_stats_clear(portid_t port_id)
|
|
{
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN)) {
|
|
print_valid_ports();
|
|
return;
|
|
}
|
|
|
|
ret = rte_eth_stats_reset(port_id);
|
|
if (ret != 0) {
|
|
printf("%s: Error: failed to reset stats (port %u): %s",
|
|
__func__, port_id, strerror(-ret));
|
|
return;
|
|
}
|
|
|
|
ret = rte_eth_stats_get(port_id, &ports[port_id].stats);
|
|
if (ret != 0) {
|
|
if (ret < 0)
|
|
ret = -ret;
|
|
printf("%s: Error: failed to get stats (port %u): %s",
|
|
__func__, port_id, strerror(ret));
|
|
return;
|
|
}
|
|
printf("\n NIC statistics for port %d cleared\n", port_id);
|
|
}
|
|
|
|
void
|
|
nic_xstats_display(portid_t port_id)
|
|
{
|
|
struct rte_eth_xstat *xstats;
|
|
int cnt_xstats, idx_xstat;
|
|
struct rte_eth_xstat_name *xstats_names;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN)) {
|
|
print_valid_ports();
|
|
return;
|
|
}
|
|
printf("###### NIC extended statistics for port %-2d\n", port_id);
|
|
if (!rte_eth_dev_is_valid_port(port_id)) {
|
|
printf("Error: Invalid port number %i\n", port_id);
|
|
return;
|
|
}
|
|
|
|
/* Get count */
|
|
cnt_xstats = rte_eth_xstats_get_names(port_id, NULL, 0);
|
|
if (cnt_xstats < 0) {
|
|
printf("Error: Cannot get count of xstats\n");
|
|
return;
|
|
}
|
|
|
|
/* Get id-name lookup table */
|
|
xstats_names = malloc(sizeof(struct rte_eth_xstat_name) * cnt_xstats);
|
|
if (xstats_names == NULL) {
|
|
printf("Cannot allocate memory for xstats lookup\n");
|
|
return;
|
|
}
|
|
if (cnt_xstats != rte_eth_xstats_get_names(
|
|
port_id, xstats_names, cnt_xstats)) {
|
|
printf("Error: Cannot get xstats lookup\n");
|
|
free(xstats_names);
|
|
return;
|
|
}
|
|
|
|
/* Get stats themselves */
|
|
xstats = malloc(sizeof(struct rte_eth_xstat) * cnt_xstats);
|
|
if (xstats == NULL) {
|
|
printf("Cannot allocate memory for xstats\n");
|
|
free(xstats_names);
|
|
return;
|
|
}
|
|
if (cnt_xstats != rte_eth_xstats_get(port_id, xstats, cnt_xstats)) {
|
|
printf("Error: Unable to get xstats\n");
|
|
free(xstats_names);
|
|
free(xstats);
|
|
return;
|
|
}
|
|
|
|
/* Display xstats */
|
|
for (idx_xstat = 0; idx_xstat < cnt_xstats; idx_xstat++) {
|
|
if (xstats_hide_zero && !xstats[idx_xstat].value)
|
|
continue;
|
|
printf("%s: %"PRIu64"\n",
|
|
xstats_names[idx_xstat].name,
|
|
xstats[idx_xstat].value);
|
|
}
|
|
free(xstats_names);
|
|
free(xstats);
|
|
}
|
|
|
|
void
|
|
nic_xstats_clear(portid_t port_id)
|
|
{
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN)) {
|
|
print_valid_ports();
|
|
return;
|
|
}
|
|
|
|
ret = rte_eth_xstats_reset(port_id);
|
|
if (ret != 0) {
|
|
printf("%s: Error: failed to reset xstats (port %u): %s",
|
|
__func__, port_id, strerror(-ret));
|
|
return;
|
|
}
|
|
|
|
ret = rte_eth_stats_get(port_id, &ports[port_id].stats);
|
|
if (ret != 0) {
|
|
if (ret < 0)
|
|
ret = -ret;
|
|
printf("%s: Error: failed to get stats (port %u): %s",
|
|
__func__, port_id, strerror(ret));
|
|
return;
|
|
}
|
|
}
|
|
|
|
static const char *
|
|
get_queue_state_name(uint8_t queue_state)
|
|
{
|
|
if (queue_state == RTE_ETH_QUEUE_STATE_STOPPED)
|
|
return "stopped";
|
|
else if (queue_state == RTE_ETH_QUEUE_STATE_STARTED)
|
|
return "started";
|
|
else if (queue_state == RTE_ETH_QUEUE_STATE_HAIRPIN)
|
|
return "hairpin";
|
|
else
|
|
return "unknown";
|
|
}
|
|
|
|
void
|
|
rx_queue_infos_display(portid_t port_id, uint16_t queue_id)
|
|
{
|
|
struct rte_eth_burst_mode mode;
|
|
struct rte_eth_rxq_info qinfo;
|
|
int32_t rc;
|
|
static const char *info_border = "*********************";
|
|
|
|
rc = rte_eth_rx_queue_info_get(port_id, queue_id, &qinfo);
|
|
if (rc != 0) {
|
|
printf("Failed to retrieve information for port: %u, "
|
|
"RX queue: %hu\nerror desc: %s(%d)\n",
|
|
port_id, queue_id, strerror(-rc), rc);
|
|
return;
|
|
}
|
|
|
|
printf("\n%s Infos for port %-2u, RX queue %-2u %s",
|
|
info_border, port_id, queue_id, info_border);
|
|
|
|
printf("\nMempool: %s", (qinfo.mp == NULL) ? "NULL" : qinfo.mp->name);
|
|
printf("\nRX prefetch threshold: %hhu", qinfo.conf.rx_thresh.pthresh);
|
|
printf("\nRX host threshold: %hhu", qinfo.conf.rx_thresh.hthresh);
|
|
printf("\nRX writeback threshold: %hhu", qinfo.conf.rx_thresh.wthresh);
|
|
printf("\nRX free threshold: %hu", qinfo.conf.rx_free_thresh);
|
|
printf("\nRX drop packets: %s",
|
|
(qinfo.conf.rx_drop_en != 0) ? "on" : "off");
|
|
printf("\nRX deferred start: %s",
|
|
(qinfo.conf.rx_deferred_start != 0) ? "on" : "off");
|
|
printf("\nRX scattered packets: %s",
|
|
(qinfo.scattered_rx != 0) ? "on" : "off");
|
|
printf("\nRx queue state: %s", get_queue_state_name(qinfo.queue_state));
|
|
if (qinfo.rx_buf_size != 0)
|
|
printf("\nRX buffer size: %hu", qinfo.rx_buf_size);
|
|
printf("\nNumber of RXDs: %hu", qinfo.nb_desc);
|
|
|
|
if (rte_eth_rx_burst_mode_get(port_id, queue_id, &mode) == 0)
|
|
printf("\nBurst mode: %s%s",
|
|
mode.info,
|
|
mode.flags & RTE_ETH_BURST_FLAG_PER_QUEUE ?
|
|
" (per queue)" : "");
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
void
|
|
tx_queue_infos_display(portid_t port_id, uint16_t queue_id)
|
|
{
|
|
struct rte_eth_burst_mode mode;
|
|
struct rte_eth_txq_info qinfo;
|
|
int32_t rc;
|
|
static const char *info_border = "*********************";
|
|
|
|
rc = rte_eth_tx_queue_info_get(port_id, queue_id, &qinfo);
|
|
if (rc != 0) {
|
|
printf("Failed to retrieve information for port: %u, "
|
|
"TX queue: %hu\nerror desc: %s(%d)\n",
|
|
port_id, queue_id, strerror(-rc), rc);
|
|
return;
|
|
}
|
|
|
|
printf("\n%s Infos for port %-2u, TX queue %-2u %s",
|
|
info_border, port_id, queue_id, info_border);
|
|
|
|
printf("\nTX prefetch threshold: %hhu", qinfo.conf.tx_thresh.pthresh);
|
|
printf("\nTX host threshold: %hhu", qinfo.conf.tx_thresh.hthresh);
|
|
printf("\nTX writeback threshold: %hhu", qinfo.conf.tx_thresh.wthresh);
|
|
printf("\nTX RS threshold: %hu", qinfo.conf.tx_rs_thresh);
|
|
printf("\nTX free threshold: %hu", qinfo.conf.tx_free_thresh);
|
|
printf("\nTX deferred start: %s",
|
|
(qinfo.conf.tx_deferred_start != 0) ? "on" : "off");
|
|
printf("\nNumber of TXDs: %hu", qinfo.nb_desc);
|
|
printf("\nTx queue state: %s", get_queue_state_name(qinfo.queue_state));
|
|
|
|
if (rte_eth_tx_burst_mode_get(port_id, queue_id, &mode) == 0)
|
|
printf("\nBurst mode: %s%s",
|
|
mode.info,
|
|
mode.flags & RTE_ETH_BURST_FLAG_PER_QUEUE ?
|
|
" (per queue)" : "");
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
static int bus_match_all(const struct rte_bus *bus, const void *data)
|
|
{
|
|
RTE_SET_USED(bus);
|
|
RTE_SET_USED(data);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
device_infos_display_speeds(uint32_t speed_capa)
|
|
{
|
|
printf("\n\tDevice speed capability:");
|
|
if (speed_capa == ETH_LINK_SPEED_AUTONEG)
|
|
printf(" Autonegotiate (all speeds)");
|
|
if (speed_capa & ETH_LINK_SPEED_FIXED)
|
|
printf(" Disable autonegotiate (fixed speed) ");
|
|
if (speed_capa & ETH_LINK_SPEED_10M_HD)
|
|
printf(" 10 Mbps half-duplex ");
|
|
if (speed_capa & ETH_LINK_SPEED_10M)
|
|
printf(" 10 Mbps full-duplex ");
|
|
if (speed_capa & ETH_LINK_SPEED_100M_HD)
|
|
printf(" 100 Mbps half-duplex ");
|
|
if (speed_capa & ETH_LINK_SPEED_100M)
|
|
printf(" 100 Mbps full-duplex ");
|
|
if (speed_capa & ETH_LINK_SPEED_1G)
|
|
printf(" 1 Gbps ");
|
|
if (speed_capa & ETH_LINK_SPEED_2_5G)
|
|
printf(" 2.5 Gbps ");
|
|
if (speed_capa & ETH_LINK_SPEED_5G)
|
|
printf(" 5 Gbps ");
|
|
if (speed_capa & ETH_LINK_SPEED_10G)
|
|
printf(" 10 Gbps ");
|
|
if (speed_capa & ETH_LINK_SPEED_20G)
|
|
printf(" 20 Gbps ");
|
|
if (speed_capa & ETH_LINK_SPEED_25G)
|
|
printf(" 25 Gbps ");
|
|
if (speed_capa & ETH_LINK_SPEED_40G)
|
|
printf(" 40 Gbps ");
|
|
if (speed_capa & ETH_LINK_SPEED_50G)
|
|
printf(" 50 Gbps ");
|
|
if (speed_capa & ETH_LINK_SPEED_56G)
|
|
printf(" 56 Gbps ");
|
|
if (speed_capa & ETH_LINK_SPEED_100G)
|
|
printf(" 100 Gbps ");
|
|
if (speed_capa & ETH_LINK_SPEED_200G)
|
|
printf(" 200 Gbps ");
|
|
}
|
|
|
|
void
|
|
device_infos_display(const char *identifier)
|
|
{
|
|
static const char *info_border = "*********************";
|
|
struct rte_bus *start = NULL, *next;
|
|
struct rte_dev_iterator dev_iter;
|
|
char name[RTE_ETH_NAME_MAX_LEN];
|
|
struct rte_ether_addr mac_addr;
|
|
struct rte_device *dev;
|
|
struct rte_devargs da;
|
|
portid_t port_id;
|
|
struct rte_eth_dev_info dev_info;
|
|
char devstr[128];
|
|
|
|
memset(&da, 0, sizeof(da));
|
|
if (!identifier)
|
|
goto skip_parse;
|
|
|
|
if (rte_devargs_parsef(&da, "%s", identifier)) {
|
|
printf("cannot parse identifier\n");
|
|
return;
|
|
}
|
|
|
|
skip_parse:
|
|
while ((next = rte_bus_find(start, bus_match_all, NULL)) != NULL) {
|
|
|
|
start = next;
|
|
if (identifier && da.bus != next)
|
|
continue;
|
|
|
|
/* Skip buses that don't have iterate method */
|
|
if (!next->dev_iterate)
|
|
continue;
|
|
|
|
snprintf(devstr, sizeof(devstr), "bus=%s", next->name);
|
|
RTE_DEV_FOREACH(dev, devstr, &dev_iter) {
|
|
|
|
if (!dev->driver)
|
|
continue;
|
|
/* Check for matching device if identifier is present */
|
|
if (identifier &&
|
|
strncmp(da.name, dev->name, strlen(dev->name)))
|
|
continue;
|
|
printf("\n%s Infos for device %s %s\n",
|
|
info_border, dev->name, info_border);
|
|
printf("Bus name: %s", dev->bus->name);
|
|
printf("\nDriver name: %s", dev->driver->name);
|
|
printf("\nDevargs: %s",
|
|
dev->devargs ? dev->devargs->args : "");
|
|
printf("\nConnect to socket: %d", dev->numa_node);
|
|
printf("\n");
|
|
|
|
/* List ports with matching device name */
|
|
RTE_ETH_FOREACH_DEV_OF(port_id, dev) {
|
|
printf("\n\tPort id: %-2d", port_id);
|
|
if (eth_macaddr_get_print_err(port_id,
|
|
&mac_addr) == 0)
|
|
print_ethaddr("\n\tMAC address: ",
|
|
&mac_addr);
|
|
rte_eth_dev_get_name_by_port(port_id, name);
|
|
printf("\n\tDevice name: %s", name);
|
|
if (rte_eth_dev_info_get(port_id, &dev_info) == 0)
|
|
device_infos_display_speeds(dev_info.speed_capa);
|
|
printf("\n");
|
|
}
|
|
}
|
|
};
|
|
rte_devargs_reset(&da);
|
|
}
|
|
|
|
void
|
|
port_infos_display(portid_t port_id)
|
|
{
|
|
struct rte_port *port;
|
|
struct rte_ether_addr mac_addr;
|
|
struct rte_eth_link link;
|
|
struct rte_eth_dev_info dev_info;
|
|
int vlan_offload;
|
|
struct rte_mempool * mp;
|
|
static const char *info_border = "*********************";
|
|
uint16_t mtu;
|
|
char name[RTE_ETH_NAME_MAX_LEN];
|
|
int ret;
|
|
char fw_version[ETHDEV_FWVERS_LEN];
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN)) {
|
|
print_valid_ports();
|
|
return;
|
|
}
|
|
port = &ports[port_id];
|
|
ret = eth_link_get_nowait_print_err(port_id, &link);
|
|
if (ret < 0)
|
|
return;
|
|
|
|
ret = eth_dev_info_get_print_err(port_id, &dev_info);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
printf("\n%s Infos for port %-2d %s\n",
|
|
info_border, port_id, info_border);
|
|
if (eth_macaddr_get_print_err(port_id, &mac_addr) == 0)
|
|
print_ethaddr("MAC address: ", &mac_addr);
|
|
rte_eth_dev_get_name_by_port(port_id, name);
|
|
printf("\nDevice name: %s", name);
|
|
printf("\nDriver name: %s", dev_info.driver_name);
|
|
|
|
if (rte_eth_dev_fw_version_get(port_id, fw_version,
|
|
ETHDEV_FWVERS_LEN) == 0)
|
|
printf("\nFirmware-version: %s", fw_version);
|
|
else
|
|
printf("\nFirmware-version: %s", "not available");
|
|
|
|
if (dev_info.device->devargs && dev_info.device->devargs->args)
|
|
printf("\nDevargs: %s", dev_info.device->devargs->args);
|
|
printf("\nConnect to socket: %u", port->socket_id);
|
|
|
|
if (port_numa[port_id] != NUMA_NO_CONFIG) {
|
|
mp = mbuf_pool_find(port_numa[port_id], 0);
|
|
if (mp)
|
|
printf("\nmemory allocation on the socket: %d",
|
|
port_numa[port_id]);
|
|
} else
|
|
printf("\nmemory allocation on the socket: %u",port->socket_id);
|
|
|
|
printf("\nLink status: %s\n", (link.link_status) ? ("up") : ("down"));
|
|
printf("Link speed: %s\n", rte_eth_link_speed_to_str(link.link_speed));
|
|
printf("Link duplex: %s\n", (link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
|
|
("full-duplex") : ("half-duplex"));
|
|
printf("Autoneg status: %s\n", (link.link_autoneg == ETH_LINK_AUTONEG) ?
|
|
("On") : ("Off"));
|
|
|
|
if (!rte_eth_dev_get_mtu(port_id, &mtu))
|
|
printf("MTU: %u\n", mtu);
|
|
|
|
printf("Promiscuous mode: %s\n",
|
|
rte_eth_promiscuous_get(port_id) ? "enabled" : "disabled");
|
|
printf("Allmulticast mode: %s\n",
|
|
rte_eth_allmulticast_get(port_id) ? "enabled" : "disabled");
|
|
printf("Maximum number of MAC addresses: %u\n",
|
|
(unsigned int)(port->dev_info.max_mac_addrs));
|
|
printf("Maximum number of MAC addresses of hash filtering: %u\n",
|
|
(unsigned int)(port->dev_info.max_hash_mac_addrs));
|
|
|
|
vlan_offload = rte_eth_dev_get_vlan_offload(port_id);
|
|
if (vlan_offload >= 0){
|
|
printf("VLAN offload: \n");
|
|
if (vlan_offload & ETH_VLAN_STRIP_OFFLOAD)
|
|
printf(" strip on, ");
|
|
else
|
|
printf(" strip off, ");
|
|
|
|
if (vlan_offload & ETH_VLAN_FILTER_OFFLOAD)
|
|
printf("filter on, ");
|
|
else
|
|
printf("filter off, ");
|
|
|
|
if (vlan_offload & ETH_VLAN_EXTEND_OFFLOAD)
|
|
printf("extend on, ");
|
|
else
|
|
printf("extend off, ");
|
|
|
|
if (vlan_offload & ETH_QINQ_STRIP_OFFLOAD)
|
|
printf("qinq strip on\n");
|
|
else
|
|
printf("qinq strip off\n");
|
|
}
|
|
|
|
if (dev_info.hash_key_size > 0)
|
|
printf("Hash key size in bytes: %u\n", dev_info.hash_key_size);
|
|
if (dev_info.reta_size > 0)
|
|
printf("Redirection table size: %u\n", dev_info.reta_size);
|
|
if (!dev_info.flow_type_rss_offloads)
|
|
printf("No RSS offload flow type is supported.\n");
|
|
else {
|
|
uint16_t i;
|
|
char *p;
|
|
|
|
printf("Supported RSS offload flow types:\n");
|
|
for (i = RTE_ETH_FLOW_UNKNOWN + 1;
|
|
i < sizeof(dev_info.flow_type_rss_offloads) * CHAR_BIT; i++) {
|
|
if (!(dev_info.flow_type_rss_offloads & (1ULL << i)))
|
|
continue;
|
|
p = flowtype_to_str(i);
|
|
if (p)
|
|
printf(" %s\n", p);
|
|
else
|
|
printf(" user defined %d\n", i);
|
|
}
|
|
}
|
|
|
|
printf("Minimum size of RX buffer: %u\n", dev_info.min_rx_bufsize);
|
|
printf("Maximum configurable length of RX packet: %u\n",
|
|
dev_info.max_rx_pktlen);
|
|
printf("Maximum configurable size of LRO aggregated packet: %u\n",
|
|
dev_info.max_lro_pkt_size);
|
|
if (dev_info.max_vfs)
|
|
printf("Maximum number of VFs: %u\n", dev_info.max_vfs);
|
|
if (dev_info.max_vmdq_pools)
|
|
printf("Maximum number of VMDq pools: %u\n",
|
|
dev_info.max_vmdq_pools);
|
|
|
|
printf("Current number of RX queues: %u\n", dev_info.nb_rx_queues);
|
|
printf("Max possible RX queues: %u\n", dev_info.max_rx_queues);
|
|
printf("Max possible number of RXDs per queue: %hu\n",
|
|
dev_info.rx_desc_lim.nb_max);
|
|
printf("Min possible number of RXDs per queue: %hu\n",
|
|
dev_info.rx_desc_lim.nb_min);
|
|
printf("RXDs number alignment: %hu\n", dev_info.rx_desc_lim.nb_align);
|
|
|
|
printf("Current number of TX queues: %u\n", dev_info.nb_tx_queues);
|
|
printf("Max possible TX queues: %u\n", dev_info.max_tx_queues);
|
|
printf("Max possible number of TXDs per queue: %hu\n",
|
|
dev_info.tx_desc_lim.nb_max);
|
|
printf("Min possible number of TXDs per queue: %hu\n",
|
|
dev_info.tx_desc_lim.nb_min);
|
|
printf("TXDs number alignment: %hu\n", dev_info.tx_desc_lim.nb_align);
|
|
printf("Max segment number per packet: %hu\n",
|
|
dev_info.tx_desc_lim.nb_seg_max);
|
|
printf("Max segment number per MTU/TSO: %hu\n",
|
|
dev_info.tx_desc_lim.nb_mtu_seg_max);
|
|
|
|
/* Show switch info only if valid switch domain and port id is set */
|
|
if (dev_info.switch_info.domain_id !=
|
|
RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID) {
|
|
if (dev_info.switch_info.name)
|
|
printf("Switch name: %s\n", dev_info.switch_info.name);
|
|
|
|
printf("Switch domain Id: %u\n",
|
|
dev_info.switch_info.domain_id);
|
|
printf("Switch Port Id: %u\n",
|
|
dev_info.switch_info.port_id);
|
|
}
|
|
}
|
|
|
|
void
|
|
port_summary_header_display(void)
|
|
{
|
|
uint16_t port_number;
|
|
|
|
port_number = rte_eth_dev_count_avail();
|
|
printf("Number of available ports: %i\n", port_number);
|
|
printf("%-4s %-17s %-12s %-14s %-8s %s\n", "Port", "MAC Address", "Name",
|
|
"Driver", "Status", "Link");
|
|
}
|
|
|
|
void
|
|
port_summary_display(portid_t port_id)
|
|
{
|
|
struct rte_ether_addr mac_addr;
|
|
struct rte_eth_link link;
|
|
struct rte_eth_dev_info dev_info;
|
|
char name[RTE_ETH_NAME_MAX_LEN];
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN)) {
|
|
print_valid_ports();
|
|
return;
|
|
}
|
|
|
|
ret = eth_link_get_nowait_print_err(port_id, &link);
|
|
if (ret < 0)
|
|
return;
|
|
|
|
ret = eth_dev_info_get_print_err(port_id, &dev_info);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
rte_eth_dev_get_name_by_port(port_id, name);
|
|
ret = eth_macaddr_get_print_err(port_id, &mac_addr);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
printf("%-4d %02X:%02X:%02X:%02X:%02X:%02X %-12s %-14s %-8s %s\n",
|
|
port_id, mac_addr.addr_bytes[0], mac_addr.addr_bytes[1],
|
|
mac_addr.addr_bytes[2], mac_addr.addr_bytes[3],
|
|
mac_addr.addr_bytes[4], mac_addr.addr_bytes[5], name,
|
|
dev_info.driver_name, (link.link_status) ? ("up") : ("down"),
|
|
rte_eth_link_speed_to_str(link.link_speed));
|
|
}
|
|
|
|
void
|
|
port_eeprom_display(portid_t port_id)
|
|
{
|
|
struct rte_dev_eeprom_info einfo;
|
|
int ret;
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN)) {
|
|
print_valid_ports();
|
|
return;
|
|
}
|
|
|
|
int len_eeprom = rte_eth_dev_get_eeprom_length(port_id);
|
|
if (len_eeprom < 0) {
|
|
switch (len_eeprom) {
|
|
case -ENODEV:
|
|
printf("port index %d invalid\n", port_id);
|
|
break;
|
|
case -ENOTSUP:
|
|
printf("operation not supported by device\n");
|
|
break;
|
|
case -EIO:
|
|
printf("device is removed\n");
|
|
break;
|
|
default:
|
|
printf("Unable to get EEPROM: %d\n", len_eeprom);
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
char buf[len_eeprom];
|
|
einfo.offset = 0;
|
|
einfo.length = len_eeprom;
|
|
einfo.data = buf;
|
|
|
|
ret = rte_eth_dev_get_eeprom(port_id, &einfo);
|
|
if (ret != 0) {
|
|
switch (ret) {
|
|
case -ENODEV:
|
|
printf("port index %d invalid\n", port_id);
|
|
break;
|
|
case -ENOTSUP:
|
|
printf("operation not supported by device\n");
|
|
break;
|
|
case -EIO:
|
|
printf("device is removed\n");
|
|
break;
|
|
default:
|
|
printf("Unable to get EEPROM: %d\n", ret);
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
rte_hexdump(stdout, "hexdump", einfo.data, einfo.length);
|
|
printf("Finish -- Port: %d EEPROM length: %d bytes\n", port_id, len_eeprom);
|
|
}
|
|
|
|
void
|
|
port_module_eeprom_display(portid_t port_id)
|
|
{
|
|
struct rte_eth_dev_module_info minfo;
|
|
struct rte_dev_eeprom_info einfo;
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN)) {
|
|
print_valid_ports();
|
|
return;
|
|
}
|
|
|
|
|
|
ret = rte_eth_dev_get_module_info(port_id, &minfo);
|
|
if (ret != 0) {
|
|
switch (ret) {
|
|
case -ENODEV:
|
|
printf("port index %d invalid\n", port_id);
|
|
break;
|
|
case -ENOTSUP:
|
|
printf("operation not supported by device\n");
|
|
break;
|
|
case -EIO:
|
|
printf("device is removed\n");
|
|
break;
|
|
default:
|
|
printf("Unable to get module EEPROM: %d\n", ret);
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
char buf[minfo.eeprom_len];
|
|
einfo.offset = 0;
|
|
einfo.length = minfo.eeprom_len;
|
|
einfo.data = buf;
|
|
|
|
ret = rte_eth_dev_get_module_eeprom(port_id, &einfo);
|
|
if (ret != 0) {
|
|
switch (ret) {
|
|
case -ENODEV:
|
|
printf("port index %d invalid\n", port_id);
|
|
break;
|
|
case -ENOTSUP:
|
|
printf("operation not supported by device\n");
|
|
break;
|
|
case -EIO:
|
|
printf("device is removed\n");
|
|
break;
|
|
default:
|
|
printf("Unable to get module EEPROM: %d\n", ret);
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
rte_hexdump(stdout, "hexdump", einfo.data, einfo.length);
|
|
printf("Finish -- Port: %d MODULE EEPROM length: %d bytes\n", port_id, einfo.length);
|
|
}
|
|
|
|
int
|
|
port_id_is_invalid(portid_t port_id, enum print_warning warning)
|
|
{
|
|
uint16_t pid;
|
|
|
|
if (port_id == (portid_t)RTE_PORT_ALL)
|
|
return 0;
|
|
|
|
RTE_ETH_FOREACH_DEV(pid)
|
|
if (port_id == pid)
|
|
return 0;
|
|
|
|
if (warning == ENABLED_WARN)
|
|
printf("Invalid port %d\n", port_id);
|
|
|
|
return 1;
|
|
}
|
|
|
|
void print_valid_ports(void)
|
|
{
|
|
portid_t pid;
|
|
|
|
printf("The valid ports array is [");
|
|
RTE_ETH_FOREACH_DEV(pid) {
|
|
printf(" %d", pid);
|
|
}
|
|
printf(" ]\n");
|
|
}
|
|
|
|
static int
|
|
vlan_id_is_invalid(uint16_t vlan_id)
|
|
{
|
|
if (vlan_id < 4096)
|
|
return 0;
|
|
printf("Invalid vlan_id %d (must be < 4096)\n", vlan_id);
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
port_reg_off_is_invalid(portid_t port_id, uint32_t reg_off)
|
|
{
|
|
const struct rte_pci_device *pci_dev;
|
|
const struct rte_bus *bus;
|
|
uint64_t pci_len;
|
|
|
|
if (reg_off & 0x3) {
|
|
printf("Port register offset 0x%X not aligned on a 4-byte "
|
|
"boundary\n",
|
|
(unsigned)reg_off);
|
|
return 1;
|
|
}
|
|
|
|
if (!ports[port_id].dev_info.device) {
|
|
printf("Invalid device\n");
|
|
return 0;
|
|
}
|
|
|
|
bus = rte_bus_find_by_device(ports[port_id].dev_info.device);
|
|
if (bus && !strcmp(bus->name, "pci")) {
|
|
pci_dev = RTE_DEV_TO_PCI(ports[port_id].dev_info.device);
|
|
} else {
|
|
printf("Not a PCI device\n");
|
|
return 1;
|
|
}
|
|
|
|
pci_len = pci_dev->mem_resource[0].len;
|
|
if (reg_off >= pci_len) {
|
|
printf("Port %d: register offset %u (0x%X) out of port PCI "
|
|
"resource (length=%"PRIu64")\n",
|
|
port_id, (unsigned)reg_off, (unsigned)reg_off, pci_len);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
reg_bit_pos_is_invalid(uint8_t bit_pos)
|
|
{
|
|
if (bit_pos <= 31)
|
|
return 0;
|
|
printf("Invalid bit position %d (must be <= 31)\n", bit_pos);
|
|
return 1;
|
|
}
|
|
|
|
#define display_port_and_reg_off(port_id, reg_off) \
|
|
printf("port %d PCI register at offset 0x%X: ", (port_id), (reg_off))
|
|
|
|
static inline void
|
|
display_port_reg_value(portid_t port_id, uint32_t reg_off, uint32_t reg_v)
|
|
{
|
|
display_port_and_reg_off(port_id, (unsigned)reg_off);
|
|
printf("0x%08X (%u)\n", (unsigned)reg_v, (unsigned)reg_v);
|
|
}
|
|
|
|
void
|
|
port_reg_bit_display(portid_t port_id, uint32_t reg_off, uint8_t bit_x)
|
|
{
|
|
uint32_t reg_v;
|
|
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
if (port_reg_off_is_invalid(port_id, reg_off))
|
|
return;
|
|
if (reg_bit_pos_is_invalid(bit_x))
|
|
return;
|
|
reg_v = port_id_pci_reg_read(port_id, reg_off);
|
|
display_port_and_reg_off(port_id, (unsigned)reg_off);
|
|
printf("bit %d=%d\n", bit_x, (int) ((reg_v & (1 << bit_x)) >> bit_x));
|
|
}
|
|
|
|
void
|
|
port_reg_bit_field_display(portid_t port_id, uint32_t reg_off,
|
|
uint8_t bit1_pos, uint8_t bit2_pos)
|
|
{
|
|
uint32_t reg_v;
|
|
uint8_t l_bit;
|
|
uint8_t h_bit;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
if (port_reg_off_is_invalid(port_id, reg_off))
|
|
return;
|
|
if (reg_bit_pos_is_invalid(bit1_pos))
|
|
return;
|
|
if (reg_bit_pos_is_invalid(bit2_pos))
|
|
return;
|
|
if (bit1_pos > bit2_pos)
|
|
l_bit = bit2_pos, h_bit = bit1_pos;
|
|
else
|
|
l_bit = bit1_pos, h_bit = bit2_pos;
|
|
|
|
reg_v = port_id_pci_reg_read(port_id, reg_off);
|
|
reg_v >>= l_bit;
|
|
if (h_bit < 31)
|
|
reg_v &= ((1 << (h_bit - l_bit + 1)) - 1);
|
|
display_port_and_reg_off(port_id, (unsigned)reg_off);
|
|
printf("bits[%d, %d]=0x%0*X (%u)\n", l_bit, h_bit,
|
|
((h_bit - l_bit) / 4) + 1, (unsigned)reg_v, (unsigned)reg_v);
|
|
}
|
|
|
|
void
|
|
port_reg_display(portid_t port_id, uint32_t reg_off)
|
|
{
|
|
uint32_t reg_v;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
if (port_reg_off_is_invalid(port_id, reg_off))
|
|
return;
|
|
reg_v = port_id_pci_reg_read(port_id, reg_off);
|
|
display_port_reg_value(port_id, reg_off, reg_v);
|
|
}
|
|
|
|
void
|
|
port_reg_bit_set(portid_t port_id, uint32_t reg_off, uint8_t bit_pos,
|
|
uint8_t bit_v)
|
|
{
|
|
uint32_t reg_v;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
if (port_reg_off_is_invalid(port_id, reg_off))
|
|
return;
|
|
if (reg_bit_pos_is_invalid(bit_pos))
|
|
return;
|
|
if (bit_v > 1) {
|
|
printf("Invalid bit value %d (must be 0 or 1)\n", (int) bit_v);
|
|
return;
|
|
}
|
|
reg_v = port_id_pci_reg_read(port_id, reg_off);
|
|
if (bit_v == 0)
|
|
reg_v &= ~(1 << bit_pos);
|
|
else
|
|
reg_v |= (1 << bit_pos);
|
|
port_id_pci_reg_write(port_id, reg_off, reg_v);
|
|
display_port_reg_value(port_id, reg_off, reg_v);
|
|
}
|
|
|
|
void
|
|
port_reg_bit_field_set(portid_t port_id, uint32_t reg_off,
|
|
uint8_t bit1_pos, uint8_t bit2_pos, uint32_t value)
|
|
{
|
|
uint32_t max_v;
|
|
uint32_t reg_v;
|
|
uint8_t l_bit;
|
|
uint8_t h_bit;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
if (port_reg_off_is_invalid(port_id, reg_off))
|
|
return;
|
|
if (reg_bit_pos_is_invalid(bit1_pos))
|
|
return;
|
|
if (reg_bit_pos_is_invalid(bit2_pos))
|
|
return;
|
|
if (bit1_pos > bit2_pos)
|
|
l_bit = bit2_pos, h_bit = bit1_pos;
|
|
else
|
|
l_bit = bit1_pos, h_bit = bit2_pos;
|
|
|
|
if ((h_bit - l_bit) < 31)
|
|
max_v = (1 << (h_bit - l_bit + 1)) - 1;
|
|
else
|
|
max_v = 0xFFFFFFFF;
|
|
|
|
if (value > max_v) {
|
|
printf("Invalid value %u (0x%x) must be < %u (0x%x)\n",
|
|
(unsigned)value, (unsigned)value,
|
|
(unsigned)max_v, (unsigned)max_v);
|
|
return;
|
|
}
|
|
reg_v = port_id_pci_reg_read(port_id, reg_off);
|
|
reg_v &= ~(max_v << l_bit); /* Keep unchanged bits */
|
|
reg_v |= (value << l_bit); /* Set changed bits */
|
|
port_id_pci_reg_write(port_id, reg_off, reg_v);
|
|
display_port_reg_value(port_id, reg_off, reg_v);
|
|
}
|
|
|
|
void
|
|
port_reg_set(portid_t port_id, uint32_t reg_off, uint32_t reg_v)
|
|
{
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
if (port_reg_off_is_invalid(port_id, reg_off))
|
|
return;
|
|
port_id_pci_reg_write(port_id, reg_off, reg_v);
|
|
display_port_reg_value(port_id, reg_off, reg_v);
|
|
}
|
|
|
|
void
|
|
port_mtu_set(portid_t port_id, uint16_t mtu)
|
|
{
|
|
int diag;
|
|
struct rte_port *rte_port = &ports[port_id];
|
|
struct rte_eth_dev_info dev_info;
|
|
uint16_t eth_overhead;
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
ret = eth_dev_info_get_print_err(port_id, &dev_info);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
if (mtu > dev_info.max_mtu || mtu < dev_info.min_mtu) {
|
|
printf("Set MTU failed. MTU:%u is not in valid range, min:%u - max:%u\n",
|
|
mtu, dev_info.min_mtu, dev_info.max_mtu);
|
|
return;
|
|
}
|
|
diag = rte_eth_dev_set_mtu(port_id, mtu);
|
|
if (diag)
|
|
printf("Set MTU failed. diag=%d\n", diag);
|
|
else if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_JUMBO_FRAME) {
|
|
/*
|
|
* Ether overhead in driver is equal to the difference of
|
|
* max_rx_pktlen and max_mtu in rte_eth_dev_info when the
|
|
* device supports jumbo frame.
|
|
*/
|
|
eth_overhead = dev_info.max_rx_pktlen - dev_info.max_mtu;
|
|
if (mtu > RTE_ETHER_MTU) {
|
|
rte_port->dev_conf.rxmode.offloads |=
|
|
DEV_RX_OFFLOAD_JUMBO_FRAME;
|
|
rte_port->dev_conf.rxmode.max_rx_pkt_len =
|
|
mtu + eth_overhead;
|
|
} else
|
|
rte_port->dev_conf.rxmode.offloads &=
|
|
~DEV_RX_OFFLOAD_JUMBO_FRAME;
|
|
}
|
|
}
|
|
|
|
/* Generic flow management functions. */
|
|
|
|
static struct port_flow_tunnel *
|
|
port_flow_locate_tunnel_id(struct rte_port *port, uint32_t port_tunnel_id)
|
|
{
|
|
struct port_flow_tunnel *flow_tunnel;
|
|
|
|
LIST_FOREACH(flow_tunnel, &port->flow_tunnel_list, chain) {
|
|
if (flow_tunnel->id == port_tunnel_id)
|
|
goto out;
|
|
}
|
|
flow_tunnel = NULL;
|
|
|
|
out:
|
|
return flow_tunnel;
|
|
}
|
|
|
|
const char *
|
|
port_flow_tunnel_type(struct rte_flow_tunnel *tunnel)
|
|
{
|
|
const char *type;
|
|
switch (tunnel->type) {
|
|
default:
|
|
type = "unknown";
|
|
break;
|
|
case RTE_FLOW_ITEM_TYPE_VXLAN:
|
|
type = "vxlan";
|
|
break;
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
struct port_flow_tunnel *
|
|
port_flow_locate_tunnel(uint16_t port_id, struct rte_flow_tunnel *tun)
|
|
{
|
|
struct rte_port *port = &ports[port_id];
|
|
struct port_flow_tunnel *flow_tunnel;
|
|
|
|
LIST_FOREACH(flow_tunnel, &port->flow_tunnel_list, chain) {
|
|
if (!memcmp(&flow_tunnel->tunnel, tun, sizeof(*tun)))
|
|
goto out;
|
|
}
|
|
flow_tunnel = NULL;
|
|
|
|
out:
|
|
return flow_tunnel;
|
|
}
|
|
|
|
void port_flow_tunnel_list(portid_t port_id)
|
|
{
|
|
struct rte_port *port = &ports[port_id];
|
|
struct port_flow_tunnel *flt;
|
|
|
|
LIST_FOREACH(flt, &port->flow_tunnel_list, chain) {
|
|
printf("port %u tunnel #%u type=%s",
|
|
port_id, flt->id, port_flow_tunnel_type(&flt->tunnel));
|
|
if (flt->tunnel.tun_id)
|
|
printf(" id=%" PRIu64, flt->tunnel.tun_id);
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
void port_flow_tunnel_destroy(portid_t port_id, uint32_t tunnel_id)
|
|
{
|
|
struct rte_port *port = &ports[port_id];
|
|
struct port_flow_tunnel *flt;
|
|
|
|
LIST_FOREACH(flt, &port->flow_tunnel_list, chain) {
|
|
if (flt->id == tunnel_id)
|
|
break;
|
|
}
|
|
if (flt) {
|
|
LIST_REMOVE(flt, chain);
|
|
free(flt);
|
|
printf("port %u: flow tunnel #%u destroyed\n",
|
|
port_id, tunnel_id);
|
|
}
|
|
}
|
|
|
|
void port_flow_tunnel_create(portid_t port_id, const struct tunnel_ops *ops)
|
|
{
|
|
struct rte_port *port = &ports[port_id];
|
|
enum rte_flow_item_type type;
|
|
struct port_flow_tunnel *flt;
|
|
|
|
if (!strcmp(ops->type, "vxlan"))
|
|
type = RTE_FLOW_ITEM_TYPE_VXLAN;
|
|
else {
|
|
printf("cannot offload \"%s\" tunnel type\n", ops->type);
|
|
return;
|
|
}
|
|
LIST_FOREACH(flt, &port->flow_tunnel_list, chain) {
|
|
if (flt->tunnel.type == type)
|
|
break;
|
|
}
|
|
if (!flt) {
|
|
flt = calloc(1, sizeof(*flt));
|
|
if (!flt) {
|
|
printf("failed to allocate port flt object\n");
|
|
return;
|
|
}
|
|
flt->tunnel.type = type;
|
|
flt->id = LIST_EMPTY(&port->flow_tunnel_list) ? 1 :
|
|
LIST_FIRST(&port->flow_tunnel_list)->id + 1;
|
|
LIST_INSERT_HEAD(&port->flow_tunnel_list, flt, chain);
|
|
}
|
|
printf("port %d: flow tunnel #%u type %s\n",
|
|
port_id, flt->id, ops->type);
|
|
}
|
|
|
|
/** Generate a port_flow entry from attributes/pattern/actions. */
|
|
static struct port_flow *
|
|
port_flow_new(const struct rte_flow_attr *attr,
|
|
const struct rte_flow_item *pattern,
|
|
const struct rte_flow_action *actions,
|
|
struct rte_flow_error *error)
|
|
{
|
|
const struct rte_flow_conv_rule rule = {
|
|
.attr_ro = attr,
|
|
.pattern_ro = pattern,
|
|
.actions_ro = actions,
|
|
};
|
|
struct port_flow *pf;
|
|
int ret;
|
|
|
|
ret = rte_flow_conv(RTE_FLOW_CONV_OP_RULE, NULL, 0, &rule, error);
|
|
if (ret < 0)
|
|
return NULL;
|
|
pf = calloc(1, offsetof(struct port_flow, rule) + ret);
|
|
if (!pf) {
|
|
rte_flow_error_set
|
|
(error, errno, RTE_FLOW_ERROR_TYPE_UNSPECIFIED, NULL,
|
|
"calloc() failed");
|
|
return NULL;
|
|
}
|
|
if (rte_flow_conv(RTE_FLOW_CONV_OP_RULE, &pf->rule, ret, &rule,
|
|
error) >= 0)
|
|
return pf;
|
|
free(pf);
|
|
return NULL;
|
|
}
|
|
|
|
/** Print a message out of a flow error. */
|
|
static int
|
|
port_flow_complain(struct rte_flow_error *error)
|
|
{
|
|
static const char *const errstrlist[] = {
|
|
[RTE_FLOW_ERROR_TYPE_NONE] = "no error",
|
|
[RTE_FLOW_ERROR_TYPE_UNSPECIFIED] = "cause unspecified",
|
|
[RTE_FLOW_ERROR_TYPE_HANDLE] = "flow rule (handle)",
|
|
[RTE_FLOW_ERROR_TYPE_ATTR_GROUP] = "group field",
|
|
[RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY] = "priority field",
|
|
[RTE_FLOW_ERROR_TYPE_ATTR_INGRESS] = "ingress field",
|
|
[RTE_FLOW_ERROR_TYPE_ATTR_EGRESS] = "egress field",
|
|
[RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER] = "transfer field",
|
|
[RTE_FLOW_ERROR_TYPE_ATTR] = "attributes structure",
|
|
[RTE_FLOW_ERROR_TYPE_ITEM_NUM] = "pattern length",
|
|
[RTE_FLOW_ERROR_TYPE_ITEM_SPEC] = "item specification",
|
|
[RTE_FLOW_ERROR_TYPE_ITEM_LAST] = "item specification range",
|
|
[RTE_FLOW_ERROR_TYPE_ITEM_MASK] = "item specification mask",
|
|
[RTE_FLOW_ERROR_TYPE_ITEM] = "specific pattern item",
|
|
[RTE_FLOW_ERROR_TYPE_ACTION_NUM] = "number of actions",
|
|
[RTE_FLOW_ERROR_TYPE_ACTION_CONF] = "action configuration",
|
|
[RTE_FLOW_ERROR_TYPE_ACTION] = "specific action",
|
|
};
|
|
const char *errstr;
|
|
char buf[32];
|
|
int err = rte_errno;
|
|
|
|
if ((unsigned int)error->type >= RTE_DIM(errstrlist) ||
|
|
!errstrlist[error->type])
|
|
errstr = "unknown type";
|
|
else
|
|
errstr = errstrlist[error->type];
|
|
printf("%s(): Caught PMD error type %d (%s): %s%s: %s\n", __func__,
|
|
error->type, errstr,
|
|
error->cause ? (snprintf(buf, sizeof(buf), "cause: %p, ",
|
|
error->cause), buf) : "",
|
|
error->message ? error->message : "(no stated reason)",
|
|
rte_strerror(err));
|
|
return -err;
|
|
}
|
|
|
|
static void
|
|
rss_config_display(struct rte_flow_action_rss *rss_conf)
|
|
{
|
|
uint8_t i;
|
|
|
|
if (rss_conf == NULL) {
|
|
printf("Invalid rule\n");
|
|
return;
|
|
}
|
|
|
|
printf("RSS:\n"
|
|
" queues:");
|
|
if (rss_conf->queue_num == 0)
|
|
printf(" none");
|
|
for (i = 0; i < rss_conf->queue_num; i++)
|
|
printf(" %d", rss_conf->queue[i]);
|
|
printf("\n");
|
|
|
|
printf(" function: ");
|
|
switch (rss_conf->func) {
|
|
case RTE_ETH_HASH_FUNCTION_DEFAULT:
|
|
printf("default\n");
|
|
break;
|
|
case RTE_ETH_HASH_FUNCTION_TOEPLITZ:
|
|
printf("toeplitz\n");
|
|
break;
|
|
case RTE_ETH_HASH_FUNCTION_SIMPLE_XOR:
|
|
printf("simple_xor\n");
|
|
break;
|
|
case RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ:
|
|
printf("symmetric_toeplitz\n");
|
|
break;
|
|
default:
|
|
printf("Unknown function\n");
|
|
return;
|
|
}
|
|
|
|
printf(" types:\n");
|
|
if (rss_conf->types == 0) {
|
|
printf(" none\n");
|
|
return;
|
|
}
|
|
for (i = 0; rss_type_table[i].str; i++) {
|
|
if ((rss_conf->types &
|
|
rss_type_table[i].rss_type) ==
|
|
rss_type_table[i].rss_type &&
|
|
rss_type_table[i].rss_type != 0)
|
|
printf(" %s\n", rss_type_table[i].str);
|
|
}
|
|
}
|
|
|
|
static struct port_indirect_action *
|
|
action_get_by_id(portid_t port_id, uint32_t id)
|
|
{
|
|
struct rte_port *port;
|
|
struct port_indirect_action **ppia;
|
|
struct port_indirect_action *pia = NULL;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN) ||
|
|
port_id == (portid_t)RTE_PORT_ALL)
|
|
return NULL;
|
|
port = &ports[port_id];
|
|
ppia = &port->actions_list;
|
|
while (*ppia) {
|
|
if ((*ppia)->id == id) {
|
|
pia = *ppia;
|
|
break;
|
|
}
|
|
ppia = &(*ppia)->next;
|
|
}
|
|
if (!pia)
|
|
printf("Failed to find indirect action #%u on port %u\n",
|
|
id, port_id);
|
|
return pia;
|
|
}
|
|
|
|
static int
|
|
action_alloc(portid_t port_id, uint32_t id,
|
|
struct port_indirect_action **action)
|
|
{
|
|
struct rte_port *port;
|
|
struct port_indirect_action **ppia;
|
|
struct port_indirect_action *pia = NULL;
|
|
|
|
*action = NULL;
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN) ||
|
|
port_id == (portid_t)RTE_PORT_ALL)
|
|
return -EINVAL;
|
|
port = &ports[port_id];
|
|
if (id == UINT32_MAX) {
|
|
/* taking first available ID */
|
|
if (port->actions_list) {
|
|
if (port->actions_list->id == UINT32_MAX - 1) {
|
|
printf("Highest indirect action ID is already"
|
|
" assigned, delete it first\n");
|
|
return -ENOMEM;
|
|
}
|
|
id = port->actions_list->id + 1;
|
|
} else {
|
|
id = 0;
|
|
}
|
|
}
|
|
pia = calloc(1, sizeof(*pia));
|
|
if (!pia) {
|
|
printf("Allocation of port %u indirect action failed\n",
|
|
port_id);
|
|
return -ENOMEM;
|
|
}
|
|
ppia = &port->actions_list;
|
|
while (*ppia && (*ppia)->id > id)
|
|
ppia = &(*ppia)->next;
|
|
if (*ppia && (*ppia)->id == id) {
|
|
printf("Indirect action #%u is already assigned,"
|
|
" delete it first\n", id);
|
|
free(pia);
|
|
return -EINVAL;
|
|
}
|
|
pia->next = *ppia;
|
|
pia->id = id;
|
|
*ppia = pia;
|
|
*action = pia;
|
|
return 0;
|
|
}
|
|
|
|
/** Create indirect action */
|
|
int
|
|
port_action_handle_create(portid_t port_id, uint32_t id,
|
|
const struct rte_flow_indir_action_conf *conf,
|
|
const struct rte_flow_action *action)
|
|
{
|
|
struct port_indirect_action *pia;
|
|
int ret;
|
|
struct rte_flow_error error;
|
|
|
|
ret = action_alloc(port_id, id, &pia);
|
|
if (ret)
|
|
return ret;
|
|
if (action->type == RTE_FLOW_ACTION_TYPE_AGE) {
|
|
struct rte_flow_action_age *age =
|
|
(struct rte_flow_action_age *)(uintptr_t)(action->conf);
|
|
|
|
pia->age_type = ACTION_AGE_CONTEXT_TYPE_INDIRECT_ACTION;
|
|
age->context = &pia->age_type;
|
|
} else if (action->type == RTE_FLOW_ACTION_TYPE_CONNTRACK) {
|
|
struct rte_flow_action_conntrack *ct =
|
|
(struct rte_flow_action_conntrack *)(uintptr_t)(action->conf);
|
|
|
|
memcpy(ct, &conntrack_context, sizeof(*ct));
|
|
}
|
|
/* Poisoning to make sure PMDs update it in case of error. */
|
|
memset(&error, 0x22, sizeof(error));
|
|
pia->handle = rte_flow_action_handle_create(port_id, conf, action,
|
|
&error);
|
|
if (!pia->handle) {
|
|
uint32_t destroy_id = pia->id;
|
|
port_action_handle_destroy(port_id, 1, &destroy_id);
|
|
return port_flow_complain(&error);
|
|
}
|
|
pia->type = action->type;
|
|
printf("Indirect action #%u created\n", pia->id);
|
|
return 0;
|
|
}
|
|
|
|
/** Destroy indirect action */
|
|
int
|
|
port_action_handle_destroy(portid_t port_id,
|
|
uint32_t n,
|
|
const uint32_t *actions)
|
|
{
|
|
struct rte_port *port;
|
|
struct port_indirect_action **tmp;
|
|
uint32_t c = 0;
|
|
int ret = 0;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN) ||
|
|
port_id == (portid_t)RTE_PORT_ALL)
|
|
return -EINVAL;
|
|
port = &ports[port_id];
|
|
tmp = &port->actions_list;
|
|
while (*tmp) {
|
|
uint32_t i;
|
|
|
|
for (i = 0; i != n; ++i) {
|
|
struct rte_flow_error error;
|
|
struct port_indirect_action *pia = *tmp;
|
|
|
|
if (actions[i] != pia->id)
|
|
continue;
|
|
/*
|
|
* Poisoning to make sure PMDs update it in case
|
|
* of error.
|
|
*/
|
|
memset(&error, 0x33, sizeof(error));
|
|
|
|
if (pia->handle && rte_flow_action_handle_destroy(
|
|
port_id, pia->handle, &error)) {
|
|
ret = port_flow_complain(&error);
|
|
continue;
|
|
}
|
|
*tmp = pia->next;
|
|
printf("Indirect action #%u destroyed\n", pia->id);
|
|
free(pia);
|
|
break;
|
|
}
|
|
if (i == n)
|
|
tmp = &(*tmp)->next;
|
|
++c;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/** Get indirect action by port + id */
|
|
struct rte_flow_action_handle *
|
|
port_action_handle_get_by_id(portid_t port_id, uint32_t id)
|
|
{
|
|
|
|
struct port_indirect_action *pia = action_get_by_id(port_id, id);
|
|
|
|
return (pia) ? pia->handle : NULL;
|
|
}
|
|
|
|
/** Update indirect action */
|
|
int
|
|
port_action_handle_update(portid_t port_id, uint32_t id,
|
|
const struct rte_flow_action *action)
|
|
{
|
|
struct rte_flow_error error;
|
|
struct rte_flow_action_handle *action_handle;
|
|
struct port_indirect_action *pia;
|
|
const void *update;
|
|
|
|
action_handle = port_action_handle_get_by_id(port_id, id);
|
|
if (!action_handle)
|
|
return -EINVAL;
|
|
pia = action_get_by_id(port_id, id);
|
|
if (!pia)
|
|
return -EINVAL;
|
|
switch (pia->type) {
|
|
case RTE_FLOW_ACTION_TYPE_CONNTRACK:
|
|
update = action->conf;
|
|
break;
|
|
default:
|
|
update = action;
|
|
break;
|
|
}
|
|
if (rte_flow_action_handle_update(port_id, action_handle, update,
|
|
&error)) {
|
|
return port_flow_complain(&error);
|
|
}
|
|
printf("Indirect action #%u updated\n", id);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
port_action_handle_query(portid_t port_id, uint32_t id)
|
|
{
|
|
struct rte_flow_error error;
|
|
struct port_indirect_action *pia;
|
|
uint64_t default_data;
|
|
void *data = NULL;
|
|
int ret = 0;
|
|
|
|
pia = action_get_by_id(port_id, id);
|
|
if (!pia)
|
|
return -EINVAL;
|
|
switch (pia->type) {
|
|
case RTE_FLOW_ACTION_TYPE_RSS:
|
|
case RTE_FLOW_ACTION_TYPE_AGE:
|
|
data = &default_data;
|
|
break;
|
|
default:
|
|
printf("Indirect action %u (type: %d) on port %u doesn't"
|
|
" support query\n", id, pia->type, port_id);
|
|
return -1;
|
|
}
|
|
if (rte_flow_action_handle_query(port_id, pia->handle, data, &error))
|
|
ret = port_flow_complain(&error);
|
|
switch (pia->type) {
|
|
case RTE_FLOW_ACTION_TYPE_RSS:
|
|
if (!ret)
|
|
printf("Shared RSS action:\n\trefs:%u\n",
|
|
*((uint32_t *)data));
|
|
data = NULL;
|
|
break;
|
|
case RTE_FLOW_ACTION_TYPE_AGE:
|
|
if (!ret) {
|
|
struct rte_flow_query_age *resp = data;
|
|
|
|
printf("AGE:\n"
|
|
" aged: %u\n"
|
|
" sec_since_last_hit_valid: %u\n"
|
|
" sec_since_last_hit: %" PRIu32 "\n",
|
|
resp->aged,
|
|
resp->sec_since_last_hit_valid,
|
|
resp->sec_since_last_hit);
|
|
}
|
|
data = NULL;
|
|
break;
|
|
case RTE_FLOW_ACTION_TYPE_CONNTRACK:
|
|
if (!ret) {
|
|
struct rte_flow_action_conntrack *ct = data;
|
|
|
|
printf("Conntrack Context:\n"
|
|
" Peer: %u, Flow dir: %s, Enable: %u\n"
|
|
" Live: %u, SACK: %u, CACK: %u\n"
|
|
" Packet dir: %s, Liberal: %u, State: %u\n"
|
|
" Factor: %u, Retrans: %u, TCP flags: %u\n"
|
|
" Last Seq: %u, Last ACK: %u\n"
|
|
" Last Win: %u, Last End: %u\n",
|
|
ct->peer_port,
|
|
ct->is_original_dir ? "Original" : "Reply",
|
|
ct->enable, ct->live_connection,
|
|
ct->selective_ack, ct->challenge_ack_passed,
|
|
ct->last_direction ? "Original" : "Reply",
|
|
ct->liberal_mode, ct->state,
|
|
ct->max_ack_window, ct->retransmission_limit,
|
|
ct->last_index, ct->last_seq, ct->last_ack,
|
|
ct->last_window, ct->last_end);
|
|
printf(" Original Dir:\n"
|
|
" scale: %u, fin: %u, ack seen: %u\n"
|
|
" unacked data: %u\n Sent end: %u,"
|
|
" Reply end: %u, Max win: %u, Max ACK: %u\n",
|
|
ct->original_dir.scale,
|
|
ct->original_dir.close_initiated,
|
|
ct->original_dir.last_ack_seen,
|
|
ct->original_dir.data_unacked,
|
|
ct->original_dir.sent_end,
|
|
ct->original_dir.reply_end,
|
|
ct->original_dir.max_win,
|
|
ct->original_dir.max_ack);
|
|
printf(" Reply Dir:\n"
|
|
" scale: %u, fin: %u, ack seen: %u\n"
|
|
" unacked data: %u\n Sent end: %u,"
|
|
" Reply end: %u, Max win: %u, Max ACK: %u\n",
|
|
ct->reply_dir.scale,
|
|
ct->reply_dir.close_initiated,
|
|
ct->reply_dir.last_ack_seen,
|
|
ct->reply_dir.data_unacked,
|
|
ct->reply_dir.sent_end, ct->reply_dir.reply_end,
|
|
ct->reply_dir.max_win, ct->reply_dir.max_ack);
|
|
}
|
|
data = NULL;
|
|
break;
|
|
default:
|
|
printf("Indirect action %u (type: %d) on port %u doesn't"
|
|
" support query\n", id, pia->type, port_id);
|
|
ret = -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static struct port_flow_tunnel *
|
|
port_flow_tunnel_offload_cmd_prep(portid_t port_id,
|
|
const struct rte_flow_item *pattern,
|
|
const struct rte_flow_action *actions,
|
|
const struct tunnel_ops *tunnel_ops)
|
|
{
|
|
int ret;
|
|
struct rte_port *port;
|
|
struct port_flow_tunnel *pft;
|
|
struct rte_flow_error error;
|
|
|
|
port = &ports[port_id];
|
|
pft = port_flow_locate_tunnel_id(port, tunnel_ops->id);
|
|
if (!pft) {
|
|
printf("failed to locate port flow tunnel #%u\n",
|
|
tunnel_ops->id);
|
|
return NULL;
|
|
}
|
|
if (tunnel_ops->actions) {
|
|
uint32_t num_actions;
|
|
const struct rte_flow_action *aptr;
|
|
|
|
ret = rte_flow_tunnel_decap_set(port_id, &pft->tunnel,
|
|
&pft->pmd_actions,
|
|
&pft->num_pmd_actions,
|
|
&error);
|
|
if (ret) {
|
|
port_flow_complain(&error);
|
|
return NULL;
|
|
}
|
|
for (aptr = actions, num_actions = 1;
|
|
aptr->type != RTE_FLOW_ACTION_TYPE_END;
|
|
aptr++, num_actions++);
|
|
pft->actions = malloc(
|
|
(num_actions + pft->num_pmd_actions) *
|
|
sizeof(actions[0]));
|
|
if (!pft->actions) {
|
|
rte_flow_tunnel_action_decap_release(
|
|
port_id, pft->actions,
|
|
pft->num_pmd_actions, &error);
|
|
return NULL;
|
|
}
|
|
rte_memcpy(pft->actions, pft->pmd_actions,
|
|
pft->num_pmd_actions * sizeof(actions[0]));
|
|
rte_memcpy(pft->actions + pft->num_pmd_actions, actions,
|
|
num_actions * sizeof(actions[0]));
|
|
}
|
|
if (tunnel_ops->items) {
|
|
uint32_t num_items;
|
|
const struct rte_flow_item *iptr;
|
|
|
|
ret = rte_flow_tunnel_match(port_id, &pft->tunnel,
|
|
&pft->pmd_items,
|
|
&pft->num_pmd_items,
|
|
&error);
|
|
if (ret) {
|
|
port_flow_complain(&error);
|
|
return NULL;
|
|
}
|
|
for (iptr = pattern, num_items = 1;
|
|
iptr->type != RTE_FLOW_ITEM_TYPE_END;
|
|
iptr++, num_items++);
|
|
pft->items = malloc((num_items + pft->num_pmd_items) *
|
|
sizeof(pattern[0]));
|
|
if (!pft->items) {
|
|
rte_flow_tunnel_item_release(
|
|
port_id, pft->pmd_items,
|
|
pft->num_pmd_items, &error);
|
|
return NULL;
|
|
}
|
|
rte_memcpy(pft->items, pft->pmd_items,
|
|
pft->num_pmd_items * sizeof(pattern[0]));
|
|
rte_memcpy(pft->items + pft->num_pmd_items, pattern,
|
|
num_items * sizeof(pattern[0]));
|
|
}
|
|
|
|
return pft;
|
|
}
|
|
|
|
static void
|
|
port_flow_tunnel_offload_cmd_release(portid_t port_id,
|
|
const struct tunnel_ops *tunnel_ops,
|
|
struct port_flow_tunnel *pft)
|
|
{
|
|
struct rte_flow_error error;
|
|
|
|
if (tunnel_ops->actions) {
|
|
free(pft->actions);
|
|
rte_flow_tunnel_action_decap_release(
|
|
port_id, pft->pmd_actions,
|
|
pft->num_pmd_actions, &error);
|
|
pft->actions = NULL;
|
|
pft->pmd_actions = NULL;
|
|
}
|
|
if (tunnel_ops->items) {
|
|
free(pft->items);
|
|
rte_flow_tunnel_item_release(port_id, pft->pmd_items,
|
|
pft->num_pmd_items,
|
|
&error);
|
|
pft->items = NULL;
|
|
pft->pmd_items = NULL;
|
|
}
|
|
}
|
|
|
|
/** Add port meter policy */
|
|
int
|
|
port_meter_policy_add(portid_t port_id, uint32_t policy_id,
|
|
const struct rte_flow_action *actions)
|
|
{
|
|
struct rte_mtr_error error;
|
|
const struct rte_flow_action *act = actions;
|
|
const struct rte_flow_action *start;
|
|
struct rte_mtr_meter_policy_params policy;
|
|
uint32_t i = 0, act_n;
|
|
int ret;
|
|
|
|
for (i = 0; i < RTE_COLORS; i++) {
|
|
for (act_n = 0, start = act;
|
|
act->type != RTE_FLOW_ACTION_TYPE_END; act++)
|
|
act_n++;
|
|
if (act_n && act->type == RTE_FLOW_ACTION_TYPE_END)
|
|
policy.actions[i] = start;
|
|
else
|
|
policy.actions[i] = NULL;
|
|
act++;
|
|
}
|
|
ret = rte_mtr_meter_policy_add(port_id,
|
|
policy_id,
|
|
&policy, &error);
|
|
if (ret)
|
|
print_mtr_err_msg(&error);
|
|
return ret;
|
|
}
|
|
|
|
/** Validate flow rule. */
|
|
int
|
|
port_flow_validate(portid_t port_id,
|
|
const struct rte_flow_attr *attr,
|
|
const struct rte_flow_item *pattern,
|
|
const struct rte_flow_action *actions,
|
|
const struct tunnel_ops *tunnel_ops)
|
|
{
|
|
struct rte_flow_error error;
|
|
struct port_flow_tunnel *pft = NULL;
|
|
|
|
/* Poisoning to make sure PMDs update it in case of error. */
|
|
memset(&error, 0x11, sizeof(error));
|
|
if (tunnel_ops->enabled) {
|
|
pft = port_flow_tunnel_offload_cmd_prep(port_id, pattern,
|
|
actions, tunnel_ops);
|
|
if (!pft)
|
|
return -ENOENT;
|
|
if (pft->items)
|
|
pattern = pft->items;
|
|
if (pft->actions)
|
|
actions = pft->actions;
|
|
}
|
|
if (rte_flow_validate(port_id, attr, pattern, actions, &error))
|
|
return port_flow_complain(&error);
|
|
if (tunnel_ops->enabled)
|
|
port_flow_tunnel_offload_cmd_release(port_id, tunnel_ops, pft);
|
|
printf("Flow rule validated\n");
|
|
return 0;
|
|
}
|
|
|
|
/** Return age action structure if exists, otherwise NULL. */
|
|
static struct rte_flow_action_age *
|
|
age_action_get(const struct rte_flow_action *actions)
|
|
{
|
|
for (; actions->type != RTE_FLOW_ACTION_TYPE_END; actions++) {
|
|
switch (actions->type) {
|
|
case RTE_FLOW_ACTION_TYPE_AGE:
|
|
return (struct rte_flow_action_age *)
|
|
(uintptr_t)actions->conf;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/** Create flow rule. */
|
|
int
|
|
port_flow_create(portid_t port_id,
|
|
const struct rte_flow_attr *attr,
|
|
const struct rte_flow_item *pattern,
|
|
const struct rte_flow_action *actions,
|
|
const struct tunnel_ops *tunnel_ops)
|
|
{
|
|
struct rte_flow *flow;
|
|
struct rte_port *port;
|
|
struct port_flow *pf;
|
|
uint32_t id = 0;
|
|
struct rte_flow_error error;
|
|
struct port_flow_tunnel *pft = NULL;
|
|
struct rte_flow_action_age *age = age_action_get(actions);
|
|
|
|
port = &ports[port_id];
|
|
if (port->flow_list) {
|
|
if (port->flow_list->id == UINT32_MAX) {
|
|
printf("Highest rule ID is already assigned, delete"
|
|
" it first");
|
|
return -ENOMEM;
|
|
}
|
|
id = port->flow_list->id + 1;
|
|
}
|
|
if (tunnel_ops->enabled) {
|
|
pft = port_flow_tunnel_offload_cmd_prep(port_id, pattern,
|
|
actions, tunnel_ops);
|
|
if (!pft)
|
|
return -ENOENT;
|
|
if (pft->items)
|
|
pattern = pft->items;
|
|
if (pft->actions)
|
|
actions = pft->actions;
|
|
}
|
|
pf = port_flow_new(attr, pattern, actions, &error);
|
|
if (!pf)
|
|
return port_flow_complain(&error);
|
|
if (age) {
|
|
pf->age_type = ACTION_AGE_CONTEXT_TYPE_FLOW;
|
|
age->context = &pf->age_type;
|
|
}
|
|
/* Poisoning to make sure PMDs update it in case of error. */
|
|
memset(&error, 0x22, sizeof(error));
|
|
flow = rte_flow_create(port_id, attr, pattern, actions, &error);
|
|
if (!flow) {
|
|
free(pf);
|
|
return port_flow_complain(&error);
|
|
}
|
|
pf->next = port->flow_list;
|
|
pf->id = id;
|
|
pf->flow = flow;
|
|
port->flow_list = pf;
|
|
if (tunnel_ops->enabled)
|
|
port_flow_tunnel_offload_cmd_release(port_id, tunnel_ops, pft);
|
|
printf("Flow rule #%u created\n", pf->id);
|
|
return 0;
|
|
}
|
|
|
|
/** Destroy a number of flow rules. */
|
|
int
|
|
port_flow_destroy(portid_t port_id, uint32_t n, const uint32_t *rule)
|
|
{
|
|
struct rte_port *port;
|
|
struct port_flow **tmp;
|
|
uint32_t c = 0;
|
|
int ret = 0;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN) ||
|
|
port_id == (portid_t)RTE_PORT_ALL)
|
|
return -EINVAL;
|
|
port = &ports[port_id];
|
|
tmp = &port->flow_list;
|
|
while (*tmp) {
|
|
uint32_t i;
|
|
|
|
for (i = 0; i != n; ++i) {
|
|
struct rte_flow_error error;
|
|
struct port_flow *pf = *tmp;
|
|
|
|
if (rule[i] != pf->id)
|
|
continue;
|
|
/*
|
|
* Poisoning to make sure PMDs update it in case
|
|
* of error.
|
|
*/
|
|
memset(&error, 0x33, sizeof(error));
|
|
if (rte_flow_destroy(port_id, pf->flow, &error)) {
|
|
ret = port_flow_complain(&error);
|
|
continue;
|
|
}
|
|
printf("Flow rule #%u destroyed\n", pf->id);
|
|
*tmp = pf->next;
|
|
free(pf);
|
|
break;
|
|
}
|
|
if (i == n)
|
|
tmp = &(*tmp)->next;
|
|
++c;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/** Remove all flow rules. */
|
|
int
|
|
port_flow_flush(portid_t port_id)
|
|
{
|
|
struct rte_flow_error error;
|
|
struct rte_port *port;
|
|
int ret = 0;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN) ||
|
|
port_id == (portid_t)RTE_PORT_ALL)
|
|
return -EINVAL;
|
|
|
|
port = &ports[port_id];
|
|
|
|
if (port->flow_list == NULL)
|
|
return ret;
|
|
|
|
/* Poisoning to make sure PMDs update it in case of error. */
|
|
memset(&error, 0x44, sizeof(error));
|
|
if (rte_flow_flush(port_id, &error)) {
|
|
port_flow_complain(&error);
|
|
}
|
|
|
|
while (port->flow_list) {
|
|
struct port_flow *pf = port->flow_list->next;
|
|
|
|
free(port->flow_list);
|
|
port->flow_list = pf;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/** Dump flow rules. */
|
|
int
|
|
port_flow_dump(portid_t port_id, bool dump_all, uint32_t rule_id,
|
|
const char *file_name)
|
|
{
|
|
int ret = 0;
|
|
FILE *file = stdout;
|
|
struct rte_flow_error error;
|
|
struct rte_port *port;
|
|
struct port_flow *pflow;
|
|
struct rte_flow *tmpFlow = NULL;
|
|
bool found = false;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN) ||
|
|
port_id == (portid_t)RTE_PORT_ALL)
|
|
return -EINVAL;
|
|
|
|
if (!dump_all) {
|
|
port = &ports[port_id];
|
|
pflow = port->flow_list;
|
|
while (pflow) {
|
|
if (rule_id != pflow->id) {
|
|
pflow = pflow->next;
|
|
} else {
|
|
tmpFlow = pflow->flow;
|
|
if (tmpFlow)
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (found == false) {
|
|
printf("Failed to dump to flow %d\n", rule_id);
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
if (file_name && strlen(file_name)) {
|
|
file = fopen(file_name, "w");
|
|
if (!file) {
|
|
printf("Failed to create file %s: %s\n", file_name,
|
|
strerror(errno));
|
|
return -errno;
|
|
}
|
|
}
|
|
|
|
if (!dump_all)
|
|
ret = rte_flow_dev_dump(port_id, tmpFlow, file, &error);
|
|
else
|
|
ret = rte_flow_dev_dump(port_id, NULL, file, &error);
|
|
if (ret) {
|
|
port_flow_complain(&error);
|
|
printf("Failed to dump flow: %s\n", strerror(-ret));
|
|
} else
|
|
printf("Flow dump finished\n");
|
|
if (file_name && strlen(file_name))
|
|
fclose(file);
|
|
return ret;
|
|
}
|
|
|
|
/** Query a flow rule. */
|
|
int
|
|
port_flow_query(portid_t port_id, uint32_t rule,
|
|
const struct rte_flow_action *action)
|
|
{
|
|
struct rte_flow_error error;
|
|
struct rte_port *port;
|
|
struct port_flow *pf;
|
|
const char *name;
|
|
union {
|
|
struct rte_flow_query_count count;
|
|
struct rte_flow_action_rss rss_conf;
|
|
struct rte_flow_query_age age;
|
|
} query;
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN) ||
|
|
port_id == (portid_t)RTE_PORT_ALL)
|
|
return -EINVAL;
|
|
port = &ports[port_id];
|
|
for (pf = port->flow_list; pf; pf = pf->next)
|
|
if (pf->id == rule)
|
|
break;
|
|
if (!pf) {
|
|
printf("Flow rule #%u not found\n", rule);
|
|
return -ENOENT;
|
|
}
|
|
ret = rte_flow_conv(RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
|
|
&name, sizeof(name),
|
|
(void *)(uintptr_t)action->type, &error);
|
|
if (ret < 0)
|
|
return port_flow_complain(&error);
|
|
switch (action->type) {
|
|
case RTE_FLOW_ACTION_TYPE_COUNT:
|
|
case RTE_FLOW_ACTION_TYPE_RSS:
|
|
case RTE_FLOW_ACTION_TYPE_AGE:
|
|
break;
|
|
default:
|
|
printf("Cannot query action type %d (%s)\n",
|
|
action->type, name);
|
|
return -ENOTSUP;
|
|
}
|
|
/* Poisoning to make sure PMDs update it in case of error. */
|
|
memset(&error, 0x55, sizeof(error));
|
|
memset(&query, 0, sizeof(query));
|
|
if (rte_flow_query(port_id, pf->flow, action, &query, &error))
|
|
return port_flow_complain(&error);
|
|
switch (action->type) {
|
|
case RTE_FLOW_ACTION_TYPE_COUNT:
|
|
printf("%s:\n"
|
|
" hits_set: %u\n"
|
|
" bytes_set: %u\n"
|
|
" hits: %" PRIu64 "\n"
|
|
" bytes: %" PRIu64 "\n",
|
|
name,
|
|
query.count.hits_set,
|
|
query.count.bytes_set,
|
|
query.count.hits,
|
|
query.count.bytes);
|
|
break;
|
|
case RTE_FLOW_ACTION_TYPE_RSS:
|
|
rss_config_display(&query.rss_conf);
|
|
break;
|
|
case RTE_FLOW_ACTION_TYPE_AGE:
|
|
printf("%s:\n"
|
|
" aged: %u\n"
|
|
" sec_since_last_hit_valid: %u\n"
|
|
" sec_since_last_hit: %" PRIu32 "\n",
|
|
name,
|
|
query.age.aged,
|
|
query.age.sec_since_last_hit_valid,
|
|
query.age.sec_since_last_hit);
|
|
break;
|
|
default:
|
|
printf("Cannot display result for action type %d (%s)\n",
|
|
action->type, name);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/** List simply and destroy all aged flows. */
|
|
void
|
|
port_flow_aged(portid_t port_id, uint8_t destroy)
|
|
{
|
|
void **contexts;
|
|
int nb_context, total = 0, idx;
|
|
struct rte_flow_error error;
|
|
enum age_action_context_type *type;
|
|
union {
|
|
struct port_flow *pf;
|
|
struct port_indirect_action *pia;
|
|
} ctx;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN) ||
|
|
port_id == (portid_t)RTE_PORT_ALL)
|
|
return;
|
|
total = rte_flow_get_aged_flows(port_id, NULL, 0, &error);
|
|
printf("Port %u total aged flows: %d\n", port_id, total);
|
|
if (total < 0) {
|
|
port_flow_complain(&error);
|
|
return;
|
|
}
|
|
if (total == 0)
|
|
return;
|
|
contexts = malloc(sizeof(void *) * total);
|
|
if (contexts == NULL) {
|
|
printf("Cannot allocate contexts for aged flow\n");
|
|
return;
|
|
}
|
|
printf("%-20s\tID\tGroup\tPrio\tAttr\n", "Type");
|
|
nb_context = rte_flow_get_aged_flows(port_id, contexts, total, &error);
|
|
if (nb_context != total) {
|
|
printf("Port:%d get aged flows count(%d) != total(%d)\n",
|
|
port_id, nb_context, total);
|
|
free(contexts);
|
|
return;
|
|
}
|
|
total = 0;
|
|
for (idx = 0; idx < nb_context; idx++) {
|
|
if (!contexts[idx]) {
|
|
printf("Error: get Null context in port %u\n", port_id);
|
|
continue;
|
|
}
|
|
type = (enum age_action_context_type *)contexts[idx];
|
|
switch (*type) {
|
|
case ACTION_AGE_CONTEXT_TYPE_FLOW:
|
|
ctx.pf = container_of(type, struct port_flow, age_type);
|
|
printf("%-20s\t%" PRIu32 "\t%" PRIu32 "\t%" PRIu32
|
|
"\t%c%c%c\t\n",
|
|
"Flow",
|
|
ctx.pf->id,
|
|
ctx.pf->rule.attr->group,
|
|
ctx.pf->rule.attr->priority,
|
|
ctx.pf->rule.attr->ingress ? 'i' : '-',
|
|
ctx.pf->rule.attr->egress ? 'e' : '-',
|
|
ctx.pf->rule.attr->transfer ? 't' : '-');
|
|
if (destroy && !port_flow_destroy(port_id, 1,
|
|
&ctx.pf->id))
|
|
total++;
|
|
break;
|
|
case ACTION_AGE_CONTEXT_TYPE_INDIRECT_ACTION:
|
|
ctx.pia = container_of(type,
|
|
struct port_indirect_action, age_type);
|
|
printf("%-20s\t%" PRIu32 "\n", "Indirect action",
|
|
ctx.pia->id);
|
|
break;
|
|
default:
|
|
printf("Error: invalid context type %u\n", port_id);
|
|
break;
|
|
}
|
|
}
|
|
printf("\n%d flows destroyed\n", total);
|
|
free(contexts);
|
|
}
|
|
|
|
/** List flow rules. */
|
|
void
|
|
port_flow_list(portid_t port_id, uint32_t n, const uint32_t *group)
|
|
{
|
|
struct rte_port *port;
|
|
struct port_flow *pf;
|
|
struct port_flow *list = NULL;
|
|
uint32_t i;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN) ||
|
|
port_id == (portid_t)RTE_PORT_ALL)
|
|
return;
|
|
port = &ports[port_id];
|
|
if (!port->flow_list)
|
|
return;
|
|
/* Sort flows by group, priority and ID. */
|
|
for (pf = port->flow_list; pf != NULL; pf = pf->next) {
|
|
struct port_flow **tmp;
|
|
const struct rte_flow_attr *curr = pf->rule.attr;
|
|
|
|
if (n) {
|
|
/* Filter out unwanted groups. */
|
|
for (i = 0; i != n; ++i)
|
|
if (curr->group == group[i])
|
|
break;
|
|
if (i == n)
|
|
continue;
|
|
}
|
|
for (tmp = &list; *tmp; tmp = &(*tmp)->tmp) {
|
|
const struct rte_flow_attr *comp = (*tmp)->rule.attr;
|
|
|
|
if (curr->group > comp->group ||
|
|
(curr->group == comp->group &&
|
|
curr->priority > comp->priority) ||
|
|
(curr->group == comp->group &&
|
|
curr->priority == comp->priority &&
|
|
pf->id > (*tmp)->id))
|
|
continue;
|
|
break;
|
|
}
|
|
pf->tmp = *tmp;
|
|
*tmp = pf;
|
|
}
|
|
printf("ID\tGroup\tPrio\tAttr\tRule\n");
|
|
for (pf = list; pf != NULL; pf = pf->tmp) {
|
|
const struct rte_flow_item *item = pf->rule.pattern;
|
|
const struct rte_flow_action *action = pf->rule.actions;
|
|
const char *name;
|
|
|
|
printf("%" PRIu32 "\t%" PRIu32 "\t%" PRIu32 "\t%c%c%c\t",
|
|
pf->id,
|
|
pf->rule.attr->group,
|
|
pf->rule.attr->priority,
|
|
pf->rule.attr->ingress ? 'i' : '-',
|
|
pf->rule.attr->egress ? 'e' : '-',
|
|
pf->rule.attr->transfer ? 't' : '-');
|
|
while (item->type != RTE_FLOW_ITEM_TYPE_END) {
|
|
if ((uint32_t)item->type > INT_MAX)
|
|
name = "PMD_INTERNAL";
|
|
else if (rte_flow_conv(RTE_FLOW_CONV_OP_ITEM_NAME_PTR,
|
|
&name, sizeof(name),
|
|
(void *)(uintptr_t)item->type,
|
|
NULL) <= 0)
|
|
name = "[UNKNOWN]";
|
|
if (item->type != RTE_FLOW_ITEM_TYPE_VOID)
|
|
printf("%s ", name);
|
|
++item;
|
|
}
|
|
printf("=>");
|
|
while (action->type != RTE_FLOW_ACTION_TYPE_END) {
|
|
if ((uint32_t)action->type > INT_MAX)
|
|
name = "PMD_INTERNAL";
|
|
else if (rte_flow_conv(RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
|
|
&name, sizeof(name),
|
|
(void *)(uintptr_t)action->type,
|
|
NULL) <= 0)
|
|
name = "[UNKNOWN]";
|
|
if (action->type != RTE_FLOW_ACTION_TYPE_VOID)
|
|
printf(" %s", name);
|
|
++action;
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
/** Restrict ingress traffic to the defined flow rules. */
|
|
int
|
|
port_flow_isolate(portid_t port_id, int set)
|
|
{
|
|
struct rte_flow_error error;
|
|
|
|
/* Poisoning to make sure PMDs update it in case of error. */
|
|
memset(&error, 0x66, sizeof(error));
|
|
if (rte_flow_isolate(port_id, set, &error))
|
|
return port_flow_complain(&error);
|
|
printf("Ingress traffic on port %u is %s to the defined flow rules\n",
|
|
port_id,
|
|
set ? "now restricted" : "not restricted anymore");
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* RX/TX ring descriptors display functions.
|
|
*/
|
|
int
|
|
rx_queue_id_is_invalid(queueid_t rxq_id)
|
|
{
|
|
if (rxq_id < nb_rxq)
|
|
return 0;
|
|
printf("Invalid RX queue %d (must be < nb_rxq=%d)\n", rxq_id, nb_rxq);
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
tx_queue_id_is_invalid(queueid_t txq_id)
|
|
{
|
|
if (txq_id < nb_txq)
|
|
return 0;
|
|
printf("Invalid TX queue %d (must be < nb_txq=%d)\n", txq_id, nb_txq);
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
get_rx_ring_size(portid_t port_id, queueid_t rxq_id, uint16_t *ring_size)
|
|
{
|
|
struct rte_port *port = &ports[port_id];
|
|
struct rte_eth_rxq_info rx_qinfo;
|
|
int ret;
|
|
|
|
ret = rte_eth_rx_queue_info_get(port_id, rxq_id, &rx_qinfo);
|
|
if (ret == 0) {
|
|
*ring_size = rx_qinfo.nb_desc;
|
|
return ret;
|
|
}
|
|
|
|
if (ret != -ENOTSUP)
|
|
return ret;
|
|
/*
|
|
* If the rte_eth_rx_queue_info_get is not support for this PMD,
|
|
* ring_size stored in testpmd will be used for validity verification.
|
|
* When configure the rxq by rte_eth_rx_queue_setup with nb_rx_desc
|
|
* being 0, it will use a default value provided by PMDs to setup this
|
|
* rxq. If the default value is 0, it will use the
|
|
* RTE_ETH_DEV_FALLBACK_RX_RINGSIZE to setup this rxq.
|
|
*/
|
|
if (port->nb_rx_desc[rxq_id])
|
|
*ring_size = port->nb_rx_desc[rxq_id];
|
|
else if (port->dev_info.default_rxportconf.ring_size)
|
|
*ring_size = port->dev_info.default_rxportconf.ring_size;
|
|
else
|
|
*ring_size = RTE_ETH_DEV_FALLBACK_RX_RINGSIZE;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
get_tx_ring_size(portid_t port_id, queueid_t txq_id, uint16_t *ring_size)
|
|
{
|
|
struct rte_port *port = &ports[port_id];
|
|
struct rte_eth_txq_info tx_qinfo;
|
|
int ret;
|
|
|
|
ret = rte_eth_tx_queue_info_get(port_id, txq_id, &tx_qinfo);
|
|
if (ret == 0) {
|
|
*ring_size = tx_qinfo.nb_desc;
|
|
return ret;
|
|
}
|
|
|
|
if (ret != -ENOTSUP)
|
|
return ret;
|
|
/*
|
|
* If the rte_eth_tx_queue_info_get is not support for this PMD,
|
|
* ring_size stored in testpmd will be used for validity verification.
|
|
* When configure the txq by rte_eth_tx_queue_setup with nb_tx_desc
|
|
* being 0, it will use a default value provided by PMDs to setup this
|
|
* txq. If the default value is 0, it will use the
|
|
* RTE_ETH_DEV_FALLBACK_TX_RINGSIZE to setup this txq.
|
|
*/
|
|
if (port->nb_tx_desc[txq_id])
|
|
*ring_size = port->nb_tx_desc[txq_id];
|
|
else if (port->dev_info.default_txportconf.ring_size)
|
|
*ring_size = port->dev_info.default_txportconf.ring_size;
|
|
else
|
|
*ring_size = RTE_ETH_DEV_FALLBACK_TX_RINGSIZE;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
rx_desc_id_is_invalid(portid_t port_id, queueid_t rxq_id, uint16_t rxdesc_id)
|
|
{
|
|
uint16_t ring_size;
|
|
int ret;
|
|
|
|
ret = get_rx_ring_size(port_id, rxq_id, &ring_size);
|
|
if (ret)
|
|
return 1;
|
|
|
|
if (rxdesc_id < ring_size)
|
|
return 0;
|
|
|
|
printf("Invalid RX descriptor %u (must be < ring_size=%u)\n",
|
|
rxdesc_id, ring_size);
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
tx_desc_id_is_invalid(portid_t port_id, queueid_t txq_id, uint16_t txdesc_id)
|
|
{
|
|
uint16_t ring_size;
|
|
int ret;
|
|
|
|
ret = get_tx_ring_size(port_id, txq_id, &ring_size);
|
|
if (ret)
|
|
return 1;
|
|
|
|
if (txdesc_id < ring_size)
|
|
return 0;
|
|
|
|
printf("Invalid TX descriptor %u (must be < ring_size=%u)\n",
|
|
txdesc_id, ring_size);
|
|
return 1;
|
|
}
|
|
|
|
static const struct rte_memzone *
|
|
ring_dma_zone_lookup(const char *ring_name, portid_t port_id, uint16_t q_id)
|
|
{
|
|
char mz_name[RTE_MEMZONE_NAMESIZE];
|
|
const struct rte_memzone *mz;
|
|
|
|
snprintf(mz_name, sizeof(mz_name), "eth_p%d_q%d_%s",
|
|
port_id, q_id, ring_name);
|
|
mz = rte_memzone_lookup(mz_name);
|
|
if (mz == NULL)
|
|
printf("%s ring memory zoneof (port %d, queue %d) not"
|
|
"found (zone name = %s\n",
|
|
ring_name, port_id, q_id, mz_name);
|
|
return mz;
|
|
}
|
|
|
|
union igb_ring_dword {
|
|
uint64_t dword;
|
|
struct {
|
|
#if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
|
|
uint32_t lo;
|
|
uint32_t hi;
|
|
#else
|
|
uint32_t hi;
|
|
uint32_t lo;
|
|
#endif
|
|
} words;
|
|
};
|
|
|
|
struct igb_ring_desc_32_bytes {
|
|
union igb_ring_dword lo_dword;
|
|
union igb_ring_dword hi_dword;
|
|
union igb_ring_dword resv1;
|
|
union igb_ring_dword resv2;
|
|
};
|
|
|
|
struct igb_ring_desc_16_bytes {
|
|
union igb_ring_dword lo_dword;
|
|
union igb_ring_dword hi_dword;
|
|
};
|
|
|
|
static void
|
|
ring_rxd_display_dword(union igb_ring_dword dword)
|
|
{
|
|
printf(" 0x%08X - 0x%08X\n", (unsigned)dword.words.lo,
|
|
(unsigned)dword.words.hi);
|
|
}
|
|
|
|
static void
|
|
ring_rx_descriptor_display(const struct rte_memzone *ring_mz,
|
|
#ifndef RTE_LIBRTE_I40E_16BYTE_RX_DESC
|
|
portid_t port_id,
|
|
#else
|
|
__rte_unused portid_t port_id,
|
|
#endif
|
|
uint16_t desc_id)
|
|
{
|
|
struct igb_ring_desc_16_bytes *ring =
|
|
(struct igb_ring_desc_16_bytes *)ring_mz->addr;
|
|
#ifndef RTE_LIBRTE_I40E_16BYTE_RX_DESC
|
|
int ret;
|
|
struct rte_eth_dev_info dev_info;
|
|
|
|
ret = eth_dev_info_get_print_err(port_id, &dev_info);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
if (strstr(dev_info.driver_name, "i40e") != NULL) {
|
|
/* 32 bytes RX descriptor, i40e only */
|
|
struct igb_ring_desc_32_bytes *ring =
|
|
(struct igb_ring_desc_32_bytes *)ring_mz->addr;
|
|
ring[desc_id].lo_dword.dword =
|
|
rte_le_to_cpu_64(ring[desc_id].lo_dword.dword);
|
|
ring_rxd_display_dword(ring[desc_id].lo_dword);
|
|
ring[desc_id].hi_dword.dword =
|
|
rte_le_to_cpu_64(ring[desc_id].hi_dword.dword);
|
|
ring_rxd_display_dword(ring[desc_id].hi_dword);
|
|
ring[desc_id].resv1.dword =
|
|
rte_le_to_cpu_64(ring[desc_id].resv1.dword);
|
|
ring_rxd_display_dword(ring[desc_id].resv1);
|
|
ring[desc_id].resv2.dword =
|
|
rte_le_to_cpu_64(ring[desc_id].resv2.dword);
|
|
ring_rxd_display_dword(ring[desc_id].resv2);
|
|
|
|
return;
|
|
}
|
|
#endif
|
|
/* 16 bytes RX descriptor */
|
|
ring[desc_id].lo_dword.dword =
|
|
rte_le_to_cpu_64(ring[desc_id].lo_dword.dword);
|
|
ring_rxd_display_dword(ring[desc_id].lo_dword);
|
|
ring[desc_id].hi_dword.dword =
|
|
rte_le_to_cpu_64(ring[desc_id].hi_dword.dword);
|
|
ring_rxd_display_dword(ring[desc_id].hi_dword);
|
|
}
|
|
|
|
static void
|
|
ring_tx_descriptor_display(const struct rte_memzone *ring_mz, uint16_t desc_id)
|
|
{
|
|
struct igb_ring_desc_16_bytes *ring;
|
|
struct igb_ring_desc_16_bytes txd;
|
|
|
|
ring = (struct igb_ring_desc_16_bytes *)ring_mz->addr;
|
|
txd.lo_dword.dword = rte_le_to_cpu_64(ring[desc_id].lo_dword.dword);
|
|
txd.hi_dword.dword = rte_le_to_cpu_64(ring[desc_id].hi_dword.dword);
|
|
printf(" 0x%08X - 0x%08X / 0x%08X - 0x%08X\n",
|
|
(unsigned)txd.lo_dword.words.lo,
|
|
(unsigned)txd.lo_dword.words.hi,
|
|
(unsigned)txd.hi_dword.words.lo,
|
|
(unsigned)txd.hi_dword.words.hi);
|
|
}
|
|
|
|
void
|
|
rx_ring_desc_display(portid_t port_id, queueid_t rxq_id, uint16_t rxd_id)
|
|
{
|
|
const struct rte_memzone *rx_mz;
|
|
|
|
if (rx_desc_id_is_invalid(port_id, rxq_id, rxd_id))
|
|
return;
|
|
rx_mz = ring_dma_zone_lookup("rx_ring", port_id, rxq_id);
|
|
if (rx_mz == NULL)
|
|
return;
|
|
ring_rx_descriptor_display(rx_mz, port_id, rxd_id);
|
|
}
|
|
|
|
void
|
|
tx_ring_desc_display(portid_t port_id, queueid_t txq_id, uint16_t txd_id)
|
|
{
|
|
const struct rte_memzone *tx_mz;
|
|
|
|
if (tx_desc_id_is_invalid(port_id, txq_id, txd_id))
|
|
return;
|
|
tx_mz = ring_dma_zone_lookup("tx_ring", port_id, txq_id);
|
|
if (tx_mz == NULL)
|
|
return;
|
|
ring_tx_descriptor_display(tx_mz, txd_id);
|
|
}
|
|
|
|
void
|
|
fwd_lcores_config_display(void)
|
|
{
|
|
lcoreid_t lc_id;
|
|
|
|
printf("List of forwarding lcores:");
|
|
for (lc_id = 0; lc_id < nb_cfg_lcores; lc_id++)
|
|
printf(" %2u", fwd_lcores_cpuids[lc_id]);
|
|
printf("\n");
|
|
}
|
|
void
|
|
rxtx_config_display(void)
|
|
{
|
|
portid_t pid;
|
|
queueid_t qid;
|
|
|
|
printf(" %s packet forwarding%s packets/burst=%d\n",
|
|
cur_fwd_eng->fwd_mode_name,
|
|
retry_enabled == 0 ? "" : " with retry",
|
|
nb_pkt_per_burst);
|
|
|
|
if (cur_fwd_eng == &tx_only_engine || cur_fwd_eng == &flow_gen_engine)
|
|
printf(" packet len=%u - nb packet segments=%d\n",
|
|
(unsigned)tx_pkt_length, (int) tx_pkt_nb_segs);
|
|
|
|
printf(" nb forwarding cores=%d - nb forwarding ports=%d\n",
|
|
nb_fwd_lcores, nb_fwd_ports);
|
|
|
|
RTE_ETH_FOREACH_DEV(pid) {
|
|
struct rte_eth_rxconf *rx_conf = &ports[pid].rx_conf[0];
|
|
struct rte_eth_txconf *tx_conf = &ports[pid].tx_conf[0];
|
|
uint16_t *nb_rx_desc = &ports[pid].nb_rx_desc[0];
|
|
uint16_t *nb_tx_desc = &ports[pid].nb_tx_desc[0];
|
|
struct rte_eth_rxq_info rx_qinfo;
|
|
struct rte_eth_txq_info tx_qinfo;
|
|
uint16_t rx_free_thresh_tmp;
|
|
uint16_t tx_free_thresh_tmp;
|
|
uint16_t tx_rs_thresh_tmp;
|
|
uint16_t nb_rx_desc_tmp;
|
|
uint16_t nb_tx_desc_tmp;
|
|
uint64_t offloads_tmp;
|
|
uint8_t pthresh_tmp;
|
|
uint8_t hthresh_tmp;
|
|
uint8_t wthresh_tmp;
|
|
int32_t rc;
|
|
|
|
/* per port config */
|
|
printf(" port %d: RX queue number: %d Tx queue number: %d\n",
|
|
(unsigned int)pid, nb_rxq, nb_txq);
|
|
|
|
printf(" Rx offloads=0x%"PRIx64" Tx offloads=0x%"PRIx64"\n",
|
|
ports[pid].dev_conf.rxmode.offloads,
|
|
ports[pid].dev_conf.txmode.offloads);
|
|
|
|
/* per rx queue config only for first queue to be less verbose */
|
|
for (qid = 0; qid < 1; qid++) {
|
|
rc = rte_eth_rx_queue_info_get(pid, qid, &rx_qinfo);
|
|
if (rc) {
|
|
nb_rx_desc_tmp = nb_rx_desc[qid];
|
|
rx_free_thresh_tmp =
|
|
rx_conf[qid].rx_free_thresh;
|
|
pthresh_tmp = rx_conf[qid].rx_thresh.pthresh;
|
|
hthresh_tmp = rx_conf[qid].rx_thresh.hthresh;
|
|
wthresh_tmp = rx_conf[qid].rx_thresh.wthresh;
|
|
offloads_tmp = rx_conf[qid].offloads;
|
|
} else {
|
|
nb_rx_desc_tmp = rx_qinfo.nb_desc;
|
|
rx_free_thresh_tmp =
|
|
rx_qinfo.conf.rx_free_thresh;
|
|
pthresh_tmp = rx_qinfo.conf.rx_thresh.pthresh;
|
|
hthresh_tmp = rx_qinfo.conf.rx_thresh.hthresh;
|
|
wthresh_tmp = rx_qinfo.conf.rx_thresh.wthresh;
|
|
offloads_tmp = rx_qinfo.conf.offloads;
|
|
}
|
|
|
|
printf(" RX queue: %d\n", qid);
|
|
printf(" RX desc=%d - RX free threshold=%d\n",
|
|
nb_rx_desc_tmp, rx_free_thresh_tmp);
|
|
printf(" RX threshold registers: pthresh=%d hthresh=%d "
|
|
" wthresh=%d\n",
|
|
pthresh_tmp, hthresh_tmp, wthresh_tmp);
|
|
printf(" RX Offloads=0x%"PRIx64"\n", offloads_tmp);
|
|
}
|
|
|
|
/* per tx queue config only for first queue to be less verbose */
|
|
for (qid = 0; qid < 1; qid++) {
|
|
rc = rte_eth_tx_queue_info_get(pid, qid, &tx_qinfo);
|
|
if (rc) {
|
|
nb_tx_desc_tmp = nb_tx_desc[qid];
|
|
tx_free_thresh_tmp =
|
|
tx_conf[qid].tx_free_thresh;
|
|
pthresh_tmp = tx_conf[qid].tx_thresh.pthresh;
|
|
hthresh_tmp = tx_conf[qid].tx_thresh.hthresh;
|
|
wthresh_tmp = tx_conf[qid].tx_thresh.wthresh;
|
|
offloads_tmp = tx_conf[qid].offloads;
|
|
tx_rs_thresh_tmp = tx_conf[qid].tx_rs_thresh;
|
|
} else {
|
|
nb_tx_desc_tmp = tx_qinfo.nb_desc;
|
|
tx_free_thresh_tmp =
|
|
tx_qinfo.conf.tx_free_thresh;
|
|
pthresh_tmp = tx_qinfo.conf.tx_thresh.pthresh;
|
|
hthresh_tmp = tx_qinfo.conf.tx_thresh.hthresh;
|
|
wthresh_tmp = tx_qinfo.conf.tx_thresh.wthresh;
|
|
offloads_tmp = tx_qinfo.conf.offloads;
|
|
tx_rs_thresh_tmp = tx_qinfo.conf.tx_rs_thresh;
|
|
}
|
|
|
|
printf(" TX queue: %d\n", qid);
|
|
printf(" TX desc=%d - TX free threshold=%d\n",
|
|
nb_tx_desc_tmp, tx_free_thresh_tmp);
|
|
printf(" TX threshold registers: pthresh=%d hthresh=%d "
|
|
" wthresh=%d\n",
|
|
pthresh_tmp, hthresh_tmp, wthresh_tmp);
|
|
printf(" TX offloads=0x%"PRIx64" - TX RS bit threshold=%d\n",
|
|
offloads_tmp, tx_rs_thresh_tmp);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
port_rss_reta_info(portid_t port_id,
|
|
struct rte_eth_rss_reta_entry64 *reta_conf,
|
|
uint16_t nb_entries)
|
|
{
|
|
uint16_t i, idx, shift;
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
ret = rte_eth_dev_rss_reta_query(port_id, reta_conf, nb_entries);
|
|
if (ret != 0) {
|
|
printf("Failed to get RSS RETA info, return code = %d\n", ret);
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < nb_entries; i++) {
|
|
idx = i / RTE_RETA_GROUP_SIZE;
|
|
shift = i % RTE_RETA_GROUP_SIZE;
|
|
if (!(reta_conf[idx].mask & (1ULL << shift)))
|
|
continue;
|
|
printf("RSS RETA configuration: hash index=%u, queue=%u\n",
|
|
i, reta_conf[idx].reta[shift]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Displays the RSS hash functions of a port, and, optionaly, the RSS hash
|
|
* key of the port.
|
|
*/
|
|
void
|
|
port_rss_hash_conf_show(portid_t port_id, int show_rss_key)
|
|
{
|
|
struct rte_eth_rss_conf rss_conf = {0};
|
|
uint8_t rss_key[RSS_HASH_KEY_LENGTH];
|
|
uint64_t rss_hf;
|
|
uint8_t i;
|
|
int diag;
|
|
struct rte_eth_dev_info dev_info;
|
|
uint8_t hash_key_size;
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
ret = eth_dev_info_get_print_err(port_id, &dev_info);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
if (dev_info.hash_key_size > 0 &&
|
|
dev_info.hash_key_size <= sizeof(rss_key))
|
|
hash_key_size = dev_info.hash_key_size;
|
|
else {
|
|
printf("dev_info did not provide a valid hash key size\n");
|
|
return;
|
|
}
|
|
|
|
/* Get RSS hash key if asked to display it */
|
|
rss_conf.rss_key = (show_rss_key) ? rss_key : NULL;
|
|
rss_conf.rss_key_len = hash_key_size;
|
|
diag = rte_eth_dev_rss_hash_conf_get(port_id, &rss_conf);
|
|
if (diag != 0) {
|
|
switch (diag) {
|
|
case -ENODEV:
|
|
printf("port index %d invalid\n", port_id);
|
|
break;
|
|
case -ENOTSUP:
|
|
printf("operation not supported by device\n");
|
|
break;
|
|
default:
|
|
printf("operation failed - diag=%d\n", diag);
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
rss_hf = rss_conf.rss_hf;
|
|
if (rss_hf == 0) {
|
|
printf("RSS disabled\n");
|
|
return;
|
|
}
|
|
printf("RSS functions:\n ");
|
|
for (i = 0; rss_type_table[i].str; i++) {
|
|
if (rss_hf & rss_type_table[i].rss_type)
|
|
printf("%s ", rss_type_table[i].str);
|
|
}
|
|
printf("\n");
|
|
if (!show_rss_key)
|
|
return;
|
|
printf("RSS key:\n");
|
|
for (i = 0; i < hash_key_size; i++)
|
|
printf("%02X", rss_key[i]);
|
|
printf("\n");
|
|
}
|
|
|
|
void
|
|
port_rss_hash_key_update(portid_t port_id, char rss_type[], uint8_t *hash_key,
|
|
uint8_t hash_key_len)
|
|
{
|
|
struct rte_eth_rss_conf rss_conf;
|
|
int diag;
|
|
unsigned int i;
|
|
|
|
rss_conf.rss_key = NULL;
|
|
rss_conf.rss_key_len = hash_key_len;
|
|
rss_conf.rss_hf = 0;
|
|
for (i = 0; rss_type_table[i].str; i++) {
|
|
if (!strcmp(rss_type_table[i].str, rss_type))
|
|
rss_conf.rss_hf = rss_type_table[i].rss_type;
|
|
}
|
|
diag = rte_eth_dev_rss_hash_conf_get(port_id, &rss_conf);
|
|
if (diag == 0) {
|
|
rss_conf.rss_key = hash_key;
|
|
diag = rte_eth_dev_rss_hash_update(port_id, &rss_conf);
|
|
}
|
|
if (diag == 0)
|
|
return;
|
|
|
|
switch (diag) {
|
|
case -ENODEV:
|
|
printf("port index %d invalid\n", port_id);
|
|
break;
|
|
case -ENOTSUP:
|
|
printf("operation not supported by device\n");
|
|
break;
|
|
default:
|
|
printf("operation failed - diag=%d\n", diag);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Setup forwarding configuration for each logical core.
|
|
*/
|
|
static void
|
|
setup_fwd_config_of_each_lcore(struct fwd_config *cfg)
|
|
{
|
|
streamid_t nb_fs_per_lcore;
|
|
streamid_t nb_fs;
|
|
streamid_t sm_id;
|
|
lcoreid_t nb_extra;
|
|
lcoreid_t nb_fc;
|
|
lcoreid_t nb_lc;
|
|
lcoreid_t lc_id;
|
|
|
|
nb_fs = cfg->nb_fwd_streams;
|
|
nb_fc = cfg->nb_fwd_lcores;
|
|
if (nb_fs <= nb_fc) {
|
|
nb_fs_per_lcore = 1;
|
|
nb_extra = 0;
|
|
} else {
|
|
nb_fs_per_lcore = (streamid_t) (nb_fs / nb_fc);
|
|
nb_extra = (lcoreid_t) (nb_fs % nb_fc);
|
|
}
|
|
|
|
nb_lc = (lcoreid_t) (nb_fc - nb_extra);
|
|
sm_id = 0;
|
|
for (lc_id = 0; lc_id < nb_lc; lc_id++) {
|
|
fwd_lcores[lc_id]->stream_idx = sm_id;
|
|
fwd_lcores[lc_id]->stream_nb = nb_fs_per_lcore;
|
|
sm_id = (streamid_t) (sm_id + nb_fs_per_lcore);
|
|
}
|
|
|
|
/*
|
|
* Assign extra remaining streams, if any.
|
|
*/
|
|
nb_fs_per_lcore = (streamid_t) (nb_fs_per_lcore + 1);
|
|
for (lc_id = 0; lc_id < nb_extra; lc_id++) {
|
|
fwd_lcores[nb_lc + lc_id]->stream_idx = sm_id;
|
|
fwd_lcores[nb_lc + lc_id]->stream_nb = nb_fs_per_lcore;
|
|
sm_id = (streamid_t) (sm_id + nb_fs_per_lcore);
|
|
}
|
|
}
|
|
|
|
static portid_t
|
|
fwd_topology_tx_port_get(portid_t rxp)
|
|
{
|
|
static int warning_once = 1;
|
|
|
|
RTE_ASSERT(rxp < cur_fwd_config.nb_fwd_ports);
|
|
|
|
switch (port_topology) {
|
|
default:
|
|
case PORT_TOPOLOGY_PAIRED:
|
|
if ((rxp & 0x1) == 0) {
|
|
if (rxp + 1 < cur_fwd_config.nb_fwd_ports)
|
|
return rxp + 1;
|
|
if (warning_once) {
|
|
printf("\nWarning! port-topology=paired"
|
|
" and odd forward ports number,"
|
|
" the last port will pair with"
|
|
" itself.\n\n");
|
|
warning_once = 0;
|
|
}
|
|
return rxp;
|
|
}
|
|
return rxp - 1;
|
|
case PORT_TOPOLOGY_CHAINED:
|
|
return (rxp + 1) % cur_fwd_config.nb_fwd_ports;
|
|
case PORT_TOPOLOGY_LOOP:
|
|
return rxp;
|
|
}
|
|
}
|
|
|
|
static void
|
|
simple_fwd_config_setup(void)
|
|
{
|
|
portid_t i;
|
|
|
|
cur_fwd_config.nb_fwd_ports = (portid_t) nb_fwd_ports;
|
|
cur_fwd_config.nb_fwd_streams =
|
|
(streamid_t) cur_fwd_config.nb_fwd_ports;
|
|
|
|
/* reinitialize forwarding streams */
|
|
init_fwd_streams();
|
|
|
|
/*
|
|
* In the simple forwarding test, the number of forwarding cores
|
|
* must be lower or equal to the number of forwarding ports.
|
|
*/
|
|
cur_fwd_config.nb_fwd_lcores = (lcoreid_t) nb_fwd_lcores;
|
|
if (cur_fwd_config.nb_fwd_lcores > cur_fwd_config.nb_fwd_ports)
|
|
cur_fwd_config.nb_fwd_lcores =
|
|
(lcoreid_t) cur_fwd_config.nb_fwd_ports;
|
|
setup_fwd_config_of_each_lcore(&cur_fwd_config);
|
|
|
|
for (i = 0; i < cur_fwd_config.nb_fwd_ports; i++) {
|
|
fwd_streams[i]->rx_port = fwd_ports_ids[i];
|
|
fwd_streams[i]->rx_queue = 0;
|
|
fwd_streams[i]->tx_port =
|
|
fwd_ports_ids[fwd_topology_tx_port_get(i)];
|
|
fwd_streams[i]->tx_queue = 0;
|
|
fwd_streams[i]->peer_addr = fwd_streams[i]->tx_port;
|
|
fwd_streams[i]->retry_enabled = retry_enabled;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* For the RSS forwarding test all streams distributed over lcores. Each stream
|
|
* being composed of a RX queue to poll on a RX port for input messages,
|
|
* associated with a TX queue of a TX port where to send forwarded packets.
|
|
*/
|
|
static void
|
|
rss_fwd_config_setup(void)
|
|
{
|
|
portid_t rxp;
|
|
portid_t txp;
|
|
queueid_t rxq;
|
|
queueid_t nb_q;
|
|
streamid_t sm_id;
|
|
|
|
nb_q = nb_rxq;
|
|
if (nb_q > nb_txq)
|
|
nb_q = nb_txq;
|
|
cur_fwd_config.nb_fwd_lcores = (lcoreid_t) nb_fwd_lcores;
|
|
cur_fwd_config.nb_fwd_ports = nb_fwd_ports;
|
|
cur_fwd_config.nb_fwd_streams =
|
|
(streamid_t) (nb_q * cur_fwd_config.nb_fwd_ports);
|
|
|
|
if (cur_fwd_config.nb_fwd_streams < cur_fwd_config.nb_fwd_lcores)
|
|
cur_fwd_config.nb_fwd_lcores =
|
|
(lcoreid_t)cur_fwd_config.nb_fwd_streams;
|
|
|
|
/* reinitialize forwarding streams */
|
|
init_fwd_streams();
|
|
|
|
setup_fwd_config_of_each_lcore(&cur_fwd_config);
|
|
rxp = 0; rxq = 0;
|
|
for (sm_id = 0; sm_id < cur_fwd_config.nb_fwd_streams; sm_id++) {
|
|
struct fwd_stream *fs;
|
|
|
|
fs = fwd_streams[sm_id];
|
|
txp = fwd_topology_tx_port_get(rxp);
|
|
fs->rx_port = fwd_ports_ids[rxp];
|
|
fs->rx_queue = rxq;
|
|
fs->tx_port = fwd_ports_ids[txp];
|
|
fs->tx_queue = rxq;
|
|
fs->peer_addr = fs->tx_port;
|
|
fs->retry_enabled = retry_enabled;
|
|
rxp++;
|
|
if (rxp < nb_fwd_ports)
|
|
continue;
|
|
rxp = 0;
|
|
rxq++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* For the DCB forwarding test, each core is assigned on each traffic class.
|
|
*
|
|
* Each core is assigned a multi-stream, each stream being composed of
|
|
* a RX queue to poll on a RX port for input messages, associated with
|
|
* a TX queue of a TX port where to send forwarded packets. All RX and
|
|
* TX queues are mapping to the same traffic class.
|
|
* If VMDQ and DCB co-exist, each traffic class on different POOLs share
|
|
* the same core
|
|
*/
|
|
static void
|
|
dcb_fwd_config_setup(void)
|
|
{
|
|
struct rte_eth_dcb_info rxp_dcb_info, txp_dcb_info;
|
|
portid_t txp, rxp = 0;
|
|
queueid_t txq, rxq = 0;
|
|
lcoreid_t lc_id;
|
|
uint16_t nb_rx_queue, nb_tx_queue;
|
|
uint16_t i, j, k, sm_id = 0;
|
|
uint8_t tc = 0;
|
|
|
|
cur_fwd_config.nb_fwd_lcores = (lcoreid_t) nb_fwd_lcores;
|
|
cur_fwd_config.nb_fwd_ports = nb_fwd_ports;
|
|
cur_fwd_config.nb_fwd_streams =
|
|
(streamid_t) (nb_rxq * cur_fwd_config.nb_fwd_ports);
|
|
|
|
/* reinitialize forwarding streams */
|
|
init_fwd_streams();
|
|
sm_id = 0;
|
|
txp = 1;
|
|
/* get the dcb info on the first RX and TX ports */
|
|
(void)rte_eth_dev_get_dcb_info(fwd_ports_ids[rxp], &rxp_dcb_info);
|
|
(void)rte_eth_dev_get_dcb_info(fwd_ports_ids[txp], &txp_dcb_info);
|
|
|
|
for (lc_id = 0; lc_id < cur_fwd_config.nb_fwd_lcores; lc_id++) {
|
|
fwd_lcores[lc_id]->stream_nb = 0;
|
|
fwd_lcores[lc_id]->stream_idx = sm_id;
|
|
for (i = 0; i < ETH_MAX_VMDQ_POOL; i++) {
|
|
/* if the nb_queue is zero, means this tc is
|
|
* not enabled on the POOL
|
|
*/
|
|
if (rxp_dcb_info.tc_queue.tc_rxq[i][tc].nb_queue == 0)
|
|
break;
|
|
k = fwd_lcores[lc_id]->stream_nb +
|
|
fwd_lcores[lc_id]->stream_idx;
|
|
rxq = rxp_dcb_info.tc_queue.tc_rxq[i][tc].base;
|
|
txq = txp_dcb_info.tc_queue.tc_txq[i][tc].base;
|
|
nb_rx_queue = txp_dcb_info.tc_queue.tc_rxq[i][tc].nb_queue;
|
|
nb_tx_queue = txp_dcb_info.tc_queue.tc_txq[i][tc].nb_queue;
|
|
for (j = 0; j < nb_rx_queue; j++) {
|
|
struct fwd_stream *fs;
|
|
|
|
fs = fwd_streams[k + j];
|
|
fs->rx_port = fwd_ports_ids[rxp];
|
|
fs->rx_queue = rxq + j;
|
|
fs->tx_port = fwd_ports_ids[txp];
|
|
fs->tx_queue = txq + j % nb_tx_queue;
|
|
fs->peer_addr = fs->tx_port;
|
|
fs->retry_enabled = retry_enabled;
|
|
}
|
|
fwd_lcores[lc_id]->stream_nb +=
|
|
rxp_dcb_info.tc_queue.tc_rxq[i][tc].nb_queue;
|
|
}
|
|
sm_id = (streamid_t) (sm_id + fwd_lcores[lc_id]->stream_nb);
|
|
|
|
tc++;
|
|
if (tc < rxp_dcb_info.nb_tcs)
|
|
continue;
|
|
/* Restart from TC 0 on next RX port */
|
|
tc = 0;
|
|
if (numa_support && (nb_fwd_ports <= (nb_ports >> 1)))
|
|
rxp = (portid_t)
|
|
(rxp + ((nb_ports >> 1) / nb_fwd_ports));
|
|
else
|
|
rxp++;
|
|
if (rxp >= nb_fwd_ports)
|
|
return;
|
|
/* get the dcb information on next RX and TX ports */
|
|
if ((rxp & 0x1) == 0)
|
|
txp = (portid_t) (rxp + 1);
|
|
else
|
|
txp = (portid_t) (rxp - 1);
|
|
rte_eth_dev_get_dcb_info(fwd_ports_ids[rxp], &rxp_dcb_info);
|
|
rte_eth_dev_get_dcb_info(fwd_ports_ids[txp], &txp_dcb_info);
|
|
}
|
|
}
|
|
|
|
static void
|
|
icmp_echo_config_setup(void)
|
|
{
|
|
portid_t rxp;
|
|
queueid_t rxq;
|
|
lcoreid_t lc_id;
|
|
uint16_t sm_id;
|
|
|
|
if ((nb_txq * nb_fwd_ports) < nb_fwd_lcores)
|
|
cur_fwd_config.nb_fwd_lcores = (lcoreid_t)
|
|
(nb_txq * nb_fwd_ports);
|
|
else
|
|
cur_fwd_config.nb_fwd_lcores = (lcoreid_t) nb_fwd_lcores;
|
|
cur_fwd_config.nb_fwd_ports = nb_fwd_ports;
|
|
cur_fwd_config.nb_fwd_streams =
|
|
(streamid_t) (nb_rxq * cur_fwd_config.nb_fwd_ports);
|
|
if (cur_fwd_config.nb_fwd_streams < cur_fwd_config.nb_fwd_lcores)
|
|
cur_fwd_config.nb_fwd_lcores =
|
|
(lcoreid_t)cur_fwd_config.nb_fwd_streams;
|
|
if (verbose_level > 0) {
|
|
printf("%s fwd_cores=%d fwd_ports=%d fwd_streams=%d\n",
|
|
__FUNCTION__,
|
|
cur_fwd_config.nb_fwd_lcores,
|
|
cur_fwd_config.nb_fwd_ports,
|
|
cur_fwd_config.nb_fwd_streams);
|
|
}
|
|
|
|
/* reinitialize forwarding streams */
|
|
init_fwd_streams();
|
|
setup_fwd_config_of_each_lcore(&cur_fwd_config);
|
|
rxp = 0; rxq = 0;
|
|
for (lc_id = 0; lc_id < cur_fwd_config.nb_fwd_lcores; lc_id++) {
|
|
if (verbose_level > 0)
|
|
printf(" core=%d: \n", lc_id);
|
|
for (sm_id = 0; sm_id < fwd_lcores[lc_id]->stream_nb; sm_id++) {
|
|
struct fwd_stream *fs;
|
|
fs = fwd_streams[fwd_lcores[lc_id]->stream_idx + sm_id];
|
|
fs->rx_port = fwd_ports_ids[rxp];
|
|
fs->rx_queue = rxq;
|
|
fs->tx_port = fs->rx_port;
|
|
fs->tx_queue = rxq;
|
|
fs->peer_addr = fs->tx_port;
|
|
fs->retry_enabled = retry_enabled;
|
|
if (verbose_level > 0)
|
|
printf(" stream=%d port=%d rxq=%d txq=%d\n",
|
|
sm_id, fs->rx_port, fs->rx_queue,
|
|
fs->tx_queue);
|
|
rxq = (queueid_t) (rxq + 1);
|
|
if (rxq == nb_rxq) {
|
|
rxq = 0;
|
|
rxp = (portid_t) (rxp + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
fwd_config_setup(void)
|
|
{
|
|
cur_fwd_config.fwd_eng = cur_fwd_eng;
|
|
if (strcmp(cur_fwd_eng->fwd_mode_name, "icmpecho") == 0) {
|
|
icmp_echo_config_setup();
|
|
return;
|
|
}
|
|
|
|
if ((nb_rxq > 1) && (nb_txq > 1)){
|
|
if (dcb_config)
|
|
dcb_fwd_config_setup();
|
|
else
|
|
rss_fwd_config_setup();
|
|
}
|
|
else
|
|
simple_fwd_config_setup();
|
|
}
|
|
|
|
static const char *
|
|
mp_alloc_to_str(uint8_t mode)
|
|
{
|
|
switch (mode) {
|
|
case MP_ALLOC_NATIVE:
|
|
return "native";
|
|
case MP_ALLOC_ANON:
|
|
return "anon";
|
|
case MP_ALLOC_XMEM:
|
|
return "xmem";
|
|
case MP_ALLOC_XMEM_HUGE:
|
|
return "xmemhuge";
|
|
case MP_ALLOC_XBUF:
|
|
return "xbuf";
|
|
default:
|
|
return "invalid";
|
|
}
|
|
}
|
|
|
|
void
|
|
pkt_fwd_config_display(struct fwd_config *cfg)
|
|
{
|
|
struct fwd_stream *fs;
|
|
lcoreid_t lc_id;
|
|
streamid_t sm_id;
|
|
|
|
printf("%s packet forwarding%s - ports=%d - cores=%d - streams=%d - "
|
|
"NUMA support %s, MP allocation mode: %s\n",
|
|
cfg->fwd_eng->fwd_mode_name,
|
|
retry_enabled == 0 ? "" : " with retry",
|
|
cfg->nb_fwd_ports, cfg->nb_fwd_lcores, cfg->nb_fwd_streams,
|
|
numa_support == 1 ? "enabled" : "disabled",
|
|
mp_alloc_to_str(mp_alloc_type));
|
|
|
|
if (retry_enabled)
|
|
printf("TX retry num: %u, delay between TX retries: %uus\n",
|
|
burst_tx_retry_num, burst_tx_delay_time);
|
|
for (lc_id = 0; lc_id < cfg->nb_fwd_lcores; lc_id++) {
|
|
printf("Logical Core %u (socket %u) forwards packets on "
|
|
"%d streams:",
|
|
fwd_lcores_cpuids[lc_id],
|
|
rte_lcore_to_socket_id(fwd_lcores_cpuids[lc_id]),
|
|
fwd_lcores[lc_id]->stream_nb);
|
|
for (sm_id = 0; sm_id < fwd_lcores[lc_id]->stream_nb; sm_id++) {
|
|
fs = fwd_streams[fwd_lcores[lc_id]->stream_idx + sm_id];
|
|
printf("\n RX P=%d/Q=%d (socket %u) -> TX "
|
|
"P=%d/Q=%d (socket %u) ",
|
|
fs->rx_port, fs->rx_queue,
|
|
ports[fs->rx_port].socket_id,
|
|
fs->tx_port, fs->tx_queue,
|
|
ports[fs->tx_port].socket_id);
|
|
print_ethaddr("peer=",
|
|
&peer_eth_addrs[fs->peer_addr]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
void
|
|
set_fwd_eth_peer(portid_t port_id, char *peer_addr)
|
|
{
|
|
struct rte_ether_addr new_peer_addr;
|
|
if (!rte_eth_dev_is_valid_port(port_id)) {
|
|
printf("Error: Invalid port number %i\n", port_id);
|
|
return;
|
|
}
|
|
if (rte_ether_unformat_addr(peer_addr, &new_peer_addr) < 0) {
|
|
printf("Error: Invalid ethernet address: %s\n", peer_addr);
|
|
return;
|
|
}
|
|
peer_eth_addrs[port_id] = new_peer_addr;
|
|
}
|
|
|
|
int
|
|
set_fwd_lcores_list(unsigned int *lcorelist, unsigned int nb_lc)
|
|
{
|
|
unsigned int i;
|
|
unsigned int lcore_cpuid;
|
|
int record_now;
|
|
|
|
record_now = 0;
|
|
again:
|
|
for (i = 0; i < nb_lc; i++) {
|
|
lcore_cpuid = lcorelist[i];
|
|
if (! rte_lcore_is_enabled(lcore_cpuid)) {
|
|
printf("lcore %u not enabled\n", lcore_cpuid);
|
|
return -1;
|
|
}
|
|
if (lcore_cpuid == rte_get_main_lcore()) {
|
|
printf("lcore %u cannot be masked on for running "
|
|
"packet forwarding, which is the main lcore "
|
|
"and reserved for command line parsing only\n",
|
|
lcore_cpuid);
|
|
return -1;
|
|
}
|
|
if (record_now)
|
|
fwd_lcores_cpuids[i] = lcore_cpuid;
|
|
}
|
|
if (record_now == 0) {
|
|
record_now = 1;
|
|
goto again;
|
|
}
|
|
nb_cfg_lcores = (lcoreid_t) nb_lc;
|
|
if (nb_fwd_lcores != (lcoreid_t) nb_lc) {
|
|
printf("previous number of forwarding cores %u - changed to "
|
|
"number of configured cores %u\n",
|
|
(unsigned int) nb_fwd_lcores, nb_lc);
|
|
nb_fwd_lcores = (lcoreid_t) nb_lc;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
set_fwd_lcores_mask(uint64_t lcoremask)
|
|
{
|
|
unsigned int lcorelist[64];
|
|
unsigned int nb_lc;
|
|
unsigned int i;
|
|
|
|
if (lcoremask == 0) {
|
|
printf("Invalid NULL mask of cores\n");
|
|
return -1;
|
|
}
|
|
nb_lc = 0;
|
|
for (i = 0; i < 64; i++) {
|
|
if (! ((uint64_t)(1ULL << i) & lcoremask))
|
|
continue;
|
|
lcorelist[nb_lc++] = i;
|
|
}
|
|
return set_fwd_lcores_list(lcorelist, nb_lc);
|
|
}
|
|
|
|
void
|
|
set_fwd_lcores_number(uint16_t nb_lc)
|
|
{
|
|
if (test_done == 0) {
|
|
printf("Please stop forwarding first\n");
|
|
return;
|
|
}
|
|
if (nb_lc > nb_cfg_lcores) {
|
|
printf("nb fwd cores %u > %u (max. number of configured "
|
|
"lcores) - ignored\n",
|
|
(unsigned int) nb_lc, (unsigned int) nb_cfg_lcores);
|
|
return;
|
|
}
|
|
nb_fwd_lcores = (lcoreid_t) nb_lc;
|
|
printf("Number of forwarding cores set to %u\n",
|
|
(unsigned int) nb_fwd_lcores);
|
|
}
|
|
|
|
void
|
|
set_fwd_ports_list(unsigned int *portlist, unsigned int nb_pt)
|
|
{
|
|
unsigned int i;
|
|
portid_t port_id;
|
|
int record_now;
|
|
|
|
record_now = 0;
|
|
again:
|
|
for (i = 0; i < nb_pt; i++) {
|
|
port_id = (portid_t) portlist[i];
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
if (record_now)
|
|
fwd_ports_ids[i] = port_id;
|
|
}
|
|
if (record_now == 0) {
|
|
record_now = 1;
|
|
goto again;
|
|
}
|
|
nb_cfg_ports = (portid_t) nb_pt;
|
|
if (nb_fwd_ports != (portid_t) nb_pt) {
|
|
printf("previous number of forwarding ports %u - changed to "
|
|
"number of configured ports %u\n",
|
|
(unsigned int) nb_fwd_ports, nb_pt);
|
|
nb_fwd_ports = (portid_t) nb_pt;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parse the user input and obtain the list of forwarding ports
|
|
*
|
|
* @param[in] list
|
|
* String containing the user input. User can specify
|
|
* in these formats 1,3,5 or 1-3 or 1-2,5 or 3,5-6.
|
|
* For example, if the user wants to use all the available
|
|
* 4 ports in his system, then the input can be 0-3 or 0,1,2,3.
|
|
* If the user wants to use only the ports 1,2 then the input
|
|
* is 1,2.
|
|
* valid characters are '-' and ','
|
|
* @param[out] values
|
|
* This array will be filled with a list of port IDs
|
|
* based on the user input
|
|
* Note that duplicate entries are discarded and only the first
|
|
* count entries in this array are port IDs and all the rest
|
|
* will contain default values
|
|
* @param[in] maxsize
|
|
* This parameter denotes 2 things
|
|
* 1) Number of elements in the values array
|
|
* 2) Maximum value of each element in the values array
|
|
* @return
|
|
* On success, returns total count of parsed port IDs
|
|
* On failure, returns 0
|
|
*/
|
|
static unsigned int
|
|
parse_port_list(const char *list, unsigned int *values, unsigned int maxsize)
|
|
{
|
|
unsigned int count = 0;
|
|
char *end = NULL;
|
|
int min, max;
|
|
int value, i;
|
|
unsigned int marked[maxsize];
|
|
|
|
if (list == NULL || values == NULL)
|
|
return 0;
|
|
|
|
for (i = 0; i < (int)maxsize; i++)
|
|
marked[i] = 0;
|
|
|
|
min = INT_MAX;
|
|
|
|
do {
|
|
/*Remove the blank spaces if any*/
|
|
while (isblank(*list))
|
|
list++;
|
|
if (*list == '\0')
|
|
break;
|
|
errno = 0;
|
|
value = strtol(list, &end, 10);
|
|
if (errno || end == NULL)
|
|
return 0;
|
|
if (value < 0 || value >= (int)maxsize)
|
|
return 0;
|
|
while (isblank(*end))
|
|
end++;
|
|
if (*end == '-' && min == INT_MAX) {
|
|
min = value;
|
|
} else if ((*end == ',') || (*end == '\0')) {
|
|
max = value;
|
|
if (min == INT_MAX)
|
|
min = value;
|
|
for (i = min; i <= max; i++) {
|
|
if (count < maxsize) {
|
|
if (marked[i])
|
|
continue;
|
|
values[count] = i;
|
|
marked[i] = 1;
|
|
count++;
|
|
}
|
|
}
|
|
min = INT_MAX;
|
|
} else
|
|
return 0;
|
|
list = end + 1;
|
|
} while (*end != '\0');
|
|
|
|
return count;
|
|
}
|
|
|
|
void
|
|
parse_fwd_portlist(const char *portlist)
|
|
{
|
|
unsigned int portcount;
|
|
unsigned int portindex[RTE_MAX_ETHPORTS];
|
|
unsigned int i, valid_port_count = 0;
|
|
|
|
portcount = parse_port_list(portlist, portindex, RTE_MAX_ETHPORTS);
|
|
if (!portcount)
|
|
rte_exit(EXIT_FAILURE, "Invalid fwd port list\n");
|
|
|
|
/*
|
|
* Here we verify the validity of the ports
|
|
* and thereby calculate the total number of
|
|
* valid ports
|
|
*/
|
|
for (i = 0; i < portcount && i < RTE_DIM(portindex); i++) {
|
|
if (rte_eth_dev_is_valid_port(portindex[i])) {
|
|
portindex[valid_port_count] = portindex[i];
|
|
valid_port_count++;
|
|
}
|
|
}
|
|
|
|
set_fwd_ports_list(portindex, valid_port_count);
|
|
}
|
|
|
|
void
|
|
set_fwd_ports_mask(uint64_t portmask)
|
|
{
|
|
unsigned int portlist[64];
|
|
unsigned int nb_pt;
|
|
unsigned int i;
|
|
|
|
if (portmask == 0) {
|
|
printf("Invalid NULL mask of ports\n");
|
|
return;
|
|
}
|
|
nb_pt = 0;
|
|
RTE_ETH_FOREACH_DEV(i) {
|
|
if (! ((uint64_t)(1ULL << i) & portmask))
|
|
continue;
|
|
portlist[nb_pt++] = i;
|
|
}
|
|
set_fwd_ports_list(portlist, nb_pt);
|
|
}
|
|
|
|
void
|
|
set_fwd_ports_number(uint16_t nb_pt)
|
|
{
|
|
if (nb_pt > nb_cfg_ports) {
|
|
printf("nb fwd ports %u > %u (number of configured "
|
|
"ports) - ignored\n",
|
|
(unsigned int) nb_pt, (unsigned int) nb_cfg_ports);
|
|
return;
|
|
}
|
|
nb_fwd_ports = (portid_t) nb_pt;
|
|
printf("Number of forwarding ports set to %u\n",
|
|
(unsigned int) nb_fwd_ports);
|
|
}
|
|
|
|
int
|
|
port_is_forwarding(portid_t port_id)
|
|
{
|
|
unsigned int i;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return -1;
|
|
|
|
for (i = 0; i < nb_fwd_ports; i++) {
|
|
if (fwd_ports_ids[i] == port_id)
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
set_nb_pkt_per_burst(uint16_t nb)
|
|
{
|
|
if (nb > MAX_PKT_BURST) {
|
|
printf("nb pkt per burst: %u > %u (maximum packet per burst) "
|
|
" ignored\n",
|
|
(unsigned int) nb, (unsigned int) MAX_PKT_BURST);
|
|
return;
|
|
}
|
|
nb_pkt_per_burst = nb;
|
|
printf("Number of packets per burst set to %u\n",
|
|
(unsigned int) nb_pkt_per_burst);
|
|
}
|
|
|
|
static const char *
|
|
tx_split_get_name(enum tx_pkt_split split)
|
|
{
|
|
uint32_t i;
|
|
|
|
for (i = 0; i != RTE_DIM(tx_split_name); i++) {
|
|
if (tx_split_name[i].split == split)
|
|
return tx_split_name[i].name;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
set_tx_pkt_split(const char *name)
|
|
{
|
|
uint32_t i;
|
|
|
|
for (i = 0; i != RTE_DIM(tx_split_name); i++) {
|
|
if (strcmp(tx_split_name[i].name, name) == 0) {
|
|
tx_pkt_split = tx_split_name[i].split;
|
|
return;
|
|
}
|
|
}
|
|
printf("unknown value: \"%s\"\n", name);
|
|
}
|
|
|
|
int
|
|
parse_fec_mode(const char *name, uint32_t *mode)
|
|
{
|
|
uint8_t i;
|
|
|
|
for (i = 0; i < RTE_DIM(fec_mode_name); i++) {
|
|
if (strcmp(fec_mode_name[i].name, name) == 0) {
|
|
*mode = RTE_ETH_FEC_MODE_TO_CAPA(fec_mode_name[i].mode);
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
show_fec_capability(unsigned int num, struct rte_eth_fec_capa *speed_fec_capa)
|
|
{
|
|
unsigned int i, j;
|
|
|
|
printf("FEC capabilities:\n");
|
|
|
|
for (i = 0; i < num; i++) {
|
|
printf("%s : ",
|
|
rte_eth_link_speed_to_str(speed_fec_capa[i].speed));
|
|
|
|
for (j = 0; j < RTE_DIM(fec_mode_name); j++) {
|
|
if (RTE_ETH_FEC_MODE_TO_CAPA(j) &
|
|
speed_fec_capa[i].capa)
|
|
printf("%s ", fec_mode_name[j].name);
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
void
|
|
show_rx_pkt_offsets(void)
|
|
{
|
|
uint32_t i, n;
|
|
|
|
n = rx_pkt_nb_offs;
|
|
printf("Number of offsets: %u\n", n);
|
|
if (n) {
|
|
printf("Segment offsets: ");
|
|
for (i = 0; i != n - 1; i++)
|
|
printf("%hu,", rx_pkt_seg_offsets[i]);
|
|
printf("%hu\n", rx_pkt_seg_lengths[i]);
|
|
}
|
|
}
|
|
|
|
void
|
|
set_rx_pkt_offsets(unsigned int *seg_offsets, unsigned int nb_offs)
|
|
{
|
|
unsigned int i;
|
|
|
|
if (nb_offs >= MAX_SEGS_BUFFER_SPLIT) {
|
|
printf("nb segments per RX packets=%u >= "
|
|
"MAX_SEGS_BUFFER_SPLIT - ignored\n", nb_offs);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* No extra check here, the segment length will be checked by PMD
|
|
* in the extended queue setup.
|
|
*/
|
|
for (i = 0; i < nb_offs; i++) {
|
|
if (seg_offsets[i] >= UINT16_MAX) {
|
|
printf("offset[%u]=%u > UINT16_MAX - give up\n",
|
|
i, seg_offsets[i]);
|
|
return;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < nb_offs; i++)
|
|
rx_pkt_seg_offsets[i] = (uint16_t) seg_offsets[i];
|
|
|
|
rx_pkt_nb_offs = (uint8_t) nb_offs;
|
|
}
|
|
|
|
void
|
|
show_rx_pkt_segments(void)
|
|
{
|
|
uint32_t i, n;
|
|
|
|
n = rx_pkt_nb_segs;
|
|
printf("Number of segments: %u\n", n);
|
|
if (n) {
|
|
printf("Segment sizes: ");
|
|
for (i = 0; i != n - 1; i++)
|
|
printf("%hu,", rx_pkt_seg_lengths[i]);
|
|
printf("%hu\n", rx_pkt_seg_lengths[i]);
|
|
}
|
|
}
|
|
|
|
void
|
|
set_rx_pkt_segments(unsigned int *seg_lengths, unsigned int nb_segs)
|
|
{
|
|
unsigned int i;
|
|
|
|
if (nb_segs >= MAX_SEGS_BUFFER_SPLIT) {
|
|
printf("nb segments per RX packets=%u >= "
|
|
"MAX_SEGS_BUFFER_SPLIT - ignored\n", nb_segs);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* No extra check here, the segment length will be checked by PMD
|
|
* in the extended queue setup.
|
|
*/
|
|
for (i = 0; i < nb_segs; i++) {
|
|
if (seg_lengths[i] >= UINT16_MAX) {
|
|
printf("length[%u]=%u > UINT16_MAX - give up\n",
|
|
i, seg_lengths[i]);
|
|
return;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < nb_segs; i++)
|
|
rx_pkt_seg_lengths[i] = (uint16_t) seg_lengths[i];
|
|
|
|
rx_pkt_nb_segs = (uint8_t) nb_segs;
|
|
}
|
|
|
|
void
|
|
show_tx_pkt_segments(void)
|
|
{
|
|
uint32_t i, n;
|
|
const char *split;
|
|
|
|
n = tx_pkt_nb_segs;
|
|
split = tx_split_get_name(tx_pkt_split);
|
|
|
|
printf("Number of segments: %u\n", n);
|
|
printf("Segment sizes: ");
|
|
for (i = 0; i != n - 1; i++)
|
|
printf("%hu,", tx_pkt_seg_lengths[i]);
|
|
printf("%hu\n", tx_pkt_seg_lengths[i]);
|
|
printf("Split packet: %s\n", split);
|
|
}
|
|
|
|
static bool
|
|
nb_segs_is_invalid(unsigned int nb_segs)
|
|
{
|
|
uint16_t ring_size;
|
|
uint16_t queue_id;
|
|
uint16_t port_id;
|
|
int ret;
|
|
|
|
RTE_ETH_FOREACH_DEV(port_id) {
|
|
for (queue_id = 0; queue_id < nb_txq; queue_id++) {
|
|
ret = get_tx_ring_size(port_id, queue_id, &ring_size);
|
|
if (ret) {
|
|
/* Port may not be initialized yet, can't say
|
|
* the port is invalid in this stage.
|
|
*/
|
|
continue;
|
|
}
|
|
if (ring_size < nb_segs) {
|
|
printf("nb segments per TX packets=%u >= TX "
|
|
"queue(%u) ring_size=%u - txpkts ignored\n",
|
|
nb_segs, queue_id, ring_size);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
set_tx_pkt_segments(unsigned int *seg_lengths, unsigned int nb_segs)
|
|
{
|
|
uint16_t tx_pkt_len;
|
|
unsigned int i;
|
|
|
|
/*
|
|
* For single segment settings failed check is ignored.
|
|
* It is a very basic capability to send the single segment
|
|
* packets, suppose it is always supported.
|
|
*/
|
|
if (nb_segs > 1 && nb_segs_is_invalid(nb_segs)) {
|
|
printf("Tx segment size(%u) is not supported - txpkts ignored\n",
|
|
nb_segs);
|
|
return;
|
|
}
|
|
|
|
if (nb_segs > RTE_MAX_SEGS_PER_PKT) {
|
|
printf("Tx segment size(%u) is bigger than max number of segment(%u)\n",
|
|
nb_segs, RTE_MAX_SEGS_PER_PKT);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Check that each segment length is greater or equal than
|
|
* the mbuf data size.
|
|
* Check also that the total packet length is greater or equal than the
|
|
* size of an empty UDP/IP packet (sizeof(struct rte_ether_hdr) +
|
|
* 20 + 8).
|
|
*/
|
|
tx_pkt_len = 0;
|
|
for (i = 0; i < nb_segs; i++) {
|
|
if (seg_lengths[i] > mbuf_data_size[0]) {
|
|
printf("length[%u]=%u > mbuf_data_size=%u - give up\n",
|
|
i, seg_lengths[i], mbuf_data_size[0]);
|
|
return;
|
|
}
|
|
tx_pkt_len = (uint16_t)(tx_pkt_len + seg_lengths[i]);
|
|
}
|
|
if (tx_pkt_len < (sizeof(struct rte_ether_hdr) + 20 + 8)) {
|
|
printf("total packet length=%u < %d - give up\n",
|
|
(unsigned) tx_pkt_len,
|
|
(int)(sizeof(struct rte_ether_hdr) + 20 + 8));
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < nb_segs; i++)
|
|
tx_pkt_seg_lengths[i] = (uint16_t) seg_lengths[i];
|
|
|
|
tx_pkt_length = tx_pkt_len;
|
|
tx_pkt_nb_segs = (uint8_t) nb_segs;
|
|
}
|
|
|
|
void
|
|
show_tx_pkt_times(void)
|
|
{
|
|
printf("Interburst gap: %u\n", tx_pkt_times_inter);
|
|
printf("Intraburst gap: %u\n", tx_pkt_times_intra);
|
|
}
|
|
|
|
void
|
|
set_tx_pkt_times(unsigned int *tx_times)
|
|
{
|
|
tx_pkt_times_inter = tx_times[0];
|
|
tx_pkt_times_intra = tx_times[1];
|
|
}
|
|
|
|
void
|
|
setup_gro(const char *onoff, portid_t port_id)
|
|
{
|
|
if (!rte_eth_dev_is_valid_port(port_id)) {
|
|
printf("invalid port id %u\n", port_id);
|
|
return;
|
|
}
|
|
if (test_done == 0) {
|
|
printf("Before enable/disable GRO,"
|
|
" please stop forwarding first\n");
|
|
return;
|
|
}
|
|
if (strcmp(onoff, "on") == 0) {
|
|
if (gro_ports[port_id].enable != 0) {
|
|
printf("Port %u has enabled GRO. Please"
|
|
" disable GRO first\n", port_id);
|
|
return;
|
|
}
|
|
if (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) {
|
|
gro_ports[port_id].param.gro_types = RTE_GRO_TCP_IPV4;
|
|
gro_ports[port_id].param.max_flow_num =
|
|
GRO_DEFAULT_FLOW_NUM;
|
|
gro_ports[port_id].param.max_item_per_flow =
|
|
GRO_DEFAULT_ITEM_NUM_PER_FLOW;
|
|
}
|
|
gro_ports[port_id].enable = 1;
|
|
} else {
|
|
if (gro_ports[port_id].enable == 0) {
|
|
printf("Port %u has disabled GRO\n", port_id);
|
|
return;
|
|
}
|
|
gro_ports[port_id].enable = 0;
|
|
}
|
|
}
|
|
|
|
void
|
|
setup_gro_flush_cycles(uint8_t cycles)
|
|
{
|
|
if (test_done == 0) {
|
|
printf("Before change flush interval for GRO,"
|
|
" please stop forwarding first.\n");
|
|
return;
|
|
}
|
|
|
|
if (cycles > GRO_MAX_FLUSH_CYCLES || cycles <
|
|
GRO_DEFAULT_FLUSH_CYCLES) {
|
|
printf("The flushing cycle be in the range"
|
|
" of 1 to %u. Revert to the default"
|
|
" value %u.\n",
|
|
GRO_MAX_FLUSH_CYCLES,
|
|
GRO_DEFAULT_FLUSH_CYCLES);
|
|
cycles = GRO_DEFAULT_FLUSH_CYCLES;
|
|
}
|
|
|
|
gro_flush_cycles = cycles;
|
|
}
|
|
|
|
void
|
|
show_gro(portid_t port_id)
|
|
{
|
|
struct rte_gro_param *param;
|
|
uint32_t max_pkts_num;
|
|
|
|
param = &gro_ports[port_id].param;
|
|
|
|
if (!rte_eth_dev_is_valid_port(port_id)) {
|
|
printf("Invalid port id %u.\n", port_id);
|
|
return;
|
|
}
|
|
if (gro_ports[port_id].enable) {
|
|
printf("GRO type: TCP/IPv4\n");
|
|
if (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) {
|
|
max_pkts_num = param->max_flow_num *
|
|
param->max_item_per_flow;
|
|
} else
|
|
max_pkts_num = MAX_PKT_BURST * GRO_MAX_FLUSH_CYCLES;
|
|
printf("Max number of packets to perform GRO: %u\n",
|
|
max_pkts_num);
|
|
printf("Flushing cycles: %u\n", gro_flush_cycles);
|
|
} else
|
|
printf("Port %u doesn't enable GRO.\n", port_id);
|
|
}
|
|
|
|
void
|
|
setup_gso(const char *mode, portid_t port_id)
|
|
{
|
|
if (!rte_eth_dev_is_valid_port(port_id)) {
|
|
printf("invalid port id %u\n", port_id);
|
|
return;
|
|
}
|
|
if (strcmp(mode, "on") == 0) {
|
|
if (test_done == 0) {
|
|
printf("before enabling GSO,"
|
|
" please stop forwarding first\n");
|
|
return;
|
|
}
|
|
gso_ports[port_id].enable = 1;
|
|
} else if (strcmp(mode, "off") == 0) {
|
|
if (test_done == 0) {
|
|
printf("before disabling GSO,"
|
|
" please stop forwarding first\n");
|
|
return;
|
|
}
|
|
gso_ports[port_id].enable = 0;
|
|
}
|
|
}
|
|
|
|
char*
|
|
list_pkt_forwarding_modes(void)
|
|
{
|
|
static char fwd_modes[128] = "";
|
|
const char *separator = "|";
|
|
struct fwd_engine *fwd_eng;
|
|
unsigned i = 0;
|
|
|
|
if (strlen (fwd_modes) == 0) {
|
|
while ((fwd_eng = fwd_engines[i++]) != NULL) {
|
|
strncat(fwd_modes, fwd_eng->fwd_mode_name,
|
|
sizeof(fwd_modes) - strlen(fwd_modes) - 1);
|
|
strncat(fwd_modes, separator,
|
|
sizeof(fwd_modes) - strlen(fwd_modes) - 1);
|
|
}
|
|
fwd_modes[strlen(fwd_modes) - strlen(separator)] = '\0';
|
|
}
|
|
|
|
return fwd_modes;
|
|
}
|
|
|
|
char*
|
|
list_pkt_forwarding_retry_modes(void)
|
|
{
|
|
static char fwd_modes[128] = "";
|
|
const char *separator = "|";
|
|
struct fwd_engine *fwd_eng;
|
|
unsigned i = 0;
|
|
|
|
if (strlen(fwd_modes) == 0) {
|
|
while ((fwd_eng = fwd_engines[i++]) != NULL) {
|
|
if (fwd_eng == &rx_only_engine)
|
|
continue;
|
|
strncat(fwd_modes, fwd_eng->fwd_mode_name,
|
|
sizeof(fwd_modes) -
|
|
strlen(fwd_modes) - 1);
|
|
strncat(fwd_modes, separator,
|
|
sizeof(fwd_modes) -
|
|
strlen(fwd_modes) - 1);
|
|
}
|
|
fwd_modes[strlen(fwd_modes) - strlen(separator)] = '\0';
|
|
}
|
|
|
|
return fwd_modes;
|
|
}
|
|
|
|
void
|
|
set_pkt_forwarding_mode(const char *fwd_mode_name)
|
|
{
|
|
struct fwd_engine *fwd_eng;
|
|
unsigned i;
|
|
|
|
i = 0;
|
|
while ((fwd_eng = fwd_engines[i]) != NULL) {
|
|
if (! strcmp(fwd_eng->fwd_mode_name, fwd_mode_name)) {
|
|
printf("Set %s packet forwarding mode%s\n",
|
|
fwd_mode_name,
|
|
retry_enabled == 0 ? "" : " with retry");
|
|
cur_fwd_eng = fwd_eng;
|
|
return;
|
|
}
|
|
i++;
|
|
}
|
|
printf("Invalid %s packet forwarding mode\n", fwd_mode_name);
|
|
}
|
|
|
|
void
|
|
add_rx_dump_callbacks(portid_t portid)
|
|
{
|
|
struct rte_eth_dev_info dev_info;
|
|
uint16_t queue;
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(portid, ENABLED_WARN))
|
|
return;
|
|
|
|
ret = eth_dev_info_get_print_err(portid, &dev_info);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
for (queue = 0; queue < dev_info.nb_rx_queues; queue++)
|
|
if (!ports[portid].rx_dump_cb[queue])
|
|
ports[portid].rx_dump_cb[queue] =
|
|
rte_eth_add_rx_callback(portid, queue,
|
|
dump_rx_pkts, NULL);
|
|
}
|
|
|
|
void
|
|
add_tx_dump_callbacks(portid_t portid)
|
|
{
|
|
struct rte_eth_dev_info dev_info;
|
|
uint16_t queue;
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(portid, ENABLED_WARN))
|
|
return;
|
|
|
|
ret = eth_dev_info_get_print_err(portid, &dev_info);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
for (queue = 0; queue < dev_info.nb_tx_queues; queue++)
|
|
if (!ports[portid].tx_dump_cb[queue])
|
|
ports[portid].tx_dump_cb[queue] =
|
|
rte_eth_add_tx_callback(portid, queue,
|
|
dump_tx_pkts, NULL);
|
|
}
|
|
|
|
void
|
|
remove_rx_dump_callbacks(portid_t portid)
|
|
{
|
|
struct rte_eth_dev_info dev_info;
|
|
uint16_t queue;
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(portid, ENABLED_WARN))
|
|
return;
|
|
|
|
ret = eth_dev_info_get_print_err(portid, &dev_info);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
for (queue = 0; queue < dev_info.nb_rx_queues; queue++)
|
|
if (ports[portid].rx_dump_cb[queue]) {
|
|
rte_eth_remove_rx_callback(portid, queue,
|
|
ports[portid].rx_dump_cb[queue]);
|
|
ports[portid].rx_dump_cb[queue] = NULL;
|
|
}
|
|
}
|
|
|
|
void
|
|
remove_tx_dump_callbacks(portid_t portid)
|
|
{
|
|
struct rte_eth_dev_info dev_info;
|
|
uint16_t queue;
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(portid, ENABLED_WARN))
|
|
return;
|
|
|
|
ret = eth_dev_info_get_print_err(portid, &dev_info);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
for (queue = 0; queue < dev_info.nb_tx_queues; queue++)
|
|
if (ports[portid].tx_dump_cb[queue]) {
|
|
rte_eth_remove_tx_callback(portid, queue,
|
|
ports[portid].tx_dump_cb[queue]);
|
|
ports[portid].tx_dump_cb[queue] = NULL;
|
|
}
|
|
}
|
|
|
|
void
|
|
configure_rxtx_dump_callbacks(uint16_t verbose)
|
|
{
|
|
portid_t portid;
|
|
|
|
#ifndef RTE_ETHDEV_RXTX_CALLBACKS
|
|
TESTPMD_LOG(ERR, "setting rxtx callbacks is not enabled\n");
|
|
return;
|
|
#endif
|
|
|
|
RTE_ETH_FOREACH_DEV(portid)
|
|
{
|
|
if (verbose == 1 || verbose > 2)
|
|
add_rx_dump_callbacks(portid);
|
|
else
|
|
remove_rx_dump_callbacks(portid);
|
|
if (verbose >= 2)
|
|
add_tx_dump_callbacks(portid);
|
|
else
|
|
remove_tx_dump_callbacks(portid);
|
|
}
|
|
}
|
|
|
|
void
|
|
set_verbose_level(uint16_t vb_level)
|
|
{
|
|
printf("Change verbose level from %u to %u\n",
|
|
(unsigned int) verbose_level, (unsigned int) vb_level);
|
|
verbose_level = vb_level;
|
|
configure_rxtx_dump_callbacks(verbose_level);
|
|
}
|
|
|
|
void
|
|
vlan_extend_set(portid_t port_id, int on)
|
|
{
|
|
int diag;
|
|
int vlan_offload;
|
|
uint64_t port_rx_offloads = ports[port_id].dev_conf.rxmode.offloads;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
vlan_offload = rte_eth_dev_get_vlan_offload(port_id);
|
|
|
|
if (on) {
|
|
vlan_offload |= ETH_VLAN_EXTEND_OFFLOAD;
|
|
port_rx_offloads |= DEV_RX_OFFLOAD_VLAN_EXTEND;
|
|
} else {
|
|
vlan_offload &= ~ETH_VLAN_EXTEND_OFFLOAD;
|
|
port_rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_EXTEND;
|
|
}
|
|
|
|
diag = rte_eth_dev_set_vlan_offload(port_id, vlan_offload);
|
|
if (diag < 0) {
|
|
printf("rx_vlan_extend_set(port_pi=%d, on=%d) failed "
|
|
"diag=%d\n", port_id, on, diag);
|
|
return;
|
|
}
|
|
ports[port_id].dev_conf.rxmode.offloads = port_rx_offloads;
|
|
}
|
|
|
|
void
|
|
rx_vlan_strip_set(portid_t port_id, int on)
|
|
{
|
|
int diag;
|
|
int vlan_offload;
|
|
uint64_t port_rx_offloads = ports[port_id].dev_conf.rxmode.offloads;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
vlan_offload = rte_eth_dev_get_vlan_offload(port_id);
|
|
|
|
if (on) {
|
|
vlan_offload |= ETH_VLAN_STRIP_OFFLOAD;
|
|
port_rx_offloads |= DEV_RX_OFFLOAD_VLAN_STRIP;
|
|
} else {
|
|
vlan_offload &= ~ETH_VLAN_STRIP_OFFLOAD;
|
|
port_rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_STRIP;
|
|
}
|
|
|
|
diag = rte_eth_dev_set_vlan_offload(port_id, vlan_offload);
|
|
if (diag < 0) {
|
|
printf("rx_vlan_strip_set(port_pi=%d, on=%d) failed "
|
|
"diag=%d\n", port_id, on, diag);
|
|
return;
|
|
}
|
|
ports[port_id].dev_conf.rxmode.offloads = port_rx_offloads;
|
|
}
|
|
|
|
void
|
|
rx_vlan_strip_set_on_queue(portid_t port_id, uint16_t queue_id, int on)
|
|
{
|
|
int diag;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
diag = rte_eth_dev_set_vlan_strip_on_queue(port_id, queue_id, on);
|
|
if (diag < 0)
|
|
printf("rx_vlan_strip_set_on_queue(port_pi=%d, queue_id=%d, on=%d) failed "
|
|
"diag=%d\n", port_id, queue_id, on, diag);
|
|
}
|
|
|
|
void
|
|
rx_vlan_filter_set(portid_t port_id, int on)
|
|
{
|
|
int diag;
|
|
int vlan_offload;
|
|
uint64_t port_rx_offloads = ports[port_id].dev_conf.rxmode.offloads;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
vlan_offload = rte_eth_dev_get_vlan_offload(port_id);
|
|
|
|
if (on) {
|
|
vlan_offload |= ETH_VLAN_FILTER_OFFLOAD;
|
|
port_rx_offloads |= DEV_RX_OFFLOAD_VLAN_FILTER;
|
|
} else {
|
|
vlan_offload &= ~ETH_VLAN_FILTER_OFFLOAD;
|
|
port_rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_FILTER;
|
|
}
|
|
|
|
diag = rte_eth_dev_set_vlan_offload(port_id, vlan_offload);
|
|
if (diag < 0) {
|
|
printf("rx_vlan_filter_set(port_pi=%d, on=%d) failed "
|
|
"diag=%d\n", port_id, on, diag);
|
|
return;
|
|
}
|
|
ports[port_id].dev_conf.rxmode.offloads = port_rx_offloads;
|
|
}
|
|
|
|
void
|
|
rx_vlan_qinq_strip_set(portid_t port_id, int on)
|
|
{
|
|
int diag;
|
|
int vlan_offload;
|
|
uint64_t port_rx_offloads = ports[port_id].dev_conf.rxmode.offloads;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
vlan_offload = rte_eth_dev_get_vlan_offload(port_id);
|
|
|
|
if (on) {
|
|
vlan_offload |= ETH_QINQ_STRIP_OFFLOAD;
|
|
port_rx_offloads |= DEV_RX_OFFLOAD_QINQ_STRIP;
|
|
} else {
|
|
vlan_offload &= ~ETH_QINQ_STRIP_OFFLOAD;
|
|
port_rx_offloads &= ~DEV_RX_OFFLOAD_QINQ_STRIP;
|
|
}
|
|
|
|
diag = rte_eth_dev_set_vlan_offload(port_id, vlan_offload);
|
|
if (diag < 0) {
|
|
printf("%s(port_pi=%d, on=%d) failed "
|
|
"diag=%d\n", __func__, port_id, on, diag);
|
|
return;
|
|
}
|
|
ports[port_id].dev_conf.rxmode.offloads = port_rx_offloads;
|
|
}
|
|
|
|
int
|
|
rx_vft_set(portid_t port_id, uint16_t vlan_id, int on)
|
|
{
|
|
int diag;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return 1;
|
|
if (vlan_id_is_invalid(vlan_id))
|
|
return 1;
|
|
diag = rte_eth_dev_vlan_filter(port_id, vlan_id, on);
|
|
if (diag == 0)
|
|
return 0;
|
|
printf("rte_eth_dev_vlan_filter(port_pi=%d, vlan_id=%d, on=%d) failed "
|
|
"diag=%d\n",
|
|
port_id, vlan_id, on, diag);
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
rx_vlan_all_filter_set(portid_t port_id, int on)
|
|
{
|
|
uint16_t vlan_id;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
for (vlan_id = 0; vlan_id < 4096; vlan_id++) {
|
|
if (rx_vft_set(port_id, vlan_id, on))
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
vlan_tpid_set(portid_t port_id, enum rte_vlan_type vlan_type, uint16_t tp_id)
|
|
{
|
|
int diag;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
diag = rte_eth_dev_set_vlan_ether_type(port_id, vlan_type, tp_id);
|
|
if (diag == 0)
|
|
return;
|
|
|
|
printf("tx_vlan_tpid_set(port_pi=%d, vlan_type=%d, tpid=%d) failed "
|
|
"diag=%d\n",
|
|
port_id, vlan_type, tp_id, diag);
|
|
}
|
|
|
|
void
|
|
tx_vlan_set(portid_t port_id, uint16_t vlan_id)
|
|
{
|
|
struct rte_eth_dev_info dev_info;
|
|
int ret;
|
|
|
|
if (vlan_id_is_invalid(vlan_id))
|
|
return;
|
|
|
|
if (ports[port_id].dev_conf.txmode.offloads &
|
|
DEV_TX_OFFLOAD_QINQ_INSERT) {
|
|
printf("Error, as QinQ has been enabled.\n");
|
|
return;
|
|
}
|
|
|
|
ret = eth_dev_info_get_print_err(port_id, &dev_info);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
if ((dev_info.tx_offload_capa & DEV_TX_OFFLOAD_VLAN_INSERT) == 0) {
|
|
printf("Error: vlan insert is not supported by port %d\n",
|
|
port_id);
|
|
return;
|
|
}
|
|
|
|
tx_vlan_reset(port_id);
|
|
ports[port_id].dev_conf.txmode.offloads |= DEV_TX_OFFLOAD_VLAN_INSERT;
|
|
ports[port_id].tx_vlan_id = vlan_id;
|
|
}
|
|
|
|
void
|
|
tx_qinq_set(portid_t port_id, uint16_t vlan_id, uint16_t vlan_id_outer)
|
|
{
|
|
struct rte_eth_dev_info dev_info;
|
|
int ret;
|
|
|
|
if (vlan_id_is_invalid(vlan_id))
|
|
return;
|
|
if (vlan_id_is_invalid(vlan_id_outer))
|
|
return;
|
|
|
|
ret = eth_dev_info_get_print_err(port_id, &dev_info);
|
|
if (ret != 0)
|
|
return;
|
|
|
|
if ((dev_info.tx_offload_capa & DEV_TX_OFFLOAD_QINQ_INSERT) == 0) {
|
|
printf("Error: qinq insert not supported by port %d\n",
|
|
port_id);
|
|
return;
|
|
}
|
|
|
|
tx_vlan_reset(port_id);
|
|
ports[port_id].dev_conf.txmode.offloads |= (DEV_TX_OFFLOAD_VLAN_INSERT |
|
|
DEV_TX_OFFLOAD_QINQ_INSERT);
|
|
ports[port_id].tx_vlan_id = vlan_id;
|
|
ports[port_id].tx_vlan_id_outer = vlan_id_outer;
|
|
}
|
|
|
|
void
|
|
tx_vlan_reset(portid_t port_id)
|
|
{
|
|
ports[port_id].dev_conf.txmode.offloads &=
|
|
~(DEV_TX_OFFLOAD_VLAN_INSERT |
|
|
DEV_TX_OFFLOAD_QINQ_INSERT);
|
|
ports[port_id].tx_vlan_id = 0;
|
|
ports[port_id].tx_vlan_id_outer = 0;
|
|
}
|
|
|
|
void
|
|
tx_vlan_pvid_set(portid_t port_id, uint16_t vlan_id, int on)
|
|
{
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
rte_eth_dev_set_vlan_pvid(port_id, vlan_id, on);
|
|
}
|
|
|
|
void
|
|
set_qmap(portid_t port_id, uint8_t is_rx, uint16_t queue_id, uint8_t map_value)
|
|
{
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
if (is_rx ? (rx_queue_id_is_invalid(queue_id)) : (tx_queue_id_is_invalid(queue_id)))
|
|
return;
|
|
|
|
if (map_value >= RTE_ETHDEV_QUEUE_STAT_CNTRS) {
|
|
printf("map_value not in required range 0..%d\n",
|
|
RTE_ETHDEV_QUEUE_STAT_CNTRS - 1);
|
|
return;
|
|
}
|
|
|
|
if (!is_rx) { /* tx */
|
|
ret = rte_eth_dev_set_tx_queue_stats_mapping(port_id, queue_id,
|
|
map_value);
|
|
if (ret) {
|
|
printf("failed to set tx queue stats mapping.\n");
|
|
return;
|
|
}
|
|
} else { /* rx */
|
|
ret = rte_eth_dev_set_rx_queue_stats_mapping(port_id, queue_id,
|
|
map_value);
|
|
if (ret) {
|
|
printf("failed to set rx queue stats mapping.\n");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
set_xstats_hide_zero(uint8_t on_off)
|
|
{
|
|
xstats_hide_zero = on_off;
|
|
}
|
|
|
|
void
|
|
set_record_core_cycles(uint8_t on_off)
|
|
{
|
|
record_core_cycles = on_off;
|
|
}
|
|
|
|
void
|
|
set_record_burst_stats(uint8_t on_off)
|
|
{
|
|
record_burst_stats = on_off;
|
|
}
|
|
|
|
static inline void
|
|
print_fdir_mask(struct rte_eth_fdir_masks *mask)
|
|
{
|
|
printf("\n vlan_tci: 0x%04x", rte_be_to_cpu_16(mask->vlan_tci_mask));
|
|
|
|
if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL)
|
|
printf(", mac_addr: 0x%02x, tunnel_type: 0x%01x,"
|
|
" tunnel_id: 0x%08x",
|
|
mask->mac_addr_byte_mask, mask->tunnel_type_mask,
|
|
rte_be_to_cpu_32(mask->tunnel_id_mask));
|
|
else if (fdir_conf.mode != RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
|
|
printf(", src_ipv4: 0x%08x, dst_ipv4: 0x%08x",
|
|
rte_be_to_cpu_32(mask->ipv4_mask.src_ip),
|
|
rte_be_to_cpu_32(mask->ipv4_mask.dst_ip));
|
|
|
|
printf("\n src_port: 0x%04x, dst_port: 0x%04x",
|
|
rte_be_to_cpu_16(mask->src_port_mask),
|
|
rte_be_to_cpu_16(mask->dst_port_mask));
|
|
|
|
printf("\n src_ipv6: 0x%08x,0x%08x,0x%08x,0x%08x",
|
|
rte_be_to_cpu_32(mask->ipv6_mask.src_ip[0]),
|
|
rte_be_to_cpu_32(mask->ipv6_mask.src_ip[1]),
|
|
rte_be_to_cpu_32(mask->ipv6_mask.src_ip[2]),
|
|
rte_be_to_cpu_32(mask->ipv6_mask.src_ip[3]));
|
|
|
|
printf("\n dst_ipv6: 0x%08x,0x%08x,0x%08x,0x%08x",
|
|
rte_be_to_cpu_32(mask->ipv6_mask.dst_ip[0]),
|
|
rte_be_to_cpu_32(mask->ipv6_mask.dst_ip[1]),
|
|
rte_be_to_cpu_32(mask->ipv6_mask.dst_ip[2]),
|
|
rte_be_to_cpu_32(mask->ipv6_mask.dst_ip[3]));
|
|
}
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
static inline void
|
|
print_fdir_flex_payload(struct rte_eth_fdir_flex_conf *flex_conf, uint32_t num)
|
|
{
|
|
struct rte_eth_flex_payload_cfg *cfg;
|
|
uint32_t i, j;
|
|
|
|
for (i = 0; i < flex_conf->nb_payloads; i++) {
|
|
cfg = &flex_conf->flex_set[i];
|
|
if (cfg->type == RTE_ETH_RAW_PAYLOAD)
|
|
printf("\n RAW: ");
|
|
else if (cfg->type == RTE_ETH_L2_PAYLOAD)
|
|
printf("\n L2_PAYLOAD: ");
|
|
else if (cfg->type == RTE_ETH_L3_PAYLOAD)
|
|
printf("\n L3_PAYLOAD: ");
|
|
else if (cfg->type == RTE_ETH_L4_PAYLOAD)
|
|
printf("\n L4_PAYLOAD: ");
|
|
else
|
|
printf("\n UNKNOWN PAYLOAD(%u): ", cfg->type);
|
|
for (j = 0; j < num; j++)
|
|
printf(" %-5u", cfg->src_offset[j]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
static char *
|
|
flowtype_to_str(uint16_t flow_type)
|
|
{
|
|
struct flow_type_info {
|
|
char str[32];
|
|
uint16_t ftype;
|
|
};
|
|
|
|
uint8_t i;
|
|
static struct flow_type_info flowtype_str_table[] = {
|
|
{"raw", RTE_ETH_FLOW_RAW},
|
|
{"ipv4", RTE_ETH_FLOW_IPV4},
|
|
{"ipv4-frag", RTE_ETH_FLOW_FRAG_IPV4},
|
|
{"ipv4-tcp", RTE_ETH_FLOW_NONFRAG_IPV4_TCP},
|
|
{"ipv4-udp", RTE_ETH_FLOW_NONFRAG_IPV4_UDP},
|
|
{"ipv4-sctp", RTE_ETH_FLOW_NONFRAG_IPV4_SCTP},
|
|
{"ipv4-other", RTE_ETH_FLOW_NONFRAG_IPV4_OTHER},
|
|
{"ipv6", RTE_ETH_FLOW_IPV6},
|
|
{"ipv6-frag", RTE_ETH_FLOW_FRAG_IPV6},
|
|
{"ipv6-tcp", RTE_ETH_FLOW_NONFRAG_IPV6_TCP},
|
|
{"ipv6-udp", RTE_ETH_FLOW_NONFRAG_IPV6_UDP},
|
|
{"ipv6-sctp", RTE_ETH_FLOW_NONFRAG_IPV6_SCTP},
|
|
{"ipv6-other", RTE_ETH_FLOW_NONFRAG_IPV6_OTHER},
|
|
{"l2_payload", RTE_ETH_FLOW_L2_PAYLOAD},
|
|
{"port", RTE_ETH_FLOW_PORT},
|
|
{"vxlan", RTE_ETH_FLOW_VXLAN},
|
|
{"geneve", RTE_ETH_FLOW_GENEVE},
|
|
{"nvgre", RTE_ETH_FLOW_NVGRE},
|
|
{"vxlan-gpe", RTE_ETH_FLOW_VXLAN_GPE},
|
|
};
|
|
|
|
for (i = 0; i < RTE_DIM(flowtype_str_table); i++) {
|
|
if (flowtype_str_table[i].ftype == flow_type)
|
|
return flowtype_str_table[i].str;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#if defined(RTE_NET_I40E) || defined(RTE_NET_IXGBE)
|
|
|
|
static inline void
|
|
print_fdir_flex_mask(struct rte_eth_fdir_flex_conf *flex_conf, uint32_t num)
|
|
{
|
|
struct rte_eth_fdir_flex_mask *mask;
|
|
uint32_t i, j;
|
|
char *p;
|
|
|
|
for (i = 0; i < flex_conf->nb_flexmasks; i++) {
|
|
mask = &flex_conf->flex_mask[i];
|
|
p = flowtype_to_str(mask->flow_type);
|
|
printf("\n %s:\t", p ? p : "unknown");
|
|
for (j = 0; j < num; j++)
|
|
printf(" %02x", mask->mask[j]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
static inline void
|
|
print_fdir_flow_type(uint32_t flow_types_mask)
|
|
{
|
|
int i;
|
|
char *p;
|
|
|
|
for (i = RTE_ETH_FLOW_UNKNOWN; i < RTE_ETH_FLOW_MAX; i++) {
|
|
if (!(flow_types_mask & (1 << i)))
|
|
continue;
|
|
p = flowtype_to_str(i);
|
|
if (p)
|
|
printf(" %s", p);
|
|
else
|
|
printf(" unknown");
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
static int
|
|
get_fdir_info(portid_t port_id, struct rte_eth_fdir_info *fdir_info,
|
|
struct rte_eth_fdir_stats *fdir_stat)
|
|
{
|
|
int ret = -ENOTSUP;
|
|
|
|
#ifdef RTE_NET_I40E
|
|
if (ret == -ENOTSUP) {
|
|
ret = rte_pmd_i40e_get_fdir_info(port_id, fdir_info);
|
|
if (!ret)
|
|
ret = rte_pmd_i40e_get_fdir_stats(port_id, fdir_stat);
|
|
}
|
|
#endif
|
|
#ifdef RTE_NET_IXGBE
|
|
if (ret == -ENOTSUP) {
|
|
ret = rte_pmd_ixgbe_get_fdir_info(port_id, fdir_info);
|
|
if (!ret)
|
|
ret = rte_pmd_ixgbe_get_fdir_stats(port_id, fdir_stat);
|
|
}
|
|
#endif
|
|
switch (ret) {
|
|
case 0:
|
|
break;
|
|
case -ENOTSUP:
|
|
printf("\n FDIR is not supported on port %-2d\n",
|
|
port_id);
|
|
break;
|
|
default:
|
|
printf("programming error: (%s)\n", strerror(-ret));
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
fdir_get_infos(portid_t port_id)
|
|
{
|
|
struct rte_eth_fdir_stats fdir_stat;
|
|
struct rte_eth_fdir_info fdir_info;
|
|
|
|
static const char *fdir_stats_border = "########################";
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
memset(&fdir_info, 0, sizeof(fdir_info));
|
|
memset(&fdir_stat, 0, sizeof(fdir_stat));
|
|
if (get_fdir_info(port_id, &fdir_info, &fdir_stat))
|
|
return;
|
|
|
|
printf("\n %s FDIR infos for port %-2d %s\n",
|
|
fdir_stats_border, port_id, fdir_stats_border);
|
|
printf(" MODE: ");
|
|
if (fdir_info.mode == RTE_FDIR_MODE_PERFECT)
|
|
printf(" PERFECT\n");
|
|
else if (fdir_info.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN)
|
|
printf(" PERFECT-MAC-VLAN\n");
|
|
else if (fdir_info.mode == RTE_FDIR_MODE_PERFECT_TUNNEL)
|
|
printf(" PERFECT-TUNNEL\n");
|
|
else if (fdir_info.mode == RTE_FDIR_MODE_SIGNATURE)
|
|
printf(" SIGNATURE\n");
|
|
else
|
|
printf(" DISABLE\n");
|
|
if (fdir_info.mode != RTE_FDIR_MODE_PERFECT_MAC_VLAN
|
|
&& fdir_info.mode != RTE_FDIR_MODE_PERFECT_TUNNEL) {
|
|
printf(" SUPPORTED FLOW TYPE: ");
|
|
print_fdir_flow_type(fdir_info.flow_types_mask[0]);
|
|
}
|
|
printf(" FLEX PAYLOAD INFO:\n");
|
|
printf(" max_len: %-10"PRIu32" payload_limit: %-10"PRIu32"\n"
|
|
" payload_unit: %-10"PRIu32" payload_seg: %-10"PRIu32"\n"
|
|
" bitmask_unit: %-10"PRIu32" bitmask_num: %-10"PRIu32"\n",
|
|
fdir_info.max_flexpayload, fdir_info.flex_payload_limit,
|
|
fdir_info.flex_payload_unit,
|
|
fdir_info.max_flex_payload_segment_num,
|
|
fdir_info.flex_bitmask_unit, fdir_info.max_flex_bitmask_num);
|
|
printf(" MASK: ");
|
|
print_fdir_mask(&fdir_info.mask);
|
|
if (fdir_info.flex_conf.nb_payloads > 0) {
|
|
printf(" FLEX PAYLOAD SRC OFFSET:");
|
|
print_fdir_flex_payload(&fdir_info.flex_conf, fdir_info.max_flexpayload);
|
|
}
|
|
if (fdir_info.flex_conf.nb_flexmasks > 0) {
|
|
printf(" FLEX MASK CFG:");
|
|
print_fdir_flex_mask(&fdir_info.flex_conf, fdir_info.max_flexpayload);
|
|
}
|
|
printf(" guarant_count: %-10"PRIu32" best_count: %"PRIu32"\n",
|
|
fdir_stat.guarant_cnt, fdir_stat.best_cnt);
|
|
printf(" guarant_space: %-10"PRIu32" best_space: %"PRIu32"\n",
|
|
fdir_info.guarant_spc, fdir_info.best_spc);
|
|
printf(" collision: %-10"PRIu32" free: %"PRIu32"\n"
|
|
" maxhash: %-10"PRIu32" maxlen: %"PRIu32"\n"
|
|
" add: %-10"PRIu64" remove: %"PRIu64"\n"
|
|
" f_add: %-10"PRIu64" f_remove: %"PRIu64"\n",
|
|
fdir_stat.collision, fdir_stat.free,
|
|
fdir_stat.maxhash, fdir_stat.maxlen,
|
|
fdir_stat.add, fdir_stat.remove,
|
|
fdir_stat.f_add, fdir_stat.f_remove);
|
|
printf(" %s############################%s\n",
|
|
fdir_stats_border, fdir_stats_border);
|
|
}
|
|
|
|
#endif /* RTE_NET_I40E || RTE_NET_IXGBE */
|
|
|
|
void
|
|
fdir_set_flex_mask(portid_t port_id, struct rte_eth_fdir_flex_mask *cfg)
|
|
{
|
|
struct rte_port *port;
|
|
struct rte_eth_fdir_flex_conf *flex_conf;
|
|
int i, idx = 0;
|
|
|
|
port = &ports[port_id];
|
|
flex_conf = &port->dev_conf.fdir_conf.flex_conf;
|
|
for (i = 0; i < RTE_ETH_FLOW_MAX; i++) {
|
|
if (cfg->flow_type == flex_conf->flex_mask[i].flow_type) {
|
|
idx = i;
|
|
break;
|
|
}
|
|
}
|
|
if (i >= RTE_ETH_FLOW_MAX) {
|
|
if (flex_conf->nb_flexmasks < RTE_DIM(flex_conf->flex_mask)) {
|
|
idx = flex_conf->nb_flexmasks;
|
|
flex_conf->nb_flexmasks++;
|
|
} else {
|
|
printf("The flex mask table is full. Can not set flex"
|
|
" mask for flow_type(%u).", cfg->flow_type);
|
|
return;
|
|
}
|
|
}
|
|
rte_memcpy(&flex_conf->flex_mask[idx],
|
|
cfg,
|
|
sizeof(struct rte_eth_fdir_flex_mask));
|
|
}
|
|
|
|
void
|
|
fdir_set_flex_payload(portid_t port_id, struct rte_eth_flex_payload_cfg *cfg)
|
|
{
|
|
struct rte_port *port;
|
|
struct rte_eth_fdir_flex_conf *flex_conf;
|
|
int i, idx = 0;
|
|
|
|
port = &ports[port_id];
|
|
flex_conf = &port->dev_conf.fdir_conf.flex_conf;
|
|
for (i = 0; i < RTE_ETH_PAYLOAD_MAX; i++) {
|
|
if (cfg->type == flex_conf->flex_set[i].type) {
|
|
idx = i;
|
|
break;
|
|
}
|
|
}
|
|
if (i >= RTE_ETH_PAYLOAD_MAX) {
|
|
if (flex_conf->nb_payloads < RTE_DIM(flex_conf->flex_set)) {
|
|
idx = flex_conf->nb_payloads;
|
|
flex_conf->nb_payloads++;
|
|
} else {
|
|
printf("The flex payload table is full. Can not set"
|
|
" flex payload for type(%u).", cfg->type);
|
|
return;
|
|
}
|
|
}
|
|
rte_memcpy(&flex_conf->flex_set[idx],
|
|
cfg,
|
|
sizeof(struct rte_eth_flex_payload_cfg));
|
|
|
|
}
|
|
|
|
void
|
|
set_vf_traffic(portid_t port_id, uint8_t is_rx, uint16_t vf, uint8_t on)
|
|
{
|
|
#ifdef RTE_NET_IXGBE
|
|
int diag;
|
|
|
|
if (is_rx)
|
|
diag = rte_pmd_ixgbe_set_vf_rx(port_id, vf, on);
|
|
else
|
|
diag = rte_pmd_ixgbe_set_vf_tx(port_id, vf, on);
|
|
|
|
if (diag == 0)
|
|
return;
|
|
printf("rte_pmd_ixgbe_set_vf_%s for port_id=%d failed diag=%d\n",
|
|
is_rx ? "rx" : "tx", port_id, diag);
|
|
return;
|
|
#endif
|
|
printf("VF %s setting not supported for port %d\n",
|
|
is_rx ? "Rx" : "Tx", port_id);
|
|
RTE_SET_USED(vf);
|
|
RTE_SET_USED(on);
|
|
}
|
|
|
|
int
|
|
set_queue_rate_limit(portid_t port_id, uint16_t queue_idx, uint16_t rate)
|
|
{
|
|
int diag;
|
|
struct rte_eth_link link;
|
|
int ret;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return 1;
|
|
ret = eth_link_get_nowait_print_err(port_id, &link);
|
|
if (ret < 0)
|
|
return 1;
|
|
if (link.link_speed != ETH_SPEED_NUM_UNKNOWN &&
|
|
rate > link.link_speed) {
|
|
printf("Invalid rate value:%u bigger than link speed: %u\n",
|
|
rate, link.link_speed);
|
|
return 1;
|
|
}
|
|
diag = rte_eth_set_queue_rate_limit(port_id, queue_idx, rate);
|
|
if (diag == 0)
|
|
return diag;
|
|
printf("rte_eth_set_queue_rate_limit for port_id=%d failed diag=%d\n",
|
|
port_id, diag);
|
|
return diag;
|
|
}
|
|
|
|
int
|
|
set_vf_rate_limit(portid_t port_id, uint16_t vf, uint16_t rate, uint64_t q_msk)
|
|
{
|
|
int diag = -ENOTSUP;
|
|
|
|
RTE_SET_USED(vf);
|
|
RTE_SET_USED(rate);
|
|
RTE_SET_USED(q_msk);
|
|
|
|
#ifdef RTE_NET_IXGBE
|
|
if (diag == -ENOTSUP)
|
|
diag = rte_pmd_ixgbe_set_vf_rate_limit(port_id, vf, rate,
|
|
q_msk);
|
|
#endif
|
|
#ifdef RTE_NET_BNXT
|
|
if (diag == -ENOTSUP)
|
|
diag = rte_pmd_bnxt_set_vf_rate_limit(port_id, vf, rate, q_msk);
|
|
#endif
|
|
if (diag == 0)
|
|
return diag;
|
|
|
|
printf("set_vf_rate_limit for port_id=%d failed diag=%d\n",
|
|
port_id, diag);
|
|
return diag;
|
|
}
|
|
|
|
/*
|
|
* Functions to manage the set of filtered Multicast MAC addresses.
|
|
*
|
|
* A pool of filtered multicast MAC addresses is associated with each port.
|
|
* The pool is allocated in chunks of MCAST_POOL_INC multicast addresses.
|
|
* The address of the pool and the number of valid multicast MAC addresses
|
|
* recorded in the pool are stored in the fields "mc_addr_pool" and
|
|
* "mc_addr_nb" of the "rte_port" data structure.
|
|
*
|
|
* The function "rte_eth_dev_set_mc_addr_list" of the PMDs API imposes
|
|
* to be supplied a contiguous array of multicast MAC addresses.
|
|
* To comply with this constraint, the set of multicast addresses recorded
|
|
* into the pool are systematically compacted at the beginning of the pool.
|
|
* Hence, when a multicast address is removed from the pool, all following
|
|
* addresses, if any, are copied back to keep the set contiguous.
|
|
*/
|
|
#define MCAST_POOL_INC 32
|
|
|
|
static int
|
|
mcast_addr_pool_extend(struct rte_port *port)
|
|
{
|
|
struct rte_ether_addr *mc_pool;
|
|
size_t mc_pool_size;
|
|
|
|
/*
|
|
* If a free entry is available at the end of the pool, just
|
|
* increment the number of recorded multicast addresses.
|
|
*/
|
|
if ((port->mc_addr_nb % MCAST_POOL_INC) != 0) {
|
|
port->mc_addr_nb++;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* [re]allocate a pool with MCAST_POOL_INC more entries.
|
|
* The previous test guarantees that port->mc_addr_nb is a multiple
|
|
* of MCAST_POOL_INC.
|
|
*/
|
|
mc_pool_size = sizeof(struct rte_ether_addr) * (port->mc_addr_nb +
|
|
MCAST_POOL_INC);
|
|
mc_pool = (struct rte_ether_addr *) realloc(port->mc_addr_pool,
|
|
mc_pool_size);
|
|
if (mc_pool == NULL) {
|
|
printf("allocation of pool of %u multicast addresses failed\n",
|
|
port->mc_addr_nb + MCAST_POOL_INC);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
port->mc_addr_pool = mc_pool;
|
|
port->mc_addr_nb++;
|
|
return 0;
|
|
|
|
}
|
|
|
|
static void
|
|
mcast_addr_pool_append(struct rte_port *port, struct rte_ether_addr *mc_addr)
|
|
{
|
|
if (mcast_addr_pool_extend(port) != 0)
|
|
return;
|
|
rte_ether_addr_copy(mc_addr, &port->mc_addr_pool[port->mc_addr_nb - 1]);
|
|
}
|
|
|
|
static void
|
|
mcast_addr_pool_remove(struct rte_port *port, uint32_t addr_idx)
|
|
{
|
|
port->mc_addr_nb--;
|
|
if (addr_idx == port->mc_addr_nb) {
|
|
/* No need to recompact the set of multicast addressses. */
|
|
if (port->mc_addr_nb == 0) {
|
|
/* free the pool of multicast addresses. */
|
|
free(port->mc_addr_pool);
|
|
port->mc_addr_pool = NULL;
|
|
}
|
|
return;
|
|
}
|
|
memmove(&port->mc_addr_pool[addr_idx],
|
|
&port->mc_addr_pool[addr_idx + 1],
|
|
sizeof(struct rte_ether_addr) * (port->mc_addr_nb - addr_idx));
|
|
}
|
|
|
|
static int
|
|
eth_port_multicast_addr_list_set(portid_t port_id)
|
|
{
|
|
struct rte_port *port;
|
|
int diag;
|
|
|
|
port = &ports[port_id];
|
|
diag = rte_eth_dev_set_mc_addr_list(port_id, port->mc_addr_pool,
|
|
port->mc_addr_nb);
|
|
if (diag < 0)
|
|
printf("rte_eth_dev_set_mc_addr_list(port=%d, nb=%u) failed. diag=%d\n",
|
|
port_id, port->mc_addr_nb, diag);
|
|
|
|
return diag;
|
|
}
|
|
|
|
void
|
|
mcast_addr_add(portid_t port_id, struct rte_ether_addr *mc_addr)
|
|
{
|
|
struct rte_port *port;
|
|
uint32_t i;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
port = &ports[port_id];
|
|
|
|
/*
|
|
* Check that the added multicast MAC address is not already recorded
|
|
* in the pool of multicast addresses.
|
|
*/
|
|
for (i = 0; i < port->mc_addr_nb; i++) {
|
|
if (rte_is_same_ether_addr(mc_addr, &port->mc_addr_pool[i])) {
|
|
printf("multicast address already filtered by port\n");
|
|
return;
|
|
}
|
|
}
|
|
|
|
mcast_addr_pool_append(port, mc_addr);
|
|
if (eth_port_multicast_addr_list_set(port_id) < 0)
|
|
/* Rollback on failure, remove the address from the pool */
|
|
mcast_addr_pool_remove(port, i);
|
|
}
|
|
|
|
void
|
|
mcast_addr_remove(portid_t port_id, struct rte_ether_addr *mc_addr)
|
|
{
|
|
struct rte_port *port;
|
|
uint32_t i;
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
port = &ports[port_id];
|
|
|
|
/*
|
|
* Search the pool of multicast MAC addresses for the removed address.
|
|
*/
|
|
for (i = 0; i < port->mc_addr_nb; i++) {
|
|
if (rte_is_same_ether_addr(mc_addr, &port->mc_addr_pool[i]))
|
|
break;
|
|
}
|
|
if (i == port->mc_addr_nb) {
|
|
printf("multicast address not filtered by port %d\n", port_id);
|
|
return;
|
|
}
|
|
|
|
mcast_addr_pool_remove(port, i);
|
|
if (eth_port_multicast_addr_list_set(port_id) < 0)
|
|
/* Rollback on failure, add the address back into the pool */
|
|
mcast_addr_pool_append(port, mc_addr);
|
|
}
|
|
|
|
void
|
|
port_dcb_info_display(portid_t port_id)
|
|
{
|
|
struct rte_eth_dcb_info dcb_info;
|
|
uint16_t i;
|
|
int ret;
|
|
static const char *border = "================";
|
|
|
|
if (port_id_is_invalid(port_id, ENABLED_WARN))
|
|
return;
|
|
|
|
ret = rte_eth_dev_get_dcb_info(port_id, &dcb_info);
|
|
if (ret) {
|
|
printf("\n Failed to get dcb infos on port %-2d\n",
|
|
port_id);
|
|
return;
|
|
}
|
|
printf("\n %s DCB infos for port %-2d %s\n", border, port_id, border);
|
|
printf(" TC NUMBER: %d\n", dcb_info.nb_tcs);
|
|
printf("\n TC : ");
|
|
for (i = 0; i < dcb_info.nb_tcs; i++)
|
|
printf("\t%4d", i);
|
|
printf("\n Priority : ");
|
|
for (i = 0; i < dcb_info.nb_tcs; i++)
|
|
printf("\t%4d", dcb_info.prio_tc[i]);
|
|
printf("\n BW percent :");
|
|
for (i = 0; i < dcb_info.nb_tcs; i++)
|
|
printf("\t%4d%%", dcb_info.tc_bws[i]);
|
|
printf("\n RXQ base : ");
|
|
for (i = 0; i < dcb_info.nb_tcs; i++)
|
|
printf("\t%4d", dcb_info.tc_queue.tc_rxq[0][i].base);
|
|
printf("\n RXQ number :");
|
|
for (i = 0; i < dcb_info.nb_tcs; i++)
|
|
printf("\t%4d", dcb_info.tc_queue.tc_rxq[0][i].nb_queue);
|
|
printf("\n TXQ base : ");
|
|
for (i = 0; i < dcb_info.nb_tcs; i++)
|
|
printf("\t%4d", dcb_info.tc_queue.tc_txq[0][i].base);
|
|
printf("\n TXQ number :");
|
|
for (i = 0; i < dcb_info.nb_tcs; i++)
|
|
printf("\t%4d", dcb_info.tc_queue.tc_txq[0][i].nb_queue);
|
|
printf("\n");
|
|
}
|
|
|
|
uint8_t *
|
|
open_file(const char *file_path, uint32_t *size)
|
|
{
|
|
int fd = open(file_path, O_RDONLY);
|
|
off_t pkg_size;
|
|
uint8_t *buf = NULL;
|
|
int ret = 0;
|
|
struct stat st_buf;
|
|
|
|
if (size)
|
|
*size = 0;
|
|
|
|
if (fd == -1) {
|
|
printf("%s: Failed to open %s\n", __func__, file_path);
|
|
return buf;
|
|
}
|
|
|
|
if ((fstat(fd, &st_buf) != 0) || (!S_ISREG(st_buf.st_mode))) {
|
|
close(fd);
|
|
printf("%s: File operations failed\n", __func__);
|
|
return buf;
|
|
}
|
|
|
|
pkg_size = st_buf.st_size;
|
|
if (pkg_size < 0) {
|
|
close(fd);
|
|
printf("%s: File operations failed\n", __func__);
|
|
return buf;
|
|
}
|
|
|
|
buf = (uint8_t *)malloc(pkg_size);
|
|
if (!buf) {
|
|
close(fd);
|
|
printf("%s: Failed to malloc memory\n", __func__);
|
|
return buf;
|
|
}
|
|
|
|
ret = read(fd, buf, pkg_size);
|
|
if (ret < 0) {
|
|
close(fd);
|
|
printf("%s: File read operation failed\n", __func__);
|
|
close_file(buf);
|
|
return NULL;
|
|
}
|
|
|
|
if (size)
|
|
*size = pkg_size;
|
|
|
|
close(fd);
|
|
|
|
return buf;
|
|
}
|
|
|
|
int
|
|
save_file(const char *file_path, uint8_t *buf, uint32_t size)
|
|
{
|
|
FILE *fh = fopen(file_path, "wb");
|
|
|
|
if (fh == NULL) {
|
|
printf("%s: Failed to open %s\n", __func__, file_path);
|
|
return -1;
|
|
}
|
|
|
|
if (fwrite(buf, 1, size, fh) != size) {
|
|
fclose(fh);
|
|
printf("%s: File write operation failed\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
fclose(fh);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
close_file(uint8_t *buf)
|
|
{
|
|
if (buf) {
|
|
free((void *)buf);
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
port_queue_region_info_display(portid_t port_id, void *buf)
|
|
{
|
|
#ifdef RTE_NET_I40E
|
|
uint16_t i, j;
|
|
struct rte_pmd_i40e_queue_regions *info =
|
|
(struct rte_pmd_i40e_queue_regions *)buf;
|
|
static const char *queue_region_info_stats_border = "-------";
|
|
|
|
if (!info->queue_region_number)
|
|
printf("there is no region has been set before");
|
|
|
|
printf("\n %s All queue region info for port=%2d %s",
|
|
queue_region_info_stats_border, port_id,
|
|
queue_region_info_stats_border);
|
|
printf("\n queue_region_number: %-14u \n",
|
|
info->queue_region_number);
|
|
|
|
for (i = 0; i < info->queue_region_number; i++) {
|
|
printf("\n region_id: %-14u queue_number: %-14u "
|
|
"queue_start_index: %-14u \n",
|
|
info->region[i].region_id,
|
|
info->region[i].queue_num,
|
|
info->region[i].queue_start_index);
|
|
|
|
printf(" user_priority_num is %-14u :",
|
|
info->region[i].user_priority_num);
|
|
for (j = 0; j < info->region[i].user_priority_num; j++)
|
|
printf(" %-14u ", info->region[i].user_priority[j]);
|
|
|
|
printf("\n flowtype_num is %-14u :",
|
|
info->region[i].flowtype_num);
|
|
for (j = 0; j < info->region[i].flowtype_num; j++)
|
|
printf(" %-14u ", info->region[i].hw_flowtype[j]);
|
|
}
|
|
#else
|
|
RTE_SET_USED(port_id);
|
|
RTE_SET_USED(buf);
|
|
#endif
|
|
|
|
printf("\n\n");
|
|
}
|
|
|
|
void
|
|
show_macs(portid_t port_id)
|
|
{
|
|
char buf[RTE_ETHER_ADDR_FMT_SIZE];
|
|
struct rte_eth_dev_info dev_info;
|
|
struct rte_ether_addr *addr;
|
|
uint32_t i, num_macs = 0;
|
|
struct rte_eth_dev *dev;
|
|
|
|
dev = &rte_eth_devices[port_id];
|
|
|
|
if (eth_dev_info_get_print_err(port_id, &dev_info))
|
|
return;
|
|
|
|
for (i = 0; i < dev_info.max_mac_addrs; i++) {
|
|
addr = &dev->data->mac_addrs[i];
|
|
|
|
/* skip zero address */
|
|
if (rte_is_zero_ether_addr(addr))
|
|
continue;
|
|
|
|
num_macs++;
|
|
}
|
|
|
|
printf("Number of MAC address added: %d\n", num_macs);
|
|
|
|
for (i = 0; i < dev_info.max_mac_addrs; i++) {
|
|
addr = &dev->data->mac_addrs[i];
|
|
|
|
/* skip zero address */
|
|
if (rte_is_zero_ether_addr(addr))
|
|
continue;
|
|
|
|
rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, addr);
|
|
printf(" %s\n", buf);
|
|
}
|
|
}
|
|
|
|
void
|
|
show_mcast_macs(portid_t port_id)
|
|
{
|
|
char buf[RTE_ETHER_ADDR_FMT_SIZE];
|
|
struct rte_ether_addr *addr;
|
|
struct rte_port *port;
|
|
uint32_t i;
|
|
|
|
port = &ports[port_id];
|
|
|
|
printf("Number of Multicast MAC address added: %d\n", port->mc_addr_nb);
|
|
|
|
for (i = 0; i < port->mc_addr_nb; i++) {
|
|
addr = &port->mc_addr_pool[i];
|
|
|
|
rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, addr);
|
|
printf(" %s\n", buf);
|
|
}
|
|
}
|