#include <rte_eal.h>
#include <rte_per_lcore.h>
#include <rte_lcore.h>
-#include <rte_atomic.h>
#include <rte_branch_prediction.h>
#include <rte_ring.h>
#include <rte_mempool.h>
#include <rte_string_fns.h>
#include <rte_devargs.h>
#include <rte_flow.h>
+#ifdef RTE_LIB_GRO
#include <rte_gro.h>
+#endif
#include <rte_mbuf_dyn.h>
#include <cmdline_rdline.h>
"show port (port_id) macs|mcast_macs"
" Display list of mac addresses added to port.\n\n"
+ "show port (port_id) flow transfer proxy\n"
+ " Display proxy port to manage transfer flows\n\n"
+
"show port (port_id) fec capabilities"
" Show fec capabilities of a port.\n\n"
"tso show (portid)"
" Display the status of TCP Segmentation Offload.\n\n"
+#ifdef RTE_LIB_GRO
"set port (port_id) gro on|off\n"
" Enable or disable Generic Receive Offload in"
" csum forwarding engine.\n\n"
"set gro flush (cycles)\n"
" Set the cycle to flush GROed packets from"
" reassembly tables.\n\n"
+#endif
+#ifdef RTE_LIB_GSO
"set port (port_id) gso (on|off)"
" Enable or disable Generic Segmentation Offload in"
" csum forwarding engine.\n\n"
"show port (port_id) gso\n"
" Show GSO configuration.\n\n"
+#endif
"set fwd (%s)\n"
" Set packet forwarding mode.\n\n"
" Set the priority flow control parameter on a"
" port.\n\n"
+ "set pfc_queue_ctrl (port_id) rx (on|off) (tx_qid)"
+ " (tx_tc) tx (on|off) (rx_qid) (rx_tc) (pause_time)\n"
+ " Set the queue priority flow control parameter on a"
+ " given Rx and Tx queues of a port.\n\n"
+
"set stat_qmap (tx|rx) (port_id) (queue_id) (qmapping)\n"
" Set statistics mapping (qmapping 0..15) for RX/TX"
" queue on port.\n"
" Set the option to enable display of RX and TX bursts.\n"
"set port (port_id) vf (vf_id) rx|tx on|off\n"
- " Enable/Disable a VF receive/tranmit from a port\n\n"
+ " Enable/Disable a VF receive/transmit from a port\n\n"
"set port (port_id) vf (vf_id) rxmode (AUPE|ROPE|BAM"
"|MPE) (on|off)\n"
"receive buffers available.\n\n"
"port config all rss (all|default|ip|tcp|udp|sctp|"
- "ether|port|vxlan|geneve|nvgre|vxlan-gpe|ecpri|mpls|none|level-default|"
- "level-outer|level-inner|<flowtype_id>)\n"
+ "ether|port|vxlan|geneve|nvgre|vxlan-gpe|ecpri|mpls|ipv4-chksum|l2tpv2|"
+ "none|level-default|level-outer|level-inner|<flowtype_id>)\n"
" Set the RSS mode.\n\n"
"port config port-id rss reta (hash,queue)[,(hash,queue)]\n"
{
struct cmd_config_mtu_result *res = parsed_result;
- if (res->value < RTE_ETHER_MIN_LEN) {
- fprintf(stderr, "mtu cannot be less than %d\n", RTE_ETHER_MIN_LEN);
- return;
- }
port_mtu_set(res->port_id, res->value);
}
RTE_ETH_RSS_TCP | RTE_ETH_RSS_UDP | RTE_ETH_RSS_SCTP |
RTE_ETH_RSS_L2_PAYLOAD | RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_ESP |
RTE_ETH_RSS_AH | RTE_ETH_RSS_PFCP | RTE_ETH_RSS_GTPU |
- RTE_ETH_RSS_ECPRI;
+ RTE_ETH_RSS_ECPRI | RTE_ETH_RSS_L2TPV2;
else if (!strcmp(res->value, "eth"))
rss_conf.rss_hf = RTE_ETH_RSS_ETH;
else if (!strcmp(res->value, "vlan"))
rss_conf.rss_hf = RTE_ETH_RSS_MPLS;
else if (!strcmp(res->value, "ipv4-chksum"))
rss_conf.rss_hf = RTE_ETH_RSS_IPV4_CHKSUM;
+ else if (!strcmp(res->value, "l2tpv2"))
+ rss_conf.rss_hf = RTE_ETH_RSS_L2TPV2;
else if (!strcmp(res->value, "none"))
rss_conf.rss_hf = 0;
else if (!strcmp(res->value, "level-default")) {
.data = NULL,
.help_str = "port config all rss "
"all|default|eth|vlan|ip|tcp|udp|sctp|ether|port|vxlan|geneve|"
- "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|ecpri|mpls|none|level-default|"
- "level-outer|level-inner|ipv4-chksum|<flowtype_id>",
+ "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|ecpri|mpls|ipv4-chksum|l2tpv2|"
+ "none|level-default|level-outer|level-inner|<flowtype_id>",
.tokens = {
(void *)&cmd_config_rss_port,
(void *)&cmd_config_rss_keyword,
"ipv6-tcp-ex#ipv6-udp-ex#"
"l3-src-only#l3-dst-only#l4-src-only#l4-dst-only#"
"l2-src-only#l2-dst-only#s-vlan#c-vlan#"
- "l2tpv3#esp#ah#pfcp#pppoe#gtpu#ecpri#mpls");
+ "l2tpv3#esp#ah#pfcp#pppoe#gtpu#ecpri#mpls#l2tpv2");
cmdline_parse_token_string_t cmd_config_rss_hash_key_value =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, key, NULL);
"l2-payload|ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex|"
"l3-src-only|l3-dst-only|l4-src-only|l4-dst-only|"
"l2-src-only|l2-dst-only|s-vlan|c-vlan|"
- "l2tpv3|esp|ah|pfcp|pppoe|gtpu|ecpri|mpls "
+ "l2tpv3|esp|ah|pfcp|pppoe|gtpu|ecpri|mpls|l2tpv2 "
"<string of hex digits (variable length, NIC dependent)>",
.tokens = {
(void *)&cmd_config_rss_hash_key_port,
ret = rte_eth_dev_tx_queue_stop(res->portid, res->qid);
if (ret == -ENOTSUP)
- fprintf(stderr, "Function not supported in PMD driver\n");
+ fprintf(stderr, "Function not supported in PMD\n");
}
cmdline_parse_token_string_t cmd_config_rxtx_queue_port =
return -1;
}
for (i = 0; i < ret; i++)
- conf[i].mask = (uint64_t)strtoul(str_fld[i], &end, 0);
+ conf[i].mask = (uint64_t)strtoull(str_fld[i], &end, 0);
return 0;
}
},
};
+#ifdef RTE_LIB_GRO
/* *** SET GRO FOR A PORT *** */
struct cmd_gro_enable_result {
cmdline_fixed_string_t cmd_set;
NULL,
},
};
+#endif /* RTE_LIB_GRO */
+#ifdef RTE_LIB_GSO
/* *** ENABLE/DISABLE GSO *** */
struct cmd_gso_enable_result {
cmdline_fixed_string_t cmd_set;
NULL,
},
};
+#endif /* RTE_LIB_GSO */
/* *** ENABLE/DISABLE FLUSH ON RX STREAMS *** */
struct cmd_set_flush_rx {
{
struct cmd_set_bonding_mode_result *res = parsed_result;
portid_t port_id = res->port_id;
+ struct rte_port *port = &ports[port_id];
+
+ /*
+ * Bonding mode changed means resources of device changed, like whether
+ * started rte timer or not. Device should be restarted when resources
+ * of device changed.
+ */
+ if (port->port_status != RTE_PORT_STOPPED) {
+ fprintf(stderr,
+ "\t Error: Can't set bonding mode when port %d is not stopped\n",
+ port_id);
+ return;
+ }
/* Set the bonding mode for the relevant port. */
if (0 != rte_eth_bond_mode_set(port_id, res->value))
"Failed to enable promiscuous mode for port %u: %s - ignore\n",
port_id, rte_strerror(-ret));
+ ports[port_id].bond_flag = 1;
ports[port_id].need_setup = 0;
ports[port_id].port_status = RTE_PORT_STOPPED;
}
},
};
+struct cmd_queue_priority_flow_ctrl_set_result {
+ cmdline_fixed_string_t set;
+ cmdline_fixed_string_t pfc_queue_ctrl;
+ portid_t port_id;
+ cmdline_fixed_string_t rx;
+ cmdline_fixed_string_t rx_pfc_mode;
+ uint16_t tx_qid;
+ uint8_t tx_tc;
+ cmdline_fixed_string_t tx;
+ cmdline_fixed_string_t tx_pfc_mode;
+ uint16_t rx_qid;
+ uint8_t rx_tc;
+ uint16_t pause_time;
+};
+
+static void
+cmd_queue_priority_flow_ctrl_set_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_queue_priority_flow_ctrl_set_result *res = parsed_result;
+ struct rte_eth_pfc_queue_conf pfc_queue_conf;
+ int rx_fc_enable, tx_fc_enable;
+ int ret;
+
+ /*
+ * Rx on/off, flow control is enabled/disabled on RX side. This can
+ * indicate the RTE_ETH_FC_TX_PAUSE, Transmit pause frame at the Rx
+ * side. Tx on/off, flow control is enabled/disabled on TX side. This
+ * can indicate the RTE_ETH_FC_RX_PAUSE, Respond to the pause frame at
+ * the Tx side.
+ */
+ static enum rte_eth_fc_mode rx_tx_onoff_2_mode[2][2] = {
+ {RTE_ETH_FC_NONE, RTE_ETH_FC_TX_PAUSE},
+ {RTE_ETH_FC_RX_PAUSE, RTE_ETH_FC_FULL}
+ };
+
+ memset(&pfc_queue_conf, 0, sizeof(struct rte_eth_pfc_queue_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_queue_conf.mode = rx_tx_onoff_2_mode[rx_fc_enable][tx_fc_enable];
+ pfc_queue_conf.rx_pause.tc = res->tx_tc;
+ pfc_queue_conf.rx_pause.tx_qid = res->tx_qid;
+ pfc_queue_conf.tx_pause.tc = res->rx_tc;
+ pfc_queue_conf.tx_pause.rx_qid = res->rx_qid;
+ pfc_queue_conf.tx_pause.pause_time = res->pause_time;
+
+ ret = rte_eth_dev_priority_flow_ctrl_queue_configure(res->port_id,
+ &pfc_queue_conf);
+ if (ret != 0) {
+ fprintf(stderr,
+ "bad queue priority flow control parameter, rc = %d\n",
+ ret);
+ }
+}
+
+cmdline_parse_token_string_t cmd_q_pfc_set_set =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ set, "set");
+cmdline_parse_token_string_t cmd_q_pfc_set_flow_ctrl =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ pfc_queue_ctrl, "pfc_queue_ctrl");
+cmdline_parse_token_num_t cmd_q_pfc_set_portid =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ port_id, RTE_UINT16);
+cmdline_parse_token_string_t cmd_q_pfc_set_rx =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ rx, "rx");
+cmdline_parse_token_string_t cmd_q_pfc_set_rx_mode =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ rx_pfc_mode, "on#off");
+cmdline_parse_token_num_t cmd_q_pfc_set_tx_qid =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ tx_qid, RTE_UINT16);
+cmdline_parse_token_num_t cmd_q_pfc_set_tx_tc =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ tx_tc, RTE_UINT8);
+cmdline_parse_token_string_t cmd_q_pfc_set_tx =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ tx, "tx");
+cmdline_parse_token_string_t cmd_q_pfc_set_tx_mode =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ tx_pfc_mode, "on#off");
+cmdline_parse_token_num_t cmd_q_pfc_set_rx_qid =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ rx_qid, RTE_UINT16);
+cmdline_parse_token_num_t cmd_q_pfc_set_rx_tc =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ rx_tc, RTE_UINT8);
+cmdline_parse_token_num_t cmd_q_pfc_set_pause_time =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ pause_time, RTE_UINT16);
+
+cmdline_parse_inst_t cmd_queue_priority_flow_control_set = {
+ .f = cmd_queue_priority_flow_ctrl_set_parsed,
+ .data = NULL,
+ .help_str = "set pfc_queue_ctrl <port_id> rx <on|off> <tx_qid> <tx_tc> "
+ "tx <on|off> <rx_qid> <rx_tc> <pause_time>: "
+ "Configure the Ethernet queue priority flow control",
+ .tokens = {
+ (void *)&cmd_q_pfc_set_set,
+ (void *)&cmd_q_pfc_set_flow_ctrl,
+ (void *)&cmd_q_pfc_set_portid,
+ (void *)&cmd_q_pfc_set_rx,
+ (void *)&cmd_q_pfc_set_rx_mode,
+ (void *)&cmd_q_pfc_set_tx_qid,
+ (void *)&cmd_q_pfc_set_tx_tc,
+ (void *)&cmd_q_pfc_set_tx,
+ (void *)&cmd_q_pfc_set_tx_mode,
+ (void *)&cmd_q_pfc_set_rx_qid,
+ (void *)&cmd_q_pfc_set_rx_tc,
+ (void *)&cmd_q_pfc_set_pause_time,
+ NULL,
+ },
+};
+
/* *** RESET CONFIGURATION *** */
struct cmd_reset_result {
cmdline_fixed_string_t reset;
}
RTE_SET_USED(is_on);
+ RTE_SET_USED(vf_rxmode);
#ifdef RTE_NET_IXGBE
if (ret == -ENOTSUP)
ret = 0;
no_print_return:
- if (proto)
- free(proto);
+ free(proto);
#endif
if (ret == -ENOTSUP)
- fprintf(stderr, "Function not supported in PMD driver\n");
+ fprintf(stderr, "Function not supported in PMD\n");
close_file(pkg);
}
},
};
+/* *** show flow transfer proxy port ID for the given port *** */
+struct cmd_show_port_flow_transfer_proxy_result {
+ cmdline_fixed_string_t show;
+ cmdline_fixed_string_t port;
+ portid_t port_id;
+ cmdline_fixed_string_t flow;
+ cmdline_fixed_string_t transfer;
+ cmdline_fixed_string_t proxy;
+};
+
+cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_show =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_port_flow_transfer_proxy_result,
+ show, "show");
+cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_port =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_port_flow_transfer_proxy_result,
+ port, "port");
+cmdline_parse_token_num_t cmd_show_port_flow_transfer_proxy_port_id =
+ TOKEN_NUM_INITIALIZER
+ (struct cmd_show_port_flow_transfer_proxy_result,
+ port_id, RTE_UINT16);
+cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_flow =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_port_flow_transfer_proxy_result,
+ flow, "flow");
+cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_transfer =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_port_flow_transfer_proxy_result,
+ transfer, "transfer");
+cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_proxy =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_port_flow_transfer_proxy_result,
+ proxy, "proxy");
+
+static void
+cmd_show_port_flow_transfer_proxy_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_show_port_flow_transfer_proxy_result *res = parsed_result;
+ portid_t proxy_port_id;
+ int ret;
+
+ printf("\n");
+
+ ret = rte_flow_pick_transfer_proxy(res->port_id, &proxy_port_id, NULL);
+ if (ret != 0) {
+ fprintf(stderr, "Failed to pick transfer proxy: %s\n",
+ rte_strerror(-ret));
+ return;
+ }
+
+ printf("Transfer proxy port ID: %u\n\n", proxy_port_id);
+}
+
+cmdline_parse_inst_t cmd_show_port_flow_transfer_proxy = {
+ .f = cmd_show_port_flow_transfer_proxy_parsed,
+ .data = NULL,
+ .help_str = "show port <port_id> flow transfer proxy",
+ .tokens = {
+ (void *)&cmd_show_port_flow_transfer_proxy_show,
+ (void *)&cmd_show_port_flow_transfer_proxy_port,
+ (void *)&cmd_show_port_flow_transfer_proxy_port_id,
+ (void *)&cmd_show_port_flow_transfer_proxy_flow,
+ (void *)&cmd_show_port_flow_transfer_proxy_transfer,
+ (void *)&cmd_show_port_flow_transfer_proxy_proxy,
+ NULL,
+ }
+};
+
/* ******************************************************************************** */
/* list of instructions */
(cmdline_parse_inst_t *)&cmd_tso_show,
(cmdline_parse_inst_t *)&cmd_tunnel_tso_set,
(cmdline_parse_inst_t *)&cmd_tunnel_tso_show,
+#ifdef RTE_LIB_GRO
(cmdline_parse_inst_t *)&cmd_gro_enable,
(cmdline_parse_inst_t *)&cmd_gro_flush,
(cmdline_parse_inst_t *)&cmd_gro_show,
+#endif
+#ifdef RTE_LIB_GSO
(cmdline_parse_inst_t *)&cmd_gso_enable,
(cmdline_parse_inst_t *)&cmd_gso_size,
(cmdline_parse_inst_t *)&cmd_gso_show,
+#endif
(cmdline_parse_inst_t *)&cmd_link_flow_control_set,
(cmdline_parse_inst_t *)&cmd_link_flow_control_set_rx,
(cmdline_parse_inst_t *)&cmd_link_flow_control_set_tx,
(cmdline_parse_inst_t *)&cmd_link_flow_control_set_autoneg,
(cmdline_parse_inst_t *)&cmd_link_flow_control_show,
(cmdline_parse_inst_t *)&cmd_priority_flow_control_set,
+ (cmdline_parse_inst_t *)&cmd_queue_priority_flow_control_set,
(cmdline_parse_inst_t *)&cmd_config_dcb,
(cmdline_parse_inst_t *)&cmd_read_reg,
(cmdline_parse_inst_t *)&cmd_read_reg_bit_field,
(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_show_port_flow_transfer_proxy,
(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_show_port_meter_cap,
(cmdline_parse_inst_t *)&cmd_add_port_meter_profile_srtcm,
(cmdline_parse_inst_t *)&cmd_add_port_meter_profile_trtcm,
+ (cmdline_parse_inst_t *)&cmd_add_port_meter_profile_trtcm_rfc4115,
(cmdline_parse_inst_t *)&cmd_del_port_meter_profile,
(cmdline_parse_inst_t *)&cmd_create_port_meter,
(cmdline_parse_inst_t *)&cmd_enable_port_meter,
git.droids-corp.org / dpdk.git / blobdiff