#include <cmdline_parse_etheraddr.h>
#include <cmdline_socket.h>
#include <cmdline.h>
-#ifdef RTE_LIBRTE_PMD_BOND
+#ifdef RTE_NET_BOND
#include <rte_eth_bond.h>
#include <rte_eth_bond_8023ad.h>
#endif
-#if defined RTE_LIBRTE_DPAA_BUS && defined RTE_LIBRTE_DPAA_PMD
+#if defined RTE_BUS_DPAA && defined RTE_NET_DPAA
#include <rte_pmd_dpaa.h>
#endif
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
#include <rte_pmd_ixgbe.h>
#endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
#include <rte_pmd_i40e.h>
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
#include <rte_pmd_bnxt.h>
#endif
#include "testpmd.h"
"show port (info|stats|summary|xstats|fdir|stat_qmap|dcb_tc|cap) (port_id|all)\n"
" Display information for port_id, or all.\n\n"
+ "show port port_id (module_eeprom|eeprom)\n"
+ " Display the module EEPROM or EEPROM information for port_id.\n\n"
+
"show port X rss reta (size) (mask0,mask1,...)\n"
" Display the rss redirection table entry indicated"
" by masks on port X. size is used to indicate the"
"show (rxq|txq) info (port_id) (queue_id)\n"
" Display information for configured RX/TX queue.\n\n"
- "show config (rxtx|cores|fwd|txpkts)\n"
+ "show config (rxtx|cores|fwd|rxoffs|rxpkts|txpkts)\n"
" Display the given configuration.\n\n"
"read rxd (port_id) (queue_id) (rxd_id)\n"
"show port (port_id) macs|mcast_macs"
" Display list of mac addresses added to port.\n\n"
+
+ "show port (port_id) fec capabilities"
+ " Show fec capabilities of a port.\n\n"
+
+ "show port (port_id) fec_mode"
+ " Show fec mode of a port.\n\n"
);
}
" Set the transmit delay time and number of retries,"
" effective when retry is enabled.\n\n"
+ "set rxoffs (x[,y]*)\n"
+ " Set the offset of each packet segment on"
+ " receiving if split feature is engaged."
+ " Affects only the queues configured with split"
+ " offloads.\n\n"
+
+ "set rxpkts (x[,y]*)\n"
+ " Set the length of each segment to scatter"
+ " packets on receiving if split feature is engaged."
+ " Affects only the queues configured with split"
+ " offloads.\n\n"
+
"set txpkts (x[,y]*)\n"
" Set the length of each segment of TXONLY"
" and optionally CSUM packets.\n\n"
" Right now only applicable for CSUM and TXONLY"
" modes\n\n"
+ "set txtimes (x, y)\n"
+ " Set the scheduling on timestamps"
+ " timings for the TXONLY mode\n\n"
+
"set corelist (x[,y]*)\n"
" Set the list of forwarding cores.\n\n"
" Set the option to hide the zero values"
" for xstats display.\n"
+ "set record-core-cycles on|off\n"
+ " Set the option to enable measurement of CPU cycles.\n"
+
+ "set record-burst-stats on|off\n"
+ " Set the option to enable display of RX and TX bursts.\n"
+
"set port (port_id) vf (vf_id) rx|tx on|off\n"
" Enable/Disable a VF receive/tranmit from a port\n\n"
- "set port (port_id) vf (vf_id) (mac_addr)"
- " (exact-mac#exact-mac-vlan#hashmac|hashmac-vlan) on|off\n"
- " Add/Remove unicast or multicast MAC addr filter"
- " for a VF.\n\n"
-
"set port (port_id) vf (vf_id) rxmode (AUPE|ROPE|BAM"
"|MPE) (on|off)\n"
" AUPE:accepts untagged VLAN;"
" Show the bypass configuration for a bypass enabled NIC"
" using the lowest port on the NIC.\n\n"
-#ifdef RTE_LIBRTE_PMD_BOND
+#ifdef RTE_NET_BOND
"create bonded device (mode) (socket)\n"
" Create a new bonded device with specific bonding mode and socket.\n\n"
"set bonding mode IEEE802.3AD aggregator policy (port_id) (agg_name)"
" Set Aggregation mode for IEEE802.3AD (mode 4)"
- "set bonding xmit_balance_policy (port_id) (l2|l23|l34)\n"
+ "set bonding balance_xmit_policy (port_id) (l2|l23|l34)\n"
" Set the transmit balance policy for bonded device running in balance mode.\n\n"
"set bonding mon_period (port_id) (value)\n"
"show port (port_id) queue-region\n"
" show all queue region related configuration info\n\n"
+ "set port (port_id) fec_mode auto|off|rs|baser\n"
+ " set fec mode for a specific port\n\n"
+
, list_pkt_forwarding_modes()
);
}
"receive buffers available.\n\n"
"port config all rss (all|default|ip|tcp|udp|sctp|"
- "ether|port|vxlan|geneve|nvgre|vxlan-gpe|none|<flowtype_id>)\n"
+ "ether|port|vxlan|geneve|nvgre|vxlan-gpe|none|level-default|"
+ "level-outer|level-inner|<flowtype_id>)\n"
" Set the RSS mode.\n\n"
"port config port-id rss reta (hash,queue)[,(hash,queue)]\n"
"port config <port_id> rx_offload vlan_strip|"
"ipv4_cksum|udp_cksum|tcp_cksum|tcp_lro|qinq_strip|"
"outer_ipv4_cksum|macsec_strip|header_split|"
- "vlan_filter|vlan_extend|jumbo_frame|"
- "scatter|timestamp|security|keep_crc on|off\n"
+ "vlan_filter|vlan_extend|jumbo_frame|scatter|"
+ "buffer_split|timestamp|security|keep_crc on|off\n"
" Enable or disable a per port Rx offloading"
" on all Rx queues of a port\n\n"
"port (port_id) rxq (queue_id) rx_offload vlan_strip|"
"ipv4_cksum|udp_cksum|tcp_cksum|tcp_lro|qinq_strip|"
"outer_ipv4_cksum|macsec_strip|header_split|"
- "vlan_filter|vlan_extend|jumbo_frame|"
- "scatter|timestamp|security|keep_crc on|off\n"
+ "vlan_filter|vlan_extend|jumbo_frame|scatter|"
+ "buffer_split|timestamp|security|keep_crc on|off\n"
" Enable or disable a per queue Rx offloading"
" only on a specific Rx queue\n\n"
"filters:\n"
"--------\n\n"
- "ethertype_filter (port_id) (add|del)"
- " (mac_addr|mac_ignr) (mac_address) ethertype"
- " (ether_type) (drop|fwd) queue (queue_id)\n"
- " Add/Del an ethertype filter.\n\n"
-
"2tuple_filter (port_id) (add|del)"
" dst_port (dst_port_value) protocol (protocol_value)"
" mask (mask_value) tcp_flags (tcp_flags_value)"
"syn_filter (port_id) (add|del) priority (high|low) queue (queue_id)"
" Add/Del syn filter.\n\n"
- "flex_filter (port_id) (add|del) len (len_value)"
- " bytes (bytes_value) mask (mask_value)"
- " priority (prio_value) queue (queue_id)\n"
- " Add/Del a flex filter.\n\n"
-
"flow_director_filter (port_id) mode IP (add|del|update)"
" flow (ipv4-other|ipv4-frag|ipv6-other|ipv6-frag)"
" src (src_ip_address) dst (dst_ip_address)"
" List and destroy aged flows"
" flow rules\n\n"
+ "flow shared_action {port_id} create"
+ " [action_id {shared_action_id}]"
+ " [ingress] [egress]"
+ " action {action} / end\n"
+ " Create shared action.\n\n"
+
+ "flow shared_action {port_id} update"
+ " {shared_action_id} action {action} / end\n"
+ " Update shared action.\n\n"
+
+ "flow shared_action {port_id} destroy"
+ " action_id {shared_action_id} [...]\n"
+ " Destroy specific shared actions.\n\n"
+
+ "flow shared_action {port_id} query"
+ " {shared_action_id}\n"
+ " Query an existing shared action.\n\n"
+
"set vxlan ip-version (ipv4|ipv6) vni (vni) udp-src"
" (udp-src) udp-dst (udp-dst) ip-src (ip-src) ip-dst"
" (ip-dst) eth-src (eth-src) eth-dst (eth-dst)\n"
"show port tm node stats (port_id) (node_id) (clear)\n"
" Display the port TM node stats.\n\n"
-#if defined RTE_LIBRTE_PMD_SOFTNIC && defined RTE_LIBRTE_SCHED
- "set port tm hierarchy default (port_id)\n"
- " Set default traffic Management hierarchy on a port\n\n"
-#endif
-
"add port tm node shaper profile (port_id) (shaper_profile_id)"
" (cmit_tb_rate) (cmit_tb_size) (peak_tb_rate) (peak_tb_size)"
- " (packet_length_adjust)\n"
+ " (packet_length_adjust) (packet_mode)\n"
" Add port tm node private shaper profile.\n\n"
"del port tm node shaper profile (port_id) (shaper_profile_id)\n"
" [(shared_shaper_id_0) (shared_shaper_id_1)...]\n"
" Add port tm nonleaf node.\n\n"
+ "add port tm nonleaf node pktmode (port_id) (node_id) (parent_node_id)"
+ " (priority) (weight) (level_id) (shaper_profile_id)"
+ " (n_sp_priorities) (stats_mask) (n_shared_shapers)"
+ " [(shared_shaper_id_0) (shared_shaper_id_1)...]\n"
+ " Add port tm nonleaf node with pkt mode enabled.\n\n"
+
"add port tm leaf node (port_id) (node_id) (parent_node_id)"
" (priority) (weight) (level_id) (shaper_profile_id)"
" (cman_mode) (wred_profile_id) (stats_mask) (n_shared_shapers)"
rss_conf.rss_hf = 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_AH | ETH_RSS_PFCP | ETH_RSS_GTPU;
else if (!strcmp(res->value, "eth"))
rss_conf.rss_hf = ETH_RSS_ETH;
else if (!strcmp(res->value, "vlan"))
rss_conf.rss_hf = ETH_RSS_GENEVE;
else if (!strcmp(res->value, "nvgre"))
rss_conf.rss_hf = ETH_RSS_NVGRE;
+ else if (!strcmp(res->value, "l3-pre32"))
+ rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE32;
+ else if (!strcmp(res->value, "l3-pre40"))
+ rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE40;
+ else if (!strcmp(res->value, "l3-pre48"))
+ rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE48;
+ else if (!strcmp(res->value, "l3-pre56"))
+ rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE56;
+ else if (!strcmp(res->value, "l3-pre64"))
+ rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE64;
+ else if (!strcmp(res->value, "l3-pre96"))
+ rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE96;
else if (!strcmp(res->value, "l3-src-only"))
rss_conf.rss_hf = ETH_RSS_L3_SRC_ONLY;
else if (!strcmp(res->value, "l3-dst-only"))
rss_conf.rss_hf = ETH_RSS_AH;
else if (!strcmp(res->value, "pfcp"))
rss_conf.rss_hf = ETH_RSS_PFCP;
+ else if (!strcmp(res->value, "pppoe"))
+ rss_conf.rss_hf = ETH_RSS_PPPOE;
+ else if (!strcmp(res->value, "gtpu"))
+ rss_conf.rss_hf = ETH_RSS_GTPU;
else if (!strcmp(res->value, "none"))
rss_conf.rss_hf = 0;
- else if (!strcmp(res->value, "default"))
+ else if (!strcmp(res->value, "level-default")) {
+ rss_hf &= (~ETH_RSS_LEVEL_MASK);
+ rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_PMD_DEFAULT);
+ } else if (!strcmp(res->value, "level-outer")) {
+ rss_hf &= (~ETH_RSS_LEVEL_MASK);
+ rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_OUTERMOST);
+ } else if (!strcmp(res->value, "level-inner")) {
+ rss_hf &= (~ETH_RSS_LEVEL_MASK);
+ rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_INNERMOST);
+ } else if (!strcmp(res->value, "default"))
use_default = 1;
else if (isdigit(res->value[0]) && atoi(res->value) > 0 &&
atoi(res->value) < 64)
.data = NULL,
.help_str = "port config all rss "
"all|default|eth|vlan|ip|tcp|udp|sctp|ether|port|vxlan|geneve|"
- "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|none|<flowtype_id>",
+ "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|none|level-default|"
+ "level-outer|level-inner|<flowtype_id>",
.tokens = {
(void *)&cmd_config_rss_port,
(void *)&cmd_config_rss_keyword,
"ipv6-tcp-ex#ipv6-udp-ex#"
"l3-src-only#l3-dst-only#l4-src-only#l4-dst-only#"
"l2-src-only#l2-dst-only#s-vlan#c-vlan#"
- "l2tpv3#esp#ah#pfcp");
+ "l2tpv3#esp#ah#pfcp#pppoe#gtpu");
cmdline_parse_token_string_t cmd_config_rss_hash_key_value =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, key, NULL);
"l2-payload|ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex|"
"l3-src-only|l3-dst-only|l4-src-only|l4-dst-only|"
"l2-src-only|l2-dst-only|s-vlan|c-vlan|"
- "l2tpv3|esp|ah|pfcp "
+ "l2tpv3|esp|ah|pfcp|pppoe|gtpu "
"<string of hex digits (variable length, NIC dependent)>",
.tokens = {
(void *)&cmd_config_rss_hash_key_port,
if (!numa_support || socket_id == NUMA_NO_CONFIG)
socket_id = port->socket_id;
- mp = mbuf_pool_find(socket_id);
+ mp = mbuf_pool_find(socket_id, 0);
if (mp == NULL) {
printf("Failed to setup RX queue: "
"No mempool allocation"
rxring_numa[res->portid]);
return;
}
- ret = rte_eth_rx_queue_setup(res->portid,
- res->qid,
- port->nb_rx_desc[res->qid],
- socket_id,
- &port->rx_conf[res->qid],
- mp);
+ ret = rx_queue_setup(res->portid,
+ res->qid,
+ port->nb_rx_desc[res->qid],
+ socket_id,
+ &port->rx_conf[res->qid],
+ mp);
if (ret)
printf("Failed to setup RX queue\n");
} else {
},
};
+/* *** SET SEGMENT OFFSETS OF RX PACKETS SPLIT *** */
+
+struct cmd_set_rxoffs_result {
+ cmdline_fixed_string_t cmd_keyword;
+ cmdline_fixed_string_t rxoffs;
+ cmdline_fixed_string_t seg_offsets;
+};
+
+static void
+cmd_set_rxoffs_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_rxoffs_result *res;
+ unsigned int seg_offsets[MAX_SEGS_BUFFER_SPLIT];
+ unsigned int nb_segs;
+
+ res = parsed_result;
+ nb_segs = parse_item_list(res->seg_offsets, "segment offsets",
+ MAX_SEGS_BUFFER_SPLIT, seg_offsets, 0);
+ if (nb_segs > 0)
+ set_rx_pkt_offsets(seg_offsets, nb_segs);
+}
+
+cmdline_parse_token_string_t cmd_set_rxoffs_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result,
+ cmd_keyword, "set");
+cmdline_parse_token_string_t cmd_set_rxoffs_name =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result,
+ rxoffs, "rxoffs");
+cmdline_parse_token_string_t cmd_set_rxoffs_offsets =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result,
+ seg_offsets, NULL);
+
+cmdline_parse_inst_t cmd_set_rxoffs = {
+ .f = cmd_set_rxoffs_parsed,
+ .data = NULL,
+ .help_str = "set rxoffs <len0[,len1]*>",
+ .tokens = {
+ (void *)&cmd_set_rxoffs_keyword,
+ (void *)&cmd_set_rxoffs_name,
+ (void *)&cmd_set_rxoffs_offsets,
+ NULL,
+ },
+};
+
+/* *** SET SEGMENT LENGTHS OF RX PACKETS SPLIT *** */
+
+struct cmd_set_rxpkts_result {
+ cmdline_fixed_string_t cmd_keyword;
+ cmdline_fixed_string_t rxpkts;
+ cmdline_fixed_string_t seg_lengths;
+};
+
+static void
+cmd_set_rxpkts_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_rxpkts_result *res;
+ unsigned int seg_lengths[MAX_SEGS_BUFFER_SPLIT];
+ unsigned int nb_segs;
+
+ res = parsed_result;
+ nb_segs = parse_item_list(res->seg_lengths, "segment lengths",
+ MAX_SEGS_BUFFER_SPLIT, seg_lengths, 0);
+ if (nb_segs > 0)
+ set_rx_pkt_segments(seg_lengths, nb_segs);
+}
+
+cmdline_parse_token_string_t cmd_set_rxpkts_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result,
+ cmd_keyword, "set");
+cmdline_parse_token_string_t cmd_set_rxpkts_name =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result,
+ rxpkts, "rxpkts");
+cmdline_parse_token_string_t cmd_set_rxpkts_lengths =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result,
+ seg_lengths, NULL);
+
+cmdline_parse_inst_t cmd_set_rxpkts = {
+ .f = cmd_set_rxpkts_parsed,
+ .data = NULL,
+ .help_str = "set rxpkts <len0[,len1]*>",
+ .tokens = {
+ (void *)&cmd_set_rxpkts_keyword,
+ (void *)&cmd_set_rxpkts_name,
+ (void *)&cmd_set_rxpkts_lengths,
+ NULL,
+ },
+};
+
/* *** SET SEGMENT LENGTHS OF TXONLY PACKETS *** */
struct cmd_set_txpkts_result {
},
};
+/* *** SET TIMES FOR TXONLY PACKETS SCHEDULING ON TIMESTAMPS *** */
+
+struct cmd_set_txtimes_result {
+ cmdline_fixed_string_t cmd_keyword;
+ cmdline_fixed_string_t txtimes;
+ cmdline_fixed_string_t tx_times;
+};
+
+static void
+cmd_set_txtimes_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_txtimes_result *res;
+ unsigned int tx_times[2] = {0, 0};
+ unsigned int n_times;
+
+ res = parsed_result;
+ n_times = parse_item_list(res->tx_times, "tx times",
+ 2, tx_times, 0);
+ if (n_times == 2)
+ set_tx_pkt_times(tx_times);
+}
+
+cmdline_parse_token_string_t cmd_set_txtimes_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_txtimes_result,
+ cmd_keyword, "set");
+cmdline_parse_token_string_t cmd_set_txtimes_name =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_txtimes_result,
+ txtimes, "txtimes");
+cmdline_parse_token_string_t cmd_set_txtimes_value =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_txtimes_result,
+ tx_times, NULL);
+
+cmdline_parse_inst_t cmd_set_txtimes = {
+ .f = cmd_set_txtimes_parsed,
+ .data = NULL,
+ .help_str = "set txtimes <inter_burst>,<intra_burst>",
+ .tokens = {
+ (void *)&cmd_set_txtimes_keyword,
+ (void *)&cmd_set_txtimes_name,
+ (void *)&cmd_set_txtimes_value,
+ NULL,
+ },
+};
+
/* *** ADD/REMOVE ALL VLAN IDENTIFIERS TO/FROM A PORT VLAN RX FILTER *** */
struct cmd_rx_vlan_filter_all_result {
cmdline_fixed_string_t rx_vlan;
{
struct cmd_tx_vlan_set_result *res = parsed_result;
+ if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+ return;
+
if (!port_is_stopped(res->port_id)) {
printf("Please stop port %d first\n", res->port_id);
return;
{
struct cmd_tx_vlan_set_qinq_result *res = parsed_result;
+ if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+ return;
+
if (!port_is_stopped(res->port_id)) {
printf("Please stop port %d first\n", res->port_id);
return;
{
struct cmd_tx_vlan_reset_result *res = parsed_result;
+ if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+ return;
+
if (!port_is_stopped(res->port_id)) {
printf("Please stop port %d first\n", res->port_id);
return;
portid_t port_id = res->port_id;
int32_t rc = -EINVAL;
-#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS
+#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS
uint32_t bypass_mode = RTE_PMD_IXGBE_BYPASS_MODE_NORMAL;
if (!strcmp(res->value, "bypass"))
struct cmd_set_bypass_event_result *res = parsed_result;
portid_t port_id = res->port_id;
-#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS
+#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS
uint32_t bypass_event = RTE_PMD_IXGBE_BYPASS_EVENT_NONE;
uint32_t bypass_mode = RTE_PMD_IXGBE_BYPASS_MODE_NORMAL;
{
__rte_unused struct cmd_set_bypass_timeout_result *res = parsed_result;
-#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS
+#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS
if (!strcmp(res->value, "1.5"))
bypass_timeout = RTE_PMD_IXGBE_BYPASS_TMT_1_5_SEC;
else if (!strcmp(res->value, "2"))
struct cmd_show_bypass_config_result *res = parsed_result;
portid_t port_id = res->port_id;
int rc = -EINVAL;
-#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS
+#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS
uint32_t event_mode;
uint32_t bypass_mode;
uint32_t timeout = bypass_timeout;
},
};
-#ifdef RTE_LIBRTE_PMD_BOND
+#ifdef RTE_NET_BOND
/* *** SET BONDING MODE *** */
struct cmd_set_bonding_mode_result {
cmdline_fixed_string_t set;
};
-#endif /* RTE_LIBRTE_PMD_BOND */
+#endif /* RTE_NET_BOND */
/* *** SET FORWARDING MODE *** */
struct cmd_set_fwd_mode_result {
fwd_lcores_config_display();
else if (!strcmp(res->what, "fwd"))
pkt_fwd_config_display(&cur_fwd_config);
+ else if (!strcmp(res->what, "rxoffs"))
+ show_rx_pkt_offsets();
+ else if (!strcmp(res->what, "rxpkts"))
+ show_rx_pkt_segments();
else if (!strcmp(res->what, "txpkts"))
show_tx_pkt_segments();
+ else if (!strcmp(res->what, "txtimes"))
+ show_tx_pkt_times();
}
cmdline_parse_token_string_t cmd_showcfg_show =
TOKEN_STRING_INITIALIZER(struct cmd_showcfg_result, cfg, "config");
cmdline_parse_token_string_t cmd_showcfg_what =
TOKEN_STRING_INITIALIZER(struct cmd_showcfg_result, what,
- "rxtx#cores#fwd#txpkts");
+ "rxtx#cores#fwd#rxoffs#rxpkts#txpkts#txtimes");
cmdline_parse_inst_t cmd_showcfg = {
.f = cmd_showcfg_parsed,
.data = NULL,
- .help_str = "show config rxtx|cores|fwd|txpkts",
+ .help_str = "show config rxtx|cores|fwd|rxoffs|rxpkts|txpkts|txtimes",
.tokens = {
(void *)&cmd_showcfg_show,
(void *)&cmd_showcfg_port,
NULL,
},
};
+
+/* *** SHOW MODULE EEPROM/EEPROM port INFO *** */
+struct cmd_showeeprom_result {
+ cmdline_fixed_string_t show;
+ cmdline_fixed_string_t port;
+ uint16_t portnum;
+ cmdline_fixed_string_t type;
+};
+
+static void cmd_showeeprom_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_showeeprom_result *res = parsed_result;
+
+ if (!strcmp(res->type, "eeprom"))
+ port_eeprom_display(res->portnum);
+ else if (!strcmp(res->type, "module_eeprom"))
+ port_module_eeprom_display(res->portnum);
+ else
+ printf("Unknown argument\n");
+}
+
+cmdline_parse_token_string_t cmd_showeeprom_show =
+ TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, show, "show");
+cmdline_parse_token_string_t cmd_showeeprom_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, port, "port");
+cmdline_parse_token_num_t cmd_showeeprom_portnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_showeeprom_result, portnum, UINT16);
+cmdline_parse_token_string_t cmd_showeeprom_type =
+ TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, type, "module_eeprom#eeprom");
+
+cmdline_parse_inst_t cmd_showeeprom = {
+ .f = cmd_showeeprom_parsed,
+ .data = NULL,
+ .help_str = "show port <port_id> module_eeprom|eeprom",
+ .tokens = {
+ (void *)&cmd_showeeprom_show,
+ (void *)&cmd_showeeprom_port,
+ (void *)&cmd_showeeprom_portnum,
+ (void *)&cmd_showeeprom_type,
+ NULL,
+ },
+};
+
/* *** SHOW QUEUE INFO *** */
struct cmd_showqueue_result {
cmdline_fixed_string_t show;
},
};
+/* *** SET OPTION TO ENABLE MEASUREMENT OF CPU CYCLES *** */
+struct cmd_set_record_core_cycles_result {
+ cmdline_fixed_string_t keyword;
+ cmdline_fixed_string_t name;
+ cmdline_fixed_string_t on_off;
+};
+
+static void
+cmd_set_record_core_cycles_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_record_core_cycles_result *res;
+ uint16_t on_off = 0;
+
+ res = parsed_result;
+ on_off = !strcmp(res->on_off, "on") ? 1 : 0;
+ set_record_core_cycles(on_off);
+}
+
+cmdline_parse_token_string_t cmd_set_record_core_cycles_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result,
+ keyword, "set");
+cmdline_parse_token_string_t cmd_set_record_core_cycles_name =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result,
+ name, "record-core-cycles");
+cmdline_parse_token_string_t cmd_set_record_core_cycles_on_off =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result,
+ on_off, "on#off");
+
+cmdline_parse_inst_t cmd_set_record_core_cycles = {
+ .f = cmd_set_record_core_cycles_parsed,
+ .data = NULL,
+ .help_str = "set record-core-cycles on|off",
+ .tokens = {
+ (void *)&cmd_set_record_core_cycles_keyword,
+ (void *)&cmd_set_record_core_cycles_name,
+ (void *)&cmd_set_record_core_cycles_on_off,
+ NULL,
+ },
+};
+
+/* *** SET OPTION TO ENABLE DISPLAY OF RX AND TX BURSTS *** */
+struct cmd_set_record_burst_stats_result {
+ cmdline_fixed_string_t keyword;
+ cmdline_fixed_string_t name;
+ cmdline_fixed_string_t on_off;
+};
+
+static void
+cmd_set_record_burst_stats_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_record_burst_stats_result *res;
+ uint16_t on_off = 0;
+
+ res = parsed_result;
+ on_off = !strcmp(res->on_off, "on") ? 1 : 0;
+ set_record_burst_stats(on_off);
+}
+
+cmdline_parse_token_string_t cmd_set_record_burst_stats_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_record_burst_stats_result,
+ keyword, "set");
+cmdline_parse_token_string_t cmd_set_record_burst_stats_name =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_record_burst_stats_result,
+ name, "record-burst-stats");
+cmdline_parse_token_string_t cmd_set_record_burst_stats_on_off =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_record_burst_stats_result,
+ on_off, "on#off");
+
+cmdline_parse_inst_t cmd_set_record_burst_stats = {
+ .f = cmd_set_record_burst_stats_parsed,
+ .data = NULL,
+ .help_str = "set record-burst-stats on|off",
+ .tokens = {
+ (void *)&cmd_set_record_burst_stats_keyword,
+ (void *)&cmd_set_record_burst_stats_name,
+ (void *)&cmd_set_record_burst_stats_on_off,
+ NULL,
+ },
+};
+
/* *** CONFIGURE UNICAST HASH TABLE *** */
struct cmd_set_uc_hash_table {
cmdline_fixed_string_t set;
},
};
-/* *** CONFIGURE MACVLAN FILTER FOR VF(s) *** */
-struct cmd_set_vf_macvlan_filter {
- cmdline_fixed_string_t set;
- cmdline_fixed_string_t port;
- portid_t port_id;
- cmdline_fixed_string_t vf;
- uint8_t vf_id;
- struct rte_ether_addr address;
- cmdline_fixed_string_t filter_type;
- cmdline_fixed_string_t mode;
-};
-
-static void
-cmd_set_vf_macvlan_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- int is_on, ret = 0;
- struct cmd_set_vf_macvlan_filter *res = parsed_result;
- struct rte_eth_mac_filter filter;
-
- memset(&filter, 0, sizeof(struct rte_eth_mac_filter));
-
- rte_memcpy(&filter.mac_addr, &res->address, RTE_ETHER_ADDR_LEN);
-
- /* set VF MAC filter */
- filter.is_vf = 1;
-
- /* set VF ID */
- filter.dst_id = res->vf_id;
-
- if (!strcmp(res->filter_type, "exact-mac"))
- filter.filter_type = RTE_MAC_PERFECT_MATCH;
- else if (!strcmp(res->filter_type, "exact-mac-vlan"))
- filter.filter_type = RTE_MACVLAN_PERFECT_MATCH;
- else if (!strcmp(res->filter_type, "hashmac"))
- filter.filter_type = RTE_MAC_HASH_MATCH;
- else if (!strcmp(res->filter_type, "hashmac-vlan"))
- filter.filter_type = RTE_MACVLAN_HASH_MATCH;
-
- is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0;
-
- if (is_on)
- ret = rte_eth_dev_filter_ctrl(res->port_id,
- RTE_ETH_FILTER_MACVLAN,
- RTE_ETH_FILTER_ADD,
- &filter);
- else
- ret = rte_eth_dev_filter_ctrl(res->port_id,
- RTE_ETH_FILTER_MACVLAN,
- RTE_ETH_FILTER_DELETE,
- &filter);
-
- if (ret < 0)
- printf("bad set MAC hash parameter, return code = %d\n", ret);
-
-}
-
-cmdline_parse_token_string_t cmd_set_vf_macvlan_set =
- TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter,
- set, "set");
-cmdline_parse_token_string_t cmd_set_vf_macvlan_port =
- TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter,
- port, "port");
-cmdline_parse_token_num_t cmd_set_vf_macvlan_portid =
- TOKEN_NUM_INITIALIZER(struct cmd_set_vf_macvlan_filter,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_vf_macvlan_vf =
- TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter,
- vf, "vf");
-cmdline_parse_token_num_t cmd_set_vf_macvlan_vf_id =
- TOKEN_NUM_INITIALIZER(struct cmd_set_vf_macvlan_filter,
- vf_id, UINT8);
-cmdline_parse_token_etheraddr_t cmd_set_vf_macvlan_mac =
- TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vf_macvlan_filter,
- address);
-cmdline_parse_token_string_t cmd_set_vf_macvlan_filter_type =
- TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter,
- filter_type, "exact-mac#exact-mac-vlan"
- "#hashmac#hashmac-vlan");
-cmdline_parse_token_string_t cmd_set_vf_macvlan_mode =
- TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter,
- mode, "on#off");
-
-cmdline_parse_inst_t cmd_set_vf_macvlan_filter = {
- .f = cmd_set_vf_macvlan_parsed,
- .data = NULL,
- .help_str = "set port <port_id> vf <vf_id> <mac_addr> "
- "exact-mac|exact-mac-vlan|hashmac|hashmac-vlan on|off: "
- "Exact match rule: exact match of MAC or MAC and VLAN; "
- "hash match rule: hash match of MAC and exact match of VLAN",
- .tokens = {
- (void *)&cmd_set_vf_macvlan_set,
- (void *)&cmd_set_vf_macvlan_port,
- (void *)&cmd_set_vf_macvlan_portid,
- (void *)&cmd_set_vf_macvlan_vf,
- (void *)&cmd_set_vf_macvlan_vf_id,
- (void *)&cmd_set_vf_macvlan_mac,
- (void *)&cmd_set_vf_macvlan_filter_type,
- (void *)&cmd_set_vf_macvlan_mode,
- NULL,
- },
-};
-
/* *** CONFIGURE VF TRAFFIC CONTROL *** */
struct cmd_set_vf_traffic {
cmdline_fixed_string_t set;
RTE_SET_USED(is_on);
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
if (ret == -ENOTSUP)
ret = rte_pmd_ixgbe_set_vf_rxmode(res->port_id, res->vf_id,
vf_rxmode, (uint8_t)is_on);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_set_vf_rxmode(res->port_id, res->vf_id,
vf_rxmode, (uint8_t)is_on);
if (strcmp(res->what, "add") != 0)
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_add_vf_mac_addr(res->port_num, res->vf_num,
&res->address);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_mac_addr_add(res->port_num, &res->address,
res->vf_num);
__rte_unused int is_add = (strcmp(res->what, "add") == 0) ? 1 : 0;
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
if (ret == -ENOTSUP)
ret = rte_pmd_ixgbe_set_vf_vlan_filter(res->port_id,
res->vlan_id, res->vf_mask, is_add);
#endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_set_vf_vlan_filter(res->port_id,
res->vlan_id, res->vf_mask, is_add);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_set_vf_vlan_filter(res->port_id,
res->vlan_id, res->vf_mask, is_add);
conf.cfg.gre_key_len = res->len;
ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_NONE,
RTE_ETH_FILTER_SET, &conf);
+#ifdef RTE_NET_I40E
+ if (ret == -ENOTSUP)
+ ret = rte_pmd_i40e_set_gre_key_len(res->port_id, res->len);
+#endif
if (ret != 0)
printf("Global config error\n");
}
{
struct cmd_queue_region_result *res = parsed_result;
int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct rte_pmd_i40e_queue_region_conf region_conf;
enum rte_pmd_i40e_queue_region_op op_type;
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
memset(®ion_conf, 0, sizeof(region_conf));
op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_SET;
region_conf.region_id = res->region_id;
{
struct cmd_region_flowtype_result *res = parsed_result;
int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct rte_pmd_i40e_queue_region_conf region_conf;
enum rte_pmd_i40e_queue_region_op op_type;
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
memset(®ion_conf, 0, sizeof(region_conf));
op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_FLOWTYPE_SET;
{
struct cmd_user_priority_region_result *res = parsed_result;
int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct rte_pmd_i40e_queue_region_conf region_conf;
enum rte_pmd_i40e_queue_region_op op_type;
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
memset(®ion_conf, 0, sizeof(region_conf));
op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_USER_PRIORITY_SET;
region_conf.user_priority = res->user_priority_id;
{
struct cmd_flush_queue_region_result *res = parsed_result;
int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct rte_pmd_i40e_queue_region_conf region_conf;
enum rte_pmd_i40e_queue_region_op op_type;
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
memset(®ion_conf, 0, sizeof(region_conf));
if (strcmp(res->what, "on") == 0)
{
struct cmd_show_queue_region_info *res = parsed_result;
int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct rte_pmd_i40e_queue_regions rte_pmd_regions;
enum rte_pmd_i40e_queue_region_op op_type;
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
memset(&rte_pmd_regions, 0, sizeof(rte_pmd_regions));
op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_INFO_GET;
},
};
-/* *** ADD/REMOVE A flex FILTER *** */
-struct cmd_flex_filter_result {
- cmdline_fixed_string_t filter;
- cmdline_fixed_string_t ops;
- portid_t port_id;
- cmdline_fixed_string_t len;
- uint8_t len_value;
- cmdline_fixed_string_t bytes;
- cmdline_fixed_string_t bytes_value;
- cmdline_fixed_string_t mask;
- cmdline_fixed_string_t mask_value;
- cmdline_fixed_string_t priority;
- uint8_t priority_value;
- cmdline_fixed_string_t queue;
- uint16_t queue_id;
-};
-
-static int xdigit2val(unsigned char c)
-{
- int val;
- if (isdigit(c))
- val = c - '0';
- else if (isupper(c))
- val = c - 'A' + 10;
- else
- val = c - 'a' + 10;
- return val;
-}
-
-static void
-cmd_flex_filter_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- int ret = 0;
- struct rte_eth_flex_filter filter;
- struct cmd_flex_filter_result *res = parsed_result;
- char *bytes_ptr, *mask_ptr;
- uint16_t len, i, j = 0;
- char c;
- int val;
- uint8_t byte = 0;
-
- if (res->len_value > RTE_FLEX_FILTER_MAXLEN) {
- printf("the len exceed the max length 128\n");
- return;
- }
- memset(&filter, 0, sizeof(struct rte_eth_flex_filter));
- filter.len = res->len_value;
- filter.priority = res->priority_value;
- filter.queue = res->queue_id;
- bytes_ptr = res->bytes_value;
- mask_ptr = res->mask_value;
-
- /* translate bytes string to array. */
- if (bytes_ptr[0] == '0' && ((bytes_ptr[1] == 'x') ||
- (bytes_ptr[1] == 'X')))
- bytes_ptr += 2;
- len = strnlen(bytes_ptr, res->len_value * 2);
- if (len == 0 || (len % 8 != 0)) {
- printf("please check len and bytes input\n");
- return;
- }
- for (i = 0; i < len; i++) {
- c = bytes_ptr[i];
- if (isxdigit(c) == 0) {
- /* invalid characters. */
- printf("invalid input\n");
- return;
- }
- val = xdigit2val(c);
- if (i % 2) {
- byte |= val;
- filter.bytes[j] = byte;
- printf("bytes[%d]:%02x ", j, filter.bytes[j]);
- j++;
- byte = 0;
- } else
- byte |= val << 4;
- }
- printf("\n");
- /* translate mask string to uint8_t array. */
- if (mask_ptr[0] == '0' && ((mask_ptr[1] == 'x') ||
- (mask_ptr[1] == 'X')))
- mask_ptr += 2;
- len = strnlen(mask_ptr, (res->len_value + 3) / 4);
- if (len == 0) {
- printf("invalid input\n");
- return;
- }
- j = 0;
- byte = 0;
- for (i = 0; i < len; i++) {
- c = mask_ptr[i];
- if (isxdigit(c) == 0) {
- /* invalid characters. */
- printf("invalid input\n");
- return;
- }
- val = xdigit2val(c);
- if (i % 2) {
- byte |= val;
- filter.mask[j] = byte;
- printf("mask[%d]:%02x ", j, filter.mask[j]);
- j++;
- byte = 0;
- } else
- byte |= val << 4;
- }
- printf("\n");
-
- if (!strcmp(res->ops, "add"))
- ret = rte_eth_dev_filter_ctrl(res->port_id,
- RTE_ETH_FILTER_FLEXIBLE,
- RTE_ETH_FILTER_ADD,
- &filter);
- else
- ret = rte_eth_dev_filter_ctrl(res->port_id,
- RTE_ETH_FILTER_FLEXIBLE,
- RTE_ETH_FILTER_DELETE,
- &filter);
-
- if (ret < 0)
- printf("flex filter setting error: (%s)\n", strerror(-ret));
-}
-
-cmdline_parse_token_string_t cmd_flex_filter_filter =
- TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
- filter, "flex_filter");
-cmdline_parse_token_num_t cmd_flex_filter_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_flex_filter_ops =
- TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
- ops, "add#del");
-cmdline_parse_token_string_t cmd_flex_filter_len =
- TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
- len, "len");
-cmdline_parse_token_num_t cmd_flex_filter_len_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
- len_value, UINT8);
-cmdline_parse_token_string_t cmd_flex_filter_bytes =
- TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
- bytes, "bytes");
-cmdline_parse_token_string_t cmd_flex_filter_bytes_value =
- TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
- bytes_value, NULL);
-cmdline_parse_token_string_t cmd_flex_filter_mask =
- TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
- mask, "mask");
-cmdline_parse_token_string_t cmd_flex_filter_mask_value =
- TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
- mask_value, NULL);
-cmdline_parse_token_string_t cmd_flex_filter_priority =
- TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
- priority, "priority");
-cmdline_parse_token_num_t cmd_flex_filter_priority_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
- priority_value, UINT8);
-cmdline_parse_token_string_t cmd_flex_filter_queue =
- TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
- queue, "queue");
-cmdline_parse_token_num_t cmd_flex_filter_queue_id =
- TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
- queue_id, UINT16);
-cmdline_parse_inst_t cmd_flex_filter = {
- .f = cmd_flex_filter_parsed,
- .data = NULL,
- .help_str = "flex_filter <port_id> add|del len <value> bytes "
- "<value> mask <value> priority <value> queue <queue_id>: "
- "Add/Del a flex filter",
- .tokens = {
- (void *)&cmd_flex_filter_filter,
- (void *)&cmd_flex_filter_port_id,
- (void *)&cmd_flex_filter_ops,
- (void *)&cmd_flex_filter_len,
- (void *)&cmd_flex_filter_len_value,
- (void *)&cmd_flex_filter_bytes,
- (void *)&cmd_flex_filter_bytes_value,
- (void *)&cmd_flex_filter_mask,
- (void *)&cmd_flex_filter_mask_value,
- (void *)&cmd_flex_filter_priority,
- (void *)&cmd_flex_filter_priority_value,
- (void *)&cmd_flex_filter_queue,
- (void *)&cmd_flex_filter_queue_id,
- NULL,
- },
-};
-
/* *** Filters Control *** */
-/* *** deal with ethertype filter *** */
-struct cmd_ethertype_filter_result {
- cmdline_fixed_string_t filter;
- portid_t port_id;
- cmdline_fixed_string_t ops;
- cmdline_fixed_string_t mac;
- struct rte_ether_addr mac_addr;
- cmdline_fixed_string_t ethertype;
- uint16_t ethertype_value;
- cmdline_fixed_string_t drop;
- cmdline_fixed_string_t queue;
- uint16_t queue_id;
-};
-
-cmdline_parse_token_string_t cmd_ethertype_filter_filter =
- TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
- filter, "ethertype_filter");
-cmdline_parse_token_num_t cmd_ethertype_filter_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_ethertype_filter_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_ethertype_filter_ops =
- TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
- ops, "add#del");
-cmdline_parse_token_string_t cmd_ethertype_filter_mac =
- TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
- mac, "mac_addr#mac_ignr");
-cmdline_parse_token_etheraddr_t cmd_ethertype_filter_mac_addr =
- TOKEN_ETHERADDR_INITIALIZER(struct cmd_ethertype_filter_result,
- mac_addr);
-cmdline_parse_token_string_t cmd_ethertype_filter_ethertype =
- TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
- ethertype, "ethertype");
-cmdline_parse_token_num_t cmd_ethertype_filter_ethertype_value =
- TOKEN_NUM_INITIALIZER(struct cmd_ethertype_filter_result,
- ethertype_value, UINT16);
-cmdline_parse_token_string_t cmd_ethertype_filter_drop =
- TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
- drop, "drop#fwd");
-cmdline_parse_token_string_t cmd_ethertype_filter_queue =
- TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
- queue, "queue");
-cmdline_parse_token_num_t cmd_ethertype_filter_queue_id =
- TOKEN_NUM_INITIALIZER(struct cmd_ethertype_filter_result,
- queue_id, UINT16);
-
-static void
-cmd_ethertype_filter_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_ethertype_filter_result *res = parsed_result;
- struct rte_eth_ethertype_filter filter;
- int ret = 0;
-
- ret = rte_eth_dev_filter_supported(res->port_id,
- RTE_ETH_FILTER_ETHERTYPE);
- if (ret < 0) {
- printf("ethertype filter is not supported on port %u.\n",
- res->port_id);
- return;
- }
-
- memset(&filter, 0, sizeof(filter));
- if (!strcmp(res->mac, "mac_addr")) {
- filter.flags |= RTE_ETHTYPE_FLAGS_MAC;
- rte_memcpy(&filter.mac_addr, &res->mac_addr,
- sizeof(struct rte_ether_addr));
- }
- if (!strcmp(res->drop, "drop"))
- filter.flags |= RTE_ETHTYPE_FLAGS_DROP;
- filter.ether_type = res->ethertype_value;
- filter.queue = res->queue_id;
-
- if (!strcmp(res->ops, "add"))
- ret = rte_eth_dev_filter_ctrl(res->port_id,
- RTE_ETH_FILTER_ETHERTYPE,
- RTE_ETH_FILTER_ADD,
- &filter);
- else
- ret = rte_eth_dev_filter_ctrl(res->port_id,
- RTE_ETH_FILTER_ETHERTYPE,
- RTE_ETH_FILTER_DELETE,
- &filter);
- if (ret < 0)
- printf("ethertype filter programming error: (%s)\n",
- strerror(-ret));
-}
-
-cmdline_parse_inst_t cmd_ethertype_filter = {
- .f = cmd_ethertype_filter_parsed,
- .data = NULL,
- .help_str = "ethertype_filter <port_id> add|del mac_addr|mac_ignr "
- "<mac_addr> ethertype <value> drop|fw queue <queue_id>: "
- "Add or delete an ethertype filter entry",
- .tokens = {
- (void *)&cmd_ethertype_filter_filter,
- (void *)&cmd_ethertype_filter_port_id,
- (void *)&cmd_ethertype_filter_ops,
- (void *)&cmd_ethertype_filter_mac,
- (void *)&cmd_ethertype_filter_mac_addr,
- (void *)&cmd_ethertype_filter_ethertype,
- (void *)&cmd_ethertype_filter_ethertype_value,
- (void *)&cmd_ethertype_filter_drop,
- (void *)&cmd_ethertype_filter_queue,
- (void *)&cmd_ethertype_filter_queue_id,
- NULL,
- },
-};
-
/* *** deal with flow director filter *** */
struct cmd_flow_director_result {
cmdline_fixed_string_t flow_director_filter;
}
} else {
if (!strcmp(res->mode_value, "raw")) {
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct rte_pmd_i40e_flow_type_mapping
mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
struct rte_pmd_i40e_pkt_template_conf conf;
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
if (ret == -ENOTSUP)
ret = rte_pmd_ixgbe_set_vf_vlan_anti_spoof(res->port_id,
res->vf_id, is_on);
#endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_set_vf_vlan_anti_spoof(res->port_id,
res->vf_id, is_on);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_set_vf_vlan_anti_spoof(res->port_id,
res->vf_id, is_on);
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
if (ret == -ENOTSUP)
ret = rte_pmd_ixgbe_set_vf_mac_anti_spoof(res->port_id,
res->vf_id, is_on);
#endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_set_vf_mac_anti_spoof(res->port_id,
res->vf_id, is_on);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_set_vf_mac_anti_spoof(res->port_id,
res->vf_id, is_on);
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
if (ret == -ENOTSUP)
ret = rte_pmd_ixgbe_set_vf_vlan_stripq(res->port_id,
res->vf_id, is_on);
#endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_set_vf_vlan_stripq(res->port_id,
res->vf_id, is_on);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_set_vf_vlan_stripq(res->port_id,
res->vf_id, is_on);
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
if (ret == -ENOTSUP)
ret = rte_pmd_ixgbe_set_vf_vlan_insert(res->port_id, res->vf_id,
res->vlan_id);
#endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_set_vf_vlan_insert(res->port_id, res->vf_id,
res->vlan_id);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_set_vf_vlan_insert(res->port_id, res->vf_id,
res->vlan_id);
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
if (ret == -ENOTSUP)
ret = rte_pmd_ixgbe_set_tx_loopback(res->port_id, is_on);
#endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_set_tx_loopback(res->port_id, is_on);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_set_tx_loopback(res->port_id, is_on);
#endif
-#if defined RTE_LIBRTE_DPAA_BUS && defined RTE_LIBRTE_DPAA_PMD
+#if defined RTE_BUS_DPAA && defined RTE_NET_DPAA
if (ret == -ENOTSUP)
ret = rte_pmd_dpaa_set_tx_loopback(res->port_id, is_on);
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
if (ret == -ENOTSUP)
ret = rte_pmd_ixgbe_set_all_queues_drop_en(res->port_id, is_on);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_set_all_queues_drop_en(res->port_id, is_on);
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
ret = rte_pmd_ixgbe_set_vf_split_drop_en(res->port_id, res->vf_id,
is_on);
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
if (ret == -ENOTSUP)
ret = rte_pmd_ixgbe_set_vf_mac_addr(res->port_id, res->vf_id,
&res->mac_addr);
#endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_set_vf_mac_addr(res->port_id, res->vf_id,
&res->mac_addr);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_set_vf_mac_addr(res->port_id, res->vf_id,
&res->mac_addr);
return;
if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) {
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
ret = rte_pmd_ixgbe_macsec_enable(port_id, en, rp);
#endif
}
return;
if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) {
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
ret = rte_pmd_ixgbe_macsec_disable(port_id);
#endif
}
int ret = -ENOTSUP;
int is_tx = (strcmp(res->tx_rx, "tx") == 0) ? 1 : 0;
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
ret = is_tx ?
rte_pmd_ixgbe_macsec_config_txsc(res->port_id,
res->mac.addr_bytes) :
key[i] = (uint8_t) ((xdgt0 * 16) + xdgt1);
}
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
ret = is_tx ?
rte_pmd_ixgbe_macsec_select_txsa(res->port_id,
res->idx, res->an, res->pn, key) :
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_set_vf_unicast_promisc(res->port_id,
res->vf_id, is_on);
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_set_vf_multicast_promisc(res->port_id,
res->vf_id, is_on);
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_set_vf_broadcast(res->port_id,
res->vf_id, is_on);
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_set_vf_vlan_tag(res->port_id,
res->vf_id, is_on);
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_set_vf_max_bw(res->port_id,
res->vf_id, res->bw);
#endif
if (ret)
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_set_vf_tc_bw_alloc(res->port_id, res->vf_id,
tc_num, bw);
#endif
if (ret)
return;
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
ret = rte_pmd_ixgbe_set_tc_bw_alloc(res->port_id, tc_num, bw);
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_set_vf_tc_max_bw(res->port_id, res->vf_id,
res->tc_no, res->bw);
#endif
},
};
-
-#if defined RTE_LIBRTE_PMD_SOFTNIC && defined RTE_LIBRTE_SCHED
-
-/* *** Set Port default Traffic Management Hierarchy *** */
-struct cmd_set_port_tm_hierarchy_default_result {
- cmdline_fixed_string_t set;
- cmdline_fixed_string_t port;
- cmdline_fixed_string_t tm;
- cmdline_fixed_string_t hierarchy;
- cmdline_fixed_string_t def;
- portid_t port_id;
-};
-
-cmdline_parse_token_string_t cmd_set_port_tm_hierarchy_default_set =
- TOKEN_STRING_INITIALIZER(
- struct cmd_set_port_tm_hierarchy_default_result, set, "set");
-cmdline_parse_token_string_t cmd_set_port_tm_hierarchy_default_port =
- TOKEN_STRING_INITIALIZER(
- struct cmd_set_port_tm_hierarchy_default_result, port, "port");
-cmdline_parse_token_string_t cmd_set_port_tm_hierarchy_default_tm =
- TOKEN_STRING_INITIALIZER(
- struct cmd_set_port_tm_hierarchy_default_result, tm, "tm");
-cmdline_parse_token_string_t cmd_set_port_tm_hierarchy_default_hierarchy =
- TOKEN_STRING_INITIALIZER(
- struct cmd_set_port_tm_hierarchy_default_result,
- hierarchy, "hierarchy");
-cmdline_parse_token_string_t cmd_set_port_tm_hierarchy_default_default =
- TOKEN_STRING_INITIALIZER(
- struct cmd_set_port_tm_hierarchy_default_result,
- def, "default");
-cmdline_parse_token_num_t cmd_set_port_tm_hierarchy_default_port_id =
- TOKEN_NUM_INITIALIZER(
- struct cmd_set_port_tm_hierarchy_default_result,
- port_id, UINT16);
-
-static void cmd_set_port_tm_hierarchy_default_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_set_port_tm_hierarchy_default_result *res = parsed_result;
- struct rte_port *p;
- portid_t port_id = res->port_id;
-
- if (port_id_is_invalid(port_id, ENABLED_WARN))
- return;
-
- p = &ports[port_id];
-
- /* Forward mode: tm */
- if (strcmp(cur_fwd_config.fwd_eng->fwd_mode_name, "softnic")) {
- printf(" softnicfwd mode not enabled(error)\n");
- return;
- }
-
- /* Set the default tm hierarchy */
- p->softport.default_tm_hierarchy_enable = 1;
-}
-
-cmdline_parse_inst_t cmd_set_port_tm_hierarchy_default = {
- .f = cmd_set_port_tm_hierarchy_default_parsed,
- .data = NULL,
- .help_str = "set port tm hierarchy default <port_id>",
- .tokens = {
- (void *)&cmd_set_port_tm_hierarchy_default_set,
- (void *)&cmd_set_port_tm_hierarchy_default_port,
- (void *)&cmd_set_port_tm_hierarchy_default_tm,
- (void *)&cmd_set_port_tm_hierarchy_default_hierarchy,
- (void *)&cmd_set_port_tm_hierarchy_default_default,
- (void *)&cmd_set_port_tm_hierarchy_default_port_id,
- NULL,
- },
-};
-#endif
-
/** Set VXLAN encapsulation details */
struct cmd_set_vxlan_result {
cmdline_fixed_string_t set;
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_set_tc_strict_prio(res->port_id, res->tc_map);
#endif
return;
}
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_process_ddp_package(res->port_id,
buff, size,
if (!buff)
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_process_ddp_package(res->port_id,
buff, size,
uint8_t *pkg;
uint32_t pkg_size;
int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
uint32_t i, j, n;
uint8_t *buff;
uint32_t buff_size = 0;
if (!pkg)
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
(uint8_t *)&info, sizeof(info),
RTE_PMD_I40E_PKG_INFO_GLOBAL_HEADER);
__rte_unused struct cmdline *cl,
__rte_unused void *data)
{
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct cmd_ddp_get_list_result *res = parsed_result;
struct rte_pmd_i40e_profile_list *p_list;
struct rte_pmd_i40e_profile_info *p_info;
#endif
int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
size = PROFILE_INFO_SIZE * MAX_PROFILE_NUM + 4;
p_list = (struct rte_pmd_i40e_profile_list *)malloc(size);
- if (!p_list)
+ if (!p_list) {
printf("%s: Failed to malloc buffer\n", __func__);
+ return;
+ }
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_get_ddp_list(res->port_id,
__rte_unused struct cmdline *cl,
__rte_unused void *data)
{
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct cmd_cfg_input_set_result *res = parsed_result;
enum rte_pmd_i40e_inset_type inset_type = INSET_NONE;
struct rte_pmd_i40e_inset inset;
return;
}
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (!strcmp(res->inset_type, "hash_inset"))
inset_type = INSET_HASH;
else if (!strcmp(res->inset_type, "fdir_inset"))
__rte_unused struct cmdline *cl,
__rte_unused void *data)
{
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct cmd_clear_input_set_result *res = parsed_result;
enum rte_pmd_i40e_inset_type inset_type = INSET_NONE;
struct rte_pmd_i40e_inset inset;
return;
}
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (!strcmp(res->inset_type, "hash_inset"))
inset_type = INSET_HASH;
else if (!strcmp(res->inset_type, "fdir_inset"))
memset(&stats, 0, sizeof(stats));
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_get_vf_stats(res->port_id,
res->vf_id,
&stats);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_get_vf_stats(res->port_id,
res->vf_id,
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (ret == -ENOTSUP)
ret = rte_pmd_i40e_reset_vf_stats(res->port_id,
res->vf_id);
#endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_reset_vf_stats(res->port_id,
res->vf_id);
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_flow_type_mapping_reset(res->port_id);
#endif
{
struct cmd_pctype_mapping_get_result *res = parsed_result;
int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct rte_pmd_i40e_flow_type_mapping
mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
int i, j, first_pctype;
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id, mapping);
#endif
return;
}
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
for (i = 0; i < RTE_PMD_I40E_FLOW_TYPE_MAX; i++) {
if (mapping[i].pctype != 0ULL) {
first_pctype = 1;
{
struct cmd_pctype_mapping_update_result *res = parsed_result;
int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct rte_pmd_i40e_flow_type_mapping mapping;
unsigned int i;
unsigned int nb_item;
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
nb_item = parse_item_list(res->pctype_list, "pctypes",
RTE_PMD_I40E_PCTYPE_MAX, pctype_list, 1);
mapping.flow_type = res->flow_type;
{
struct cmd_ptype_mapping_get_result *res = parsed_result;
int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
int max_ptype_num = 256;
struct rte_pmd_i40e_ptype_mapping mapping[max_ptype_num];
uint16_t count;
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_ptype_mapping_get(res->port_id,
mapping,
max_ptype_num,
printf("programming error: (%s)\n", strerror(-ret));
}
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
if (!ret) {
for (i = 0; i < count; i++)
printf("%3d\t0x%08x\n",
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_ptype_mapping_replace(res->port_id,
res->target,
res->mask,
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
ret = rte_pmd_i40e_ptype_mapping_reset(res->port_id);
#endif
{
struct cmd_ptype_mapping_update_result *res = parsed_result;
int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
struct rte_pmd_i40e_ptype_mapping mapping;
#endif
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
mapping.hw_ptype = res->hw_ptype;
mapping.sw_ptype = res->sw_ptype;
ret = rte_pmd_i40e_ptype_mapping_update(res->port_id,
offload, "vlan_strip#ipv4_cksum#udp_cksum#tcp_cksum#tcp_lro#"
"qinq_strip#outer_ipv4_cksum#macsec_strip#"
"header_split#vlan_filter#vlan_extend#jumbo_frame#"
- "scatter#timestamp#security#keep_crc#rss_hash");
+ "scatter#buffer_split#timestamp#security#"
+ "keep_crc#rss_hash");
cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_port_rx_offload_result,
.help_str = "port config <port_id> rx_offload vlan_strip|ipv4_cksum|"
"udp_cksum|tcp_cksum|tcp_lro|qinq_strip|outer_ipv4_cksum|"
"macsec_strip|header_split|vlan_filter|vlan_extend|"
- "jumbo_frame|scatter|timestamp|security|keep_crc|rss_hash "
- "on|off",
+ "jumbo_frame|scatter|buffer_split|timestamp|security|"
+ "keep_crc|rss_hash on|off",
.tokens = {
(void *)&cmd_config_per_port_rx_offload_result_port,
(void *)&cmd_config_per_port_rx_offload_result_config,
offload, "vlan_strip#ipv4_cksum#udp_cksum#tcp_cksum#tcp_lro#"
"qinq_strip#outer_ipv4_cksum#macsec_strip#"
"header_split#vlan_filter#vlan_extend#jumbo_frame#"
- "scatter#timestamp#security#keep_crc");
+ "scatter#buffer_split#timestamp#security#keep_crc");
cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_rx_offload_result,
"vlan_strip|ipv4_cksum|"
"udp_cksum|tcp_cksum|tcp_lro|qinq_strip|outer_ipv4_cksum|"
"macsec_strip|header_split|vlan_filter|vlan_extend|"
- "jumbo_frame|scatter|timestamp|security|keep_crc "
- "on|off",
+ "jumbo_frame|scatter|buffer_split|timestamp|security|"
+ "keep_crc on|off",
.tokens = {
(void *)&cmd_config_per_queue_rx_offload_result_port,
(void *)&cmd_config_per_queue_rx_offload_result_port_id,
"sctp_cksum#tcp_tso#udp_tso#outer_ipv4_cksum#"
"qinq_insert#vxlan_tnl_tso#gre_tnl_tso#"
"ipip_tnl_tso#geneve_tnl_tso#macsec_insert#"
- "mt_lockfree#multi_segs#mbuf_fast_free#security");
+ "mt_lockfree#multi_segs#mbuf_fast_free#security#"
+ "send_on_timestamp");
cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_port_tx_offload_result,
"sctp_cksum|tcp_tso|udp_tso|outer_ipv4_cksum|"
"qinq_insert|vxlan_tnl_tso|gre_tnl_tso|"
"ipip_tnl_tso|geneve_tnl_tso|macsec_insert|"
- "mt_lockfree|multi_segs|mbuf_fast_free|security on|off",
+ "mt_lockfree|multi_segs|mbuf_fast_free|security|"
+ "send_on_timestamp on|off",
.tokens = {
(void *)&cmd_config_per_port_tx_offload_result_port,
(void *)&cmd_config_per_port_tx_offload_result_config,
},
};
+/* *** show fec capability per port configuration *** */
+struct cmd_show_fec_capability_result {
+ cmdline_fixed_string_t cmd_show;
+ cmdline_fixed_string_t cmd_port;
+ cmdline_fixed_string_t cmd_fec;
+ cmdline_fixed_string_t cmd_keyword;
+ portid_t cmd_pid;
+};
+
+static void
+cmd_show_fec_capability_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+#define FEC_CAP_NUM 2
+ struct cmd_show_fec_capability_result *res = parsed_result;
+ struct rte_eth_fec_capa speed_fec_capa[FEC_CAP_NUM];
+ unsigned int num = FEC_CAP_NUM;
+ unsigned int ret_num;
+ int ret;
+
+ if (!rte_eth_dev_is_valid_port(res->cmd_pid)) {
+ printf("Invalid port id %u\n", res->cmd_pid);
+ return;
+ }
+
+ ret = rte_eth_fec_get_capability(res->cmd_pid, speed_fec_capa, num);
+ if (ret == -ENOTSUP) {
+ printf("Function not implemented\n");
+ return;
+ } else if (ret < 0) {
+ printf("Get FEC capability failed\n");
+ return;
+ }
+
+ ret_num = (unsigned int)ret;
+ show_fec_capability(ret_num, speed_fec_capa);
+}
+
+cmdline_parse_token_string_t cmd_show_fec_capability_show =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result,
+ cmd_show, "show");
+cmdline_parse_token_string_t cmd_show_fec_capability_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result,
+ cmd_port, "port");
+cmdline_parse_token_num_t cmd_show_fec_capability_pid =
+ TOKEN_NUM_INITIALIZER(struct cmd_show_fec_capability_result,
+ cmd_pid, UINT16);
+cmdline_parse_token_string_t cmd_show_fec_capability_fec =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result,
+ cmd_fec, "fec");
+cmdline_parse_token_string_t cmd_show_fec_capability_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result,
+ cmd_keyword, "capabilities");
+
+cmdline_parse_inst_t cmd_show_capability = {
+ .f = cmd_show_fec_capability_parsed,
+ .data = NULL,
+ .help_str = "show port <port_id> fec capabilities",
+ .tokens = {
+ (void *)&cmd_show_fec_capability_show,
+ (void *)&cmd_show_fec_capability_port,
+ (void *)&cmd_show_fec_capability_pid,
+ (void *)&cmd_show_fec_capability_fec,
+ (void *)&cmd_show_fec_capability_keyword,
+ NULL,
+ },
+};
+
+/* *** show fec mode per port configuration *** */
+struct cmd_show_fec_metadata_result {
+ cmdline_fixed_string_t cmd_show;
+ cmdline_fixed_string_t cmd_port;
+ cmdline_fixed_string_t cmd_keyword;
+ portid_t cmd_pid;
+};
+
+static void
+cmd_show_fec_mode_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+#define FEC_NAME_SIZE 16
+ struct cmd_show_fec_metadata_result *res = parsed_result;
+ uint32_t mode;
+ char buf[FEC_NAME_SIZE];
+ int ret;
+
+ if (!rte_eth_dev_is_valid_port(res->cmd_pid)) {
+ printf("Invalid port id %u\n", res->cmd_pid);
+ return;
+ }
+ ret = rte_eth_fec_get(res->cmd_pid, &mode);
+ if (ret == -ENOTSUP) {
+ printf("Function not implemented\n");
+ return;
+ } else if (ret < 0) {
+ printf("Get FEC mode failed\n");
+ return;
+ }
+
+ switch (mode) {
+ case RTE_ETH_FEC_MODE_CAPA_MASK(NOFEC):
+ strlcpy(buf, "off", sizeof(buf));
+ break;
+ case RTE_ETH_FEC_MODE_CAPA_MASK(AUTO):
+ strlcpy(buf, "auto", sizeof(buf));
+ break;
+ case RTE_ETH_FEC_MODE_CAPA_MASK(BASER):
+ strlcpy(buf, "baser", sizeof(buf));
+ break;
+ case RTE_ETH_FEC_MODE_CAPA_MASK(RS):
+ strlcpy(buf, "rs", sizeof(buf));
+ break;
+ default:
+ return;
+ }
+
+ printf("%s\n", buf);
+}
+
+cmdline_parse_token_string_t cmd_show_fec_mode_show =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_fec_metadata_result,
+ cmd_show, "show");
+cmdline_parse_token_string_t cmd_show_fec_mode_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_fec_metadata_result,
+ cmd_port, "port");
+cmdline_parse_token_num_t cmd_show_fec_mode_pid =
+ TOKEN_NUM_INITIALIZER(struct cmd_show_fec_metadata_result,
+ cmd_pid, UINT16);
+cmdline_parse_token_string_t cmd_show_fec_mode_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_fec_metadata_result,
+ cmd_keyword, "fec_mode");
+
+cmdline_parse_inst_t cmd_show_fec_mode = {
+ .f = cmd_show_fec_mode_parsed,
+ .data = NULL,
+ .help_str = "show port <port_id> fec_mode",
+ .tokens = {
+ (void *)&cmd_show_fec_mode_show,
+ (void *)&cmd_show_fec_mode_port,
+ (void *)&cmd_show_fec_mode_pid,
+ (void *)&cmd_show_fec_mode_keyword,
+ NULL,
+ },
+};
+
+/* *** set fec mode per port configuration *** */
+struct cmd_set_port_fec_mode {
+ cmdline_fixed_string_t set;
+ cmdline_fixed_string_t port;
+ portid_t port_id;
+ cmdline_fixed_string_t fec_mode;
+ cmdline_fixed_string_t fec_value;
+};
+
+/* Common CLI fields for set fec mode */
+cmdline_parse_token_string_t cmd_set_port_fec_mode_set =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_set_port_fec_mode,
+ set, "set");
+cmdline_parse_token_string_t cmd_set_port_fec_mode_port =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_set_port_fec_mode,
+ port, "port");
+cmdline_parse_token_num_t cmd_set_port_fec_mode_port_id =
+ TOKEN_NUM_INITIALIZER
+ (struct cmd_set_port_fec_mode,
+ port_id, UINT16);
+cmdline_parse_token_string_t cmd_set_port_fec_mode_str =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_set_port_fec_mode,
+ fec_mode, "fec_mode");
+cmdline_parse_token_string_t cmd_set_port_fec_mode_value =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_set_port_fec_mode,
+ fec_value, NULL);
+
+static void
+cmd_set_port_fec_mode_parsed(
+ void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_port_fec_mode *res = parsed_result;
+ uint16_t port_id = res->port_id;
+ uint32_t mode;
+ int ret;
+
+ ret = parse_fec_mode(res->fec_value, &mode);
+ if (ret < 0) {
+ printf("Unknown fec mode: %s for Port %d\n", res->fec_value,
+ port_id);
+ return;
+ }
+
+ ret = rte_eth_fec_set(port_id, mode);
+ if (ret == -ENOTSUP) {
+ printf("Function not implemented\n");
+ return;
+ } else if (ret < 0) {
+ printf("Set FEC mode failed\n");
+ return;
+ }
+}
+
+cmdline_parse_inst_t cmd_set_fec_mode = {
+ .f = cmd_set_port_fec_mode_parsed,
+ .data = NULL,
+ .help_str = "set port <port_id> fec_mode auto|off|rs|baser",
+ .tokens = {
+ (void *)&cmd_set_port_fec_mode_set,
+ (void *)&cmd_set_port_fec_mode_port,
+ (void *)&cmd_set_port_fec_mode_port_id,
+ (void *)&cmd_set_port_fec_mode_str,
+ (void *)&cmd_set_port_fec_mode_value,
+ NULL,
+ },
+};
+
/* show port supported ptypes */
/* Common result structure for show port ptypes */
(cmdline_parse_inst_t *)&cmd_load_from_file,
(cmdline_parse_inst_t *)&cmd_showport,
(cmdline_parse_inst_t *)&cmd_showqueue,
+ (cmdline_parse_inst_t *)&cmd_showeeprom,
(cmdline_parse_inst_t *)&cmd_showportall,
(cmdline_parse_inst_t *)&cmd_showdevice,
(cmdline_parse_inst_t *)&cmd_showcfg,
(cmdline_parse_inst_t *)&cmd_reset,
(cmdline_parse_inst_t *)&cmd_set_numbers,
(cmdline_parse_inst_t *)&cmd_set_log,
+ (cmdline_parse_inst_t *)&cmd_set_rxoffs,
+ (cmdline_parse_inst_t *)&cmd_set_rxpkts,
(cmdline_parse_inst_t *)&cmd_set_txpkts,
(cmdline_parse_inst_t *)&cmd_set_txsplit,
+ (cmdline_parse_inst_t *)&cmd_set_txtimes,
(cmdline_parse_inst_t *)&cmd_set_fwd_list,
(cmdline_parse_inst_t *)&cmd_set_fwd_mask,
(cmdline_parse_inst_t *)&cmd_set_fwd_mode,
(cmdline_parse_inst_t *)&cmd_set_bypass_event,
(cmdline_parse_inst_t *)&cmd_set_bypass_timeout,
(cmdline_parse_inst_t *)&cmd_show_bypass_config,
-#ifdef RTE_LIBRTE_PMD_BOND
+#ifdef RTE_NET_BOND
(cmdline_parse_inst_t *) &cmd_set_bonding_mode,
(cmdline_parse_inst_t *) &cmd_show_bonding_config,
(cmdline_parse_inst_t *) &cmd_set_bonding_primary,
(cmdline_parse_inst_t *)&cmd_set_fwd_eth_peer,
(cmdline_parse_inst_t *)&cmd_set_qmap,
(cmdline_parse_inst_t *)&cmd_set_xstats_hide_zero,
+ (cmdline_parse_inst_t *)&cmd_set_record_core_cycles,
+ (cmdline_parse_inst_t *)&cmd_set_record_burst_stats,
(cmdline_parse_inst_t *)&cmd_operate_port,
(cmdline_parse_inst_t *)&cmd_operate_specific_port,
(cmdline_parse_inst_t *)&cmd_operate_attach_port,
(cmdline_parse_inst_t *)&cmd_set_uc_hash_filter,
(cmdline_parse_inst_t *)&cmd_set_uc_all_hash_filter,
(cmdline_parse_inst_t *)&cmd_vf_mac_addr_filter,
- (cmdline_parse_inst_t *)&cmd_set_vf_macvlan_filter,
(cmdline_parse_inst_t *)&cmd_queue_rate_limit,
(cmdline_parse_inst_t *)&cmd_tunnel_filter,
(cmdline_parse_inst_t *)&cmd_tunnel_udp_config,
(cmdline_parse_inst_t *)&cmd_config_rss_hash_key,
(cmdline_parse_inst_t *)&cmd_dump,
(cmdline_parse_inst_t *)&cmd_dump_one,
- (cmdline_parse_inst_t *)&cmd_ethertype_filter,
(cmdline_parse_inst_t *)&cmd_syn_filter,
(cmdline_parse_inst_t *)&cmd_2tuple_filter,
(cmdline_parse_inst_t *)&cmd_5tuple_filter,
- (cmdline_parse_inst_t *)&cmd_flex_filter,
(cmdline_parse_inst_t *)&cmd_add_del_ip_flow_director,
(cmdline_parse_inst_t *)&cmd_add_del_udp_flow_director,
(cmdline_parse_inst_t *)&cmd_add_del_sctp_flow_director,
(cmdline_parse_inst_t *)&cmd_vf_tc_max_bw,
(cmdline_parse_inst_t *)&cmd_strict_link_prio,
(cmdline_parse_inst_t *)&cmd_tc_min_bw,
-#if defined RTE_LIBRTE_PMD_SOFTNIC && defined RTE_LIBRTE_SCHED
- (cmdline_parse_inst_t *)&cmd_set_port_tm_hierarchy_default,
-#endif
(cmdline_parse_inst_t *)&cmd_set_vxlan,
(cmdline_parse_inst_t *)&cmd_set_vxlan_tos_ttl,
(cmdline_parse_inst_t *)&cmd_set_vxlan_with_vlan,
(cmdline_parse_inst_t *)&cmd_del_port_tm_node_wred_profile,
(cmdline_parse_inst_t *)&cmd_set_port_tm_node_shaper_profile,
(cmdline_parse_inst_t *)&cmd_add_port_tm_nonleaf_node,
+ (cmdline_parse_inst_t *)&cmd_add_port_tm_nonleaf_node_pmode,
(cmdline_parse_inst_t *)&cmd_add_port_tm_leaf_node,
(cmdline_parse_inst_t *)&cmd_del_port_tm_node,
(cmdline_parse_inst_t *)&cmd_set_port_tm_node_parent,
(cmdline_parse_inst_t *)&cmd_tx_offload_get_configuration,
(cmdline_parse_inst_t *)&cmd_config_per_port_tx_offload,
(cmdline_parse_inst_t *)&cmd_config_per_queue_tx_offload,
-#ifdef RTE_LIBRTE_BPF
+#ifdef RTE_LIB_BPF
(cmdline_parse_inst_t *)&cmd_operate_bpf_ld_parse,
(cmdline_parse_inst_t *)&cmd_operate_bpf_unld_parse,
#endif
(cmdline_parse_inst_t *)&cmd_show_set_raw,
(cmdline_parse_inst_t *)&cmd_show_set_raw_all,
(cmdline_parse_inst_t *)&cmd_config_tx_dynf_specific,
+ (cmdline_parse_inst_t *)&cmd_show_fec_mode,
+ (cmdline_parse_inst_t *)&cmd_set_fec_mode,
+ (cmdline_parse_inst_t *)&cmd_show_capability,
NULL,
};
printf("Read CLI commands from %s\n", filename);
}
-/* prompt function, called from main on MASTER lcore */
+/* prompt function, called from main on MAIN lcore */
void
prompt(void)
{
git.droids-corp.org / dpdk.git / blobdiff