#include <termios.h>
#include <unistd.h>
#include <inttypes.h>
-#ifndef __linux__
-#ifndef __FreeBSD__
-#include <net/socket.h>
-#else
#include <sys/socket.h>
-#endif
-#endif
#include <netinet/in.h>
#include <sys/queue.h>
#include <rte_devargs.h>
#include <rte_flow.h>
#include <rte_gro.h>
+#include <rte_mbuf_dyn.h>
#include <cmdline_rdline.h>
#include <cmdline_parse.h>
cmdline_fixed_string_t help;
};
-static void cmd_help_brief_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_help_brief_parsed(__rte_unused void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(
cl,
" help ports : Configuring ports.\n"
" help registers : Reading and setting port registers.\n"
" help filters : Filters configuration help.\n"
- " help traffic_management : Traffic Management commmands.\n"
+ " help traffic_management : Traffic Management commands.\n"
" help devices : Device related cmds.\n"
" help all : All of the above sections.\n\n"
);
static void cmd_help_long_parsed(void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
int show_all = 0;
struct cmd_help_long_result *res = parsed_result;
" Show Tx metadata value set"
" for a specific port\n\n"
+ "show port (port_id) ptypes\n"
+ " Show port supported ptypes"
+ " for a specific port\n\n"
+
"show device info (<identifier>|all)"
" Show general information about devices probed.\n\n"
+
+ "show port (port_id) rxq|txq (queue_id) desc (desc_id) status"
+ " Show status of rx|tx descriptor.\n\n"
+
+ "show port (port_id) macs|mcast_macs"
+ " Display list of mac addresses added to port.\n\n"
);
}
"set vf broadcast (port_id) (vf_id) (on|off)\n"
" Set VF broadcast for a VF from the PF.\n\n"
- "vlan set strip (on|off) (port_id)\n"
- " Set the VLAN strip on a port.\n\n"
-
"vlan set stripq (on|off) (port_id,queue_id)\n"
" Set the VLAN strip for a queue on a port.\n\n"
"set tc tx min-bandwidth (port_id) (bw1, bw2, ...)\n"
" Set all TCs' min bandwidth(%%) for all PF and VFs.\n\n"
- "vlan set filter (on|off) (port_id)\n"
- " Set the VLAN filter on a port.\n\n"
-
- "vlan set qinq (on|off) (port_id)\n"
- " Set the VLAN QinQ (extended queue in queue)"
- " on a port.\n\n"
+ "vlan set (strip|filter|qinq_strip|extend) (on|off) (port_id)\n"
+ " Set the VLAN strip or filter or qinq strip or extend\n\n"
"vlan set (inner|outer) tpid (value) (port_id)\n"
" Set the VLAN TPID for Packet Filtering on"
"ptype mapping update (port_id) (hw_ptype) (sw_ptype)\n"
" Update a ptype mapping item on a port\n\n"
+ "set port (port_id) ptype_mask (ptype_mask)\n"
+ " set packet types classification for a specific port\n\n"
+
"set port (port_id) queue-region region_id (value) "
"queue_start_index (value) queue_num (value)\n"
" Set a queue region on a port\n\n"
"port close (port_id|all)\n"
" Close all ports or port_id.\n\n"
+ "port reset (port_id|all)\n"
+ " Reset all ports or port_id.\n\n"
+
"port attach (ident)\n"
" Attach physical or virtual dev by pci address or virtual device name\n\n"
"port config all max-pkt-len (value)\n"
" Set the max packet length.\n\n"
- "port config all (crc-strip|scatter|rx-cksum|rx-timestamp|hw-vlan|hw-vlan-filter|"
- "hw-vlan-strip|hw-vlan-extend|drop-en)"
- " (on|off)\n"
- " Set crc-strip/scatter/rx-checksum/hardware-vlan/drop_en"
- " for ports.\n\n"
+ "port config all max-lro-pkt-size (value)\n"
+ " Set the max LRO aggregated packet size.\n\n"
+
+ "port config all drop-en (on|off)\n"
+ " Enable or disable packet drop on all RX queues of all ports when no "
+ "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"
"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|crc_strip|"
+ "vlan_filter|vlan_extend|jumbo_frame|"
"scatter|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|crc_strip|"
+ "vlan_filter|vlan_extend|jumbo_frame|"
"scatter|timestamp|security|keep_crc on|off\n"
" Enable or disable a per queue Rx offloading"
" only on a specific Rx queue\n\n"
"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|match_metadata on|off\n"
+ "security on|off\n"
" Enable or disable a per port Tx offloading"
" on all Tx queues of a port\n\n"
"port config (port_id) tx_metadata (value)\n"
" Set Tx metadata value per port. Testpmd will add this value"
" to any Tx packet sent from this port\n\n"
+
+ "port config (port_id) dynf (name) set|clear\n"
+ " Register a dynf and Set/clear this flag on Tx. "
+ "Testpmd will set this value to any Tx packet "
+ "sent from this port\n\n"
);
}
"get_hash_global_config (port_id)\n"
" Get the global configurations of hash filters.\n\n"
- "set_hash_global_config (port_id) (toeplitz|simple_xor|default)"
+ "set_hash_global_config (port_id) (toeplitz|simple_xor|symmetric_toeplitz|default)"
" (ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|ipv6|"
"ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload)"
" (enable|disable)\n"
};
static void cmd_operate_port_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_operate_port_result *res = parsed_result;
};
static void cmd_operate_specific_port_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_operate_specific_port_result *res = parsed_result;
};
static void cmd_set_port_setup_on_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_setup_on_result *res = parsed_result;
struct cmd_operate_attach_port_result {
cmdline_fixed_string_t port;
cmdline_fixed_string_t keyword;
- cmdline_fixed_string_t identifier;
+ cmdline_multi_string_t identifier;
};
static void cmd_operate_attach_port_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_operate_attach_port_result *res = parsed_result;
keyword, "attach");
cmdline_parse_token_string_t cmd_operate_attach_port_identifier =
TOKEN_STRING_INITIALIZER(struct cmd_operate_attach_port_result,
- identifier, NULL);
+ identifier, TOKEN_STRING_MULTI);
cmdline_parse_inst_t cmd_operate_attach_port = {
.f = cmd_operate_attach_port_parsed,
};
static void cmd_operate_detach_port_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_operate_detach_port_result *res = parsed_result;
- if (!strcmp(res->keyword, "detach"))
+ if (!strcmp(res->keyword, "detach")) {
+ RTE_ETH_VALID_PORTID_OR_RET(res->port_id);
detach_port_device(res->port_id);
- else
+ } else {
printf("Unknown parameter\n");
+ }
}
cmdline_parse_token_string_t cmd_operate_detach_port_port =
};
static void cmd_operate_detach_device_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_operate_detach_device_result *res = parsed_result;
if (!strcmp(res->keyword, "detach"))
- detach_device(res->identifier);
+ detach_devargs(res->identifier);
else
printf("Unknown parameter\n");
}
static void
cmd_config_speed_all_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_speed_all *res = parsed_result;
uint32_t link_speed;
static void
cmd_config_speed_specific_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_speed_specific *res = parsed_result;
uint32_t link_speed;
static void
cmd_config_loopback_all_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_loopback_all *res = parsed_result;
portid_t pid;
static void
cmd_config_loopback_specific_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_loopback_specific *res = parsed_result;
static void
cmd_config_rx_tx_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rx_tx *res = parsed_result;
nb_txq = res->value;
}
else if (!strcmp(res->name, "rxd")) {
- if (res->value <= 0 || res->value > RTE_TEST_RX_DESC_MAX) {
- printf("rxd %d invalid - must be > 0 && <= %d\n",
- res->value, RTE_TEST_RX_DESC_MAX);
+ if (check_nb_rxd(res->value) != 0)
return;
- }
nb_rxd = res->value;
} else if (!strcmp(res->name, "txd")) {
- if (res->value <= 0 || res->value > RTE_TEST_TX_DESC_MAX) {
- printf("txd %d invalid - must be > 0 && <= %d\n",
- res->value, RTE_TEST_TX_DESC_MAX);
+ if (check_nb_txd(res->value) != 0)
return;
- }
+
nb_txd = res->value;
} else {
printf("Unknown parameter\n");
static void
cmd_config_max_pkt_len_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_max_pkt_len_result *res = parsed_result;
portid_t pid;
},
};
+/* *** config max LRO aggregated packet size *** */
+struct cmd_config_max_lro_pkt_size_result {
+ cmdline_fixed_string_t port;
+ cmdline_fixed_string_t keyword;
+ cmdline_fixed_string_t all;
+ cmdline_fixed_string_t name;
+ uint32_t value;
+};
+
+static void
+cmd_config_max_lro_pkt_size_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_config_max_lro_pkt_size_result *res = parsed_result;
+ portid_t pid;
+
+ if (!all_ports_stopped()) {
+ printf("Please stop all ports first\n");
+ return;
+ }
+
+ RTE_ETH_FOREACH_DEV(pid) {
+ struct rte_port *port = &ports[pid];
+
+ if (!strcmp(res->name, "max-lro-pkt-size")) {
+ if (res->value ==
+ port->dev_conf.rxmode.max_lro_pkt_size)
+ return;
+
+ port->dev_conf.rxmode.max_lro_pkt_size = res->value;
+ } else {
+ printf("Unknown parameter\n");
+ return;
+ }
+ }
+
+ init_port_config();
+
+ cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
+}
+
+cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
+ port, "port");
+cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
+ keyword, "config");
+cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_all =
+ TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
+ all, "all");
+cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_name =
+ TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
+ name, "max-lro-pkt-size");
+cmdline_parse_token_num_t cmd_config_max_lro_pkt_size_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
+ value, UINT32);
+
+cmdline_parse_inst_t cmd_config_max_lro_pkt_size = {
+ .f = cmd_config_max_lro_pkt_size_parsed,
+ .data = NULL,
+ .help_str = "port config all max-lro-pkt-size <value>",
+ .tokens = {
+ (void *)&cmd_config_max_lro_pkt_size_port,
+ (void *)&cmd_config_max_lro_pkt_size_keyword,
+ (void *)&cmd_config_max_lro_pkt_size_all,
+ (void *)&cmd_config_max_lro_pkt_size_name,
+ (void *)&cmd_config_max_lro_pkt_size_value,
+ NULL,
+ },
+};
+
/* *** configure port MTU *** */
struct cmd_config_mtu_result {
cmdline_fixed_string_t port;
static void
cmd_config_mtu_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_mtu_result *res = parsed_result;
static void
cmd_config_rx_mode_flag_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rx_mode_flag *res = parsed_result;
- portid_t pid;
- int k;
if (!all_ports_stopped()) {
printf("Please stop all ports first\n");
return;
}
- RTE_ETH_FOREACH_DEV(pid) {
- struct rte_port *port;
- uint64_t rx_offloads;
-
- port = &ports[pid];
- rx_offloads = port->dev_conf.rxmode.offloads;
- if (!strcmp(res->name, "crc-strip")) {
- if (!strcmp(res->value, "on")) {
- rx_offloads &= ~DEV_RX_OFFLOAD_KEEP_CRC;
- } else if (!strcmp(res->value, "off")) {
- rx_offloads |= DEV_RX_OFFLOAD_KEEP_CRC;
- } else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "scatter")) {
- if (!strcmp(res->value, "on")) {
- rx_offloads |= DEV_RX_OFFLOAD_SCATTER;
- } else if (!strcmp(res->value, "off")) {
- rx_offloads &= ~DEV_RX_OFFLOAD_SCATTER;
- } else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "rx-cksum")) {
- if (!strcmp(res->value, "on"))
- rx_offloads |= DEV_RX_OFFLOAD_CHECKSUM;
- else if (!strcmp(res->value, "off"))
- rx_offloads &= ~DEV_RX_OFFLOAD_CHECKSUM;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "rx-timestamp")) {
- if (!strcmp(res->value, "on"))
- rx_offloads |= DEV_RX_OFFLOAD_TIMESTAMP;
- else if (!strcmp(res->value, "off"))
- rx_offloads &= ~DEV_RX_OFFLOAD_TIMESTAMP;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "hw-vlan")) {
- if (!strcmp(res->value, "on")) {
- rx_offloads |= (DEV_RX_OFFLOAD_VLAN_FILTER |
- DEV_RX_OFFLOAD_VLAN_STRIP);
- } else if (!strcmp(res->value, "off")) {
- rx_offloads &= ~(DEV_RX_OFFLOAD_VLAN_FILTER |
- DEV_RX_OFFLOAD_VLAN_STRIP);
- } else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "hw-vlan-filter")) {
- if (!strcmp(res->value, "on"))
- rx_offloads |= DEV_RX_OFFLOAD_VLAN_FILTER;
- else if (!strcmp(res->value, "off"))
- rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_FILTER;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "hw-vlan-strip")) {
- if (!strcmp(res->value, "on"))
- rx_offloads |= DEV_RX_OFFLOAD_VLAN_STRIP;
- else if (!strcmp(res->value, "off"))
- rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_STRIP;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "hw-vlan-extend")) {
- if (!strcmp(res->value, "on"))
- rx_offloads |= DEV_RX_OFFLOAD_VLAN_EXTEND;
- else if (!strcmp(res->value, "off"))
- rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_EXTEND;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "drop-en")) {
- if (!strcmp(res->value, "on"))
- rx_drop_en = 1;
- else if (!strcmp(res->value, "off"))
- rx_drop_en = 0;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else {
+ if (!strcmp(res->name, "drop-en")) {
+ if (!strcmp(res->value, "on"))
+ rx_drop_en = 1;
+ else if (!strcmp(res->value, "off"))
+ rx_drop_en = 0;
+ else {
printf("Unknown parameter\n");
return;
}
- port->dev_conf.rxmode.offloads = rx_offloads;
- /* Apply Rx offloads configuration */
- for (k = 0; k < port->dev_info.max_rx_queues; k++)
- port->rx_conf[k].offloads =
- port->dev_conf.rxmode.offloads;
+ } else {
+ printf("Unknown parameter\n");
+ return;
}
init_port_config();
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, all, "all");
cmdline_parse_token_string_t cmd_config_rx_mode_flag_name =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, name,
- "crc-strip#scatter#rx-cksum#rx-timestamp#hw-vlan#"
- "hw-vlan-filter#hw-vlan-strip#hw-vlan-extend");
+ "drop-en");
cmdline_parse_token_string_t cmd_config_rx_mode_flag_value =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, value,
"on#off");
cmdline_parse_inst_t cmd_config_rx_mode_flag = {
.f = cmd_config_rx_mode_flag_parsed,
.data = NULL,
- .help_str = "port config all crc-strip|scatter|rx-cksum|rx-timestamp|hw-vlan|"
- "hw-vlan-filter|hw-vlan-strip|hw-vlan-extend on|off",
+ .help_str = "port config all drop-en on|off",
.tokens = {
(void *)&cmd_config_rx_mode_flag_port,
(void *)&cmd_config_rx_mode_flag_keyword,
static void
cmd_config_rss_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rss *res = parsed_result;
struct rte_eth_rss_conf rss_conf = { .rss_key_len = 0, };
int all_updated = 1;
int diag;
uint16_t i;
+ int ret;
if (!strcmp(res->value, "all"))
- rss_conf.rss_hf = ETH_RSS_IP | ETH_RSS_TCP |
- ETH_RSS_UDP | ETH_RSS_SCTP |
- ETH_RSS_L2_PAYLOAD;
+ 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;
+ 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_VLAN;
else if (!strcmp(res->value, "ip"))
rss_conf.rss_hf = ETH_RSS_IP;
else if (!strcmp(res->value, "udp"))
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-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_L3_DST_ONLY;
+ else if (!strcmp(res->value, "l4-src-only"))
+ rss_conf.rss_hf = ETH_RSS_L4_SRC_ONLY;
+ else if (!strcmp(res->value, "l4-dst-only"))
+ rss_conf.rss_hf = ETH_RSS_L4_DST_ONLY;
+ else if (!strcmp(res->value, "l2-src-only"))
+ rss_conf.rss_hf = ETH_RSS_L2_SRC_ONLY;
+ else if (!strcmp(res->value, "l2-dst-only"))
+ rss_conf.rss_hf = ETH_RSS_L2_DST_ONLY;
+ else if (!strcmp(res->value, "l2tpv3"))
+ rss_conf.rss_hf = ETH_RSS_L2TPV3;
+ else if (!strcmp(res->value, "esp"))
+ rss_conf.rss_hf = ETH_RSS_ESP;
+ else if (!strcmp(res->value, "ah"))
+ 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, "none"))
rss_conf.rss_hf = 0;
else if (!strcmp(res->value, "default"))
RTE_ETH_FOREACH_DEV(i) {
struct rte_eth_rss_conf local_rss_conf;
- rte_eth_dev_info_get(i, &dev_info);
+ ret = eth_dev_info_get_print_err(i, &dev_info);
+ if (ret != 0)
+ return;
+
if (use_default)
rss_conf.rss_hf = dev_info.flow_type_rss_offloads;
i, -diag, strerror(-diag));
}
}
- if (all_updated && !use_default)
+ if (all_updated && !use_default) {
rss_hf = rss_conf.rss_hf;
+ printf("rss_hf %#"PRIx64"\n", rss_hf);
+ }
}
cmdline_parse_token_string_t cmd_config_rss_port =
.f = cmd_config_rss_parsed,
.data = NULL,
.help_str = "port config all rss "
- "all|default|ip|tcp|udp|sctp|ether|port|vxlan|geneve|nvgre|vxlan-gpe|none|<flowtype_id>",
+ "all|default|eth|vlan|ip|tcp|udp|sctp|ether|port|vxlan|geneve|"
+ "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|none|<flowtype_id>",
.tokens = {
(void *)&cmd_config_rss_port,
(void *)&cmd_config_rss_keyword,
static void
cmd_config_rss_hash_key_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rss_hash_key *res = parsed_result;
uint8_t hash_key[RSS_HASH_KEY_LENGTH];
struct rte_eth_dev_info dev_info;
uint8_t hash_key_size;
uint32_t key_len;
+ int ret;
+
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
- memset(&dev_info, 0, sizeof(dev_info));
- rte_eth_dev_info_get(res->port_id, &dev_info);
if (dev_info.hash_key_size > 0 &&
dev_info.hash_key_size <= sizeof(hash_key))
hash_key_size = dev_info.hash_key_size;
"ipv4#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
"ipv4-other#ipv6#ipv6-frag#ipv6-tcp#ipv6-udp#"
"ipv6-sctp#ipv6-other#l2-payload#ipv6-ex#"
- "ipv6-tcp-ex#ipv6-udp-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");
cmdline_parse_token_string_t cmd_config_rss_hash_key_value =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, key, NULL);
.help_str = "port config <port_id> rss-hash-key "
"ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
"ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|"
- "l2-payload|ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex "
+ "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 "
"<string of hex digits (variable length, NIC dependent)>",
.tokens = {
(void *)&cmd_config_rss_hash_key_port,
static void
cmd_config_rxtx_ring_size_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rxtx_ring_size *res = parsed_result;
struct rte_port *port;
static void
cmd_config_rxtx_queue_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_rxtx_queue *res = parsed_result;
uint8_t isrx;
static void
cmd_config_deferred_start_rxtx_queue_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_deferred_start_rxtx_queue *res = parsed_result;
struct rte_port *port;
static void
cmd_setup_rxtx_queue_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_setup_rxtx_queue *res = parsed_result;
struct rte_port *port;
static void
cmd_set_rss_reta_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret;
struct rte_eth_dev_info dev_info;
struct rte_eth_rss_reta_entry64 reta_conf[8];
struct cmd_config_rss_reta *res = parsed_result;
- memset(&dev_info, 0, sizeof(dev_info));
- rte_eth_dev_info_get(res->port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (dev_info.reta_size == 0) {
printf("Redirection table size is 0 which is "
"invalid for RSS\n");
static void
cmd_showport_reta_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_showport_reta *res = parsed_result;
struct rte_eth_rss_reta_entry64 reta_conf[8];
struct rte_eth_dev_info dev_info;
uint16_t max_reta_size;
+ int ret;
+
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
- memset(&dev_info, 0, sizeof(dev_info));
- rte_eth_dev_info_get(res->port_id, &dev_info);
max_reta_size = RTE_MIN(dev_info.reta_size, ETH_RSS_RETA_SIZE_512);
if (res->size == 0 || res->size > max_reta_size) {
printf("Invalid redirection table size: %u (1-%u)\n",
};
static void cmd_showport_rss_hash_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
+ __rte_unused struct cmdline *cl,
void *show_rss_key)
{
struct cmd_showport_rss_hash *res = parsed_result;
static void
cmd_config_dcb_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_dcb *res = parsed_result;
portid_t port_id = res->port_id;
static void
cmd_config_burst_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_burst *res = parsed_result;
struct rte_eth_dev_info dev_info;
uint16_t rec_nb_pkts;
+ int ret;
if (!all_ports_stopped()) {
printf("Please stop all ports first\n");
* size for all ports, so assume all ports are the same
* NIC model and use the values from Port 0.
*/
- rte_eth_dev_info_get(0, &dev_info);
+ ret = eth_dev_info_get_print_err(0, &dev_info);
+ if (ret != 0)
+ return;
+
rec_nb_pkts = dev_info.default_rxportconf.burst_size;
if (rec_nb_pkts == 0) {
static void
cmd_config_thresh_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_thresh *res = parsed_result;
static void
cmd_config_threshold_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_threshold *res = parsed_result;
cmdline_fixed_string_t stop;
};
-static void cmd_stop_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+static void cmd_stop_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
stop_packet_forwarding();
}
};
static void cmd_set_list_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_list_result *res;
union {
};
static void cmd_set_mask_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_setmask_result *res = parsed_result;
};
static void cmd_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_result *res = parsed_result;
if (!strcmp(res->what, "nbport")) {
static void
cmd_set_log_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_log_result *res;
int ret;
static void
cmd_set_txpkts_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_txpkts_result *res;
unsigned seg_lengths[RTE_MAX_SEGS_PER_PKT];
static void
cmd_set_txsplit_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_txsplit_result *res;
static void
cmd_rx_vlan_filter_all_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_rx_vlan_filter_all_result *res = parsed_result;
static void
cmd_vlan_offload_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int on;
struct cmd_vlan_offload_result *res = parsed_result;
}
else if (!strcmp(res->what, "filter"))
rx_vlan_filter_set(port_id, on);
+ else if (!strcmp(res->what, "qinq_strip"))
+ rx_vlan_qinq_strip_set(port_id, on);
else
vlan_extend_set(port_id, on);
set, "set");
cmdline_parse_token_string_t cmd_vlan_offload_what =
TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result,
- what, "strip#filter#qinq#stripq");
+ what, "strip#filter#qinq_strip#extend#stripq");
cmdline_parse_token_string_t cmd_vlan_offload_on =
TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result,
on, "on#off");
cmdline_parse_inst_t cmd_vlan_offload = {
.f = cmd_vlan_offload_parsed,
.data = NULL,
- .help_str = "vlan set strip|filter|qinq|stripq on|off "
+ .help_str = "vlan set strip|filter|qinq_strip|extend|stripq on|off "
"<port_id[,queue_id]>: "
- "Filter/Strip for rx side qinq(extended) for both rx/tx sides",
+ "Strip/Filter/QinQ for rx side Extend for both rx/tx sides",
.tokens = {
(void *)&cmd_vlan_offload_vlan,
(void *)&cmd_vlan_offload_set,
static void
cmd_vlan_tpid_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vlan_tpid_result *res = parsed_result;
enum rte_vlan_type vlan_type;
static void
cmd_rx_vlan_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_rx_vlan_filter_result *res = parsed_result;
static void
cmd_tx_vlan_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_vlan_set_result *res = parsed_result;
static void
cmd_tx_vlan_set_qinq_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_vlan_set_qinq_result *res = parsed_result;
static void
cmd_tx_vlan_set_pvid_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_vlan_set_pvid_result *res = parsed_result;
static void
cmd_tx_vlan_reset_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_vlan_reset_result *res = parsed_result;
{
struct rte_eth_dev_info dev_info;
uint64_t tx_offloads;
+ int ret;
tx_offloads = ports[port_id].dev_conf.txmode.offloads;
printf("Parse tunnel is %s\n",
(tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) ? "hw" : "sw");
/* display warnings if configuration is not supported by the NIC */
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if ((tx_offloads & DEV_TX_OFFLOAD_IPV4_CKSUM) &&
(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IPV4_CKSUM) == 0) {
printf("Warning: hardware IP checksum enabled but not "
static void
cmd_csum_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_csum_result *res = parsed_result;
int hw = 0;
uint64_t csum_offloads = 0;
struct rte_eth_dev_info dev_info;
+ int ret;
if (port_id_is_invalid(res->port_id, ENABLED_WARN)) {
printf("invalid port %d\n", res->port_id);
return;
}
- rte_eth_dev_info_get(res->port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (!strcmp(res->mode, "set")) {
if (!strcmp(res->hwsw, "hw"))
static void
cmd_csum_tunnel_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_csum_tunnel_result *res = parsed_result;
static void
cmd_tso_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tso_set_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
+ int ret;
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
if (!strcmp(res->mode, "set"))
ports[res->port_id].tso_segsz = res->tso_segsz;
- rte_eth_dev_info_get(res->port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if ((ports[res->port_id].tso_segsz != 0) &&
(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_TSO) == 0) {
printf("Error: TSO is not supported by port %d\n",
cmd_config_queue_tx_offloads(&ports[res->port_id]);
/* display warnings if configuration is not supported by the NIC */
- rte_eth_dev_info_get(res->port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if ((ports[res->port_id].tso_segsz != 0) &&
(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_TSO) == 0) {
printf("Warning: TSO enabled but not "
{
struct rte_eth_dev_info dev_info;
- rte_eth_dev_info_get(port_id, &dev_info);
+ if (eth_dev_info_get_print_err(port_id, &dev_info) != 0)
+ return dev_info;
+
if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_VXLAN_TNL_TSO))
printf("Warning: VXLAN TUNNEL TSO not supported therefore "
"not enabled for port %d\n", port_id);
static void
cmd_tunnel_tso_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tunnel_tso_set_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
static void
cmd_gro_enable_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gro_enable_result *res;
static void
cmd_gro_show_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gro_show_result *res;
static void
cmd_gro_flush_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gro_flush_result *res;
static void
cmd_gso_enable_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gso_enable_result *res;
static void
cmd_gso_size_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gso_size_result *res = parsed_result;
if (test_done == 0) {
printf("Before setting GSO segsz, please first"
- " stop fowarding\n");
+ " stop forwarding\n");
return;
}
static void
cmd_gso_show_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_gso_show_result *res = parsed_result;
static void
cmd_set_flush_rx_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_flush_rx *res = parsed_result;
no_flush_rx = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1);
static void
cmd_set_link_check_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_link_check *res = parsed_result;
no_link_check = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1);
static void
cmd_set_bypass_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bypass_mode_result *res = parsed_result;
portid_t port_id = res->port_id;
static void
cmd_set_bypass_event_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int32_t rc = -EINVAL;
struct cmd_set_bypass_event_result *res = parsed_result;
static void
cmd_set_bypass_timeout_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
__rte_unused struct cmd_set_bypass_timeout_result *res = parsed_result;
static void
cmd_show_bypass_config_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_bypass_config_result *res = parsed_result;
portid_t port_id = res->port_id;
uint32_t event_mode;
uint32_t bypass_mode;
uint32_t timeout = bypass_timeout;
- int i;
+ unsigned int i;
static const char * const timeouts[RTE_PMD_IXGBE_BYPASS_TMT_NUM] =
{"off", "1.5", "2", "3", "4", "8", "16", "32"};
"OS/board off",
"power supply off",
"timeout"};
- int num_events = (sizeof events) / (sizeof events[0]);
/* Display the bypass mode.*/
if (rte_pmd_ixgbe_bypass_state_show(port_id, &bypass_mode) != 0) {
printf("\tbypass timeout = %s\n", timeouts[timeout]);
/* Display the bypass events and associated modes. */
- for (i = RTE_PMD_IXGBE_BYPASS_EVENT_START; i < num_events; i++) {
+ for (i = RTE_PMD_IXGBE_BYPASS_EVENT_START; i < RTE_DIM(events); i++) {
if (rte_pmd_ixgbe_bypass_event_show(port_id, i, &event_mode)) {
printf("\tFailed to get bypass mode for event = %s\n",
};
static void cmd_set_bonding_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bonding_mode_result *res = parsed_result;
portid_t port_id = res->port_id;
};
static void cmd_set_bonding_lacp_dedicated_queues_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bonding_lacp_dedicated_queues_result *res = parsed_result;
portid_t port_id = res->port_id;
};
static void cmd_set_bonding_balance_xmit_policy_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bonding_balance_xmit_policy_result *res = parsed_result;
portid_t port_id = res->port_id;
};
static void cmd_show_bonding_config_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_bonding_config_result *res = parsed_result;
int bonding_mode, agg_mode;
};
static void cmd_set_bonding_primary_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bonding_primary_result *res = parsed_result;
portid_t master_port_id = res->port_id;
};
static void cmd_add_bonding_slave_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_add_bonding_slave_result *res = parsed_result;
portid_t master_port_id = res->port_id;
};
static void cmd_remove_bonding_slave_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_remove_bonding_slave_result *res = parsed_result;
portid_t master_port_id = res->port_id;
static int bond_dev_num = 0;
static void cmd_create_bonded_device_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_create_bonded_device_result *res = parsed_result;
char ethdev_name[RTE_ETH_NAME_MAX_LEN];
int port_id;
+ int ret;
if (test_done == 0) {
printf("Please stop forwarding first\n");
/* Update number of ports */
nb_ports = rte_eth_dev_count_avail();
reconfig(port_id, res->socket);
- rte_eth_promiscuous_enable(port_id);
+ ret = rte_eth_promiscuous_enable(port_id);
+ if (ret != 0)
+ printf("Failed to enable promiscuous mode for port %u: %s - ignore\n",
+ port_id, rte_strerror(-ret));
+
ports[port_id].need_setup = 0;
ports[port_id].port_status = RTE_PORT_STOPPED;
}
};
static void cmd_set_bond_mac_addr_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bond_mac_addr_result *res = parsed_result;
int ret;
};
static void cmd_set_bond_mon_period_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bond_mon_period_result *res = parsed_result;
int ret;
static void
cmd_set_bonding_agg_mode(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_bonding_agg_mode_policy_result *res = parsed_result;
uint8_t policy = AGG_BANDWIDTH;
};
static void cmd_set_fwd_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_fwd_mode_result *res = parsed_result;
};
static void cmd_set_fwd_retry_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_fwd_retry_mode_result *res = parsed_result;
};
static void cmd_set_burst_tx_retry_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_burst_tx_retry_result *res = parsed_result;
};
static void cmd_set_promisc_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
+ __rte_unused struct cmdline *cl,
void *allports)
{
struct cmd_set_promisc_mode_result *res = parsed_result;
/* all ports */
if (allports) {
- RTE_ETH_FOREACH_DEV(i) {
- if (enable)
- rte_eth_promiscuous_enable(i);
- else
- rte_eth_promiscuous_disable(i);
- }
- }
- else {
- if (enable)
- rte_eth_promiscuous_enable(res->port_num);
- else
- rte_eth_promiscuous_disable(res->port_num);
+ RTE_ETH_FOREACH_DEV(i)
+ eth_set_promisc_mode(i, enable);
+ } else {
+ eth_set_promisc_mode(res->port_num, enable);
}
}
};
static void cmd_set_allmulti_mode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
+ __rte_unused struct cmdline *cl,
void *allports)
{
struct cmd_set_allmulti_mode_result *res = parsed_result;
/* all ports */
if (allports) {
RTE_ETH_FOREACH_DEV(i) {
- if (enable)
- rte_eth_allmulticast_enable(i);
- else
- rte_eth_allmulticast_disable(i);
+ eth_set_allmulticast_mode(i, enable);
}
}
else {
- if (enable)
- rte_eth_allmulticast_enable(res->port_num);
- else
- rte_eth_allmulticast_disable(res->port_num);
+ eth_set_allmulticast_mode(res->port_num, enable);
}
}
static void
cmd_link_flow_ctrl_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
+ __rte_unused struct cmdline *cl,
void *data)
{
struct cmd_link_flow_ctrl_set_result *res = parsed_result;
static void
cmd_priority_flow_ctrl_set_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_priority_flow_ctrl_set_result *res = parsed_result;
struct rte_eth_pfc_conf pfc_conf;
* the RTE_FC_RX_PAUSE, Respond to the pause frame at the Tx side.
*/
static enum rte_eth_fc_mode rx_tx_onoff_2_pfc_mode[2][2] = {
- {RTE_FC_NONE, RTE_FC_RX_PAUSE}, {RTE_FC_TX_PAUSE, RTE_FC_FULL}
+ {RTE_FC_NONE, RTE_FC_TX_PAUSE}, {RTE_FC_RX_PAUSE, RTE_FC_FULL}
};
+ memset(&pfc_conf, 0, sizeof(struct rte_eth_pfc_conf));
rx_fc_enable = (!strncmp(res->rx_pfc_mode, "on",2)) ? 1 : 0;
tx_fc_enable = (!strncmp(res->tx_pfc_mode, "on",2)) ? 1 : 0;
pfc_conf.fc.mode = rx_tx_onoff_2_pfc_mode[rx_fc_enable][tx_fc_enable];
cmdline_fixed_string_t def;
};
-static void cmd_reset_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_reset_parsed(__rte_unused void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_printf(cl, "Reset to default forwarding configuration...\n");
set_def_fwd_config();
cmdline_parse_token_string_t cmd_start_start =
TOKEN_STRING_INITIALIZER(struct cmd_start_result, start, "start");
-static void cmd_start_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+static void cmd_start_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
start_packet_forwarding(0);
}
};
static void
-cmd_start_tx_first_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+cmd_start_tx_first_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
start_packet_forwarding(1);
}
static void
cmd_start_tx_first_n_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_start_tx_first_n_result *res = parsed_result;
cmdline_parse_token_num_t cmd_set_link_up_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_set_link_up_result, port_id, UINT16);
-static void cmd_set_link_up_parsed(__attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+static void cmd_set_link_up_parsed(__rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_link_up_result *res = parsed_result;
dev_set_link_up(res->port_id);
TOKEN_NUM_INITIALIZER(struct cmd_set_link_down_result, port_id, UINT16);
static void cmd_set_link_down_parsed(
- __attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_link_down_result *res = parsed_result;
dev_set_link_down(res->port_id);
};
static void cmd_showcfg_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_showcfg_result *res = parsed_result;
if (!strcmp(res->what, "rxtx"))
};
static void cmd_showportall_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
portid_t i;
};
static void cmd_showport_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_showport_result *res = parsed_result;
if (!strcmp(res->show, "clear")) {
};
static void cmd_showdevice_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_showdevice_result *res = parsed_result;
if (!strcmp(res->what, "info")) {
static void
cmd_showqueue_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_showqueue_result *res = parsed_result;
static void
cmd_read_reg_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_read_reg_result *res = parsed_result;
port_reg_display(res->port_id, res->reg_off);
static void
cmd_read_reg_bit_field_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_read_reg_bit_field_result *res = parsed_result;
port_reg_bit_field_display(res->port_id, res->reg_off,
static void
cmd_read_reg_bit_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_read_reg_bit_result *res = parsed_result;
port_reg_bit_display(res->port_id, res->reg_off, res->bit_pos);
static void
cmd_write_reg_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_write_reg_result *res = parsed_result;
port_reg_set(res->port_id, res->reg_off, res->value);
static void
cmd_write_reg_bit_field_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_write_reg_bit_field_result *res = parsed_result;
port_reg_bit_field_set(res->port_id, res->reg_off,
static void
cmd_write_reg_bit_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_write_reg_bit_result *res = parsed_result;
port_reg_bit_set(res->port_id, res->reg_off, res->bit_pos, res->value);
static void
cmd_read_rxd_txd_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_read_rxd_txd_result *res = parsed_result;
cmdline_fixed_string_t quit;
};
-static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+static void cmd_quit_parsed(__rte_unused void *parsed_result,
struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
cmdline_quit(cl);
}
};
static void cmd_mac_addr_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_mac_addr_result *res = parsed_result;
int ret;
};
static void cmd_set_eth_peer_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_eth_peer_result *res = parsed_result;
static void
cmd_set_qmap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_qmap_result *res = parsed_result;
int is_rx = (strcmp(res->what, "tx") == 0) ? 0 : 1;
static void
cmd_set_xstats_hide_zero_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_xstats_hide_zero_result *res;
uint16_t on_off = 0;
static void
cmd_set_uc_hash_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret=0;
struct cmd_set_uc_hash_table *res = parsed_result;
static void
cmd_set_uc_all_hash_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret=0;
struct cmd_set_uc_all_hash_table *res = parsed_result;
static void
cmd_set_vf_macvlan_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int is_on, ret = 0;
struct cmd_set_vf_macvlan_filter *res = parsed_result;
static void
cmd_set_vf_traffic_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_vf_traffic *res = parsed_result;
int is_rx = (strcmp(res->what, "rx") == 0) ? 1 : 0;
static void
cmd_set_vf_rxmode_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret = -ENOTSUP;
uint16_t vf_rxmode = 0;
};
static void cmd_vf_mac_addr_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_mac_addr_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_vf_rx_vlan_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_rx_vlan_filter *res = parsed_result;
int ret = -ENOTSUP;
};
static void cmd_queue_rate_limit_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_queue_rate_limit_result *res = parsed_result;
int ret = 0;
};
static void cmd_vf_rate_limit_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_rate_limit_result *res = parsed_result;
int ret = 0;
static void
cmd_tunnel_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tunnel_filter_result *res = parsed_result;
struct rte_eth_tunnel_filter_conf tunnel_filter_conf;
static void
cmd_tunnel_udp_config_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tunnel_udp_config *res = parsed_result;
struct rte_eth_udp_tunnel tunnel_udp;
static void
cmd_cfg_tunnel_udp_port_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_tunnel_udp_port *res = parsed_result;
struct rte_eth_udp_tunnel tunnel_udp;
static void
cmd_global_config_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_global_config_result *res = parsed_result;
struct rte_eth_global_cfg conf;
static void
cmd_set_mirror_mask_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret,nb_item,i;
struct cmd_set_mirror_mask_result *res = parsed_result;
static void
cmd_set_mirror_link_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret;
struct cmd_set_mirror_link_result *res = parsed_result;
static void
cmd_reset_mirror_rule_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret;
struct cmd_set_mirror_link_result *res = parsed_result;
#undef DUMP_SIZE
}
+
+/* Dump the socket memory statistics on console */
+static void
+dump_socket_mem(FILE *f)
+{
+ struct rte_malloc_socket_stats socket_stats;
+ unsigned int i;
+ size_t total = 0;
+ size_t alloc = 0;
+ size_t free = 0;
+ unsigned int n_alloc = 0;
+ unsigned int n_free = 0;
+ static size_t last_allocs;
+ static size_t last_total;
+
+
+ for (i = 0; i < RTE_MAX_NUMA_NODES; i++) {
+ if (rte_malloc_get_socket_stats(i, &socket_stats) ||
+ !socket_stats.heap_totalsz_bytes)
+ continue;
+ total += socket_stats.heap_totalsz_bytes;
+ alloc += socket_stats.heap_allocsz_bytes;
+ free += socket_stats.heap_freesz_bytes;
+ n_alloc += socket_stats.alloc_count;
+ n_free += socket_stats.free_count;
+ fprintf(f,
+ "Socket %u: size(M) total: %.6lf alloc: %.6lf(%.3lf%%) free: %.6lf \tcount alloc: %-4u free: %u\n",
+ i,
+ (double)socket_stats.heap_totalsz_bytes / (1024 * 1024),
+ (double)socket_stats.heap_allocsz_bytes / (1024 * 1024),
+ (double)socket_stats.heap_allocsz_bytes * 100 /
+ (double)socket_stats.heap_totalsz_bytes,
+ (double)socket_stats.heap_freesz_bytes / (1024 * 1024),
+ socket_stats.alloc_count,
+ socket_stats.free_count);
+ }
+ fprintf(f,
+ "Total : size(M) total: %.6lf alloc: %.6lf(%.3lf%%) free: %.6lf \tcount alloc: %-4u free: %u\n",
+ (double)total / (1024 * 1024), (double)alloc / (1024 * 1024),
+ (double)alloc * 100 / (double)total,
+ (double)free / (1024 * 1024),
+ n_alloc, n_free);
+ if (last_allocs)
+ fprintf(stdout, "Memory total change: %.6lf(M), allocation change: %.6lf(M)\n",
+ ((double)total - (double)last_total) / (1024 * 1024),
+ (double)(alloc - (double)last_allocs) / 1024 / 1024);
+ last_allocs = alloc;
+ last_total = total;
+}
+
static void cmd_dump_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_dump_result *res = parsed_result;
if (!strcmp(res->dump, "dump_physmem"))
rte_dump_physmem_layout(stdout);
+ else if (!strcmp(res->dump, "dump_socket_mem"))
+ dump_socket_mem(stdout);
else if (!strcmp(res->dump, "dump_memzone"))
rte_memzone_dump(stdout);
else if (!strcmp(res->dump, "dump_struct_sizes"))
TOKEN_STRING_INITIALIZER(struct cmd_dump_result, dump,
"dump_physmem#"
"dump_memzone#"
+ "dump_socket_mem#"
"dump_struct_sizes#"
"dump_ring#"
"dump_mempool#"
};
static void cmd_dump_one_parsed(void *parsed_result, struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *data)
{
struct cmd_dump_one_result *res = parsed_result;
static void
cmd_syn_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_syn_filter_result *res = parsed_result;
struct rte_eth_syn_filter syn_filter;
static void
cmd_queue_region_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_queue_region_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_region_flowtype_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_region_flowtype_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_user_priority_region_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_user_priority_region_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_flush_queue_region_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flush_queue_region_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_show_queue_region_info_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_queue_region_info *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_2tuple_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct rte_eth_ntuple_filter filter;
struct cmd_2tuple_filter_result *res = parsed_result;
static void
cmd_5tuple_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct rte_eth_ntuple_filter filter;
struct cmd_5tuple_filter_result *res = parsed_result;
static void
cmd_flex_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
int ret = 0;
struct rte_eth_flex_filter filter;
static void
cmd_ethertype_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ethertype_filter_result *res = parsed_result;
struct rte_eth_ethertype_filter filter;
static void
cmd_flow_director_filter_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flow_director_result *res = parsed_result;
struct rte_eth_fdir_filter entry;
else if (!strncmp(res->pf_vf, "vf", 2)) {
struct rte_eth_dev_info dev_info;
- memset(&dev_info, 0, sizeof(dev_info));
- rte_eth_dev_info_get(res->port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(res->port_id,
+ &dev_info);
+ if (ret != 0)
+ return;
+
errno = 0;
vf_id = strtoul(res->pf_vf + 2, &end, 10);
if (errno != 0 || *end != '\0' ||
static void
cmd_flush_flow_director_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flow_director_result *res = parsed_result;
int ret = 0;
static void
cmd_flow_director_mask_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flow_director_mask_result *res = parsed_result;
struct rte_eth_fdir_masks *mask;
static void
cmd_flow_director_flex_mask_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flow_director_flex_mask_result *res = parsed_result;
struct rte_eth_fdir_info fdir_info;
static void
cmd_flow_director_flxpld_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_flow_director_flexpayload_result *res = parsed_result;
struct rte_eth_flex_payload_cfg flex_cfg;
case RTE_ETH_HASH_FUNCTION_SIMPLE_XOR:
printf("Hash function is Simple XOR\n");
break;
+ case RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ:
+ printf("Hash function is Symmetric Toeplitz\n");
+ break;
default:
printf("Unknown hash function\n");
break;
else if (!strcmp(res->hash_func, "simple_xor"))
info.info.global_conf.hash_func =
RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
+ else if (!strcmp(res->hash_func, "symmetric_toeplitz"))
+ info.info.global_conf.hash_func =
+ RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ;
else if (!strcmp(res->hash_func, "default"))
info.info.global_conf.hash_func =
RTE_ETH_HASH_FUNCTION_DEFAULT;
port_id, UINT16);
cmdline_parse_token_string_t cmd_set_hash_global_config_hash_func =
TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
- hash_func, "toeplitz#simple_xor#default");
+ hash_func, "toeplitz#simple_xor#symmetric_toeplitz#default");
cmdline_parse_token_string_t cmd_set_hash_global_config_flow_type =
TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
flow_type,
.f = cmd_set_hash_global_config_parsed,
.data = NULL,
.help_str = "set_hash_global_config <port_id> "
- "toeplitz|simple_xor|default "
+ "toeplitz|simple_xor|symmetric_toeplitz|default "
"ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
"ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|"
"l2_payload enable|disable",
};
static void cmd_mcast_addr_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_mcast_addr_result *res = parsed_result;
static void
cmd_config_l2_tunnel_eth_type_all_parsed
(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_l2_tunnel_eth_type_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
static void
cmd_config_l2_tunnel_eth_type_specific_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_l2_tunnel_eth_type_result *res =
parsed_result;
static void
cmd_config_l2_tunnel_en_dis_all_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_l2_tunnel_en_dis_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
static void
cmd_config_l2_tunnel_en_dis_specific_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_l2_tunnel_en_dis_result *res =
parsed_result;
static void
cmd_config_e_tag_insertion_en_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res =
parsed_result;
static void
cmd_config_e_tag_insertion_dis_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res =
parsed_result;
static void
cmd_config_e_tag_stripping_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res =
parsed_result;
static void
cmd_config_e_tag_forwarding_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
static void
cmd_config_e_tag_filter_add_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
static void
cmd_config_e_tag_filter_del_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_e_tag_result *res = parsed_result;
struct rte_eth_l2_tunnel_conf entry;
static void
cmd_set_vf_vlan_anti_spoof_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_vlan_anti_spoof_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_mac_anti_spoof_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_mac_anti_spoof_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_vlan_stripq_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_vlan_stripq_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_vlan_insert_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_vlan_insert_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_tx_loopback_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_loopback_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_all_queues_drop_en_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_all_queues_drop_en_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_split_drop_en_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_split_drop_en_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_mac_addr_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_vf_mac_addr_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_macsec_offload_on_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_macsec_offload_on_result *res = parsed_result;
int ret = -ENOTSUP;
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) {
#ifdef RTE_LIBRTE_IXGBE_PMD
ret = rte_pmd_ixgbe_macsec_enable(port_id, en, rp);
static void
cmd_set_macsec_offload_off_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_macsec_offload_off_result *res = parsed_result;
int ret = -ENOTSUP;
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) {
#ifdef RTE_LIBRTE_IXGBE_PMD
ret = rte_pmd_ixgbe_macsec_disable(port_id);
static void
cmd_set_macsec_sc_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_macsec_sc_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_macsec_sa_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_macsec_sa_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_promisc_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_promisc_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_allmulti_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_allmulti_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_broadcast_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_vf_broadcast_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_set_vf_vlan_tag_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_vf_vlan_tag_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_vf_max_bw_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_tc_bw_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_vf_tc_min_bw_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_tc_bw_result *res = parsed_result;
uint8_t tc_num;
static void
cmd_tc_min_bw_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_tc_bw_result *res = parsed_result;
struct rte_port *port;
static void
cmd_vf_tc_max_bw_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_tc_bw_result *res = parsed_result;
int ret = -ENOTSUP;
port_id, UINT16);
static void cmd_set_port_tm_hierarchy_default_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_port_tm_hierarchy_default_result *res = parsed_result;
struct rte_port *p;
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vxlan_result, eth_dst);
static void cmd_set_vxlan_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_vxlan_result *res = parsed_result;
union {
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_nvgre_result, eth_dst);
static void cmd_set_nvgre_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_nvgre_result *res = parsed_result;
union {
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_l2_encap_result, eth_dst);
static void cmd_set_l2_encap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_l2_encap_result *res = parsed_result;
"l2_decap-with-vlan");
static void cmd_set_l2_decap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_l2_decap_result *res = parsed_result;
eth_dst);
static void cmd_set_mplsogre_encap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_mplsogre_encap_result *res = parsed_result;
union {
ip_version, "ipv4#ipv6");
static void cmd_set_mplsogre_decap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_mplsogre_decap_result *res = parsed_result;
eth_dst);
static void cmd_set_mplsoudp_encap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_mplsoudp_encap_result *res = parsed_result;
union {
ip_version, "ipv4#ipv6");
static void cmd_set_mplsoudp_decap_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_set_mplsoudp_decap_result *res = parsed_result;
static void
cmd_strict_link_prio_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_vf_tc_bw_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_ddp_add_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ddp_add_result *res = parsed_result;
uint8_t *buff;
static void
cmd_ddp_del_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ddp_del_result *res = parsed_result;
uint8_t *buff;
static void
cmd_ddp_info_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ddp_info_result *res = parsed_result;
uint8_t *pkg;
static void
cmd_ddp_get_list_parsed(
- __attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
#ifdef RTE_LIBRTE_I40E_PMD
struct cmd_ddp_get_list_result *res = parsed_result;
static void
cmd_cfg_input_set_parsed(
- __attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
#ifdef RTE_LIBRTE_I40E_PMD
struct cmd_cfg_input_set_result *res = parsed_result;
static void
cmd_clear_input_set_parsed(
- __attribute__((unused)) void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
#ifdef RTE_LIBRTE_I40E_PMD
struct cmd_clear_input_set_result *res = parsed_result;
static void
cmd_show_vf_stats_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_vf_stats_result *res = parsed_result;
struct rte_eth_stats stats;
static void
cmd_clear_vf_stats_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_clear_vf_stats_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_pctype_mapping_reset_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_pctype_mapping_reset_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_pctype_mapping_get_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_pctype_mapping_get_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_pctype_mapping_update_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_pctype_mapping_update_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_ptype_mapping_get_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ptype_mapping_get_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_ptype_mapping_replace_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ptype_mapping_replace_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_ptype_mapping_reset_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ptype_mapping_reset_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_ptype_mapping_update_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_ptype_mapping_update_result *res = parsed_result;
int ret = -ENOTSUP;
static void
cmd_load_from_file_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_cmdfile_result *res = parsed_result;
static void
cmd_rx_offload_get_capa_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_rx_offload_get_capa_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
portid_t port_id = res->port_id;
uint64_t queue_offloads;
uint64_t port_offloads;
+ int ret;
+
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
- rte_eth_dev_info_get(port_id, &dev_info);
queue_offloads = dev_info.rx_queue_offload_capa;
port_offloads = dev_info.rx_offload_capa ^ queue_offloads;
static void
cmd_rx_offload_get_configuration_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_rx_offload_get_configuration_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
uint64_t queue_offloads;
uint16_t nb_rx_queues;
int q;
+ int ret;
printf("Rx Offloading Configuration of port %d :\n", port_id);
print_rx_offloads(port_offloads);
printf("\n");
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
nb_rx_queues = dev_info.nb_rx_queues;
for (q = 0; q < nb_rx_queues; q++) {
queue_offloads = port->rx_conf[q].offloads;
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#"
- "crc_strip#scatter#timestamp#security#keep_crc");
+ "scatter#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,
static void
cmd_config_per_port_rx_offload_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_per_port_rx_offload_result *res = parsed_result;
portid_t port_id = res->port_id;
uint64_t single_offload;
uint16_t nb_rx_queues;
int q;
+ int ret;
if (port->port_status != RTE_PORT_STOPPED) {
printf("Error: Can't config offload when Port %d "
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
nb_rx_queues = dev_info.nb_rx_queues;
if (!strcmp(res->on_off, "on")) {
port->dev_conf.rxmode.offloads |= single_offload;
.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|crc_strip|scatter|timestamp|security|keep_crc "
+ "jumbo_frame|scatter|timestamp|security|keep_crc|rss_hash "
"on|off",
.tokens = {
(void *)&cmd_config_per_port_rx_offload_result_port,
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#"
- "crc_strip#scatter#timestamp#security#keep_crc");
+ "scatter#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,
static void
cmd_config_per_queue_rx_offload_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_per_queue_rx_offload_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
uint16_t queue_id = res->queue_id;
struct rte_port *port = &ports[port_id];
uint64_t single_offload;
+ int ret;
if (port->port_status != RTE_PORT_STOPPED) {
printf("Error: Can't config offload when Port %d "
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (queue_id >= dev_info.nb_rx_queues) {
printf("Error: input queue_id should be 0 ... "
"%d\n", dev_info.nb_rx_queues - 1);
"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|crc_strip|scatter|timestamp|security|keep_crc "
+ "jumbo_frame|scatter|timestamp|security|keep_crc "
"on|off",
.tokens = {
(void *)&cmd_config_per_queue_rx_offload_result_port,
static void
cmd_tx_offload_get_capa_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_offload_get_capa_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
portid_t port_id = res->port_id;
uint64_t queue_offloads;
uint64_t port_offloads;
+ int ret;
+
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
- rte_eth_dev_info_get(port_id, &dev_info);
queue_offloads = dev_info.tx_queue_offload_capa;
port_offloads = dev_info.tx_offload_capa ^ queue_offloads;
static void
cmd_tx_offload_get_configuration_parsed(
void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_tx_offload_get_configuration_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
uint64_t queue_offloads;
uint16_t nb_tx_queues;
int q;
+ int ret;
printf("Tx Offloading Configuration of port %d :\n", port_id);
print_tx_offloads(port_offloads);
printf("\n");
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
nb_tx_queues = dev_info.nb_tx_queues;
for (q = 0; q < nb_tx_queues; q++) {
queue_offloads = port->tx_conf[q].offloads;
"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#"
- "match_metadata");
+ "mt_lockfree#multi_segs#mbuf_fast_free#security");
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,
static void
cmd_config_per_port_tx_offload_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_per_port_tx_offload_result *res = parsed_result;
portid_t port_id = res->port_id;
uint64_t single_offload;
uint16_t nb_tx_queues;
int q;
+ int ret;
if (port->port_status != RTE_PORT_STOPPED) {
printf("Error: Can't config offload when Port %d "
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
nb_tx_queues = dev_info.nb_tx_queues;
if (!strcmp(res->on_off, "on")) {
port->dev_conf.txmode.offloads |= single_offload;
"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|"
- "match_metadata on|off",
+ "mt_lockfree|multi_segs|mbuf_fast_free|security on|off",
.tokens = {
(void *)&cmd_config_per_port_tx_offload_result_port,
(void *)&cmd_config_per_port_tx_offload_result_config,
static void
cmd_config_per_queue_tx_offload_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_per_queue_tx_offload_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
uint16_t queue_id = res->queue_id;
struct rte_port *port = &ports[port_id];
uint64_t single_offload;
+ int ret;
if (port->port_status != RTE_PORT_STOPPED) {
printf("Error: Can't config offload when Port %d "
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (queue_id >= dev_info.nb_tx_queues) {
printf("Error: input queue_id should be 0 ... "
"%d\n", dev_info.nb_tx_queues - 1);
static void
cmd_config_tx_metadata_specific_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_config_tx_metadata_specific_result *res = parsed_result;
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
- ports[res->port_id].tx_metadata = rte_cpu_to_be_32(res->value);
+ ports[res->port_id].tx_metadata = res->value;
/* Add/remove callback to insert valid metadata in every Tx packet. */
if (ports[res->port_id].tx_metadata)
add_tx_md_callback(res->port_id);
else
remove_tx_md_callback(res->port_id);
+ rte_flow_dynf_metadata_register();
}
cmdline_parse_token_string_t cmd_config_tx_metadata_specific_port =
},
};
+/* *** set dynf *** */
+struct cmd_config_tx_dynf_specific_result {
+ cmdline_fixed_string_t port;
+ cmdline_fixed_string_t keyword;
+ uint16_t port_id;
+ cmdline_fixed_string_t item;
+ cmdline_fixed_string_t name;
+ cmdline_fixed_string_t value;
+};
+
+static void
+cmd_config_dynf_specific_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_config_tx_dynf_specific_result *res = parsed_result;
+ struct rte_mbuf_dynflag desc_flag;
+ int flag;
+ uint64_t old_port_flags;
+
+ if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+ return;
+ flag = rte_mbuf_dynflag_lookup(res->name, NULL);
+ if (flag <= 0) {
+ if (strlcpy(desc_flag.name, res->name,
+ RTE_MBUF_DYN_NAMESIZE) >= RTE_MBUF_DYN_NAMESIZE) {
+ printf("Flag name too long\n");
+ return;
+ }
+ desc_flag.flags = 0;
+ flag = rte_mbuf_dynflag_register(&desc_flag);
+ if (flag < 0) {
+ printf("Can't register flag\n");
+ return;
+ }
+ strcpy(dynf_names[flag], desc_flag.name);
+ }
+ old_port_flags = ports[res->port_id].mbuf_dynf;
+ if (!strcmp(res->value, "set")) {
+ ports[res->port_id].mbuf_dynf |= 1UL << flag;
+ if (old_port_flags == 0)
+ add_tx_dynf_callback(res->port_id);
+ } else {
+ ports[res->port_id].mbuf_dynf &= ~(1UL << flag);
+ if (ports[res->port_id].mbuf_dynf == 0)
+ remove_tx_dynf_callback(res->port_id);
+ }
+}
+
+cmdline_parse_token_string_t cmd_config_tx_dynf_specific_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
+ keyword, "port");
+cmdline_parse_token_string_t cmd_config_tx_dynf_specific_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
+ keyword, "config");
+cmdline_parse_token_num_t cmd_config_tx_dynf_specific_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
+ port_id, UINT16);
+cmdline_parse_token_string_t cmd_config_tx_dynf_specific_item =
+ TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
+ item, "dynf");
+cmdline_parse_token_string_t cmd_config_tx_dynf_specific_name =
+ TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
+ name, NULL);
+cmdline_parse_token_string_t cmd_config_tx_dynf_specific_value =
+ TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
+ value, "set#clear");
+
+cmdline_parse_inst_t cmd_config_tx_dynf_specific = {
+ .f = cmd_config_dynf_specific_parsed,
+ .data = NULL,
+ .help_str = "port config <port id> dynf <name> set|clear",
+ .tokens = {
+ (void *)&cmd_config_tx_dynf_specific_port,
+ (void *)&cmd_config_tx_dynf_specific_keyword,
+ (void *)&cmd_config_tx_dynf_specific_port_id,
+ (void *)&cmd_config_tx_dynf_specific_item,
+ (void *)&cmd_config_tx_dynf_specific_name,
+ (void *)&cmd_config_tx_dynf_specific_value,
+ NULL,
+ },
+};
+
/* *** display tx_metadata per port configuration *** */
struct cmd_show_tx_metadata_result {
cmdline_fixed_string_t cmd_show;
static void
cmd_show_tx_metadata_parsed(void *parsed_result,
- __attribute__((unused)) struct cmdline *cl,
- __attribute__((unused)) void *data)
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
{
struct cmd_show_tx_metadata_result *res = parsed_result;
}
if (!strcmp(res->cmd_keyword, "tx_metadata")) {
printf("Port %u tx_metadata: %u\n", res->cmd_pid,
- rte_be_to_cpu_32(ports[res->cmd_pid].tx_metadata));
+ ports[res->cmd_pid].tx_metadata);
}
}
},
};
+/* show port supported ptypes */
+
+/* Common result structure for show port ptypes */
+struct cmd_show_port_supported_ptypes_result {
+ cmdline_fixed_string_t show;
+ cmdline_fixed_string_t port;
+ portid_t port_id;
+ cmdline_fixed_string_t ptypes;
+};
+
+/* Common CLI fields for show port ptypes */
+cmdline_parse_token_string_t cmd_show_port_supported_ptypes_show =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_port_supported_ptypes_result,
+ show, "show");
+cmdline_parse_token_string_t cmd_show_port_supported_ptypes_port =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_port_supported_ptypes_result,
+ port, "port");
+cmdline_parse_token_num_t cmd_show_port_supported_ptypes_port_id =
+ TOKEN_NUM_INITIALIZER
+ (struct cmd_show_port_supported_ptypes_result,
+ port_id, UINT16);
+cmdline_parse_token_string_t cmd_show_port_supported_ptypes_ptypes =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_port_supported_ptypes_result,
+ ptypes, "ptypes");
+
+static void
+cmd_show_port_supported_ptypes_parsed(
+ void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+#define RSVD_PTYPE_MASK 0xf0000000
+#define MAX_PTYPES_PER_LAYER 16
+#define LTYPE_NAMESIZE 32
+#define PTYPE_NAMESIZE 256
+ struct cmd_show_port_supported_ptypes_result *res = parsed_result;
+ char buf[PTYPE_NAMESIZE], ltype[LTYPE_NAMESIZE];
+ uint32_t ptype_mask = RTE_PTYPE_L2_MASK;
+ uint32_t ptypes[MAX_PTYPES_PER_LAYER];
+ uint16_t port_id = res->port_id;
+ int ret, i;
+
+ ret = rte_eth_dev_get_supported_ptypes(port_id, ptype_mask, NULL, 0);
+ if (ret < 0)
+ return;
+
+ while (ptype_mask != RSVD_PTYPE_MASK) {
+
+ switch (ptype_mask) {
+ case RTE_PTYPE_L2_MASK:
+ strlcpy(ltype, "L2", sizeof(ltype));
+ break;
+ case RTE_PTYPE_L3_MASK:
+ strlcpy(ltype, "L3", sizeof(ltype));
+ break;
+ case RTE_PTYPE_L4_MASK:
+ strlcpy(ltype, "L4", sizeof(ltype));
+ break;
+ case RTE_PTYPE_TUNNEL_MASK:
+ strlcpy(ltype, "Tunnel", sizeof(ltype));
+ break;
+ case RTE_PTYPE_INNER_L2_MASK:
+ strlcpy(ltype, "Inner L2", sizeof(ltype));
+ break;
+ case RTE_PTYPE_INNER_L3_MASK:
+ strlcpy(ltype, "Inner L3", sizeof(ltype));
+ break;
+ case RTE_PTYPE_INNER_L4_MASK:
+ strlcpy(ltype, "Inner L4", sizeof(ltype));
+ break;
+ default:
+ return;
+ }
+
+ ret = rte_eth_dev_get_supported_ptypes(res->port_id,
+ ptype_mask, ptypes,
+ MAX_PTYPES_PER_LAYER);
+
+ if (ret > 0)
+ printf("Supported %s ptypes:\n", ltype);
+ else
+ printf("%s ptypes unsupported\n", ltype);
+
+ for (i = 0; i < ret; ++i) {
+ rte_get_ptype_name(ptypes[i], buf, sizeof(buf));
+ printf("%s\n", buf);
+ }
+
+ ptype_mask <<= 4;
+ }
+}
+
+cmdline_parse_inst_t cmd_show_port_supported_ptypes = {
+ .f = cmd_show_port_supported_ptypes_parsed,
+ .data = NULL,
+ .help_str = "show port <port_id> ptypes",
+ .tokens = {
+ (void *)&cmd_show_port_supported_ptypes_show,
+ (void *)&cmd_show_port_supported_ptypes_port,
+ (void *)&cmd_show_port_supported_ptypes_port_id,
+ (void *)&cmd_show_port_supported_ptypes_ptypes,
+ NULL,
+ },
+};
+
+/* *** display rx/tx descriptor status *** */
+struct cmd_show_rx_tx_desc_status_result {
+ cmdline_fixed_string_t cmd_show;
+ cmdline_fixed_string_t cmd_port;
+ cmdline_fixed_string_t cmd_keyword;
+ cmdline_fixed_string_t cmd_desc;
+ cmdline_fixed_string_t cmd_status;
+ portid_t cmd_pid;
+ portid_t cmd_qid;
+ portid_t cmd_did;
+};
+
+static void
+cmd_show_rx_tx_desc_status_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_show_rx_tx_desc_status_result *res = parsed_result;
+ int rc;
+
+ if (!rte_eth_dev_is_valid_port(res->cmd_pid)) {
+ printf("invalid port id %u\n", res->cmd_pid);
+ return;
+ }
+
+ if (!strcmp(res->cmd_keyword, "rxq")) {
+ rc = rte_eth_rx_descriptor_status(res->cmd_pid, res->cmd_qid,
+ res->cmd_did);
+ if (rc < 0) {
+ printf("Invalid queueid = %d\n", res->cmd_qid);
+ return;
+ }
+ if (rc == RTE_ETH_RX_DESC_AVAIL)
+ printf("Desc status = AVAILABLE\n");
+ else if (rc == RTE_ETH_RX_DESC_DONE)
+ printf("Desc status = DONE\n");
+ else
+ printf("Desc status = UNAVAILABLE\n");
+ } else if (!strcmp(res->cmd_keyword, "txq")) {
+ rc = rte_eth_tx_descriptor_status(res->cmd_pid, res->cmd_qid,
+ res->cmd_did);
+ if (rc < 0) {
+ printf("Invalid queueid = %d\n", res->cmd_qid);
+ return;
+ }
+ if (rc == RTE_ETH_TX_DESC_FULL)
+ printf("Desc status = FULL\n");
+ else if (rc == RTE_ETH_TX_DESC_DONE)
+ printf("Desc status = DONE\n");
+ else
+ printf("Desc status = UNAVAILABLE\n");
+ }
+}
+
+cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_show =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
+ cmd_show, "show");
+cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
+ cmd_port, "port");
+cmdline_parse_token_num_t cmd_show_rx_tx_desc_status_pid =
+ TOKEN_NUM_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
+ cmd_pid, UINT16);
+cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
+ cmd_keyword, "rxq#txq");
+cmdline_parse_token_num_t cmd_show_rx_tx_desc_status_qid =
+ TOKEN_NUM_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
+ cmd_qid, UINT16);
+cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_desc =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
+ cmd_desc, "desc");
+cmdline_parse_token_num_t cmd_show_rx_tx_desc_status_did =
+ TOKEN_NUM_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
+ cmd_did, UINT16);
+cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_status =
+ TOKEN_STRING_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
+ cmd_status, "status");
+cmdline_parse_inst_t cmd_show_rx_tx_desc_status = {
+ .f = cmd_show_rx_tx_desc_status_parsed,
+ .data = NULL,
+ .help_str = "show port <port_id> rxq|txq <queue_id> desc <desc_id> "
+ "status",
+ .tokens = {
+ (void *)&cmd_show_rx_tx_desc_status_show,
+ (void *)&cmd_show_rx_tx_desc_status_port,
+ (void *)&cmd_show_rx_tx_desc_status_pid,
+ (void *)&cmd_show_rx_tx_desc_status_keyword,
+ (void *)&cmd_show_rx_tx_desc_status_qid,
+ (void *)&cmd_show_rx_tx_desc_status_desc,
+ (void *)&cmd_show_rx_tx_desc_status_did,
+ (void *)&cmd_show_rx_tx_desc_status_status,
+ NULL,
+ },
+};
+
+/* Common result structure for set port ptypes */
+struct cmd_set_port_ptypes_result {
+ cmdline_fixed_string_t set;
+ cmdline_fixed_string_t port;
+ portid_t port_id;
+ cmdline_fixed_string_t ptype_mask;
+ uint32_t mask;
+};
+
+/* Common CLI fields for set port ptypes */
+cmdline_parse_token_string_t cmd_set_port_ptypes_set =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_set_port_ptypes_result,
+ set, "set");
+cmdline_parse_token_string_t cmd_set_port_ptypes_port =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_set_port_ptypes_result,
+ port, "port");
+cmdline_parse_token_num_t cmd_set_port_ptypes_port_id =
+ TOKEN_NUM_INITIALIZER
+ (struct cmd_set_port_ptypes_result,
+ port_id, UINT16);
+cmdline_parse_token_string_t cmd_set_port_ptypes_mask_str =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_set_port_ptypes_result,
+ ptype_mask, "ptype_mask");
+cmdline_parse_token_num_t cmd_set_port_ptypes_mask_u32 =
+ TOKEN_NUM_INITIALIZER
+ (struct cmd_set_port_ptypes_result,
+ mask, UINT32);
+
+static void
+cmd_set_port_ptypes_parsed(
+ void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_port_ptypes_result *res = parsed_result;
+#define PTYPE_NAMESIZE 256
+ char ptype_name[PTYPE_NAMESIZE];
+ uint16_t port_id = res->port_id;
+ uint32_t ptype_mask = res->mask;
+ int ret, i;
+
+ ret = rte_eth_dev_get_supported_ptypes(port_id, RTE_PTYPE_ALL_MASK,
+ NULL, 0);
+ if (ret <= 0) {
+ printf("Port %d doesn't support any ptypes.\n", port_id);
+ return;
+ }
+
+ uint32_t ptypes[ret];
+
+ ret = rte_eth_dev_set_ptypes(port_id, ptype_mask, ptypes, ret);
+ if (ret < 0) {
+ printf("Unable to set requested ptypes for Port %d\n", port_id);
+ return;
+ }
+
+ printf("Successfully set following ptypes for Port %d\n", port_id);
+ for (i = 0; i < ret && ptypes[i] != RTE_PTYPE_UNKNOWN; i++) {
+ rte_get_ptype_name(ptypes[i], ptype_name, sizeof(ptype_name));
+ printf("%s\n", ptype_name);
+ }
+
+ clear_ptypes = false;
+}
+
+cmdline_parse_inst_t cmd_set_port_ptypes = {
+ .f = cmd_set_port_ptypes_parsed,
+ .data = NULL,
+ .help_str = "set port <port_id> ptype_mask <mask>",
+ .tokens = {
+ (void *)&cmd_set_port_ptypes_set,
+ (void *)&cmd_set_port_ptypes_port,
+ (void *)&cmd_set_port_ptypes_port_id,
+ (void *)&cmd_set_port_ptypes_mask_str,
+ (void *)&cmd_set_port_ptypes_mask_u32,
+ NULL,
+ },
+};
+
+/* *** display mac addresses added to a port *** */
+struct cmd_showport_macs_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_showport_macs_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_showport_macs_result *res = parsed_result;
+
+ if (port_id_is_invalid(res->cmd_pid, ENABLED_WARN))
+ return;
+
+ if (!strcmp(res->cmd_keyword, "macs"))
+ show_macs(res->cmd_pid);
+ else if (!strcmp(res->cmd_keyword, "mcast_macs"))
+ show_mcast_macs(res->cmd_pid);
+}
+
+cmdline_parse_token_string_t cmd_showport_macs_show =
+ TOKEN_STRING_INITIALIZER(struct cmd_showport_macs_result,
+ cmd_show, "show");
+cmdline_parse_token_string_t cmd_showport_macs_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_showport_macs_result,
+ cmd_port, "port");
+cmdline_parse_token_num_t cmd_showport_macs_pid =
+ TOKEN_NUM_INITIALIZER(struct cmd_showport_macs_result,
+ cmd_pid, UINT16);
+cmdline_parse_token_string_t cmd_showport_macs_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_showport_macs_result,
+ cmd_keyword, "macs#mcast_macs");
+
+cmdline_parse_inst_t cmd_showport_macs = {
+ .f = cmd_showport_macs_parsed,
+ .data = NULL,
+ .help_str = "show port <port_id> macs|mcast_macs",
+ .tokens = {
+ (void *)&cmd_showport_macs_show,
+ (void *)&cmd_showport_macs_port,
+ (void *)&cmd_showport_macs_pid,
+ (void *)&cmd_showport_macs_keyword,
+ NULL,
+ },
+};
+
/* ******************************************************************************** */
/* list of instructions */
(cmdline_parse_inst_t *)&cmd_config_rx_tx,
(cmdline_parse_inst_t *)&cmd_config_mtu,
(cmdline_parse_inst_t *)&cmd_config_max_pkt_len,
+ (cmdline_parse_inst_t *)&cmd_config_max_lro_pkt_size,
(cmdline_parse_inst_t *)&cmd_config_rx_mode_flag,
(cmdline_parse_inst_t *)&cmd_config_rss,
(cmdline_parse_inst_t *)&cmd_config_rxtx_ring_size,
(cmdline_parse_inst_t *)&cmd_setup_rxtx_queue,
(cmdline_parse_inst_t *)&cmd_config_rss_reta,
(cmdline_parse_inst_t *)&cmd_showport_reta,
+ (cmdline_parse_inst_t *)&cmd_showport_macs,
(cmdline_parse_inst_t *)&cmd_config_burst,
(cmdline_parse_inst_t *)&cmd_config_thresh,
(cmdline_parse_inst_t *)&cmd_config_threshold,
(cmdline_parse_inst_t *)&cmd_clear_input_set,
(cmdline_parse_inst_t *)&cmd_show_vf_stats,
(cmdline_parse_inst_t *)&cmd_clear_vf_stats,
+ (cmdline_parse_inst_t *)&cmd_show_port_supported_ptypes,
+ (cmdline_parse_inst_t *)&cmd_set_port_ptypes,
(cmdline_parse_inst_t *)&cmd_ptype_mapping_get,
(cmdline_parse_inst_t *)&cmd_ptype_mapping_replace,
(cmdline_parse_inst_t *)&cmd_ptype_mapping_reset,
#endif
(cmdline_parse_inst_t *)&cmd_config_tx_metadata_specific,
(cmdline_parse_inst_t *)&cmd_show_tx_metadata,
+ (cmdline_parse_inst_t *)&cmd_show_rx_tx_desc_status,
(cmdline_parse_inst_t *)&cmd_set_raw,
+ (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,
NULL,
};
git.droids-corp.org / dpdk.git / blobdiff