"Display:\n"
"--------\n\n"
- "show port (info|stats|summary|xstats|fdir|stat_qmap|dcb_tc|cap) (port_id|all)\n"
+ "show port (info|stats|summary|xstats|fdir|dcb_tc) (port_id|all)\n"
" Display information for port_id, or all.\n\n"
"show port port_id (module_eeprom|eeprom)\n"
"show port (port_id) rss-hash [key]\n"
" Display the RSS hash functions and RSS hash key of port\n\n"
- "clear port (info|stats|xstats|fdir|stat_qmap) (port_id|all)\n"
+ "clear port (info|stats|xstats|fdir) (port_id|all)\n"
" Clear information for port_id, or all.\n\n"
"show (rxq|txq) info (port_id) (queue_id)\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) rxq (queue_id) desc used count\n"
+ " Show current number of filled receive"
+ " packet descriptors.\n\n"
+
"show port (port_id) macs|mcast_macs"
" Display list of mac addresses added to port.\n\n"
" Remove a vlan_id, to the set of VLAN identifiers"
"filtered for VF(s) from port_id.\n\n"
- "tunnel_filter add (port_id) (outer_mac) (inner_mac) (ip_addr) "
- "(inner_vlan) (vxlan|nvgre|ipingre|vxlan-gpe) (imac-ivlan|imac-ivlan-tenid|"
- "imac-tenid|imac|omac-imac-tenid|oip|iip) (tenant_id) (queue_id)\n"
- " add a tunnel filter of a port.\n\n"
-
- "tunnel_filter rm (port_id) (outer_mac) (inner_mac) (ip_addr) "
- "(inner_vlan) (vxlan|nvgre|ipingre|vxlan-gpe) (imac-ivlan|imac-ivlan-tenid|"
- "imac-tenid|imac|omac-imac-tenid|oip|iip) (tenant_id) (queue_id)\n"
- " remove a tunnel filter of a port.\n\n"
-
"rx_vxlan_port add (udp_port) (port_id)\n"
" Add an UDP port for VXLAN packet filter on a port\n\n"
"set link-down port (port_id)\n"
" Set link down for a port.\n\n"
- "E-tag set insertion on port-tag-id (value)"
- " port (port_id) vf (vf_id)\n"
- " Enable E-tag insertion for a VF on a port\n\n"
-
- "E-tag set insertion off port (port_id) vf (vf_id)\n"
- " Disable E-tag insertion for a VF on a port\n\n"
-
- "E-tag set stripping (on|off) port (port_id)\n"
- " Enable/disable E-tag stripping on a port\n\n"
-
- "E-tag set forwarding (on|off) port (port_id)\n"
- " Enable/disable E-tag based forwarding"
- " on a port\n\n"
-
- "E-tag set filter add e-tag-id (value) dst-pool"
- " (pool_id) port (port_id)\n"
- " Add an E-tag forwarding filter on a port\n\n"
-
- "E-tag set filter del e-tag-id (value) port (port_id)\n"
- " Delete an E-tag forwarding filter on a port\n\n"
-
"ddp add (port_id) (profile_path[,backup_profile_path])\n"
" Load a profile package on a port\n\n"
"show port meter cap (port_id)\n"
" Show port meter capability information\n\n"
- "add port meter profile srtcm_rfc2697 (port_id) (profile_id) (cir) (cbs) (ebs)\n"
+ "add port meter profile srtcm_rfc2697 (port_id) (profile_id) (cir) (cbs) (ebs) (packet_mode)\n"
" meter profile add - srtcm rfc 2697\n\n"
- "add port meter profile trtcm_rfc2698 (port_id) (profile_id) (cir) (pir) (cbs) (pbs)\n"
+ "add port meter profile trtcm_rfc2698 (port_id) (profile_id) (cir) (pir) (cbs) (pbs) (packet_mode)\n"
" meter profile add - trtcm rfc 2698\n\n"
- "add port meter profile trtcm_rfc4115 (port_id) (profile_id) (cir) (eir) (cbs) (ebs)\n"
+ "add port meter profile trtcm_rfc4115 (port_id) (profile_id) (cir) (eir) (cbs) (ebs) (packet_mode)\n"
" meter profile add - trtcm rfc 4115\n\n"
"del port meter profile (port_id) (profile_id)\n"
" meter profile delete\n\n"
- "create port meter (port_id) (mtr_id) (profile_id) (meter_enable)\n"
- "(g_action) (y_action) (r_action) (stats_mask) (shared)\n"
- "(use_pre_meter_color) [(dscp_tbl_entry0) (dscp_tbl_entry1)...\n"
+ "create port meter (port_id) (mtr_id) (profile_id) (policy_id) (meter_enable)\n"
+ "(stats_mask) (shared) (use_pre_meter_color) [(dscp_tbl_entry0) (dscp_tbl_entry1)...\n"
"(dscp_tbl_entry63)]\n"
" meter create\n\n"
"del port meter (port_id) (mtr_id)\n"
" meter delete\n\n"
+ "add port meter policy (port_id) (policy_id) g_actions (actions)\n"
+ "y_actions (actions) r_actions (actions)\n"
+ " meter policy add\n\n"
+
+ "del port meter policy (port_id) (policy_id)\n"
+ " meter policy delete\n\n"
+
"set port meter profile (port_id) (mtr_id) (profile_id)\n"
" meter update meter profile\n\n"
"receive buffers available.\n\n"
"port config all rss (all|default|ip|tcp|udp|sctp|"
- "ether|port|vxlan|geneve|nvgre|vxlan-gpe|none|level-default|"
+ "ether|port|vxlan|geneve|nvgre|vxlan-gpe|ecpri|mpls|none|level-default|"
"level-outer|level-inner|<flowtype_id>)\n"
" Set the RSS mode.\n\n"
"port (port_id) (rxq|txq) (queue_id) setup\n"
" Setup a rx/tx queue of port X.\n\n"
- "port config (port_id|all) l2-tunnel E-tag ether-type"
- " (value)\n"
- " Set the value of E-tag ether-type.\n\n"
-
- "port config (port_id|all) l2-tunnel E-tag"
- " (enable|disable)\n"
- " Enable/disable the E-tag support.\n\n"
-
"port config (port_id) pctype mapping reset\n"
" Reset flow type to pctype mapping on a port\n\n"
"fdir_inset|fdir_flx_inset clear all"
" Clear RSS|FDIR|FDIR_FLX input set completely for some pctype\n\n"
- "port config (port_id) udp_tunnel_port add|rm vxlan|geneve (udp_port)\n\n"
+ "port config (port_id) udp_tunnel_port add|rm vxlan|geneve|ecpri (udp_port)\n\n"
" Add/remove UDP tunnel port for tunneling offload\n\n"
"port config <port_id> rx_offload vlan_strip|"
"filters:\n"
"--------\n\n"
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow (ipv4-other|ipv4-frag|ipv6-other|ipv6-frag)"
- " src (src_ip_address) dst (dst_ip_address)"
- " tos (tos_value) proto (proto_value) ttl (ttl_value)"
- " vlan (vlan_value) flexbytes (flexbytes_value)"
- " (drop|fwd) pf|vf(vf_id) queue (queue_id)"
- " fd_id (fd_id_value)\n"
- " Add/Del an IP type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow (ipv4-tcp|ipv4-udp|ipv6-tcp|ipv6-udp)"
- " src (src_ip_address) (src_port)"
- " dst (dst_ip_address) (dst_port)"
- " tos (tos_value) ttl (ttl_value)"
- " vlan (vlan_value) flexbytes (flexbytes_value)"
- " (drop|fwd) pf|vf(vf_id) queue (queue_id)"
- " fd_id (fd_id_value)\n"
- " Add/Del an UDP/TCP type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow (ipv4-sctp|ipv6-sctp)"
- " src (src_ip_address) (src_port)"
- " dst (dst_ip_address) (dst_port)"
- " tag (verification_tag) "
- " tos (tos_value) ttl (ttl_value)"
- " vlan (vlan_value)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " pf|vf(vf_id) queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a SCTP type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow l2_payload ether (ethertype)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " pf|vf(vf_id) queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a l2 payload type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode MAC-VLAN (add|del|update)"
- " mac (mac_address) vlan (vlan_value)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a MAC-VLAN flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode Tunnel (add|del|update)"
- " mac (mac_address) vlan (vlan_value)"
- " tunnel (NVGRE|VxLAN) tunnel-id (tunnel_id_value)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a Tunnel flow director filter.\n\n"
-
+#ifdef RTE_NET_I40E
"flow_director_filter (port_id) mode raw (add|del|update)"
" flow (flow_id) (drop|fwd) queue (queue_id)"
" fd_id (fd_id_value) packet (packet file name)\n"
" Add/Del a raw type flow director filter.\n\n"
-
- "flush_flow_director (port_id)\n"
- " Flush all flow director entries of a device.\n\n"
+#endif
"flow_director_mask (port_id) mode IP vlan (vlan_value)"
" src_mask (ipv4_src) (ipv6_src) (src_port)"
" tunnel-id (tunnel_id_value)\n"
" Set flow director Tunnel mask.\n\n"
- "flow_director_flex_mask (port_id)"
- " flow (none|ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|"
- "ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|l2_payload|all)"
- " (mask)\n"
- " Configure mask of flex payload.\n\n"
-
"flow_director_flex_payload (port_id)"
" (raw|l2|l3|l4) (config)\n"
" Configure flex payload selection.\n\n"
- "get_sym_hash_ena_per_port (port_id)\n"
- " get symmetric hash enable configuration per port.\n\n"
-
- "set_sym_hash_ena_per_port (port_id) (enable|disable)\n"
- " set symmetric hash enable configuration per port"
- " to enable or disable.\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|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"
- " Set the global configurations of hash filters.\n\n"
-
- "set_hash_input_set (port_id) (ipv4|ipv4-frag|"
- "ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|ipv6|"
- "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|"
- "l2_payload|<flowtype_id>) (ovlan|ivlan|src-ipv4|dst-ipv4|"
- "src-ipv6|dst-ipv6|ipv4-tos|ipv4-proto|ipv6-tc|"
- "ipv6-next-header|udp-src-port|udp-dst-port|"
- "tcp-src-port|tcp-dst-port|sctp-src-port|"
- "sctp-dst-port|sctp-veri-tag|udp-key|gre-key|fld-1st|"
- "fld-2nd|fld-3rd|fld-4th|fld-5th|fld-6th|fld-7th|"
- "fld-8th|none) (select|add)\n"
- " Set the input set for hash.\n\n"
-
- "set_fdir_input_set (port_id) "
- "(ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
- "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|"
- "l2_payload) (ivlan|ethertype|src-ipv4|dst-ipv4|src-ipv6|"
- "dst-ipv6|ipv4-tos|ipv4-proto|ipv4-ttl|ipv6-tc|"
- "ipv6-next-header|ipv6-hop-limits|udp-src-port|"
- "udp-dst-port|tcp-src-port|tcp-dst-port|"
- "sctp-src-port|sctp-dst-port|sctp-veri-tag|none)"
- " (select|add)\n"
- " Set the input set for FDir.\n\n"
-
"flow validate {port_id}"
" [group {group_id}] [priority {level}]"
" [ingress] [egress]"
" List and destroy aged flows"
" flow rules\n\n"
- "flow shared_action {port_id} create"
- " [action_id {shared_action_id}]"
+ "flow indirect_action {port_id} create"
+ " [action_id {indirect_action_id}]"
" [ingress] [egress]"
" action {action} / end\n"
- " Create shared action.\n\n"
+ " Create indirect action.\n\n"
- "flow shared_action {port_id} update"
- " {shared_action_id} action {action} / end\n"
- " Update shared action.\n\n"
+ "flow indirect_action {port_id} update"
+ " {indirect_action_id} action {action} / end\n"
+ " Update indirect action.\n\n"
- "flow shared_action {port_id} destroy"
- " action_id {shared_action_id} [...]\n"
- " Destroy specific shared actions.\n\n"
+ "flow indirect_action {port_id} destroy"
+ " action_id {indirect_action_id} [...]\n"
+ " Destroy specific indirect actions.\n\n"
- "flow shared_action {port_id} query"
- " {shared_action_id}\n"
- " Query an existing shared action.\n\n"
+ "flow indirect_action {port_id} query"
+ " {indirect_action_id}\n"
+ " Query an existing indirect action.\n\n"
"set vxlan ip-version (ipv4|ipv6) vni (vni) udp-src"
" (udp-src) udp-dst (udp-dst) ip-src (ip-src) ip-dst"
name, "start#stop#close#reset");
cmdline_parse_token_num_t cmd_operate_specific_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_operate_specific_port_result,
- value, UINT8);
+ value, RTE_UINT8);
cmdline_parse_inst_t cmd_operate_specific_port = {
.f = cmd_operate_specific_port_parsed,
keyword, "detach");
cmdline_parse_token_num_t cmd_operate_detach_port_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_operate_detach_port_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_operate_detach_port = {
.f = cmd_operate_detach_port_parsed,
}
}
+ if (*speed != ETH_LINK_SPEED_AUTONEG)
+ *speed |= ETH_LINK_SPEED_FIXED;
+
return 0;
}
TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, keyword,
"config");
cmdline_parse_token_num_t cmd_config_speed_specific_id =
- TOKEN_NUM_INITIALIZER(struct cmd_config_speed_specific, id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_speed_specific, id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_speed_specific_item1 =
TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item1,
"speed");
TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_all, item,
"loopback");
cmdline_parse_token_num_t cmd_config_loopback_all_mode =
- TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_all, mode, UINT32);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_all, mode, RTE_UINT32);
cmdline_parse_inst_t cmd_config_loopback_all = {
.f = cmd_config_loopback_all_parsed,
"config");
cmdline_parse_token_num_t cmd_config_loopback_specific_id =
TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_specific, port_id,
- UINT16);
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_config_loopback_specific_item =
TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_specific, item,
"loopback");
cmdline_parse_token_num_t cmd_config_loopback_specific_mode =
TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_specific, mode,
- UINT32);
+ RTE_UINT32);
cmdline_parse_inst_t cmd_config_loopback_specific = {
.f = cmd_config_loopback_specific_parsed,
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, name,
"rxq#txq#rxd#txd");
cmdline_parse_token_num_t cmd_config_rx_tx_value =
- TOKEN_NUM_INITIALIZER(struct cmd_config_rx_tx, value, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_rx_tx, value, RTE_UINT16);
cmdline_parse_inst_t cmd_config_rx_tx = {
.f = cmd_config_rx_tx_parsed,
__rte_unused void *data)
{
struct cmd_config_max_pkt_len_result *res = parsed_result;
+ uint32_t max_rx_pkt_len_backup = 0;
portid_t pid;
+ int ret;
if (!all_ports_stopped()) {
printf("Please stop all ports first\n");
RTE_ETH_FOREACH_DEV(pid) {
struct rte_port *port = &ports[pid];
- uint64_t rx_offloads = port->dev_conf.rxmode.offloads;
if (!strcmp(res->name, "max-pkt-len")) {
if (res->value < RTE_ETHER_MIN_LEN) {
if (res->value == port->dev_conf.rxmode.max_rx_pkt_len)
return;
+ ret = eth_dev_info_get_print_err(pid, &port->dev_info);
+ if (ret != 0) {
+ printf("rte_eth_dev_info_get() failed for port %u\n",
+ pid);
+ return;
+ }
+
+ max_rx_pkt_len_backup = port->dev_conf.rxmode.max_rx_pkt_len;
+
port->dev_conf.rxmode.max_rx_pkt_len = res->value;
- if (res->value > RTE_ETHER_MAX_LEN)
- rx_offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME;
- else
- rx_offloads &= ~DEV_RX_OFFLOAD_JUMBO_FRAME;
- port->dev_conf.rxmode.offloads = rx_offloads;
+ if (update_jumbo_frame_offload(pid) != 0)
+ port->dev_conf.rxmode.max_rx_pkt_len = max_rx_pkt_len_backup;
} else {
printf("Unknown parameter\n");
return;
"max-pkt-len");
cmdline_parse_token_num_t cmd_config_max_pkt_len_value =
TOKEN_NUM_INITIALIZER(struct cmd_config_max_pkt_len_result, value,
- UINT32);
+ RTE_UINT32);
cmdline_parse_inst_t cmd_config_max_pkt_len = {
.f = cmd_config_max_pkt_len_parsed,
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);
+ value, RTE_UINT32);
cmdline_parse_inst_t cmd_config_max_lro_pkt_size = {
.f = cmd_config_max_lro_pkt_size_parsed,
TOKEN_STRING_INITIALIZER(struct cmd_config_mtu_result, keyword,
"mtu");
cmdline_parse_token_num_t cmd_config_mtu_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, port_id,
+ RTE_UINT16);
cmdline_parse_token_num_t cmd_config_mtu_value =
- TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, value, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, value,
+ RTE_UINT16);
cmdline_parse_inst_t cmd_config_mtu = {
.f = cmd_config_mtu_parsed,
rss_conf.rss_hf = ETH_RSS_ETH | ETH_RSS_VLAN | ETH_RSS_IP |
ETH_RSS_TCP | ETH_RSS_UDP | ETH_RSS_SCTP |
ETH_RSS_L2_PAYLOAD | ETH_RSS_L2TPV3 | ETH_RSS_ESP |
- ETH_RSS_AH | ETH_RSS_PFCP | ETH_RSS_GTPU;
+ ETH_RSS_AH | ETH_RSS_PFCP | ETH_RSS_GTPU |
+ ETH_RSS_ECPRI;
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_PPPOE;
else if (!strcmp(res->value, "gtpu"))
rss_conf.rss_hf = ETH_RSS_GTPU;
+ else if (!strcmp(res->value, "ecpri"))
+ rss_conf.rss_hf = ETH_RSS_ECPRI;
+ else if (!strcmp(res->value, "mpls"))
+ rss_conf.rss_hf = ETH_RSS_MPLS;
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|none|level-default|"
+ "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|ecpri|mpls|none|level-default|"
"level-outer|level-inner|<flowtype_id>",
.tokens = {
(void *)&cmd_config_rss_port,
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, config,
"config");
cmdline_parse_token_num_t cmd_config_rss_hash_key_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_config_rss_hash_key, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_rss_hash_key, port_id,
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_hash_key =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key,
rss_hash_key, "rss-hash-key");
"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");
+ "l2tpv3#esp#ah#pfcp#pppoe#gtpu#ecpri#mpls");
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 "
+ "l2tpv3|esp|ah|pfcp|pppoe|gtpu|ecpri|mpls "
"<string of hex digits (variable length, NIC dependent)>",
.tokens = {
(void *)&cmd_config_rss_hash_key_port,
config, "config");
cmdline_parse_token_num_t cmd_config_rxtx_ring_size_portid =
TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_ring_size,
- portid, UINT16);
+ portid, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rxtx_ring_size_rxtxq =
TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_ring_size,
rxtxq, "rxq#txq");
cmdline_parse_token_num_t cmd_config_rxtx_ring_size_qid =
TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_ring_size,
- qid, UINT16);
+ qid, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rxtx_ring_size_rsize =
TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_ring_size,
rsize, "ring_size");
cmdline_parse_token_num_t cmd_config_rxtx_ring_size_size =
TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_ring_size,
- size, UINT16);
+ size, RTE_UINT16);
cmdline_parse_inst_t cmd_config_rxtx_ring_size = {
.f = cmd_config_rxtx_ring_size_parsed,
cmdline_parse_token_string_t cmd_config_rxtx_queue_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_queue, port, "port");
cmdline_parse_token_num_t cmd_config_rxtx_queue_portid =
- TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, portid, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, portid, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rxtx_queue_rxtxq =
TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_queue, rxtxq, "rxq#txq");
cmdline_parse_token_num_t cmd_config_rxtx_queue_qid =
- TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, qid, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, qid, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rxtx_queue_opname =
TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_queue, opname,
"start#stop");
port, "port");
cmdline_parse_token_num_t cmd_config_deferred_start_rxtx_queue_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_rxtxq =
TOKEN_STRING_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
rxtxq, "rxq#txq");
cmdline_parse_token_num_t cmd_config_deferred_start_rxtx_queue_qid =
TOKEN_NUM_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
- qid, UINT16);
+ qid, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_opname =
TOKEN_STRING_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
opname, "deferred_start");
cmdline_parse_token_string_t cmd_setup_rxtx_queue_port =
TOKEN_STRING_INITIALIZER(struct cmd_setup_rxtx_queue, port, "port");
cmdline_parse_token_num_t cmd_setup_rxtx_queue_portid =
- TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, portid, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, portid, RTE_UINT16);
cmdline_parse_token_string_t cmd_setup_rxtx_queue_rxtxq =
TOKEN_STRING_INITIALIZER(struct cmd_setup_rxtx_queue, rxtxq, "rxq#txq");
cmdline_parse_token_num_t cmd_setup_rxtx_queue_qid =
- TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, qid, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, qid, RTE_UINT16);
cmdline_parse_token_string_t cmd_setup_rxtx_queue_setup =
TOKEN_STRING_INITIALIZER(struct cmd_setup_rxtx_queue, setup, "setup");
cmdline_parse_token_string_t cmd_config_rss_reta_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, keyword, "config");
cmdline_parse_token_num_t cmd_config_rss_reta_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_config_rss_reta, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_rss_reta, port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_rss_reta_name =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, name, "rss");
cmdline_parse_token_string_t cmd_config_rss_reta_list_name =
cmdline_parse_token_string_t cmd_showport_reta_port =
TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, port, "port");
cmdline_parse_token_num_t cmd_showport_reta_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_showport_reta_rss =
TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, rss, "rss");
cmdline_parse_token_string_t cmd_showport_reta_reta =
TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, reta, "reta");
cmdline_parse_token_num_t cmd_showport_reta_size =
- TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, size, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, size, RTE_UINT16);
cmdline_parse_token_string_t cmd_showport_reta_list_of_items =
TOKEN_STRING_INITIALIZER(struct cmd_showport_reta,
list_of_items, NULL);
cmdline_parse_token_string_t cmd_showport_rss_hash_port =
TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, port, "port");
cmdline_parse_token_num_t cmd_showport_rss_hash_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_showport_rss_hash, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_showport_rss_hash, port_id,
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_showport_rss_hash_rss_hash =
TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, rss_hash,
"rss-hash");
cmdline_parse_token_string_t cmd_config_dcb_config =
TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, config, "config");
cmdline_parse_token_num_t cmd_config_dcb_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_dcb_dcb =
TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, dcb, "dcb");
cmdline_parse_token_string_t cmd_config_dcb_vt =
cmdline_parse_token_string_t cmd_config_dcb_vt_en =
TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, vt_en, "on#off");
cmdline_parse_token_num_t cmd_config_dcb_num_tcs =
- TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, num_tcs, UINT8);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, num_tcs, RTE_UINT8);
cmdline_parse_token_string_t cmd_config_dcb_pfc=
TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, pfc, "pfc");
cmdline_parse_token_string_t cmd_config_dcb_pfc_en =
cmdline_parse_token_string_t cmd_config_burst_name =
TOKEN_STRING_INITIALIZER(struct cmd_config_burst, name, "burst");
cmdline_parse_token_num_t cmd_config_burst_value =
- TOKEN_NUM_INITIALIZER(struct cmd_config_burst, value, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_burst, value, RTE_UINT16);
cmdline_parse_inst_t cmd_config_burst = {
.f = cmd_config_burst_parsed,
TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, name,
"txpt#txht#txwt#rxpt#rxht#rxwt");
cmdline_parse_token_num_t cmd_config_thresh_value =
- TOKEN_NUM_INITIALIZER(struct cmd_config_thresh, value, UINT8);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_thresh, value, RTE_UINT8);
cmdline_parse_inst_t cmd_config_thresh = {
.f = cmd_config_thresh_parsed,
TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, name,
"txfreet#txrst#rxfreet");
cmdline_parse_token_num_t cmd_config_threshold_value =
- TOKEN_NUM_INITIALIZER(struct cmd_config_threshold, value, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_config_threshold, value, RTE_UINT16);
cmdline_parse_inst_t cmd_config_threshold = {
.f = cmd_config_threshold_parsed,
TOKEN_STRING_INITIALIZER(struct cmd_setmask_result, mask,
"coremask#portmask");
cmdline_parse_token_num_t cmd_setmask_value =
- TOKEN_NUM_INITIALIZER(struct cmd_setmask_result, hexavalue, UINT64);
+ TOKEN_NUM_INITIALIZER(struct cmd_setmask_result, hexavalue, RTE_UINT64);
cmdline_parse_inst_t cmd_set_fwd_mask = {
.f = cmd_set_mask_parsed,
TOKEN_STRING_INITIALIZER(struct cmd_set_result, what,
"nbport#nbcore#burst#verbose");
cmdline_parse_token_num_t cmd_set_value =
- TOKEN_NUM_INITIALIZER(struct cmd_set_result, value, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_result, value, RTE_UINT16);
cmdline_parse_inst_t cmd_set_numbers = {
.f = cmd_set_parsed,
cmdline_parse_token_string_t cmd_set_log_type =
TOKEN_STRING_INITIALIZER(struct cmd_set_log_result, type, NULL);
cmdline_parse_token_num_t cmd_set_log_level =
- TOKEN_NUM_INITIALIZER(struct cmd_set_log_result, level, UINT32);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_log_result, level, RTE_UINT32);
cmdline_parse_inst_t cmd_set_log = {
.f = cmd_set_log_parsed,
MAX_SEGS_BUFFER_SPLIT, seg_offsets, 0);
if (nb_segs > 0)
set_rx_pkt_offsets(seg_offsets, nb_segs);
+ cmd_reconfig_device_queue(RTE_PORT_ALL, 0, 1);
}
cmdline_parse_token_string_t cmd_set_rxoffs_keyword =
MAX_SEGS_BUFFER_SPLIT, seg_lengths, 0);
if (nb_segs > 0)
set_rx_pkt_segments(seg_lengths, nb_segs);
+ cmd_reconfig_device_queue(RTE_PORT_ALL, 0, 1);
}
cmdline_parse_token_string_t cmd_set_rxpkts_keyword =
all, "all");
cmdline_parse_token_num_t cmd_rx_vlan_filter_all_portid =
TOKEN_NUM_INITIALIZER(struct cmd_rx_vlan_filter_all_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_rx_vlan_filter_all = {
.f = cmd_rx_vlan_filter_all_parsed,
what, "tpid");
cmdline_parse_token_num_t cmd_vlan_tpid_tpid =
TOKEN_NUM_INITIALIZER(struct cmd_vlan_tpid_result,
- tp_id, UINT16);
+ tp_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_vlan_tpid_portid =
TOKEN_NUM_INITIALIZER(struct cmd_vlan_tpid_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_vlan_tpid = {
.f = cmd_vlan_tpid_parsed,
what, "add#rm");
cmdline_parse_token_num_t cmd_rx_vlan_filter_vlanid =
TOKEN_NUM_INITIALIZER(struct cmd_rx_vlan_filter_result,
- vlan_id, UINT16);
+ vlan_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_rx_vlan_filter_portid =
TOKEN_NUM_INITIALIZER(struct cmd_rx_vlan_filter_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_rx_vlan_filter = {
.f = cmd_rx_vlan_filter_parsed,
set, "set");
cmdline_parse_token_num_t cmd_tx_vlan_set_portid =
TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_tx_vlan_set_vlanid =
TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_result,
- vlan_id, UINT16);
+ vlan_id, RTE_UINT16);
cmdline_parse_inst_t cmd_tx_vlan_set = {
.f = cmd_tx_vlan_set_parsed,
set, "set");
cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_portid =
TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_qinq_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_vlanid =
TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_qinq_result,
- vlan_id, UINT16);
+ vlan_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_vlanid_outer =
TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_qinq_result,
- vlan_id_outer, UINT16);
+ vlan_id_outer, RTE_UINT16);
cmdline_parse_inst_t cmd_tx_vlan_set_qinq = {
.f = cmd_tx_vlan_set_qinq_parsed,
pvid, "pvid");
cmdline_parse_token_num_t cmd_tx_vlan_set_pvid_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_pvid_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_tx_vlan_set_pvid_vlan_id =
TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_pvid_result,
- vlan_id, UINT16);
+ vlan_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_mode =
TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_pvid_result,
mode, "on#off");
reset, "reset");
cmdline_parse_token_num_t cmd_tx_vlan_reset_portid =
TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_reset_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_tx_vlan_reset = {
.f = cmd_tx_vlan_reset_parsed,
hwsw, "hw#sw");
cmdline_parse_token_num_t cmd_csum_portid =
TOKEN_NUM_INITIALIZER(struct cmd_csum_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_csum_set = {
.f = cmd_csum_parsed,
onoff, "on#off");
cmdline_parse_token_num_t cmd_csum_tunnel_portid =
TOKEN_NUM_INITIALIZER(struct cmd_csum_tunnel_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_csum_tunnel = {
.f = cmd_csum_tunnel_parsed,
mode, "set");
cmdline_parse_token_num_t cmd_tso_set_tso_segsz =
TOKEN_NUM_INITIALIZER(struct cmd_tso_set_result,
- tso_segsz, UINT16);
+ tso_segsz, RTE_UINT16);
cmdline_parse_token_num_t cmd_tso_set_portid =
TOKEN_NUM_INITIALIZER(struct cmd_tso_set_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_tso_set = {
.f = cmd_tso_set_parsed,
mode, "set");
cmdline_parse_token_num_t cmd_tunnel_tso_set_tso_segsz =
TOKEN_NUM_INITIALIZER(struct cmd_tunnel_tso_set_result,
- tso_segsz, UINT16);
+ tso_segsz, RTE_UINT16);
cmdline_parse_token_num_t cmd_tunnel_tso_set_portid =
TOKEN_NUM_INITIALIZER(struct cmd_tunnel_tso_set_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_tunnel_tso_set = {
.f = cmd_tunnel_tso_set_parsed,
cmd_keyword, "port");
cmdline_parse_token_num_t cmd_gro_enable_pid =
TOKEN_NUM_INITIALIZER(struct cmd_gro_enable_result,
- cmd_pid, UINT16);
+ cmd_pid, RTE_UINT16);
cmdline_parse_token_string_t cmd_gro_enable_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_gro_enable_result,
cmd_keyword, "gro");
cmd_port, "port");
cmdline_parse_token_num_t cmd_gro_show_pid =
TOKEN_NUM_INITIALIZER(struct cmd_gro_show_result,
- cmd_pid, UINT16);
+ cmd_pid, RTE_UINT16);
cmdline_parse_token_string_t cmd_gro_show_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_gro_show_result,
cmd_keyword, "gro");
cmd_flush, "flush");
cmdline_parse_token_num_t cmd_gro_flush_cycles =
TOKEN_NUM_INITIALIZER(struct cmd_gro_flush_result,
- cmd_cycles, UINT8);
+ cmd_cycles, RTE_UINT8);
cmdline_parse_inst_t cmd_gro_flush = {
.f = cmd_gro_flush_parsed,
cmd_mode, "on#off");
cmdline_parse_token_num_t cmd_gso_enable_pid =
TOKEN_NUM_INITIALIZER(struct cmd_gso_enable_result,
- cmd_pid, UINT16);
+ cmd_pid, RTE_UINT16);
cmdline_parse_inst_t cmd_gso_enable = {
.f = cmd_gso_enable_parsed,
cmd_segsz, "segsz");
cmdline_parse_token_num_t cmd_gso_size_size =
TOKEN_NUM_INITIALIZER(struct cmd_gso_size_result,
- cmd_size, UINT16);
+ cmd_size, RTE_UINT16);
cmdline_parse_inst_t cmd_gso_size = {
.f = cmd_gso_size_parsed,
cmd_keyword, "gso");
cmdline_parse_token_num_t cmd_gso_show_pid =
TOKEN_NUM_INITIALIZER(struct cmd_gso_show_result,
- cmd_pid, UINT16);
+ cmd_pid, RTE_UINT16);
cmdline_parse_inst_t cmd_gso_show = {
.f = cmd_gso_show_parsed,
value, "normal#bypass#isolate");
cmdline_parse_token_num_t cmd_setbypass_mode_port =
TOKEN_NUM_INITIALIZER(struct cmd_set_bypass_mode_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_set_bypass_mode = {
.f = cmd_set_bypass_mode_parsed,
mode_value, "normal#bypass#isolate");
cmdline_parse_token_num_t cmd_setbypass_event_port =
TOKEN_NUM_INITIALIZER(struct cmd_set_bypass_event_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_set_bypass_event = {
.f = cmd_set_bypass_event_parsed,
config, "config");
cmdline_parse_token_num_t cmd_showbypass_config_port =
TOKEN_NUM_INITIALIZER(struct cmd_show_bypass_config_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_show_bypass_config = {
.f = cmd_show_bypass_config_parsed,
mode, "mode");
cmdline_parse_token_num_t cmd_setbonding_mode_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_mode_result,
- value, UINT8);
+ value, RTE_UINT8);
cmdline_parse_token_num_t cmd_setbonding_mode_port =
TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_mode_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_set_bonding_mode = {
.f = cmd_set_bonding_mode_parsed,
dedicated_queues, "dedicated_queues");
cmdline_parse_token_num_t cmd_setbonding_lacp_dedicated_queues_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_lacp_dedicated_queues_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_setbonding_lacp_dedicated_queues_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_lacp_dedicated_queues_result,
mode, "enable#disable");
balance_xmit_policy, "balance_xmit_policy");
cmdline_parse_token_num_t cmd_setbonding_balance_xmit_policy_port =
TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_policy =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
policy, "l2#l23#l34");
config, "config");
cmdline_parse_token_num_t cmd_showbonding_config_port =
TOKEN_NUM_INITIALIZER(struct cmd_show_bonding_config_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_show_bonding_config = {
.f = cmd_show_bonding_config_parsed,
primary, "primary");
cmdline_parse_token_num_t cmd_setbonding_primary_slave =
TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_primary_result,
- slave_id, UINT16);
+ slave_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_setbonding_primary_port =
TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_primary_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_set_bonding_primary = {
.f = cmd_set_bonding_primary_parsed,
slave, "slave");
cmdline_parse_token_num_t cmd_addbonding_slave_slaveid =
TOKEN_NUM_INITIALIZER(struct cmd_add_bonding_slave_result,
- slave_id, UINT16);
+ slave_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_addbonding_slave_port =
TOKEN_NUM_INITIALIZER(struct cmd_add_bonding_slave_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_add_bonding_slave = {
.f = cmd_add_bonding_slave_parsed,
slave, "slave");
cmdline_parse_token_num_t cmd_removebonding_slave_slaveid =
TOKEN_NUM_INITIALIZER(struct cmd_remove_bonding_slave_result,
- slave_id, UINT16);
+ slave_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_removebonding_slave_port =
TOKEN_NUM_INITIALIZER(struct cmd_remove_bonding_slave_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_remove_bonding_slave = {
.f = cmd_remove_bonding_slave_parsed,
device, "device");
cmdline_parse_token_num_t cmd_createbonded_device_mode =
TOKEN_NUM_INITIALIZER(struct cmd_create_bonded_device_result,
- mode, UINT8);
+ mode, RTE_UINT8);
cmdline_parse_token_num_t cmd_createbonded_device_socket =
TOKEN_NUM_INITIALIZER(struct cmd_create_bonded_device_result,
- socket, UINT8);
+ socket, RTE_UINT8);
cmdline_parse_inst_t cmd_create_bonded_device = {
.f = cmd_create_bonded_device_parsed,
"mac_addr");
cmdline_parse_token_num_t cmd_set_bond_mac_addr_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_set_bond_mac_addr_result,
- port_num, UINT16);
+ port_num, RTE_UINT16);
cmdline_parse_token_etheraddr_t cmd_set_bond_mac_addr_addr =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_bond_mac_addr_result, address);
mon_period, "mon_period");
cmdline_parse_token_num_t cmd_set_bond_mon_period_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_set_bond_mon_period_result,
- port_num, UINT16);
+ port_num, RTE_UINT16);
cmdline_parse_token_num_t cmd_set_bond_mon_period_period_ms =
TOKEN_NUM_INITIALIZER(struct cmd_set_bond_mon_period_result,
- period_ms, UINT32);
+ period_ms, RTE_UINT32);
cmdline_parse_inst_t cmd_set_bond_mon_period = {
.f = cmd_set_bond_mon_period_parsed,
cmdline_parse_token_num_t cmd_set_bonding_agg_mode_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_agg_mode_policy_result,
- port_num, UINT16);
+ port_num, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_bonding_agg_mode_policy_string =
TOKEN_STRING_INITIALIZER(
cmdline_parse_token_string_t cmd_set_burst_tx_retry_delay =
TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, delay, "delay");
cmdline_parse_token_num_t cmd_set_burst_tx_retry_time =
- TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, time, UINT32);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, time,
+ RTE_UINT32);
cmdline_parse_token_string_t cmd_set_burst_tx_retry_retry =
TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry, "retry");
cmdline_parse_token_num_t cmd_set_burst_tx_retry_retry_num =
- TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry_num, UINT32);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry_num,
+ RTE_UINT32);
cmdline_parse_inst_t cmd_set_burst_tx_retry = {
.f = cmd_set_burst_tx_retry_parsed,
"all");
cmdline_parse_token_num_t cmd_setpromisc_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_set_promisc_mode_result, port_num,
- UINT16);
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_setpromisc_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_promisc_mode_result, mode,
"on#off");
"all");
cmdline_parse_token_num_t cmd_setallmulti_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_set_allmulti_mode_result, port_num,
- UINT16);
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_setallmulti_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_allmulti_mode_result, mode,
"on#off");
hw_str, "high_water");
cmdline_parse_token_num_t cmd_lfc_set_high_water =
TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
- high_water, UINT32);
+ high_water, RTE_UINT32);
cmdline_parse_token_string_t cmd_lfc_set_low_water_str =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
lw_str, "low_water");
cmdline_parse_token_num_t cmd_lfc_set_low_water =
TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
- low_water, UINT32);
+ low_water, RTE_UINT32);
cmdline_parse_token_string_t cmd_lfc_set_pause_time_str =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
pt_str, "pause_time");
cmdline_parse_token_num_t cmd_lfc_set_pause_time =
TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
- pause_time, UINT16);
+ pause_time, RTE_UINT16);
cmdline_parse_token_string_t cmd_lfc_set_send_xon_str =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
xon_str, "send_xon");
cmdline_parse_token_num_t cmd_lfc_set_send_xon =
TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
- send_xon, UINT16);
+ send_xon, RTE_UINT16);
cmdline_parse_token_string_t cmd_lfc_set_mac_ctrl_frame_fwd_mode =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
mac_ctrl_frame_fwd, "mac_ctrl_frame_fwd");
autoneg, "on#off");
cmdline_parse_token_num_t cmd_lfc_set_portid =
TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
/* forward declaration */
static void
tx_pfc_mode, "on#off");
cmdline_parse_token_num_t cmd_pfc_set_high_water =
TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
- high_water, UINT32);
+ high_water, RTE_UINT32);
cmdline_parse_token_num_t cmd_pfc_set_low_water =
TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
- low_water, UINT32);
+ low_water, RTE_UINT32);
cmdline_parse_token_num_t cmd_pfc_set_pause_time =
TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
- pause_time, UINT16);
+ pause_time, RTE_UINT16);
cmdline_parse_token_num_t cmd_pfc_set_priority =
TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
- priority, UINT8);
+ priority, RTE_UINT8);
cmdline_parse_token_num_t cmd_pfc_set_portid =
TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_priority_flow_control_set = {
.f = cmd_priority_flow_ctrl_set_parsed,
tx_first, "tx_first");
cmdline_parse_token_num_t cmd_start_tx_first_n_tx_num =
TOKEN_NUM_INITIALIZER(struct cmd_start_tx_first_n_result,
- tx_num, UINT32);
+ tx_num, RTE_UINT32);
cmdline_parse_inst_t cmd_start_tx_first_n = {
.f = cmd_start_tx_first_n_parsed,
cmdline_parse_token_string_t cmd_set_link_up_port =
TOKEN_STRING_INITIALIZER(struct cmd_set_link_up_result, port, "port");
cmdline_parse_token_num_t cmd_set_link_up_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_set_link_up_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_link_up_result, port_id,
+ RTE_UINT16);
static void cmd_set_link_up_parsed(__rte_unused void *parsed_result,
__rte_unused struct cmdline *cl,
cmdline_parse_token_string_t cmd_set_link_down_port =
TOKEN_STRING_INITIALIZER(struct cmd_set_link_down_result, port, "port");
cmdline_parse_token_num_t cmd_set_link_down_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_set_link_down_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_link_down_result, port_id,
+ RTE_UINT16);
static void cmd_set_link_down_parsed(
__rte_unused void *parsed_result,
else if (!strcmp(res->what, "xstats"))
RTE_ETH_FOREACH_DEV(i)
nic_xstats_display(i);
+#if defined(RTE_NET_I40E) || defined(RTE_NET_IXGBE)
else if (!strcmp(res->what, "fdir"))
RTE_ETH_FOREACH_DEV(i)
fdir_get_infos(i);
- else if (!strcmp(res->what, "stat_qmap"))
- RTE_ETH_FOREACH_DEV(i)
- nic_stats_mapping_display(i);
+#endif
else if (!strcmp(res->what, "dcb_tc"))
RTE_ETH_FOREACH_DEV(i)
port_dcb_info_display(i);
- else if (!strcmp(res->what, "cap"))
- RTE_ETH_FOREACH_DEV(i)
- port_offload_cap_display(i);
}
cmdline_parse_token_string_t cmd_showportall_show =
TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, port, "port");
cmdline_parse_token_string_t cmd_showportall_what =
TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, what,
- "info#summary#stats#xstats#fdir#stat_qmap#dcb_tc#cap");
+ "info#summary#stats#xstats#fdir#dcb_tc");
cmdline_parse_token_string_t cmd_showportall_all =
TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, all, "all");
cmdline_parse_inst_t cmd_showportall = {
.f = cmd_showportall_parsed,
.data = NULL,
.help_str = "show|clear port "
- "info|summary|stats|xstats|fdir|stat_qmap|dcb_tc|cap all",
+ "info|summary|stats|xstats|fdir|dcb_tc all",
.tokens = {
(void *)&cmd_showportall_show,
(void *)&cmd_showportall_port,
nic_stats_display(res->portnum);
else if (!strcmp(res->what, "xstats"))
nic_xstats_display(res->portnum);
+#if defined(RTE_NET_I40E) || defined(RTE_NET_IXGBE)
else if (!strcmp(res->what, "fdir"))
fdir_get_infos(res->portnum);
- else if (!strcmp(res->what, "stat_qmap"))
- nic_stats_mapping_display(res->portnum);
+#endif
else if (!strcmp(res->what, "dcb_tc"))
port_dcb_info_display(res->portnum);
- else if (!strcmp(res->what, "cap"))
- port_offload_cap_display(res->portnum);
}
cmdline_parse_token_string_t cmd_showport_show =
TOKEN_STRING_INITIALIZER(struct cmd_showport_result, port, "port");
cmdline_parse_token_string_t cmd_showport_what =
TOKEN_STRING_INITIALIZER(struct cmd_showport_result, what,
- "info#summary#stats#xstats#fdir#stat_qmap#dcb_tc#cap");
+ "info#summary#stats#xstats#fdir#dcb_tc");
cmdline_parse_token_num_t cmd_showport_portnum =
- TOKEN_NUM_INITIALIZER(struct cmd_showport_result, portnum, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_showport_result, portnum, RTE_UINT16);
cmdline_parse_inst_t cmd_showport = {
.f = cmd_showport_parsed,
.data = NULL,
.help_str = "show|clear port "
- "info|summary|stats|xstats|fdir|stat_qmap|dcb_tc|cap "
+ "info|summary|stats|xstats|fdir|dcb_tc "
"<port_id>",
.tokens = {
(void *)&cmd_showport_show,
cmdline_parse_token_string_t cmd_showeeprom_port =
TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, port, "port");
cmdline_parse_token_num_t cmd_showeeprom_portnum =
- TOKEN_NUM_INITIALIZER(struct cmd_showeeprom_result, portnum, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_showeeprom_result, portnum,
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_showeeprom_type =
TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, type, "module_eeprom#eeprom");
cmdline_parse_token_string_t cmd_showqueue_what =
TOKEN_STRING_INITIALIZER(struct cmd_showqueue_result, what, "info");
cmdline_parse_token_num_t cmd_showqueue_portnum =
- TOKEN_NUM_INITIALIZER(struct cmd_showqueue_result, portnum, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_showqueue_result, portnum,
+ RTE_UINT16);
cmdline_parse_token_num_t cmd_showqueue_queuenum =
- TOKEN_NUM_INITIALIZER(struct cmd_showqueue_result, queuenum, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_showqueue_result, queuenum,
+ RTE_UINT16);
cmdline_parse_inst_t cmd_showqueue = {
.f = cmd_showqueue_parsed,
cmdline_parse_token_string_t cmd_read_reg_reg =
TOKEN_STRING_INITIALIZER(struct cmd_read_reg_result, reg, "reg");
cmdline_parse_token_num_t cmd_read_reg_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_read_reg_reg_off =
- TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, reg_off, UINT32);
+ TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, reg_off, RTE_UINT32);
cmdline_parse_inst_t cmd_read_reg = {
.f = cmd_read_reg_parsed,
regfield, "regfield");
cmdline_parse_token_num_t cmd_read_reg_bit_field_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, port_id,
- UINT16);
+ RTE_UINT16);
cmdline_parse_token_num_t cmd_read_reg_bit_field_reg_off =
TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, reg_off,
- UINT32);
+ RTE_UINT32);
cmdline_parse_token_num_t cmd_read_reg_bit_field_bit1_pos =
TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, bit1_pos,
- UINT8);
+ RTE_UINT8);
cmdline_parse_token_num_t cmd_read_reg_bit_field_bit2_pos =
TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, bit2_pos,
- UINT8);
+ RTE_UINT8);
cmdline_parse_inst_t cmd_read_reg_bit_field = {
.f = cmd_read_reg_bit_field_parsed,
TOKEN_STRING_INITIALIZER(struct cmd_read_reg_bit_result,
regbit, "regbit");
cmdline_parse_token_num_t cmd_read_reg_bit_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, port_id,
+ RTE_UINT16);
cmdline_parse_token_num_t cmd_read_reg_bit_reg_off =
- TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, reg_off, UINT32);
+ TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, reg_off,
+ RTE_UINT32);
cmdline_parse_token_num_t cmd_read_reg_bit_bit_pos =
- TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, bit_pos, UINT8);
+ TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, bit_pos,
+ RTE_UINT8);
cmdline_parse_inst_t cmd_read_reg_bit = {
.f = cmd_read_reg_bit_parsed,
cmdline_parse_token_string_t cmd_write_reg_reg =
TOKEN_STRING_INITIALIZER(struct cmd_write_reg_result, reg, "reg");
cmdline_parse_token_num_t cmd_write_reg_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_write_reg_reg_off =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, reg_off, UINT32);
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, reg_off, RTE_UINT32);
cmdline_parse_token_num_t cmd_write_reg_value =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, value, UINT32);
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, value, RTE_UINT32);
cmdline_parse_inst_t cmd_write_reg = {
.f = cmd_write_reg_parsed,
regfield, "regfield");
cmdline_parse_token_num_t cmd_write_reg_bit_field_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, port_id,
- UINT16);
+ RTE_UINT16);
cmdline_parse_token_num_t cmd_write_reg_bit_field_reg_off =
TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, reg_off,
- UINT32);
+ RTE_UINT32);
cmdline_parse_token_num_t cmd_write_reg_bit_field_bit1_pos =
TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, bit1_pos,
- UINT8);
+ RTE_UINT8);
cmdline_parse_token_num_t cmd_write_reg_bit_field_bit2_pos =
TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, bit2_pos,
- UINT8);
+ RTE_UINT8);
cmdline_parse_token_num_t cmd_write_reg_bit_field_value =
TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, value,
- UINT32);
+ RTE_UINT32);
cmdline_parse_inst_t cmd_write_reg_bit_field = {
.f = cmd_write_reg_bit_field_parsed,
TOKEN_STRING_INITIALIZER(struct cmd_write_reg_bit_result,
regbit, "regbit");
cmdline_parse_token_num_t cmd_write_reg_bit_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, port_id,
+ RTE_UINT16);
cmdline_parse_token_num_t cmd_write_reg_bit_reg_off =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, reg_off, UINT32);
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, reg_off,
+ RTE_UINT32);
cmdline_parse_token_num_t cmd_write_reg_bit_bit_pos =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, bit_pos, UINT8);
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, bit_pos,
+ RTE_UINT8);
cmdline_parse_token_num_t cmd_write_reg_bit_value =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, value, UINT8);
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, value,
+ RTE_UINT8);
cmdline_parse_inst_t cmd_write_reg_bit = {
.f = cmd_write_reg_bit_parsed,
TOKEN_STRING_INITIALIZER(struct cmd_read_rxd_txd_result, rxd_txd,
"rxd#txd");
cmdline_parse_token_num_t cmd_read_rxd_txd_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, port_id,
+ RTE_UINT16);
cmdline_parse_token_num_t cmd_read_rxd_txd_queue_id =
- TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, queue_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, queue_id,
+ RTE_UINT16);
cmdline_parse_token_num_t cmd_read_rxd_txd_desc_id =
- TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, desc_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, desc_id,
+ RTE_UINT16);
cmdline_parse_inst_t cmd_read_rxd_txd = {
.f = cmd_read_rxd_txd_parsed,
"add#remove#set");
cmdline_parse_token_num_t cmd_mac_addr_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_mac_addr_result, port_num,
- UINT16);
+ RTE_UINT16);
cmdline_parse_token_etheraddr_t cmd_mac_addr_addr =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address);
cmdline_parse_token_string_t cmd_eth_peer =
TOKEN_STRING_INITIALIZER(struct cmd_eth_peer_result, eth_peer, "eth-peer");
cmdline_parse_token_num_t cmd_eth_peer_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_eth_peer_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_eth_peer_result, port_id,
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_eth_peer_addr =
TOKEN_STRING_INITIALIZER(struct cmd_eth_peer_result, peer_addr, NULL);
what, "tx#rx");
cmdline_parse_token_num_t cmd_setqmap_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_qmap_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_setqmap_queueid =
TOKEN_NUM_INITIALIZER(struct cmd_set_qmap_result,
- queue_id, UINT16);
+ queue_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_setqmap_mapvalue =
TOKEN_NUM_INITIALIZER(struct cmd_set_qmap_result,
- map_value, UINT8);
+ map_value, RTE_UINT8);
cmdline_parse_inst_t cmd_set_qmap = {
.f = cmd_set_qmap_parsed,
port, "port");
cmdline_parse_token_num_t cmd_set_uc_hash_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_uc_hash_table,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_uc_hash_what =
TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table,
what, "uta");
port, "port");
cmdline_parse_token_num_t cmd_set_uc_all_hash_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_uc_all_hash_table,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_uc_all_hash_what =
TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table,
what, "uta");
port, "port");
cmdline_parse_token_num_t cmd_setvf_traffic_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_setvf_traffic_vf =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
vf, "vf");
cmdline_parse_token_num_t cmd_setvf_traffic_vfid =
TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic,
- vf_id, UINT8);
+ vf_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_setvf_traffic_what =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
what, "tx#rx");
port, "port");
cmdline_parse_token_num_t cmd_set_vf_rxmode_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_vf_rxmode_vf =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
vf, "vf");
cmdline_parse_token_num_t cmd_set_vf_rxmode_vfid =
TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode,
- vf_id, UINT8);
+ vf_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_set_vf_rxmode_what =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
what, "rxmode");
port,"port");
cmdline_parse_token_num_t cmd_vf_mac_addr_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result,
- port_num, UINT16);
+ port_num, RTE_UINT16);
cmdline_parse_token_string_t cmd_vf_mac_addr_vf =
TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result,
vf,"vf");
cmdline_parse_token_num_t cmd_vf_mac_addr_vfnum =
TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result,
- vf_num, UINT8);
+ vf_num, RTE_UINT8);
cmdline_parse_token_etheraddr_t cmd_vf_mac_addr_addr =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_vf_mac_addr_result,
address);
what, "add#rm");
cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vlanid =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter,
- vlan_id, UINT16);
+ vlan_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_port =
TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter,
port, "port");
cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_portid =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_vf =
TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter,
vf, "vf");
cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vf_mask =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter,
- vf_mask, UINT64);
+ vf_mask, RTE_UINT64);
cmdline_parse_inst_t cmd_vf_rxvlan_filter = {
.f = cmd_vf_rx_vlan_filter_parsed,
port, "port");
cmdline_parse_token_num_t cmd_queue_rate_limit_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_queue_rate_limit_result,
- port_num, UINT16);
+ port_num, RTE_UINT16);
cmdline_parse_token_string_t cmd_queue_rate_limit_queue =
TOKEN_STRING_INITIALIZER(struct cmd_queue_rate_limit_result,
queue, "queue");
cmdline_parse_token_num_t cmd_queue_rate_limit_queuenum =
TOKEN_NUM_INITIALIZER(struct cmd_queue_rate_limit_result,
- queue_num, UINT8);
+ queue_num, RTE_UINT8);
cmdline_parse_token_string_t cmd_queue_rate_limit_rate =
TOKEN_STRING_INITIALIZER(struct cmd_queue_rate_limit_result,
rate, "rate");
cmdline_parse_token_num_t cmd_queue_rate_limit_ratenum =
TOKEN_NUM_INITIALIZER(struct cmd_queue_rate_limit_result,
- rate_num, UINT16);
+ rate_num, RTE_UINT16);
cmdline_parse_inst_t cmd_queue_rate_limit = {
.f = cmd_queue_rate_limit_parsed,
port, "port");
cmdline_parse_token_num_t cmd_vf_rate_limit_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result,
- port_num, UINT16);
+ port_num, RTE_UINT16);
cmdline_parse_token_string_t cmd_vf_rate_limit_vf =
TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result,
vf, "vf");
cmdline_parse_token_num_t cmd_vf_rate_limit_vfnum =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result,
- vf_num, UINT8);
+ vf_num, RTE_UINT8);
cmdline_parse_token_string_t cmd_vf_rate_limit_rate =
TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result,
rate, "rate");
cmdline_parse_token_num_t cmd_vf_rate_limit_ratenum =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result,
- rate_num, UINT16);
+ rate_num, RTE_UINT16);
cmdline_parse_token_string_t cmd_vf_rate_limit_q_msk =
TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result,
q_msk, "queue_mask");
cmdline_parse_token_num_t cmd_vf_rate_limit_q_msk_val =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result,
- q_msk_val, UINT64);
+ q_msk_val, RTE_UINT64);
cmdline_parse_inst_t cmd_vf_rate_limit = {
.f = cmd_vf_rate_limit_parsed,
},
};
-/* *** ADD TUNNEL FILTER OF A PORT *** */
-struct cmd_tunnel_filter_result {
- cmdline_fixed_string_t cmd;
- cmdline_fixed_string_t what;
- portid_t port_id;
- struct rte_ether_addr outer_mac;
- struct rte_ether_addr inner_mac;
- cmdline_ipaddr_t ip_value;
- uint16_t inner_vlan;
- cmdline_fixed_string_t tunnel_type;
- cmdline_fixed_string_t filter_type;
- uint32_t tenant_id;
- uint16_t queue_num;
-};
-
-static void
-cmd_tunnel_filter_parsed(void *parsed_result,
- __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;
- int ret = 0;
-
- memset(&tunnel_filter_conf, 0, sizeof(tunnel_filter_conf));
-
- rte_ether_addr_copy(&res->outer_mac, &tunnel_filter_conf.outer_mac);
- rte_ether_addr_copy(&res->inner_mac, &tunnel_filter_conf.inner_mac);
- tunnel_filter_conf.inner_vlan = res->inner_vlan;
-
- if (res->ip_value.family == AF_INET) {
- tunnel_filter_conf.ip_addr.ipv4_addr =
- res->ip_value.addr.ipv4.s_addr;
- tunnel_filter_conf.ip_type = RTE_TUNNEL_IPTYPE_IPV4;
- } else {
- memcpy(&(tunnel_filter_conf.ip_addr.ipv6_addr),
- &(res->ip_value.addr.ipv6),
- sizeof(struct in6_addr));
- tunnel_filter_conf.ip_type = RTE_TUNNEL_IPTYPE_IPV6;
- }
-
- if (!strcmp(res->filter_type, "imac-ivlan"))
- tunnel_filter_conf.filter_type = RTE_TUNNEL_FILTER_IMAC_IVLAN;
- else if (!strcmp(res->filter_type, "imac-ivlan-tenid"))
- tunnel_filter_conf.filter_type =
- RTE_TUNNEL_FILTER_IMAC_IVLAN_TENID;
- else if (!strcmp(res->filter_type, "imac-tenid"))
- tunnel_filter_conf.filter_type = RTE_TUNNEL_FILTER_IMAC_TENID;
- else if (!strcmp(res->filter_type, "imac"))
- tunnel_filter_conf.filter_type = ETH_TUNNEL_FILTER_IMAC;
- else if (!strcmp(res->filter_type, "omac-imac-tenid"))
- tunnel_filter_conf.filter_type =
- RTE_TUNNEL_FILTER_OMAC_TENID_IMAC;
- else if (!strcmp(res->filter_type, "oip"))
- tunnel_filter_conf.filter_type = ETH_TUNNEL_FILTER_OIP;
- else if (!strcmp(res->filter_type, "iip"))
- tunnel_filter_conf.filter_type = ETH_TUNNEL_FILTER_IIP;
- else {
- printf("The filter type is not supported");
- return;
- }
-
- if (!strcmp(res->tunnel_type, "vxlan"))
- tunnel_filter_conf.tunnel_type = RTE_TUNNEL_TYPE_VXLAN;
- else if (!strcmp(res->tunnel_type, "vxlan-gpe"))
- tunnel_filter_conf.tunnel_type = RTE_TUNNEL_TYPE_VXLAN_GPE;
- else if (!strcmp(res->tunnel_type, "nvgre"))
- tunnel_filter_conf.tunnel_type = RTE_TUNNEL_TYPE_NVGRE;
- else if (!strcmp(res->tunnel_type, "ipingre"))
- tunnel_filter_conf.tunnel_type = RTE_TUNNEL_TYPE_IP_IN_GRE;
- else {
- printf("The tunnel type %s not supported.\n", res->tunnel_type);
- return;
- }
-
- tunnel_filter_conf.tenant_id = res->tenant_id;
- tunnel_filter_conf.queue_id = res->queue_num;
- if (!strcmp(res->what, "add"))
- ret = rte_eth_dev_filter_ctrl(res->port_id,
- RTE_ETH_FILTER_TUNNEL,
- RTE_ETH_FILTER_ADD,
- &tunnel_filter_conf);
- else
- ret = rte_eth_dev_filter_ctrl(res->port_id,
- RTE_ETH_FILTER_TUNNEL,
- RTE_ETH_FILTER_DELETE,
- &tunnel_filter_conf);
- if (ret < 0)
- printf("cmd_tunnel_filter_parsed error: (%s)\n",
- strerror(-ret));
-
-}
-cmdline_parse_token_string_t cmd_tunnel_filter_cmd =
- TOKEN_STRING_INITIALIZER(struct cmd_tunnel_filter_result,
- cmd, "tunnel_filter");
-cmdline_parse_token_string_t cmd_tunnel_filter_what =
- TOKEN_STRING_INITIALIZER(struct cmd_tunnel_filter_result,
- what, "add#rm");
-cmdline_parse_token_num_t cmd_tunnel_filter_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_tunnel_filter_result,
- port_id, UINT16);
-cmdline_parse_token_etheraddr_t cmd_tunnel_filter_outer_mac =
- TOKEN_ETHERADDR_INITIALIZER(struct cmd_tunnel_filter_result,
- outer_mac);
-cmdline_parse_token_etheraddr_t cmd_tunnel_filter_inner_mac =
- TOKEN_ETHERADDR_INITIALIZER(struct cmd_tunnel_filter_result,
- inner_mac);
-cmdline_parse_token_num_t cmd_tunnel_filter_innner_vlan =
- TOKEN_NUM_INITIALIZER(struct cmd_tunnel_filter_result,
- inner_vlan, UINT16);
-cmdline_parse_token_ipaddr_t cmd_tunnel_filter_ip_value =
- TOKEN_IPADDR_INITIALIZER(struct cmd_tunnel_filter_result,
- ip_value);
-cmdline_parse_token_string_t cmd_tunnel_filter_tunnel_type =
- TOKEN_STRING_INITIALIZER(struct cmd_tunnel_filter_result,
- tunnel_type, "vxlan#nvgre#ipingre#vxlan-gpe");
-
-cmdline_parse_token_string_t cmd_tunnel_filter_filter_type =
- TOKEN_STRING_INITIALIZER(struct cmd_tunnel_filter_result,
- filter_type, "oip#iip#imac-ivlan#imac-ivlan-tenid#imac-tenid#"
- "imac#omac-imac-tenid");
-cmdline_parse_token_num_t cmd_tunnel_filter_tenant_id =
- TOKEN_NUM_INITIALIZER(struct cmd_tunnel_filter_result,
- tenant_id, UINT32);
-cmdline_parse_token_num_t cmd_tunnel_filter_queue_num =
- TOKEN_NUM_INITIALIZER(struct cmd_tunnel_filter_result,
- queue_num, UINT16);
-
-cmdline_parse_inst_t cmd_tunnel_filter = {
- .f = cmd_tunnel_filter_parsed,
- .data = (void *)0,
- .help_str = "tunnel_filter add|rm <port_id> <outer_mac> <inner_mac> "
- "<ip> <inner_vlan> vxlan|nvgre|ipingre oip|iip|imac-ivlan|"
- "imac-ivlan-tenid|imac-tenid|imac|omac-imac-tenid <tenant_id> "
- "<queue_id>: Add/Rm tunnel filter of a port",
- .tokens = {
- (void *)&cmd_tunnel_filter_cmd,
- (void *)&cmd_tunnel_filter_what,
- (void *)&cmd_tunnel_filter_port_id,
- (void *)&cmd_tunnel_filter_outer_mac,
- (void *)&cmd_tunnel_filter_inner_mac,
- (void *)&cmd_tunnel_filter_ip_value,
- (void *)&cmd_tunnel_filter_innner_vlan,
- (void *)&cmd_tunnel_filter_tunnel_type,
- (void *)&cmd_tunnel_filter_filter_type,
- (void *)&cmd_tunnel_filter_tenant_id,
- (void *)&cmd_tunnel_filter_queue_num,
- NULL,
- },
-};
-
/* *** CONFIGURE TUNNEL UDP PORT *** */
struct cmd_tunnel_udp_config {
- cmdline_fixed_string_t cmd;
+ cmdline_fixed_string_t rx_vxlan_port;
cmdline_fixed_string_t what;
uint16_t udp_port;
portid_t port_id;
int ret;
tunnel_udp.udp_port = res->udp_port;
-
- if (!strcmp(res->cmd, "rx_vxlan_port"))
- tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN;
+ tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN;
if (!strcmp(res->what, "add"))
ret = rte_eth_dev_udp_tunnel_port_add(res->port_id,
printf("udp tunneling add error: (%s)\n", strerror(-ret));
}
-cmdline_parse_token_string_t cmd_tunnel_udp_config_cmd =
+cmdline_parse_token_string_t cmd_tunnel_udp_config_rx_vxlan_port =
TOKEN_STRING_INITIALIZER(struct cmd_tunnel_udp_config,
- cmd, "rx_vxlan_port");
+ rx_vxlan_port, "rx_vxlan_port");
cmdline_parse_token_string_t cmd_tunnel_udp_config_what =
TOKEN_STRING_INITIALIZER(struct cmd_tunnel_udp_config,
what, "add#rm");
cmdline_parse_token_num_t cmd_tunnel_udp_config_udp_port =
TOKEN_NUM_INITIALIZER(struct cmd_tunnel_udp_config,
- udp_port, UINT16);
+ udp_port, RTE_UINT16);
cmdline_parse_token_num_t cmd_tunnel_udp_config_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_tunnel_udp_config,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_inst_t cmd_tunnel_udp_config = {
.f = cmd_tunnel_udp_config_parsed,
.help_str = "rx_vxlan_port add|rm <udp_port> <port_id>: "
"Add/Remove a tunneling UDP port filter",
.tokens = {
- (void *)&cmd_tunnel_udp_config_cmd,
+ (void *)&cmd_tunnel_udp_config_rx_vxlan_port,
(void *)&cmd_tunnel_udp_config_what,
(void *)&cmd_tunnel_udp_config_udp_port,
(void *)&cmd_tunnel_udp_config_port_id,
tunnel_udp.prot_type = RTE_TUNNEL_TYPE_GENEVE;
} else if (!strcmp(res->tunnel_type, "vxlan-gpe")) {
tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN_GPE;
+ } else if (!strcmp(res->tunnel_type, "ecpri")) {
+ tunnel_udp.prot_type = RTE_TUNNEL_TYPE_ECPRI;
} else {
printf("Invalid tunnel type\n");
return;
"config");
cmdline_parse_token_num_t cmd_config_tunnel_udp_port_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_config_tunnel_udp_port, port_id,
- UINT16);
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_config_tunnel_udp_port_tunnel_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_tunnel_udp_port,
udp_tunnel_port,
"add#rm");
cmdline_parse_token_string_t cmd_config_tunnel_udp_port_tunnel_type =
TOKEN_STRING_INITIALIZER(struct cmd_config_tunnel_udp_port, tunnel_type,
- "vxlan#geneve#vxlan-gpe");
+ "vxlan#geneve#vxlan-gpe#ecpri");
cmdline_parse_token_num_t cmd_config_tunnel_udp_port_value =
TOKEN_NUM_INITIALIZER(struct cmd_config_tunnel_udp_port, udp_port,
- UINT16);
+ RTE_UINT16);
cmdline_parse_inst_t cmd_cfg_tunnel_udp_port = {
.f = cmd_cfg_tunnel_udp_port_parsed,
.data = NULL,
- .help_str = "port config <port_id> udp_tunnel_port add|rm vxlan|geneve|vxlan-gpe <udp_port>",
+ .help_str = "port config <port_id> udp_tunnel_port add|rm vxlan|"
+ "geneve|vxlan-gpe|ecpri <udp_port>",
.tokens = {
(void *)&cmd_config_tunnel_udp_port_port,
(void *)&cmd_config_tunnel_udp_port_config,
},
};
-/* *** GLOBAL CONFIG *** */
-struct cmd_global_config_result {
- cmdline_fixed_string_t cmd;
- portid_t port_id;
- cmdline_fixed_string_t cfg_type;
- uint8_t len;
-};
-
-static void
-cmd_global_config_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_global_config_result *res = parsed_result;
- struct rte_eth_global_cfg conf;
- int ret;
-
- memset(&conf, 0, sizeof(conf));
- conf.cfg_type = RTE_ETH_GLOBAL_CFG_TYPE_GRE_KEY_LEN;
- conf.cfg.gre_key_len = res->len;
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_NONE,
- RTE_ETH_FILTER_SET, &conf);
-#ifdef RTE_NET_I40E
- if (ret == -ENOTSUP)
- ret = rte_pmd_i40e_set_gre_key_len(res->port_id, res->len);
-#endif
- if (ret != 0)
- printf("Global config error\n");
-}
-
-cmdline_parse_token_string_t cmd_global_config_cmd =
- TOKEN_STRING_INITIALIZER(struct cmd_global_config_result, cmd,
- "global_config");
-cmdline_parse_token_num_t cmd_global_config_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_global_config_result, port_id,
- UINT16);
-cmdline_parse_token_string_t cmd_global_config_type =
- TOKEN_STRING_INITIALIZER(struct cmd_global_config_result,
- cfg_type, "gre-key-len");
-cmdline_parse_token_num_t cmd_global_config_gre_key_len =
- TOKEN_NUM_INITIALIZER(struct cmd_global_config_result,
- len, UINT8);
-
-cmdline_parse_inst_t cmd_global_config = {
- .f = cmd_global_config_parsed,
- .data = (void *)NULL,
- .help_str = "global_config <port_id> gre-key-len <key_len>",
- .tokens = {
- (void *)&cmd_global_config_cmd,
- (void *)&cmd_global_config_port_id,
- (void *)&cmd_global_config_type,
- (void *)&cmd_global_config_gre_key_len,
- NULL,
- },
-};
-
/* *** CONFIGURE VM MIRROR VLAN/POOL RULE *** */
struct cmd_set_mirror_mask_result {
cmdline_fixed_string_t set;
port, "port");
cmdline_parse_token_num_t cmd_mirror_mask_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_mirror_mask_mirror =
TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
mirror, "mirror-rule");
cmdline_parse_token_num_t cmd_mirror_mask_ruleid =
TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result,
- rule_id, UINT8);
+ rule_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_mirror_mask_what =
TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
what, "pool-mirror-up#pool-mirror-down"
dstpool, "dst-pool");
cmdline_parse_token_num_t cmd_mirror_mask_poolid =
TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result,
- dstpool_id, UINT8);
+ dstpool_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_mirror_mask_on =
TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
on, "on#off");
port, "port");
cmdline_parse_token_num_t cmd_mirror_link_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_mirror_link_mirror =
TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
mirror, "mirror-rule");
cmdline_parse_token_num_t cmd_mirror_link_ruleid =
TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result,
- rule_id, UINT8);
+ rule_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_mirror_link_what =
TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
what, "uplink-mirror#downlink-mirror");
dstpool, "dst-pool");
cmdline_parse_token_num_t cmd_mirror_link_poolid =
TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result,
- dstpool_id, UINT8);
+ dstpool_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_mirror_link_on =
TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
on, "on#off");
port, "port");
cmdline_parse_token_num_t cmd_rm_mirror_rule_portid =
TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_rm_mirror_rule_mirror =
TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result,
mirror, "mirror-rule");
cmdline_parse_token_num_t cmd_rm_mirror_rule_ruleid =
TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result,
- rule_id, UINT8);
+ rule_id, RTE_UINT8);
static void
cmd_reset_mirror_rule_parsed(void *parsed_result,
TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result, port, "port");
cmdline_parse_token_num_t cmd_queue_region_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_queue_region_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
cmd, "queue-region");
region, "region_id");
cmdline_parse_token_num_t cmd_queue_region_index =
TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
- region_id, UINT8);
+ region_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_queue_region_queue_start_index =
TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
queue_start_index, "queue_start_index");
cmdline_parse_token_num_t cmd_queue_region_queue_id =
TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
- queue_id, UINT8);
+ queue_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_queue_region_queue_num =
TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
queue_num, "queue_num");
cmdline_parse_token_num_t cmd_queue_region_queue_num_value =
TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
- queue_num_value, UINT8);
+ queue_num_value, RTE_UINT8);
cmdline_parse_inst_t cmd_queue_region = {
.f = cmd_queue_region_parsed,
port, "port");
cmdline_parse_token_num_t cmd_region_flowtype_port_index =
TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_region_flowtype_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
cmd, "queue-region");
region, "region_id");
cmdline_parse_token_num_t cmd_region_flowtype_id =
TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
- region_id, UINT8);
+ region_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_region_flowtype_flow_index =
TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
flowtype, "flowtype");
cmdline_parse_token_num_t cmd_region_flowtype_flow_id =
TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
- flowtype_id, UINT8);
+ flowtype_id, RTE_UINT8);
cmdline_parse_inst_t cmd_region_flowtype = {
.f = cmd_region_flowtype_parsed,
.data = NULL,
port, "port");
cmdline_parse_token_num_t cmd_user_priority_region_port_index =
TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_user_priority_region_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
cmd, "queue-region");
user_priority, "UP");
cmdline_parse_token_num_t cmd_user_priority_region_UP_id =
TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
- user_priority_id, UINT8);
+ user_priority_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_user_priority_region_region =
TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
region, "region_id");
cmdline_parse_token_num_t cmd_user_priority_region_region_id =
TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
- region_id, UINT8);
+ region_id, RTE_UINT8);
cmdline_parse_inst_t cmd_user_priority_region = {
.f = cmd_user_priority_region_parsed,
port, "port");
cmdline_parse_token_num_t cmd_flush_queue_region_port_index =
TOKEN_NUM_INITIALIZER(struct cmd_flush_queue_region_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_flush_queue_region_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
cmd, "queue-region");
port, "port");
cmdline_parse_token_num_t cmd_show_queue_region_info_port_index =
TOKEN_NUM_INITIALIZER(struct cmd_show_queue_region_info,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_show_queue_region_info_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_show_queue_region_info,
cmd, "queue-region");
/* *** Filters Control *** */
-/* *** deal with flow director filter *** */
-struct cmd_flow_director_result {
- cmdline_fixed_string_t flow_director_filter;
- portid_t port_id;
- cmdline_fixed_string_t mode;
- cmdline_fixed_string_t mode_value;
- cmdline_fixed_string_t ops;
- cmdline_fixed_string_t flow;
- cmdline_fixed_string_t flow_type;
- cmdline_fixed_string_t ether;
- uint16_t ether_type;
- cmdline_fixed_string_t src;
- cmdline_ipaddr_t ip_src;
- uint16_t port_src;
- cmdline_fixed_string_t dst;
- cmdline_ipaddr_t ip_dst;
- uint16_t port_dst;
- cmdline_fixed_string_t verify_tag;
- uint32_t verify_tag_value;
- cmdline_fixed_string_t tos;
- uint8_t tos_value;
- cmdline_fixed_string_t proto;
- uint8_t proto_value;
- cmdline_fixed_string_t ttl;
- uint8_t ttl_value;
- cmdline_fixed_string_t vlan;
- uint16_t vlan_value;
- cmdline_fixed_string_t flexbytes;
- cmdline_fixed_string_t flexbytes_value;
- cmdline_fixed_string_t pf_vf;
- cmdline_fixed_string_t drop;
- cmdline_fixed_string_t queue;
- uint16_t queue_id;
- cmdline_fixed_string_t fd_id;
- uint32_t fd_id_value;
- cmdline_fixed_string_t mac;
- struct rte_ether_addr mac_addr;
- cmdline_fixed_string_t tunnel;
- cmdline_fixed_string_t tunnel_type;
- cmdline_fixed_string_t tunnel_id;
- uint32_t tunnel_id_value;
- cmdline_fixed_string_t packet;
- char filepath[];
-};
-
-static inline int
-parse_flexbytes(const char *q_arg, uint8_t *flexbytes, uint16_t max_num)
-{
- char s[256];
- const char *p, *p0 = q_arg;
- char *end;
- unsigned long int_fld;
- char *str_fld[max_num];
- int i;
- unsigned size;
- int ret = -1;
-
- p = strchr(p0, '(');
- if (p == NULL)
- return -1;
- ++p;
- p0 = strchr(p, ')');
- if (p0 == NULL)
- return -1;
+#define IPV4_ADDR_TO_UINT(ip_addr, ip) \
+do { \
+ if ((ip_addr).family == AF_INET) \
+ (ip) = (ip_addr).addr.ipv4.s_addr; \
+ else { \
+ printf("invalid parameter.\n"); \
+ return; \
+ } \
+} while (0)
- size = p0 - p;
- if (size >= sizeof(s))
- return -1;
+#define IPV6_ADDR_TO_ARRAY(ip_addr, ip) \
+do { \
+ if ((ip_addr).family == AF_INET6) \
+ rte_memcpy(&(ip), \
+ &((ip_addr).addr.ipv6), \
+ sizeof(struct in6_addr)); \
+ else { \
+ printf("invalid parameter.\n"); \
+ return; \
+ } \
+} while (0)
- snprintf(s, sizeof(s), "%.*s", size, p);
- ret = rte_strsplit(s, sizeof(s), str_fld, max_num, ',');
- if (ret < 0 || ret > max_num)
- return -1;
- for (i = 0; i < ret; i++) {
- errno = 0;
- int_fld = strtoul(str_fld[i], &end, 0);
- if (errno != 0 || *end != '\0' || int_fld > UINT8_MAX)
- return -1;
- flexbytes[i] = (uint8_t)int_fld;
- }
- return ret;
-}
+#ifdef RTE_NET_I40E
static uint16_t
str2flowtype(char *string)
return RTE_ETH_FLOW_UNKNOWN;
}
-static enum rte_eth_fdir_tunnel_type
-str2fdir_tunneltype(char *string)
-{
- uint8_t i = 0;
-
- static const struct {
- char str[32];
- enum rte_eth_fdir_tunnel_type type;
- } tunneltype_str[] = {
- {"NVGRE", RTE_FDIR_TUNNEL_TYPE_NVGRE},
- {"VxLAN", RTE_FDIR_TUNNEL_TYPE_VXLAN},
- };
-
- for (i = 0; i < RTE_DIM(tunneltype_str); i++) {
- if (!strcmp(tunneltype_str[i].str, string))
- return tunneltype_str[i].type;
- }
- return RTE_FDIR_TUNNEL_TYPE_UNKNOWN;
-}
-
-#define IPV4_ADDR_TO_UINT(ip_addr, ip) \
-do { \
- if ((ip_addr).family == AF_INET) \
- (ip) = (ip_addr).addr.ipv4.s_addr; \
- else { \
- printf("invalid parameter.\n"); \
- return; \
- } \
-} while (0)
-
-#define IPV6_ADDR_TO_ARRAY(ip_addr, ip) \
-do { \
- if ((ip_addr).family == AF_INET6) \
- rte_memcpy(&(ip), \
- &((ip_addr).addr.ipv6), \
- sizeof(struct in6_addr)); \
- else { \
- printf("invalid parameter.\n"); \
- return; \
- } \
-} while (0)
+/* *** deal with flow director filter *** */
+struct cmd_flow_director_result {
+ cmdline_fixed_string_t flow_director_filter;
+ portid_t port_id;
+ cmdline_fixed_string_t mode;
+ cmdline_fixed_string_t mode_value;
+ cmdline_fixed_string_t ops;
+ cmdline_fixed_string_t flow;
+ cmdline_fixed_string_t flow_type;
+ cmdline_fixed_string_t drop;
+ cmdline_fixed_string_t queue;
+ uint16_t queue_id;
+ cmdline_fixed_string_t fd_id;
+ uint32_t fd_id_value;
+ cmdline_fixed_string_t packet;
+ char filepath[];
+};
static void
cmd_flow_director_filter_parsed(void *parsed_result,
__rte_unused void *data)
{
struct cmd_flow_director_result *res = parsed_result;
- struct rte_eth_fdir_filter entry;
- uint8_t flexbytes[RTE_ETH_FDIR_MAX_FLEXLEN];
- char *end;
- unsigned long vf_id;
int ret = 0;
+ struct rte_pmd_i40e_flow_type_mapping
+ mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
+ struct rte_pmd_i40e_pkt_template_conf conf;
+ uint16_t flow_type = str2flowtype(res->flow_type);
+ uint16_t i, port = res->port_id;
+ uint8_t add;
- ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_FDIR);
- if (ret < 0) {
- printf("flow director is not supported on port %u.\n",
- res->port_id);
+ memset(&conf, 0, sizeof(conf));
+
+ if (flow_type == RTE_ETH_FLOW_UNKNOWN) {
+ printf("Invalid flow type specified.\n");
return;
}
- memset(flexbytes, 0, sizeof(flexbytes));
- memset(&entry, 0, sizeof(struct rte_eth_fdir_filter));
-
- if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
- if (strcmp(res->mode_value, "MAC-VLAN")) {
- printf("Please set mode to MAC-VLAN.\n");
- return;
- }
- } else if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) {
- if (strcmp(res->mode_value, "Tunnel")) {
- printf("Please set mode to Tunnel.\n");
- return;
- }
- } else {
- if (!strcmp(res->mode_value, "raw")) {
-#ifdef RTE_NET_I40E
- struct rte_pmd_i40e_flow_type_mapping
- mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
- struct rte_pmd_i40e_pkt_template_conf conf;
- uint16_t flow_type = str2flowtype(res->flow_type);
- uint16_t i, port = res->port_id;
- uint8_t add;
-
- memset(&conf, 0, sizeof(conf));
-
- if (flow_type == RTE_ETH_FLOW_UNKNOWN) {
- printf("Invalid flow type specified.\n");
- return;
- }
- ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id,
- mapping);
- if (ret)
- return;
- if (mapping[flow_type].pctype == 0ULL) {
- printf("Invalid flow type specified.\n");
- return;
- }
- for (i = 0; i < RTE_PMD_I40E_PCTYPE_MAX; i++) {
- if (mapping[flow_type].pctype & (1ULL << i)) {
- conf.input.pctype = i;
- break;
- }
- }
-
- conf.input.packet = open_file(res->filepath,
- &conf.input.length);
- if (!conf.input.packet)
- return;
- if (!strcmp(res->drop, "drop"))
- conf.action.behavior =
- RTE_PMD_I40E_PKT_TEMPLATE_REJECT;
- else
- conf.action.behavior =
- RTE_PMD_I40E_PKT_TEMPLATE_ACCEPT;
- conf.action.report_status =
- RTE_PMD_I40E_PKT_TEMPLATE_REPORT_ID;
- conf.action.rx_queue = res->queue_id;
- conf.soft_id = res->fd_id_value;
- add = strcmp(res->ops, "del") ? 1 : 0;
- ret = rte_pmd_i40e_flow_add_del_packet_template(port,
- &conf,
- add);
- if (ret < 0)
- printf("flow director config error: (%s)\n",
- strerror(-ret));
- close_file(conf.input.packet);
-#endif
- return;
- } else if (strcmp(res->mode_value, "IP")) {
- printf("Please set mode to IP or raw.\n");
- return;
+ ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id,
+ mapping);
+ if (ret)
+ return;
+ if (mapping[flow_type].pctype == 0ULL) {
+ printf("Invalid flow type specified.\n");
+ return;
+ }
+ for (i = 0; i < RTE_PMD_I40E_PCTYPE_MAX; i++) {
+ if (mapping[flow_type].pctype & (1ULL << i)) {
+ conf.input.pctype = i;
+ break;
}
- entry.input.flow_type = str2flowtype(res->flow_type);
}
- ret = parse_flexbytes(res->flexbytes_value,
- flexbytes,
- RTE_ETH_FDIR_MAX_FLEXLEN);
- if (ret < 0) {
- printf("error: Cannot parse flexbytes input.\n");
+ conf.input.packet = open_file(res->filepath,
+ &conf.input.length);
+ if (!conf.input.packet)
return;
- }
-
- switch (entry.input.flow_type) {
- case RTE_ETH_FLOW_FRAG_IPV4:
- case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
- entry.input.flow.ip4_flow.proto = res->proto_value;
- /* fall-through */
- case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
- IPV4_ADDR_TO_UINT(res->ip_dst,
- entry.input.flow.ip4_flow.dst_ip);
- IPV4_ADDR_TO_UINT(res->ip_src,
- entry.input.flow.ip4_flow.src_ip);
- entry.input.flow.ip4_flow.tos = res->tos_value;
- entry.input.flow.ip4_flow.ttl = res->ttl_value;
- /* need convert to big endian. */
- entry.input.flow.udp4_flow.dst_port =
- rte_cpu_to_be_16(res->port_dst);
- entry.input.flow.udp4_flow.src_port =
- rte_cpu_to_be_16(res->port_src);
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV4_SCTP:
- IPV4_ADDR_TO_UINT(res->ip_dst,
- entry.input.flow.sctp4_flow.ip.dst_ip);
- IPV4_ADDR_TO_UINT(res->ip_src,
- entry.input.flow.sctp4_flow.ip.src_ip);
- entry.input.flow.ip4_flow.tos = res->tos_value;
- entry.input.flow.ip4_flow.ttl = res->ttl_value;
- /* need convert to big endian. */
- entry.input.flow.sctp4_flow.dst_port =
- rte_cpu_to_be_16(res->port_dst);
- entry.input.flow.sctp4_flow.src_port =
- rte_cpu_to_be_16(res->port_src);
- entry.input.flow.sctp4_flow.verify_tag =
- rte_cpu_to_be_32(res->verify_tag_value);
- break;
- case RTE_ETH_FLOW_FRAG_IPV6:
- case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
- entry.input.flow.ipv6_flow.proto = res->proto_value;
- /* fall-through */
- case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
- case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
- IPV6_ADDR_TO_ARRAY(res->ip_dst,
- entry.input.flow.ipv6_flow.dst_ip);
- IPV6_ADDR_TO_ARRAY(res->ip_src,
- entry.input.flow.ipv6_flow.src_ip);
- entry.input.flow.ipv6_flow.tc = res->tos_value;
- entry.input.flow.ipv6_flow.hop_limits = res->ttl_value;
- /* need convert to big endian. */
- entry.input.flow.udp6_flow.dst_port =
- rte_cpu_to_be_16(res->port_dst);
- entry.input.flow.udp6_flow.src_port =
- rte_cpu_to_be_16(res->port_src);
- break;
- case RTE_ETH_FLOW_NONFRAG_IPV6_SCTP:
- IPV6_ADDR_TO_ARRAY(res->ip_dst,
- entry.input.flow.sctp6_flow.ip.dst_ip);
- IPV6_ADDR_TO_ARRAY(res->ip_src,
- entry.input.flow.sctp6_flow.ip.src_ip);
- entry.input.flow.ipv6_flow.tc = res->tos_value;
- entry.input.flow.ipv6_flow.hop_limits = res->ttl_value;
- /* need convert to big endian. */
- entry.input.flow.sctp6_flow.dst_port =
- rte_cpu_to_be_16(res->port_dst);
- entry.input.flow.sctp6_flow.src_port =
- rte_cpu_to_be_16(res->port_src);
- entry.input.flow.sctp6_flow.verify_tag =
- rte_cpu_to_be_32(res->verify_tag_value);
- break;
- case RTE_ETH_FLOW_L2_PAYLOAD:
- entry.input.flow.l2_flow.ether_type =
- rte_cpu_to_be_16(res->ether_type);
- break;
- default:
- break;
- }
-
- if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN)
- rte_memcpy(&entry.input.flow.mac_vlan_flow.mac_addr,
- &res->mac_addr,
- sizeof(struct rte_ether_addr));
-
- if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) {
- rte_memcpy(&entry.input.flow.tunnel_flow.mac_addr,
- &res->mac_addr,
- sizeof(struct rte_ether_addr));
- entry.input.flow.tunnel_flow.tunnel_type =
- str2fdir_tunneltype(res->tunnel_type);
- entry.input.flow.tunnel_flow.tunnel_id =
- rte_cpu_to_be_32(res->tunnel_id_value);
- }
-
- rte_memcpy(entry.input.flow_ext.flexbytes,
- flexbytes,
- RTE_ETH_FDIR_MAX_FLEXLEN);
-
- entry.input.flow_ext.vlan_tci = rte_cpu_to_be_16(res->vlan_value);
-
- entry.action.flex_off = 0; /*use 0 by default */
if (!strcmp(res->drop, "drop"))
- entry.action.behavior = RTE_ETH_FDIR_REJECT;
- else
- entry.action.behavior = RTE_ETH_FDIR_ACCEPT;
-
- if (fdir_conf.mode != RTE_FDIR_MODE_PERFECT_MAC_VLAN &&
- fdir_conf.mode != RTE_FDIR_MODE_PERFECT_TUNNEL) {
- if (!strcmp(res->pf_vf, "pf"))
- entry.input.flow_ext.is_vf = 0;
- else if (!strncmp(res->pf_vf, "vf", 2)) {
- struct rte_eth_dev_info 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' ||
- vf_id >= dev_info.max_vfs) {
- printf("invalid parameter %s.\n", res->pf_vf);
- return;
- }
- entry.input.flow_ext.is_vf = 1;
- entry.input.flow_ext.dst_id = (uint16_t)vf_id;
- } else {
- printf("invalid parameter %s.\n", res->pf_vf);
- return;
- }
- }
-
- /* set to report FD ID by default */
- entry.action.report_status = RTE_ETH_FDIR_REPORT_ID;
- entry.action.rx_queue = res->queue_id;
- entry.soft_id = res->fd_id_value;
- if (!strcmp(res->ops, "add"))
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_ADD, &entry);
- else if (!strcmp(res->ops, "del"))
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_DELETE, &entry);
+ conf.action.behavior =
+ RTE_PMD_I40E_PKT_TEMPLATE_REJECT;
else
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_UPDATE, &entry);
+ conf.action.behavior =
+ RTE_PMD_I40E_PKT_TEMPLATE_ACCEPT;
+ conf.action.report_status =
+ RTE_PMD_I40E_PKT_TEMPLATE_REPORT_ID;
+ conf.action.rx_queue = res->queue_id;
+ conf.soft_id = res->fd_id_value;
+ add = strcmp(res->ops, "del") ? 1 : 0;
+ ret = rte_pmd_i40e_flow_add_del_packet_template(port,
+ &conf,
+ add);
if (ret < 0)
- printf("flow director programming error: (%s)\n",
- strerror(-ret));
+ printf("flow director config error: (%s)\n",
+ strerror(-ret));
+ close_file(conf.input.packet);
}
cmdline_parse_token_string_t cmd_flow_director_filter =
flow_director_filter, "flow_director_filter");
cmdline_parse_token_num_t cmd_flow_director_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_flow_director_ops =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
ops, "add#del#update");
cmdline_parse_token_string_t cmd_flow_director_flow_type =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
flow_type, NULL);
-cmdline_parse_token_string_t cmd_flow_director_ether =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- ether, "ether");
-cmdline_parse_token_num_t cmd_flow_director_ether_type =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- ether_type, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_src =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- src, "src");
-cmdline_parse_token_ipaddr_t cmd_flow_director_ip_src =
- TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
- ip_src);
-cmdline_parse_token_num_t cmd_flow_director_port_src =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- port_src, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_dst =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- dst, "dst");
-cmdline_parse_token_ipaddr_t cmd_flow_director_ip_dst =
- TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
- ip_dst);
-cmdline_parse_token_num_t cmd_flow_director_port_dst =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- port_dst, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_verify_tag =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- verify_tag, "verify_tag");
-cmdline_parse_token_num_t cmd_flow_director_verify_tag_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- verify_tag_value, UINT32);
-cmdline_parse_token_string_t cmd_flow_director_tos =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- tos, "tos");
-cmdline_parse_token_num_t cmd_flow_director_tos_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- tos_value, UINT8);
-cmdline_parse_token_string_t cmd_flow_director_proto =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- proto, "proto");
-cmdline_parse_token_num_t cmd_flow_director_proto_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- proto_value, UINT8);
-cmdline_parse_token_string_t cmd_flow_director_ttl =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- ttl, "ttl");
-cmdline_parse_token_num_t cmd_flow_director_ttl_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- ttl_value, UINT8);
-cmdline_parse_token_string_t cmd_flow_director_vlan =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- vlan, "vlan");
-cmdline_parse_token_num_t cmd_flow_director_vlan_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- vlan_value, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_flexbytes =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- flexbytes, "flexbytes");
-cmdline_parse_token_string_t cmd_flow_director_flexbytes_value =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- flexbytes_value, NULL);
cmdline_parse_token_string_t cmd_flow_director_drop =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
drop, "drop#fwd");
-cmdline_parse_token_string_t cmd_flow_director_pf_vf =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- pf_vf, NULL);
cmdline_parse_token_string_t cmd_flow_director_queue =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
queue, "queue");
cmdline_parse_token_num_t cmd_flow_director_queue_id =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- queue_id, UINT16);
+ queue_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_flow_director_fd_id =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
fd_id, "fd_id");
cmdline_parse_token_num_t cmd_flow_director_fd_id_value =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- fd_id_value, UINT32);
+ fd_id_value, RTE_UINT32);
cmdline_parse_token_string_t cmd_flow_director_mode =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
mode, "mode");
-cmdline_parse_token_string_t cmd_flow_director_mode_ip =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- mode_value, "IP");
-cmdline_parse_token_string_t cmd_flow_director_mode_mac_vlan =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- mode_value, "MAC-VLAN");
-cmdline_parse_token_string_t cmd_flow_director_mode_tunnel =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- mode_value, "Tunnel");
cmdline_parse_token_string_t cmd_flow_director_mode_raw =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
mode_value, "raw");
-cmdline_parse_token_string_t cmd_flow_director_mac =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- mac, "mac");
-cmdline_parse_token_etheraddr_t cmd_flow_director_mac_addr =
- TOKEN_ETHERADDR_INITIALIZER(struct cmd_flow_director_result,
- mac_addr);
-cmdline_parse_token_string_t cmd_flow_director_tunnel =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- tunnel, "tunnel");
-cmdline_parse_token_string_t cmd_flow_director_tunnel_type =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- tunnel_type, "NVGRE#VxLAN");
-cmdline_parse_token_string_t cmd_flow_director_tunnel_id =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
- tunnel_id, "tunnel-id");
-cmdline_parse_token_num_t cmd_flow_director_tunnel_id_value =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- tunnel_id_value, UINT32);
cmdline_parse_token_string_t cmd_flow_director_packet =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
packet, "packet");
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
filepath, NULL);
-cmdline_parse_inst_t cmd_add_del_ip_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter <port_id> mode IP add|del|update flow"
- " ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|"
- "ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|"
- "l2_payload src <src_ip> dst <dst_ip> tos <tos_value> "
- "proto <proto_value> ttl <ttl_value> vlan <vlan_value> "
- "flexbytes <flexbyte_values> drop|fw <pf_vf> queue <queue_id> "
- "fd_id <fd_id_value>: "
- "Add or delete an ip flow director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_ip,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_flow,
- (void *)&cmd_flow_director_flow_type,
- (void *)&cmd_flow_director_src,
- (void *)&cmd_flow_director_ip_src,
- (void *)&cmd_flow_director_dst,
- (void *)&cmd_flow_director_ip_dst,
- (void *)&cmd_flow_director_tos,
- (void *)&cmd_flow_director_tos_value,
- (void *)&cmd_flow_director_proto,
- (void *)&cmd_flow_director_proto_value,
- (void *)&cmd_flow_director_ttl,
- (void *)&cmd_flow_director_ttl_value,
- (void *)&cmd_flow_director_vlan,
- (void *)&cmd_flow_director_vlan_value,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_pf_vf,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_add_del_udp_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter ... : Add or delete an udp/tcp flow "
- "director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_ip,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_flow,
- (void *)&cmd_flow_director_flow_type,
- (void *)&cmd_flow_director_src,
- (void *)&cmd_flow_director_ip_src,
- (void *)&cmd_flow_director_port_src,
- (void *)&cmd_flow_director_dst,
- (void *)&cmd_flow_director_ip_dst,
- (void *)&cmd_flow_director_port_dst,
- (void *)&cmd_flow_director_tos,
- (void *)&cmd_flow_director_tos_value,
- (void *)&cmd_flow_director_ttl,
- (void *)&cmd_flow_director_ttl_value,
- (void *)&cmd_flow_director_vlan,
- (void *)&cmd_flow_director_vlan_value,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_pf_vf,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_add_del_sctp_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter ... : Add or delete a sctp flow "
- "director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_ip,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_flow,
- (void *)&cmd_flow_director_flow_type,
- (void *)&cmd_flow_director_src,
- (void *)&cmd_flow_director_ip_src,
- (void *)&cmd_flow_director_port_src,
- (void *)&cmd_flow_director_dst,
- (void *)&cmd_flow_director_ip_dst,
- (void *)&cmd_flow_director_port_dst,
- (void *)&cmd_flow_director_verify_tag,
- (void *)&cmd_flow_director_verify_tag_value,
- (void *)&cmd_flow_director_tos,
- (void *)&cmd_flow_director_tos_value,
- (void *)&cmd_flow_director_ttl,
- (void *)&cmd_flow_director_ttl_value,
- (void *)&cmd_flow_director_vlan,
- (void *)&cmd_flow_director_vlan_value,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_pf_vf,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_add_del_l2_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter ... : Add or delete a L2 flow "
- "director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_ip,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_flow,
- (void *)&cmd_flow_director_flow_type,
- (void *)&cmd_flow_director_ether,
- (void *)&cmd_flow_director_ether_type,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_pf_vf,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_add_del_mac_vlan_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter ... : Add or delete a MAC VLAN flow "
- "director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_mac_vlan,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_mac,
- (void *)&cmd_flow_director_mac_addr,
- (void *)&cmd_flow_director_vlan,
- (void *)&cmd_flow_director_vlan_value,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_add_del_tunnel_flow_director = {
- .f = cmd_flow_director_filter_parsed,
- .data = NULL,
- .help_str = "flow_director_filter ... : Add or delete a tunnel flow "
- "director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_tunnel,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_mac,
- (void *)&cmd_flow_director_mac_addr,
- (void *)&cmd_flow_director_vlan,
- (void *)&cmd_flow_director_vlan_value,
- (void *)&cmd_flow_director_tunnel,
- (void *)&cmd_flow_director_tunnel_type,
- (void *)&cmd_flow_director_tunnel_id,
- (void *)&cmd_flow_director_tunnel_id_value,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
cmdline_parse_inst_t cmd_add_del_raw_flow_director = {
.f = cmd_flow_director_filter_parsed,
.data = NULL,
},
};
-struct cmd_flush_flow_director_result {
- cmdline_fixed_string_t flush_flow_director;
- portid_t port_id;
-};
-
-cmdline_parse_token_string_t cmd_flush_flow_director_flush =
- TOKEN_STRING_INITIALIZER(struct cmd_flush_flow_director_result,
- flush_flow_director, "flush_flow_director");
-cmdline_parse_token_num_t cmd_flush_flow_director_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_flush_flow_director_result,
- port_id, UINT16);
-
-static void
-cmd_flush_flow_director_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_flow_director_result *res = parsed_result;
- int ret = 0;
-
- ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_FDIR);
- if (ret < 0) {
- printf("flow director is not supported on port %u.\n",
- res->port_id);
- return;
- }
-
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_FLUSH, NULL);
- if (ret < 0)
- printf("flow director table flushing error: (%s)\n",
- strerror(-ret));
-}
-
-cmdline_parse_inst_t cmd_flush_flow_director = {
- .f = cmd_flush_flow_director_parsed,
- .data = NULL,
- .help_str = "flush_flow_director <port_id>: "
- "Flush all flow director entries of a device on NIC",
- .tokens = {
- (void *)&cmd_flush_flow_director_flush,
- (void *)&cmd_flush_flow_director_port_id,
- NULL,
- },
-};
+#endif /* RTE_NET_I40E */
/* *** deal with flow director mask *** */
struct cmd_flow_director_mask_result {
flow_director_mask, "flow_director_mask");
cmdline_parse_token_num_t cmd_flow_director_mask_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_flow_director_mask_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
vlan, "vlan");
cmdline_parse_token_num_t cmd_flow_director_mask_vlan_value =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
- vlan_mask, UINT16);
+ vlan_mask, RTE_UINT16);
cmdline_parse_token_string_t cmd_flow_director_mask_src =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
src_mask, "src_mask");
ipv6_src);
cmdline_parse_token_num_t cmd_flow_director_mask_port_src =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
- port_src, UINT16);
+ port_src, RTE_UINT16);
cmdline_parse_token_string_t cmd_flow_director_mask_dst =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
dst_mask, "dst_mask");
ipv6_dst);
cmdline_parse_token_num_t cmd_flow_director_mask_port_dst =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
- port_dst, UINT16);
+ port_dst, RTE_UINT16);
cmdline_parse_token_string_t cmd_flow_director_mask_mode =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
mac, "mac");
cmdline_parse_token_num_t cmd_flow_director_mask_mac_value =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
- mac_addr_byte_mask, UINT8);
+ mac_addr_byte_mask, RTE_UINT8);
cmdline_parse_token_string_t cmd_flow_director_mask_tunnel_type =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
tunnel_type, "tunnel-type");
cmdline_parse_token_num_t cmd_flow_director_mask_tunnel_type_value =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
- tunnel_type_mask, UINT8);
+ tunnel_type_mask, RTE_UINT8);
cmdline_parse_token_string_t cmd_flow_director_mask_tunnel_id =
TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
tunnel_id, "tunnel-id");
cmdline_parse_token_num_t cmd_flow_director_mask_tunnel_id_value =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
- tunnel_id_mask, UINT32);
+ tunnel_id_mask, RTE_UINT32);
cmdline_parse_inst_t cmd_set_flow_director_ip_mask = {
.f = cmd_flow_director_mask_parsed,
(void *)&cmd_flow_director_mask_mac,
(void *)&cmd_flow_director_mask_mac_value,
(void *)&cmd_flow_director_mask_tunnel_type,
- (void *)&cmd_flow_director_mask_tunnel_type_value,
- (void *)&cmd_flow_director_mask_tunnel_id,
- (void *)&cmd_flow_director_mask_tunnel_id_value,
- NULL,
- },
-};
-
-/* *** deal with flow director mask on flexible payload *** */
-struct cmd_flow_director_flex_mask_result {
- cmdline_fixed_string_t flow_director_flexmask;
- portid_t port_id;
- cmdline_fixed_string_t flow;
- cmdline_fixed_string_t flow_type;
- cmdline_fixed_string_t mask;
-};
-
-static void
-cmd_flow_director_flex_mask_parsed(void *parsed_result,
- __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;
- struct rte_eth_fdir_flex_mask flex_mask;
- struct rte_port *port;
- uint64_t flow_type_mask;
- uint16_t i;
- int ret;
-
- port = &ports[res->port_id];
- /** Check if the port is not started **/
- if (port->port_status != RTE_PORT_STOPPED) {
- printf("Please stop port %d first\n", res->port_id);
- return;
- }
-
- memset(&flex_mask, 0, sizeof(struct rte_eth_fdir_flex_mask));
- ret = parse_flexbytes(res->mask,
- flex_mask.mask,
- RTE_ETH_FDIR_MAX_FLEXLEN);
- if (ret < 0) {
- printf("error: Cannot parse mask input.\n");
- return;
- }
-
- memset(&fdir_info, 0, sizeof(fdir_info));
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_INFO, &fdir_info);
- if (ret < 0) {
- printf("Cannot get FDir filter info\n");
- return;
- }
-
- if (!strcmp(res->flow_type, "none")) {
- /* means don't specify the flow type */
- flex_mask.flow_type = RTE_ETH_FLOW_UNKNOWN;
- for (i = 0; i < RTE_ETH_FLOW_MAX; i++)
- memset(&port->dev_conf.fdir_conf.flex_conf.flex_mask[i],
- 0, sizeof(struct rte_eth_fdir_flex_mask));
- port->dev_conf.fdir_conf.flex_conf.nb_flexmasks = 1;
- rte_memcpy(&port->dev_conf.fdir_conf.flex_conf.flex_mask[0],
- &flex_mask,
- sizeof(struct rte_eth_fdir_flex_mask));
- cmd_reconfig_device_queue(res->port_id, 1, 1);
- return;
- }
- flow_type_mask = fdir_info.flow_types_mask[0];
- if (!strcmp(res->flow_type, "all")) {
- if (!flow_type_mask) {
- printf("No flow type supported\n");
- return;
- }
- for (i = RTE_ETH_FLOW_UNKNOWN; i < RTE_ETH_FLOW_MAX; i++) {
- if (flow_type_mask & (1ULL << i)) {
- flex_mask.flow_type = i;
- fdir_set_flex_mask(res->port_id, &flex_mask);
- }
- }
- cmd_reconfig_device_queue(res->port_id, 1, 1);
- return;
- }
- flex_mask.flow_type = str2flowtype(res->flow_type);
- if (!(flow_type_mask & (1ULL << flex_mask.flow_type))) {
- printf("Flow type %s not supported on port %d\n",
- res->flow_type, res->port_id);
- return;
- }
- fdir_set_flex_mask(res->port_id, &flex_mask);
- cmd_reconfig_device_queue(res->port_id, 1, 1);
-}
-
-cmdline_parse_token_string_t cmd_flow_director_flexmask =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result,
- flow_director_flexmask,
- "flow_director_flex_mask");
-cmdline_parse_token_num_t cmd_flow_director_flexmask_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_flex_mask_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_flexmask_flow =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result,
- flow, "flow");
-cmdline_parse_token_string_t cmd_flow_director_flexmask_flow_type =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result,
- flow_type, "none#ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
- "ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#l2_payload#all");
-cmdline_parse_token_string_t cmd_flow_director_flexmask_mask =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result,
- mask, NULL);
-
-cmdline_parse_inst_t cmd_set_flow_director_flex_mask = {
- .f = cmd_flow_director_flex_mask_parsed,
- .data = NULL,
- .help_str = "flow_director_flex_mask ... : "
- "Set flow director's flex mask on NIC",
- .tokens = {
- (void *)&cmd_flow_director_flexmask,
- (void *)&cmd_flow_director_flexmask_port_id,
- (void *)&cmd_flow_director_flexmask_flow,
- (void *)&cmd_flow_director_flexmask_flow_type,
- (void *)&cmd_flow_director_flexmask_mask,
- NULL,
- },
-};
-
-/* *** deal with flow director flexible payload configuration *** */
-struct cmd_flow_director_flexpayload_result {
- cmdline_fixed_string_t flow_director_flexpayload;
- portid_t port_id;
- cmdline_fixed_string_t payload_layer;
- cmdline_fixed_string_t payload_cfg;
-};
-
-static inline int
-parse_offsets(const char *q_arg, uint16_t *offsets, uint16_t max_num)
-{
- char s[256];
- const char *p, *p0 = q_arg;
- char *end;
- unsigned long int_fld;
- char *str_fld[max_num];
- int i;
- unsigned size;
- int ret = -1;
-
- p = strchr(p0, '(');
- if (p == NULL)
- return -1;
- ++p;
- p0 = strchr(p, ')');
- if (p0 == NULL)
- return -1;
-
- size = p0 - p;
- if (size >= sizeof(s))
- return -1;
-
- snprintf(s, sizeof(s), "%.*s", size, p);
- ret = rte_strsplit(s, sizeof(s), str_fld, max_num, ',');
- if (ret < 0 || ret > max_num)
- return -1;
- for (i = 0; i < ret; i++) {
- errno = 0;
- int_fld = strtoul(str_fld[i], &end, 0);
- if (errno != 0 || *end != '\0' || int_fld > UINT16_MAX)
- return -1;
- offsets[i] = (uint16_t)int_fld;
- }
- return ret;
-}
-
-static void
-cmd_flow_director_flxpld_parsed(void *parsed_result,
- __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;
- struct rte_port *port;
- int ret = 0;
-
- port = &ports[res->port_id];
- /** Check if the port is not started **/
- if (port->port_status != RTE_PORT_STOPPED) {
- printf("Please stop port %d first\n", res->port_id);
- return;
- }
-
- memset(&flex_cfg, 0, sizeof(struct rte_eth_flex_payload_cfg));
-
- if (!strcmp(res->payload_layer, "raw"))
- flex_cfg.type = RTE_ETH_RAW_PAYLOAD;
- else if (!strcmp(res->payload_layer, "l2"))
- flex_cfg.type = RTE_ETH_L2_PAYLOAD;
- else if (!strcmp(res->payload_layer, "l3"))
- flex_cfg.type = RTE_ETH_L3_PAYLOAD;
- else if (!strcmp(res->payload_layer, "l4"))
- flex_cfg.type = RTE_ETH_L4_PAYLOAD;
-
- ret = parse_offsets(res->payload_cfg, flex_cfg.src_offset,
- RTE_ETH_FDIR_MAX_FLEXLEN);
- if (ret < 0) {
- printf("error: Cannot parse flex payload input.\n");
- return;
- }
-
- fdir_set_flex_payload(res->port_id, &flex_cfg);
- cmd_reconfig_device_queue(res->port_id, 1, 1);
-}
-
-cmdline_parse_token_string_t cmd_flow_director_flexpayload =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
- flow_director_flexpayload,
- "flow_director_flex_payload");
-cmdline_parse_token_num_t cmd_flow_director_flexpayload_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_flow_director_flexpayload_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_flexpayload_payload_layer =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
- payload_layer, "raw#l2#l3#l4");
-cmdline_parse_token_string_t cmd_flow_director_flexpayload_payload_cfg =
- TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
- payload_cfg, NULL);
-
-cmdline_parse_inst_t cmd_set_flow_director_flex_payload = {
- .f = cmd_flow_director_flxpld_parsed,
- .data = NULL,
- .help_str = "flow_director_flexpayload ... : "
- "Set flow director's flex payload on NIC",
- .tokens = {
- (void *)&cmd_flow_director_flexpayload,
- (void *)&cmd_flow_director_flexpayload_port_id,
- (void *)&cmd_flow_director_flexpayload_payload_layer,
- (void *)&cmd_flow_director_flexpayload_payload_cfg,
- NULL,
- },
-};
-
-/* Generic flow interface command. */
-extern cmdline_parse_inst_t cmd_flow;
-
-/* *** Classification Filters Control *** */
-/* *** Get symmetric hash enable per port *** */
-struct cmd_get_sym_hash_ena_per_port_result {
- cmdline_fixed_string_t get_sym_hash_ena_per_port;
- portid_t port_id;
-};
-
-static void
-cmd_get_sym_hash_per_port_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_get_sym_hash_ena_per_port_result *res = parsed_result;
- struct rte_eth_hash_filter_info info;
- int ret;
-
- if (rte_eth_dev_filter_supported(res->port_id,
- RTE_ETH_FILTER_HASH) < 0) {
- printf("RTE_ETH_FILTER_HASH not supported on port: %d\n",
- res->port_id);
- return;
- }
-
- memset(&info, 0, sizeof(info));
- info.info_type = RTE_ETH_HASH_FILTER_SYM_HASH_ENA_PER_PORT;
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
- RTE_ETH_FILTER_GET, &info);
-
- if (ret < 0) {
- printf("Cannot get symmetric hash enable per port "
- "on port %u\n", res->port_id);
- return;
- }
-
- printf("Symmetric hash is %s on port %u\n", info.info.enable ?
- "enabled" : "disabled", res->port_id);
-}
-
-cmdline_parse_token_string_t cmd_get_sym_hash_ena_per_port_all =
- TOKEN_STRING_INITIALIZER(struct cmd_get_sym_hash_ena_per_port_result,
- get_sym_hash_ena_per_port, "get_sym_hash_ena_per_port");
-cmdline_parse_token_num_t cmd_get_sym_hash_ena_per_port_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_get_sym_hash_ena_per_port_result,
- port_id, UINT16);
-
-cmdline_parse_inst_t cmd_get_sym_hash_ena_per_port = {
- .f = cmd_get_sym_hash_per_port_parsed,
- .data = NULL,
- .help_str = "get_sym_hash_ena_per_port <port_id>",
- .tokens = {
- (void *)&cmd_get_sym_hash_ena_per_port_all,
- (void *)&cmd_get_sym_hash_ena_per_port_port_id,
- NULL,
- },
-};
-
-/* *** Set symmetric hash enable per port *** */
-struct cmd_set_sym_hash_ena_per_port_result {
- cmdline_fixed_string_t set_sym_hash_ena_per_port;
- cmdline_fixed_string_t enable;
- portid_t port_id;
-};
-
-static void
-cmd_set_sym_hash_per_port_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_set_sym_hash_ena_per_port_result *res = parsed_result;
- struct rte_eth_hash_filter_info info;
- int ret;
-
- if (rte_eth_dev_filter_supported(res->port_id,
- RTE_ETH_FILTER_HASH) < 0) {
- printf("RTE_ETH_FILTER_HASH not supported on port: %d\n",
- res->port_id);
- return;
- }
-
- memset(&info, 0, sizeof(info));
- info.info_type = RTE_ETH_HASH_FILTER_SYM_HASH_ENA_PER_PORT;
- if (!strcmp(res->enable, "enable"))
- info.info.enable = 1;
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
- RTE_ETH_FILTER_SET, &info);
- if (ret < 0) {
- printf("Cannot set symmetric hash enable per port on "
- "port %u\n", res->port_id);
- return;
- }
- printf("Symmetric hash has been set to %s on port %u\n",
- res->enable, res->port_id);
-}
-
-cmdline_parse_token_string_t cmd_set_sym_hash_ena_per_port_all =
- TOKEN_STRING_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
- set_sym_hash_ena_per_port, "set_sym_hash_ena_per_port");
-cmdline_parse_token_num_t cmd_set_sym_hash_ena_per_port_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_sym_hash_ena_per_port_enable =
- TOKEN_STRING_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
- enable, "enable#disable");
-
-cmdline_parse_inst_t cmd_set_sym_hash_ena_per_port = {
- .f = cmd_set_sym_hash_per_port_parsed,
- .data = NULL,
- .help_str = "set_sym_hash_ena_per_port <port_id> enable|disable",
- .tokens = {
- (void *)&cmd_set_sym_hash_ena_per_port_all,
- (void *)&cmd_set_sym_hash_ena_per_port_port_id,
- (void *)&cmd_set_sym_hash_ena_per_port_enable,
- NULL,
- },
-};
-
-/* Get global config of hash function */
-struct cmd_get_hash_global_config_result {
- cmdline_fixed_string_t get_hash_global_config;
- portid_t port_id;
-};
-
-static char *
-flowtype_to_str(uint16_t ftype)
-{
- uint16_t i;
- static struct {
- char str[16];
- uint16_t ftype;
- } ftype_table[] = {
- {"ipv4", RTE_ETH_FLOW_IPV4},
- {"ipv4-frag", RTE_ETH_FLOW_FRAG_IPV4},
- {"ipv4-tcp", RTE_ETH_FLOW_NONFRAG_IPV4_TCP},
- {"ipv4-udp", RTE_ETH_FLOW_NONFRAG_IPV4_UDP},
- {"ipv4-sctp", RTE_ETH_FLOW_NONFRAG_IPV4_SCTP},
- {"ipv4-other", RTE_ETH_FLOW_NONFRAG_IPV4_OTHER},
- {"ipv6", RTE_ETH_FLOW_IPV6},
- {"ipv6-frag", RTE_ETH_FLOW_FRAG_IPV6},
- {"ipv6-tcp", RTE_ETH_FLOW_NONFRAG_IPV6_TCP},
- {"ipv6-udp", RTE_ETH_FLOW_NONFRAG_IPV6_UDP},
- {"ipv6-sctp", RTE_ETH_FLOW_NONFRAG_IPV6_SCTP},
- {"ipv6-other", RTE_ETH_FLOW_NONFRAG_IPV6_OTHER},
- {"l2_payload", RTE_ETH_FLOW_L2_PAYLOAD},
- {"port", RTE_ETH_FLOW_PORT},
- {"vxlan", RTE_ETH_FLOW_VXLAN},
- {"geneve", RTE_ETH_FLOW_GENEVE},
- {"nvgre", RTE_ETH_FLOW_NVGRE},
- {"vxlan-gpe", RTE_ETH_FLOW_VXLAN_GPE},
- };
-
- for (i = 0; i < RTE_DIM(ftype_table); i++) {
- if (ftype_table[i].ftype == ftype)
- return ftype_table[i].str;
- }
-
- return NULL;
-}
-
-static void
-cmd_get_hash_global_config_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_get_hash_global_config_result *res = parsed_result;
- struct rte_eth_hash_filter_info info;
- uint32_t idx, offset;
- uint16_t i;
- char *str;
- int ret;
-
- if (rte_eth_dev_filter_supported(res->port_id,
- RTE_ETH_FILTER_HASH) < 0) {
- printf("RTE_ETH_FILTER_HASH not supported on port %d\n",
- res->port_id);
- return;
- }
-
- memset(&info, 0, sizeof(info));
- info.info_type = RTE_ETH_HASH_FILTER_GLOBAL_CONFIG;
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
- RTE_ETH_FILTER_GET, &info);
- if (ret < 0) {
- printf("Cannot get hash global configurations by port %d\n",
- res->port_id);
- return;
- }
-
- switch (info.info.global_conf.hash_func) {
- case RTE_ETH_HASH_FUNCTION_TOEPLITZ:
- printf("Hash function is Toeplitz\n");
- break;
- 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;
- }
-
- for (i = 0; i < RTE_ETH_FLOW_MAX; i++) {
- idx = i / UINT64_BIT;
- offset = i % UINT64_BIT;
- if (!(info.info.global_conf.valid_bit_mask[idx] &
- (1ULL << offset)))
- continue;
- str = flowtype_to_str(i);
- if (!str)
- continue;
- printf("Symmetric hash is %s globally for flow type %s "
- "by port %d\n",
- ((info.info.global_conf.sym_hash_enable_mask[idx] &
- (1ULL << offset)) ? "enabled" : "disabled"), str,
- res->port_id);
- }
-}
-
-cmdline_parse_token_string_t cmd_get_hash_global_config_all =
- TOKEN_STRING_INITIALIZER(struct cmd_get_hash_global_config_result,
- get_hash_global_config, "get_hash_global_config");
-cmdline_parse_token_num_t cmd_get_hash_global_config_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_get_hash_global_config_result,
- port_id, UINT16);
-
-cmdline_parse_inst_t cmd_get_hash_global_config = {
- .f = cmd_get_hash_global_config_parsed,
- .data = NULL,
- .help_str = "get_hash_global_config <port_id>",
- .tokens = {
- (void *)&cmd_get_hash_global_config_all,
- (void *)&cmd_get_hash_global_config_port_id,
- NULL,
- },
-};
-
-/* Set global config of hash function */
-struct cmd_set_hash_global_config_result {
- cmdline_fixed_string_t set_hash_global_config;
- portid_t port_id;
- cmdline_fixed_string_t hash_func;
- cmdline_fixed_string_t flow_type;
- cmdline_fixed_string_t enable;
-};
-
-static void
-cmd_set_hash_global_config_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_set_hash_global_config_result *res = parsed_result;
- struct rte_eth_hash_filter_info info;
- uint32_t ftype, idx, offset;
- int ret;
-
- if (rte_eth_dev_filter_supported(res->port_id,
- RTE_ETH_FILTER_HASH) < 0) {
- printf("RTE_ETH_FILTER_HASH not supported on port %d\n",
- res->port_id);
- return;
- }
- memset(&info, 0, sizeof(info));
- info.info_type = RTE_ETH_HASH_FILTER_GLOBAL_CONFIG;
- if (!strcmp(res->hash_func, "toeplitz"))
- info.info.global_conf.hash_func =
- RTE_ETH_HASH_FUNCTION_TOEPLITZ;
- 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;
-
- ftype = str2flowtype(res->flow_type);
- idx = ftype / UINT64_BIT;
- offset = ftype % UINT64_BIT;
- info.info.global_conf.valid_bit_mask[idx] |= (1ULL << offset);
- if (!strcmp(res->enable, "enable"))
- info.info.global_conf.sym_hash_enable_mask[idx] |=
- (1ULL << offset);
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
- RTE_ETH_FILTER_SET, &info);
- if (ret < 0)
- printf("Cannot set global hash configurations by port %d\n",
- res->port_id);
- else
- printf("Global hash configurations have been set "
- "successfully by port %d\n", res->port_id);
-}
-
-cmdline_parse_token_string_t cmd_set_hash_global_config_all =
- TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
- set_hash_global_config, "set_hash_global_config");
-cmdline_parse_token_num_t cmd_set_hash_global_config_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_set_hash_global_config_result,
- 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#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,
- "ipv4#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#ipv4-other#ipv6#"
- "ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#ipv6-other#l2_payload");
-cmdline_parse_token_string_t cmd_set_hash_global_config_enable =
- TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
- enable, "enable#disable");
-
-cmdline_parse_inst_t cmd_set_hash_global_config = {
- .f = cmd_set_hash_global_config_parsed,
- .data = NULL,
- .help_str = "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",
- .tokens = {
- (void *)&cmd_set_hash_global_config_all,
- (void *)&cmd_set_hash_global_config_port_id,
- (void *)&cmd_set_hash_global_config_hash_func,
- (void *)&cmd_set_hash_global_config_flow_type,
- (void *)&cmd_set_hash_global_config_enable,
- NULL,
- },
-};
-
-/* Set hash input set */
-struct cmd_set_hash_input_set_result {
- cmdline_fixed_string_t set_hash_input_set;
- portid_t port_id;
- cmdline_fixed_string_t flow_type;
- cmdline_fixed_string_t inset_field;
- cmdline_fixed_string_t select;
-};
-
-static enum rte_eth_input_set_field
-str2inset(char *string)
-{
- uint16_t i;
-
- static const struct {
- char str[32];
- enum rte_eth_input_set_field inset;
- } inset_table[] = {
- {"ethertype", RTE_ETH_INPUT_SET_L2_ETHERTYPE},
- {"ovlan", RTE_ETH_INPUT_SET_L2_OUTER_VLAN},
- {"ivlan", RTE_ETH_INPUT_SET_L2_INNER_VLAN},
- {"src-ipv4", RTE_ETH_INPUT_SET_L3_SRC_IP4},
- {"dst-ipv4", RTE_ETH_INPUT_SET_L3_DST_IP4},
- {"ipv4-tos", RTE_ETH_INPUT_SET_L3_IP4_TOS},
- {"ipv4-proto", RTE_ETH_INPUT_SET_L3_IP4_PROTO},
- {"ipv4-ttl", RTE_ETH_INPUT_SET_L3_IP4_TTL},
- {"src-ipv6", RTE_ETH_INPUT_SET_L3_SRC_IP6},
- {"dst-ipv6", RTE_ETH_INPUT_SET_L3_DST_IP6},
- {"ipv6-tc", RTE_ETH_INPUT_SET_L3_IP6_TC},
- {"ipv6-next-header", RTE_ETH_INPUT_SET_L3_IP6_NEXT_HEADER},
- {"ipv6-hop-limits", RTE_ETH_INPUT_SET_L3_IP6_HOP_LIMITS},
- {"udp-src-port", RTE_ETH_INPUT_SET_L4_UDP_SRC_PORT},
- {"udp-dst-port", RTE_ETH_INPUT_SET_L4_UDP_DST_PORT},
- {"tcp-src-port", RTE_ETH_INPUT_SET_L4_TCP_SRC_PORT},
- {"tcp-dst-port", RTE_ETH_INPUT_SET_L4_TCP_DST_PORT},
- {"sctp-src-port", RTE_ETH_INPUT_SET_L4_SCTP_SRC_PORT},
- {"sctp-dst-port", RTE_ETH_INPUT_SET_L4_SCTP_DST_PORT},
- {"sctp-veri-tag", RTE_ETH_INPUT_SET_L4_SCTP_VERIFICATION_TAG},
- {"udp-key", RTE_ETH_INPUT_SET_TUNNEL_L4_UDP_KEY},
- {"gre-key", RTE_ETH_INPUT_SET_TUNNEL_GRE_KEY},
- {"fld-1st", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_1ST_WORD},
- {"fld-2nd", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_2ND_WORD},
- {"fld-3rd", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_3RD_WORD},
- {"fld-4th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_4TH_WORD},
- {"fld-5th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_5TH_WORD},
- {"fld-6th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_6TH_WORD},
- {"fld-7th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_7TH_WORD},
- {"fld-8th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_8TH_WORD},
- {"none", RTE_ETH_INPUT_SET_NONE},
- };
-
- for (i = 0; i < RTE_DIM(inset_table); i++) {
- if (!strcmp(string, inset_table[i].str))
- return inset_table[i].inset;
- }
-
- return RTE_ETH_INPUT_SET_UNKNOWN;
-}
-
-static void
-cmd_set_hash_input_set_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_set_hash_input_set_result *res = parsed_result;
- struct rte_eth_hash_filter_info info;
-
- memset(&info, 0, sizeof(info));
- info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
- info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
- info.info.input_set_conf.field[0] = str2inset(res->inset_field);
- info.info.input_set_conf.inset_size = 1;
- if (!strcmp(res->select, "select"))
- info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
- else if (!strcmp(res->select, "add"))
- info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
- rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
- RTE_ETH_FILTER_SET, &info);
-}
-
-cmdline_parse_token_string_t cmd_set_hash_input_set_cmd =
- TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
- set_hash_input_set, "set_hash_input_set");
-cmdline_parse_token_num_t cmd_set_hash_input_set_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_set_hash_input_set_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_hash_input_set_flow_type =
- TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
- flow_type, NULL);
-cmdline_parse_token_string_t cmd_set_hash_input_set_field =
- TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
- inset_field,
- "ovlan#ivlan#src-ipv4#dst-ipv4#src-ipv6#dst-ipv6#"
- "ipv4-tos#ipv4-proto#ipv6-tc#ipv6-next-header#udp-src-port#"
- "udp-dst-port#tcp-src-port#tcp-dst-port#sctp-src-port#"
- "sctp-dst-port#sctp-veri-tag#udp-key#gre-key#fld-1st#"
- "fld-2nd#fld-3rd#fld-4th#fld-5th#fld-6th#fld-7th#"
- "fld-8th#none");
-cmdline_parse_token_string_t cmd_set_hash_input_set_select =
- TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
- select, "select#add");
-
-cmdline_parse_inst_t cmd_set_hash_input_set = {
- .f = cmd_set_hash_input_set_parsed,
- .data = NULL,
- .help_str = "set_hash_input_set <port_id> "
- "ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
- "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload|<flowtype_id> "
- "ovlan|ivlan|src-ipv4|dst-ipv4|src-ipv6|dst-ipv6|ipv4-tos|ipv4-proto|"
- "ipv6-tc|ipv6-next-header|udp-src-port|udp-dst-port|tcp-src-port|"
- "tcp-dst-port|sctp-src-port|sctp-dst-port|sctp-veri-tag|udp-key|"
- "gre-key|fld-1st|fld-2nd|fld-3rd|fld-4th|fld-5th|fld-6th|"
- "fld-7th|fld-8th|none select|add",
- .tokens = {
- (void *)&cmd_set_hash_input_set_cmd,
- (void *)&cmd_set_hash_input_set_port_id,
- (void *)&cmd_set_hash_input_set_flow_type,
- (void *)&cmd_set_hash_input_set_field,
- (void *)&cmd_set_hash_input_set_select,
- NULL,
- },
-};
-
-/* Set flow director input set */
-struct cmd_set_fdir_input_set_result {
- cmdline_fixed_string_t set_fdir_input_set;
- portid_t port_id;
- cmdline_fixed_string_t flow_type;
- cmdline_fixed_string_t inset_field;
- cmdline_fixed_string_t select;
-};
-
-static void
-cmd_set_fdir_input_set_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_set_fdir_input_set_result *res = parsed_result;
- struct rte_eth_fdir_filter_info info;
-
- memset(&info, 0, sizeof(info));
- info.info_type = RTE_ETH_FDIR_FILTER_INPUT_SET_SELECT;
- info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
- info.info.input_set_conf.field[0] = str2inset(res->inset_field);
- info.info.input_set_conf.inset_size = 1;
- if (!strcmp(res->select, "select"))
- info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
- else if (!strcmp(res->select, "add"))
- info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
- rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_SET, &info);
-}
-
-cmdline_parse_token_string_t cmd_set_fdir_input_set_cmd =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- set_fdir_input_set, "set_fdir_input_set");
-cmdline_parse_token_num_t cmd_set_fdir_input_set_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_set_fdir_input_set_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_fdir_input_set_flow_type =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- flow_type,
- "ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#ipv4-other#"
- "ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#ipv6-other#l2_payload");
-cmdline_parse_token_string_t cmd_set_fdir_input_set_field =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- inset_field,
- "ivlan#ethertype#src-ipv4#dst-ipv4#src-ipv6#dst-ipv6#"
- "ipv4-tos#ipv4-proto#ipv4-ttl#ipv6-tc#ipv6-next-header#"
- "ipv6-hop-limits#udp-src-port#udp-dst-port#"
- "tcp-src-port#tcp-dst-port#sctp-src-port#sctp-dst-port#"
- "sctp-veri-tag#none");
-cmdline_parse_token_string_t cmd_set_fdir_input_set_select =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- select, "select#add");
-
-cmdline_parse_inst_t cmd_set_fdir_input_set = {
- .f = cmd_set_fdir_input_set_parsed,
- .data = NULL,
- .help_str = "set_fdir_input_set <port_id> "
- "ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
- "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
- "ivlan|ethertype|src-ipv4|dst-ipv4|src-ipv6|dst-ipv6|"
- "ipv4-tos|ipv4-proto|ipv4-ttl|ipv6-tc|ipv6-next-header|"
- "ipv6-hop-limits|udp-src-port|udp-dst-port|"
- "tcp-src-port|tcp-dst-port|sctp-src-port|sctp-dst-port|"
- "sctp-veri-tag|none select|add",
- .tokens = {
- (void *)&cmd_set_fdir_input_set_cmd,
- (void *)&cmd_set_fdir_input_set_port_id,
- (void *)&cmd_set_fdir_input_set_flow_type,
- (void *)&cmd_set_fdir_input_set_field,
- (void *)&cmd_set_fdir_input_set_select,
- NULL,
- },
-};
-
-/* *** ADD/REMOVE A MULTICAST MAC ADDRESS TO/FROM A PORT *** */
-struct cmd_mcast_addr_result {
- cmdline_fixed_string_t mcast_addr_cmd;
- cmdline_fixed_string_t what;
- uint16_t port_num;
- struct rte_ether_addr mc_addr;
-};
-
-static void cmd_mcast_addr_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_mcast_addr_result *res = parsed_result;
-
- if (!rte_is_multicast_ether_addr(&res->mc_addr)) {
- printf("Invalid multicast addr %02X:%02X:%02X:%02X:%02X:%02X\n",
- res->mc_addr.addr_bytes[0], res->mc_addr.addr_bytes[1],
- res->mc_addr.addr_bytes[2], res->mc_addr.addr_bytes[3],
- res->mc_addr.addr_bytes[4], res->mc_addr.addr_bytes[5]);
- return;
- }
- if (strcmp(res->what, "add") == 0)
- mcast_addr_add(res->port_num, &res->mc_addr);
- else
- mcast_addr_remove(res->port_num, &res->mc_addr);
-}
-
-cmdline_parse_token_string_t cmd_mcast_addr_cmd =
- TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result,
- mcast_addr_cmd, "mcast_addr");
-cmdline_parse_token_string_t cmd_mcast_addr_what =
- TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result, what,
- "add#remove");
-cmdline_parse_token_num_t cmd_mcast_addr_portnum =
- TOKEN_NUM_INITIALIZER(struct cmd_mcast_addr_result, port_num, UINT16);
-cmdline_parse_token_etheraddr_t cmd_mcast_addr_addr =
- TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address);
-
-cmdline_parse_inst_t cmd_mcast_addr = {
- .f = cmd_mcast_addr_parsed,
- .data = (void *)0,
- .help_str = "mcast_addr add|remove <port_id> <mcast_addr>: "
- "Add/Remove multicast MAC address on port_id",
- .tokens = {
- (void *)&cmd_mcast_addr_cmd,
- (void *)&cmd_mcast_addr_what,
- (void *)&cmd_mcast_addr_portnum,
- (void *)&cmd_mcast_addr_addr,
- NULL,
- },
-};
-
-/* l2 tunnel config
- * only support E-tag now.
- */
-
-/* Ether type config */
-struct cmd_config_l2_tunnel_eth_type_result {
- cmdline_fixed_string_t port;
- cmdline_fixed_string_t config;
- cmdline_fixed_string_t all;
- portid_t id;
- cmdline_fixed_string_t l2_tunnel;
- cmdline_fixed_string_t l2_tunnel_type;
- cmdline_fixed_string_t eth_type;
- uint16_t eth_type_val;
-};
-
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_port =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- port, "port");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_config =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- config, "config");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_all_str =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- all, "all");
-cmdline_parse_token_num_t cmd_config_l2_tunnel_eth_type_id =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- id, UINT16);
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_l2_tunnel =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- l2_tunnel, "l2-tunnel");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_l2_tunnel_type =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- l2_tunnel_type, "E-tag");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_eth_type =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- eth_type, "ether-type");
-cmdline_parse_token_num_t cmd_config_l2_tunnel_eth_type_eth_type_val =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- eth_type_val, UINT16);
-
-static enum rte_eth_tunnel_type
-str2fdir_l2_tunnel_type(char *string)
-{
- uint32_t i = 0;
-
- static const struct {
- char str[32];
- enum rte_eth_tunnel_type type;
- } l2_tunnel_type_str[] = {
- {"E-tag", RTE_L2_TUNNEL_TYPE_E_TAG},
- };
-
- for (i = 0; i < RTE_DIM(l2_tunnel_type_str); i++) {
- if (!strcmp(l2_tunnel_type_str[i].str, string))
- return l2_tunnel_type_str[i].type;
- }
- return RTE_TUNNEL_TYPE_NONE;
-}
-
-/* ether type config for all ports */
-static void
-cmd_config_l2_tunnel_eth_type_all_parsed
- (void *parsed_result,
- __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;
- portid_t pid;
-
- entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
- entry.ether_type = res->eth_type_val;
-
- RTE_ETH_FOREACH_DEV(pid) {
- rte_eth_dev_l2_tunnel_eth_type_conf(pid, &entry);
- }
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_eth_type_all = {
- .f = cmd_config_l2_tunnel_eth_type_all_parsed,
- .data = NULL,
- .help_str = "port config all l2-tunnel E-tag ether-type <value>",
- .tokens = {
- (void *)&cmd_config_l2_tunnel_eth_type_port,
- (void *)&cmd_config_l2_tunnel_eth_type_config,
- (void *)&cmd_config_l2_tunnel_eth_type_all_str,
- (void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel,
- (void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel_type,
- (void *)&cmd_config_l2_tunnel_eth_type_eth_type,
- (void *)&cmd_config_l2_tunnel_eth_type_eth_type_val,
- NULL,
- },
-};
-
-/* ether type config for a specific port */
-static void
-cmd_config_l2_tunnel_eth_type_specific_parsed(
- void *parsed_result,
- __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;
-
- if (port_id_is_invalid(res->id, ENABLED_WARN))
- return;
-
- entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
- entry.ether_type = res->eth_type_val;
-
- rte_eth_dev_l2_tunnel_eth_type_conf(res->id, &entry);
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_eth_type_specific = {
- .f = cmd_config_l2_tunnel_eth_type_specific_parsed,
- .data = NULL,
- .help_str = "port config <port_id> l2-tunnel E-tag ether-type <value>",
- .tokens = {
- (void *)&cmd_config_l2_tunnel_eth_type_port,
- (void *)&cmd_config_l2_tunnel_eth_type_config,
- (void *)&cmd_config_l2_tunnel_eth_type_id,
- (void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel,
- (void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel_type,
- (void *)&cmd_config_l2_tunnel_eth_type_eth_type,
- (void *)&cmd_config_l2_tunnel_eth_type_eth_type_val,
- NULL,
- },
-};
-
-/* Enable/disable l2 tunnel */
-struct cmd_config_l2_tunnel_en_dis_result {
- cmdline_fixed_string_t port;
- cmdline_fixed_string_t config;
- cmdline_fixed_string_t all;
- portid_t id;
- cmdline_fixed_string_t l2_tunnel;
- cmdline_fixed_string_t l2_tunnel_type;
- cmdline_fixed_string_t en_dis;
-};
-
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_port =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- port, "port");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_config =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- config, "config");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_all_str =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- all, "all");
-cmdline_parse_token_num_t cmd_config_l2_tunnel_en_dis_id =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- id, UINT16);
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_l2_tunnel =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- l2_tunnel, "l2-tunnel");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_l2_tunnel_type =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- l2_tunnel_type, "E-tag");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_en_dis =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- en_dis, "enable#disable");
-
-/* enable/disable l2 tunnel for all ports */
-static void
-cmd_config_l2_tunnel_en_dis_all_parsed(
- void *parsed_result,
- __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;
- portid_t pid;
- uint8_t en;
-
- entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
-
- if (!strcmp("enable", res->en_dis))
- en = 1;
- else
- en = 0;
-
- RTE_ETH_FOREACH_DEV(pid) {
- rte_eth_dev_l2_tunnel_offload_set(pid,
- &entry,
- ETH_L2_TUNNEL_ENABLE_MASK,
- en);
- }
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_en_dis_all = {
- .f = cmd_config_l2_tunnel_en_dis_all_parsed,
- .data = NULL,
- .help_str = "port config all l2-tunnel E-tag enable|disable",
- .tokens = {
- (void *)&cmd_config_l2_tunnel_en_dis_port,
- (void *)&cmd_config_l2_tunnel_en_dis_config,
- (void *)&cmd_config_l2_tunnel_en_dis_all_str,
- (void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel,
- (void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel_type,
- (void *)&cmd_config_l2_tunnel_en_dis_en_dis,
- NULL,
- },
-};
-
-/* enable/disable l2 tunnel for a port */
-static void
-cmd_config_l2_tunnel_en_dis_specific_parsed(
- void *parsed_result,
- __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;
-
- if (port_id_is_invalid(res->id, ENABLED_WARN))
- return;
-
- entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
-
- if (!strcmp("enable", res->en_dis))
- rte_eth_dev_l2_tunnel_offload_set(res->id,
- &entry,
- ETH_L2_TUNNEL_ENABLE_MASK,
- 1);
- else
- rte_eth_dev_l2_tunnel_offload_set(res->id,
- &entry,
- ETH_L2_TUNNEL_ENABLE_MASK,
- 0);
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_en_dis_specific = {
- .f = cmd_config_l2_tunnel_en_dis_specific_parsed,
- .data = NULL,
- .help_str = "port config <port_id> l2-tunnel E-tag enable|disable",
- .tokens = {
- (void *)&cmd_config_l2_tunnel_en_dis_port,
- (void *)&cmd_config_l2_tunnel_en_dis_config,
- (void *)&cmd_config_l2_tunnel_en_dis_id,
- (void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel,
- (void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel_type,
- (void *)&cmd_config_l2_tunnel_en_dis_en_dis,
- NULL,
- },
-};
-
-/* E-tag configuration */
-
-/* Common result structure for all E-tag configuration */
-struct cmd_config_e_tag_result {
- cmdline_fixed_string_t e_tag;
- cmdline_fixed_string_t set;
- cmdline_fixed_string_t insertion;
- cmdline_fixed_string_t stripping;
- cmdline_fixed_string_t forwarding;
- cmdline_fixed_string_t filter;
- cmdline_fixed_string_t add;
- cmdline_fixed_string_t del;
- cmdline_fixed_string_t on;
- cmdline_fixed_string_t off;
- cmdline_fixed_string_t on_off;
- cmdline_fixed_string_t port_tag_id;
- uint32_t port_tag_id_val;
- cmdline_fixed_string_t e_tag_id;
- uint16_t e_tag_id_val;
- cmdline_fixed_string_t dst_pool;
- uint8_t dst_pool_val;
- cmdline_fixed_string_t port;
- portid_t port_id;
- cmdline_fixed_string_t vf;
- uint8_t vf_id;
-};
-
-/* Common CLI fields for all E-tag configuration */
-cmdline_parse_token_string_t cmd_config_e_tag_e_tag =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- e_tag, "E-tag");
-cmdline_parse_token_string_t cmd_config_e_tag_set =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- set, "set");
-cmdline_parse_token_string_t cmd_config_e_tag_insertion =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- insertion, "insertion");
-cmdline_parse_token_string_t cmd_config_e_tag_stripping =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- stripping, "stripping");
-cmdline_parse_token_string_t cmd_config_e_tag_forwarding =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- forwarding, "forwarding");
-cmdline_parse_token_string_t cmd_config_e_tag_filter =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- filter, "filter");
-cmdline_parse_token_string_t cmd_config_e_tag_add =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- add, "add");
-cmdline_parse_token_string_t cmd_config_e_tag_del =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- del, "del");
-cmdline_parse_token_string_t cmd_config_e_tag_on =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- on, "on");
-cmdline_parse_token_string_t cmd_config_e_tag_off =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- off, "off");
-cmdline_parse_token_string_t cmd_config_e_tag_on_off =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- on_off, "on#off");
-cmdline_parse_token_string_t cmd_config_e_tag_port_tag_id =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- port_tag_id, "port-tag-id");
-cmdline_parse_token_num_t cmd_config_e_tag_port_tag_id_val =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_e_tag_result,
- port_tag_id_val, UINT32);
-cmdline_parse_token_string_t cmd_config_e_tag_e_tag_id =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- e_tag_id, "e-tag-id");
-cmdline_parse_token_num_t cmd_config_e_tag_e_tag_id_val =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_e_tag_result,
- e_tag_id_val, UINT16);
-cmdline_parse_token_string_t cmd_config_e_tag_dst_pool =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- dst_pool, "dst-pool");
-cmdline_parse_token_num_t cmd_config_e_tag_dst_pool_val =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_e_tag_result,
- dst_pool_val, UINT8);
-cmdline_parse_token_string_t cmd_config_e_tag_port =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- port, "port");
-cmdline_parse_token_num_t cmd_config_e_tag_port_id =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_e_tag_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_config_e_tag_vf =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- vf, "vf");
-cmdline_parse_token_num_t cmd_config_e_tag_vf_id =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_e_tag_result,
- vf_id, UINT8);
-
-/* E-tag insertion configuration */
-static void
-cmd_config_e_tag_insertion_en_parsed(
- void *parsed_result,
- __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;
-
- if (port_id_is_invalid(res->port_id, ENABLED_WARN))
- return;
-
- entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
- entry.tunnel_id = res->port_tag_id_val;
- entry.vf_id = res->vf_id;
- rte_eth_dev_l2_tunnel_offload_set(res->port_id,
- &entry,
- ETH_L2_TUNNEL_INSERTION_MASK,
- 1);
-}
-
-static void
-cmd_config_e_tag_insertion_dis_parsed(
- void *parsed_result,
- __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;
-
- if (port_id_is_invalid(res->port_id, ENABLED_WARN))
- return;
-
- entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
- entry.vf_id = res->vf_id;
-
- rte_eth_dev_l2_tunnel_offload_set(res->port_id,
- &entry,
- ETH_L2_TUNNEL_INSERTION_MASK,
- 0);
-}
-
-cmdline_parse_inst_t cmd_config_e_tag_insertion_en = {
- .f = cmd_config_e_tag_insertion_en_parsed,
- .data = NULL,
- .help_str = "E-tag ... : E-tag insertion enable",
- .tokens = {
- (void *)&cmd_config_e_tag_e_tag,
- (void *)&cmd_config_e_tag_set,
- (void *)&cmd_config_e_tag_insertion,
- (void *)&cmd_config_e_tag_on,
- (void *)&cmd_config_e_tag_port_tag_id,
- (void *)&cmd_config_e_tag_port_tag_id_val,
- (void *)&cmd_config_e_tag_port,
- (void *)&cmd_config_e_tag_port_id,
- (void *)&cmd_config_e_tag_vf,
- (void *)&cmd_config_e_tag_vf_id,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_config_e_tag_insertion_dis = {
- .f = cmd_config_e_tag_insertion_dis_parsed,
- .data = NULL,
- .help_str = "E-tag ... : E-tag insertion disable",
- .tokens = {
- (void *)&cmd_config_e_tag_e_tag,
- (void *)&cmd_config_e_tag_set,
- (void *)&cmd_config_e_tag_insertion,
- (void *)&cmd_config_e_tag_off,
- (void *)&cmd_config_e_tag_port,
- (void *)&cmd_config_e_tag_port_id,
- (void *)&cmd_config_e_tag_vf,
- (void *)&cmd_config_e_tag_vf_id,
- NULL,
- },
-};
-
-/* E-tag stripping configuration */
-static void
-cmd_config_e_tag_stripping_parsed(
- void *parsed_result,
- __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;
-
- if (port_id_is_invalid(res->port_id, ENABLED_WARN))
- return;
-
- entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
-
- if (!strcmp(res->on_off, "on"))
- rte_eth_dev_l2_tunnel_offload_set
- (res->port_id,
- &entry,
- ETH_L2_TUNNEL_STRIPPING_MASK,
- 1);
- else
- rte_eth_dev_l2_tunnel_offload_set
- (res->port_id,
- &entry,
- ETH_L2_TUNNEL_STRIPPING_MASK,
- 0);
-}
-
-cmdline_parse_inst_t cmd_config_e_tag_stripping_en_dis = {
- .f = cmd_config_e_tag_stripping_parsed,
- .data = NULL,
- .help_str = "E-tag ... : E-tag stripping enable/disable",
- .tokens = {
- (void *)&cmd_config_e_tag_e_tag,
- (void *)&cmd_config_e_tag_set,
- (void *)&cmd_config_e_tag_stripping,
- (void *)&cmd_config_e_tag_on_off,
- (void *)&cmd_config_e_tag_port,
- (void *)&cmd_config_e_tag_port_id,
+ (void *)&cmd_flow_director_mask_tunnel_type_value,
+ (void *)&cmd_flow_director_mask_tunnel_id,
+ (void *)&cmd_flow_director_mask_tunnel_id_value,
NULL,
},
};
-/* E-tag forwarding configuration */
-static void
-cmd_config_e_tag_forwarding_parsed(
- void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
+/* *** deal with flow director flexible payload configuration *** */
+struct cmd_flow_director_flexpayload_result {
+ cmdline_fixed_string_t flow_director_flexpayload;
+ portid_t port_id;
+ cmdline_fixed_string_t payload_layer;
+ cmdline_fixed_string_t payload_cfg;
+};
+
+static inline int
+parse_offsets(const char *q_arg, uint16_t *offsets, uint16_t max_num)
{
- struct cmd_config_e_tag_result *res = parsed_result;
- struct rte_eth_l2_tunnel_conf entry;
+ char s[256];
+ const char *p, *p0 = q_arg;
+ char *end;
+ unsigned long int_fld;
+ char *str_fld[max_num];
+ int i;
+ unsigned size;
+ int ret = -1;
- if (port_id_is_invalid(res->port_id, ENABLED_WARN))
- return;
+ p = strchr(p0, '(');
+ if (p == NULL)
+ return -1;
+ ++p;
+ p0 = strchr(p, ')');
+ if (p0 == NULL)
+ return -1;
- entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
+ size = p0 - p;
+ if (size >= sizeof(s))
+ return -1;
- if (!strcmp(res->on_off, "on"))
- rte_eth_dev_l2_tunnel_offload_set
- (res->port_id,
- &entry,
- ETH_L2_TUNNEL_FORWARDING_MASK,
- 1);
- else
- rte_eth_dev_l2_tunnel_offload_set
- (res->port_id,
- &entry,
- ETH_L2_TUNNEL_FORWARDING_MASK,
- 0);
+ snprintf(s, sizeof(s), "%.*s", size, p);
+ ret = rte_strsplit(s, sizeof(s), str_fld, max_num, ',');
+ if (ret < 0 || ret > max_num)
+ return -1;
+ for (i = 0; i < ret; i++) {
+ errno = 0;
+ int_fld = strtoul(str_fld[i], &end, 0);
+ if (errno != 0 || *end != '\0' || int_fld > UINT16_MAX)
+ return -1;
+ offsets[i] = (uint16_t)int_fld;
+ }
+ return ret;
}
-cmdline_parse_inst_t cmd_config_e_tag_forwarding_en_dis = {
- .f = cmd_config_e_tag_forwarding_parsed,
- .data = NULL,
- .help_str = "E-tag ... : E-tag forwarding enable/disable",
- .tokens = {
- (void *)&cmd_config_e_tag_e_tag,
- (void *)&cmd_config_e_tag_set,
- (void *)&cmd_config_e_tag_forwarding,
- (void *)&cmd_config_e_tag_on_off,
- (void *)&cmd_config_e_tag_port,
- (void *)&cmd_config_e_tag_port_id,
- NULL,
- },
-};
-
-/* E-tag filter configuration */
static void
-cmd_config_e_tag_filter_add_parsed(
- void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
+cmd_flow_director_flxpld_parsed(void *parsed_result,
+ __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;
+ struct cmd_flow_director_flexpayload_result *res = parsed_result;
+ struct rte_eth_flex_payload_cfg flex_cfg;
+ struct rte_port *port;
int ret = 0;
- if (port_id_is_invalid(res->port_id, ENABLED_WARN))
- return;
-
- if (res->e_tag_id_val > 0x3fff) {
- printf("e-tag-id must be equal or less than 0x3fff.\n");
+ port = &ports[res->port_id];
+ /** Check if the port is not started **/
+ if (port->port_status != RTE_PORT_STOPPED) {
+ printf("Please stop port %d first\n", res->port_id);
return;
}
- ret = rte_eth_dev_filter_supported(res->port_id,
- RTE_ETH_FILTER_L2_TUNNEL);
+ memset(&flex_cfg, 0, sizeof(struct rte_eth_flex_payload_cfg));
+
+ if (!strcmp(res->payload_layer, "raw"))
+ flex_cfg.type = RTE_ETH_RAW_PAYLOAD;
+ else if (!strcmp(res->payload_layer, "l2"))
+ flex_cfg.type = RTE_ETH_L2_PAYLOAD;
+ else if (!strcmp(res->payload_layer, "l3"))
+ flex_cfg.type = RTE_ETH_L3_PAYLOAD;
+ else if (!strcmp(res->payload_layer, "l4"))
+ flex_cfg.type = RTE_ETH_L4_PAYLOAD;
+
+ ret = parse_offsets(res->payload_cfg, flex_cfg.src_offset,
+ RTE_ETH_FDIR_MAX_FLEXLEN);
if (ret < 0) {
- printf("E-tag filter is not supported on port %u.\n",
- res->port_id);
+ printf("error: Cannot parse flex payload input.\n");
return;
}
- entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
- entry.tunnel_id = res->e_tag_id_val;
- entry.pool = res->dst_pool_val;
-
- ret = rte_eth_dev_filter_ctrl(res->port_id,
- RTE_ETH_FILTER_L2_TUNNEL,
- RTE_ETH_FILTER_ADD,
- &entry);
- if (ret < 0)
- printf("E-tag filter programming error: (%s)\n",
- strerror(-ret));
+ fdir_set_flex_payload(res->port_id, &flex_cfg);
+ cmd_reconfig_device_queue(res->port_id, 1, 1);
}
-cmdline_parse_inst_t cmd_config_e_tag_filter_add = {
- .f = cmd_config_e_tag_filter_add_parsed,
+cmdline_parse_token_string_t cmd_flow_director_flexpayload =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
+ flow_director_flexpayload,
+ "flow_director_flex_payload");
+cmdline_parse_token_num_t cmd_flow_director_flexpayload_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_flow_director_flexpayload_result,
+ port_id, RTE_UINT16);
+cmdline_parse_token_string_t cmd_flow_director_flexpayload_payload_layer =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
+ payload_layer, "raw#l2#l3#l4");
+cmdline_parse_token_string_t cmd_flow_director_flexpayload_payload_cfg =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
+ payload_cfg, NULL);
+
+cmdline_parse_inst_t cmd_set_flow_director_flex_payload = {
+ .f = cmd_flow_director_flxpld_parsed,
.data = NULL,
- .help_str = "E-tag ... : E-tag filter add",
+ .help_str = "flow_director_flexpayload ... : "
+ "Set flow director's flex payload on NIC",
.tokens = {
- (void *)&cmd_config_e_tag_e_tag,
- (void *)&cmd_config_e_tag_set,
- (void *)&cmd_config_e_tag_filter,
- (void *)&cmd_config_e_tag_add,
- (void *)&cmd_config_e_tag_e_tag_id,
- (void *)&cmd_config_e_tag_e_tag_id_val,
- (void *)&cmd_config_e_tag_dst_pool,
- (void *)&cmd_config_e_tag_dst_pool_val,
- (void *)&cmd_config_e_tag_port,
- (void *)&cmd_config_e_tag_port_id,
+ (void *)&cmd_flow_director_flexpayload,
+ (void *)&cmd_flow_director_flexpayload_port_id,
+ (void *)&cmd_flow_director_flexpayload_payload_layer,
+ (void *)&cmd_flow_director_flexpayload_payload_cfg,
NULL,
},
};
-static void
-cmd_config_e_tag_filter_del_parsed(
- void *parsed_result,
- __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;
- int ret = 0;
+/* Generic flow interface command. */
+extern cmdline_parse_inst_t cmd_flow;
- if (port_id_is_invalid(res->port_id, ENABLED_WARN))
- return;
+/* *** ADD/REMOVE A MULTICAST MAC ADDRESS TO/FROM A PORT *** */
+struct cmd_mcast_addr_result {
+ cmdline_fixed_string_t mcast_addr_cmd;
+ cmdline_fixed_string_t what;
+ uint16_t port_num;
+ struct rte_ether_addr mc_addr;
+};
- if (res->e_tag_id_val > 0x3fff) {
- printf("e-tag-id must be less than 0x3fff.\n");
- return;
- }
+static void cmd_mcast_addr_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_mcast_addr_result *res = parsed_result;
- ret = rte_eth_dev_filter_supported(res->port_id,
- RTE_ETH_FILTER_L2_TUNNEL);
- if (ret < 0) {
- printf("E-tag filter is not supported on port %u.\n",
- res->port_id);
+ if (!rte_is_multicast_ether_addr(&res->mc_addr)) {
+ printf("Invalid multicast addr %02X:%02X:%02X:%02X:%02X:%02X\n",
+ res->mc_addr.addr_bytes[0], res->mc_addr.addr_bytes[1],
+ res->mc_addr.addr_bytes[2], res->mc_addr.addr_bytes[3],
+ res->mc_addr.addr_bytes[4], res->mc_addr.addr_bytes[5]);
return;
}
-
- entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
- entry.tunnel_id = res->e_tag_id_val;
-
- ret = rte_eth_dev_filter_ctrl(res->port_id,
- RTE_ETH_FILTER_L2_TUNNEL,
- RTE_ETH_FILTER_DELETE,
- &entry);
- if (ret < 0)
- printf("E-tag filter programming error: (%s)\n",
- strerror(-ret));
+ if (strcmp(res->what, "add") == 0)
+ mcast_addr_add(res->port_num, &res->mc_addr);
+ else
+ mcast_addr_remove(res->port_num, &res->mc_addr);
}
-cmdline_parse_inst_t cmd_config_e_tag_filter_del = {
- .f = cmd_config_e_tag_filter_del_parsed,
- .data = NULL,
- .help_str = "E-tag ... : E-tag filter delete",
+cmdline_parse_token_string_t cmd_mcast_addr_cmd =
+ TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result,
+ mcast_addr_cmd, "mcast_addr");
+cmdline_parse_token_string_t cmd_mcast_addr_what =
+ TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result, what,
+ "add#remove");
+cmdline_parse_token_num_t cmd_mcast_addr_portnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_mcast_addr_result, port_num,
+ RTE_UINT16);
+cmdline_parse_token_etheraddr_t cmd_mcast_addr_addr =
+ TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address);
+
+cmdline_parse_inst_t cmd_mcast_addr = {
+ .f = cmd_mcast_addr_parsed,
+ .data = (void *)0,
+ .help_str = "mcast_addr add|remove <port_id> <mcast_addr>: "
+ "Add/Remove multicast MAC address on port_id",
.tokens = {
- (void *)&cmd_config_e_tag_e_tag,
- (void *)&cmd_config_e_tag_set,
- (void *)&cmd_config_e_tag_filter,
- (void *)&cmd_config_e_tag_del,
- (void *)&cmd_config_e_tag_e_tag_id,
- (void *)&cmd_config_e_tag_e_tag_id_val,
- (void *)&cmd_config_e_tag_port,
- (void *)&cmd_config_e_tag_port_id,
+ (void *)&cmd_mcast_addr_cmd,
+ (void *)&cmd_mcast_addr_what,
+ (void *)&cmd_mcast_addr_portnum,
+ (void *)&cmd_mcast_addr_addr,
NULL,
},
};
cmdline_parse_token_num_t cmd_vf_vlan_anti_spoof_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_vlan_anti_spoof_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_vf_vlan_anti_spoof_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_vlan_anti_spoof_result,
- vf_id, UINT32);
+ vf_id, RTE_UINT32);
cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_anti_spoof_result,
cmdline_parse_token_num_t cmd_vf_mac_anti_spoof_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_mac_anti_spoof_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_vf_mac_anti_spoof_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_mac_anti_spoof_result,
- vf_id, UINT32);
+ vf_id, RTE_UINT32);
cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_mac_anti_spoof_result,
cmdline_parse_token_num_t cmd_vf_vlan_stripq_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_vlan_stripq_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_vf_vlan_stripq_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_vlan_stripq_result,
- vf_id, UINT16);
+ vf_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_vf_vlan_stripq_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_stripq_result,
cmdline_parse_token_num_t cmd_vf_vlan_insert_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_vlan_insert_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_vf_vlan_insert_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_vlan_insert_result,
- vf_id, UINT16);
+ vf_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_vf_vlan_insert_vlan_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_vlan_insert_result,
- vlan_id, UINT16);
+ vlan_id, RTE_UINT16);
static void
cmd_set_vf_vlan_insert_parsed(
cmdline_parse_token_num_t cmd_tx_loopback_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_tx_loopback_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_tx_loopback_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_loopback_result,
cmdline_parse_token_num_t cmd_all_queues_drop_en_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_all_queues_drop_en_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_all_queues_drop_en_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_all_queues_drop_en_result,
cmdline_parse_token_num_t cmd_vf_split_drop_en_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_split_drop_en_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_vf_split_drop_en_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_split_drop_en_result,
- vf_id, UINT16);
+ vf_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_vf_split_drop_en_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_split_drop_en_result,
cmdline_parse_token_num_t cmd_set_vf_mac_addr_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_vf_mac_addr_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_set_vf_mac_addr_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_vf_mac_addr_result,
- vf_id, UINT16);
+ vf_id, RTE_UINT16);
cmdline_parse_token_etheraddr_t cmd_set_vf_mac_addr_mac_addr =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vf_mac_addr_result,
mac_addr);
cmdline_parse_token_num_t cmd_macsec_offload_on_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_offload_on_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_macsec_offload_on_on =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_on_result,
cmdline_parse_token_num_t cmd_macsec_offload_off_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_offload_off_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_macsec_offload_off_off =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_off_result,
cmdline_parse_token_num_t cmd_macsec_sc_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_sc_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_etheraddr_t cmd_macsec_sc_mac =
TOKEN_ETHERADDR_INITIALIZER
(struct cmd_macsec_sc_result,
cmdline_parse_token_num_t cmd_macsec_sc_pi =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_sc_result,
- pi, UINT16);
+ pi, RTE_UINT16);
static void
cmd_set_macsec_sc_parsed(
cmdline_parse_token_num_t cmd_macsec_sa_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_sa_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_macsec_sa_idx =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_sa_result,
- idx, UINT8);
+ idx, RTE_UINT8);
cmdline_parse_token_num_t cmd_macsec_sa_an =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_sa_result,
- an, UINT8);
+ an, RTE_UINT8);
cmdline_parse_token_num_t cmd_macsec_sa_pn =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_sa_result,
- pn, UINT32);
+ pn, RTE_UINT32);
cmdline_parse_token_string_t cmd_macsec_sa_key =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_sa_result,
cmdline_parse_token_num_t cmd_vf_promisc_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_promisc_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_vf_promisc_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_promisc_result,
- vf_id, UINT32);
+ vf_id, RTE_UINT32);
cmdline_parse_token_string_t cmd_vf_promisc_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_promisc_result,
cmdline_parse_token_num_t cmd_vf_allmulti_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_allmulti_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_vf_allmulti_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_allmulti_result,
- vf_id, UINT32);
+ vf_id, RTE_UINT32);
cmdline_parse_token_string_t cmd_vf_allmulti_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_allmulti_result,
cmdline_parse_token_num_t cmd_set_vf_broadcast_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_vf_broadcast_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_set_vf_broadcast_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_vf_broadcast_result,
- vf_id, UINT16);
+ vf_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_vf_broadcast_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_broadcast_result,
cmdline_parse_token_num_t cmd_set_vf_vlan_tag_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_vf_vlan_tag_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_set_vf_vlan_tag_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_vf_vlan_tag_result,
- vf_id, UINT16);
+ vf_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_vf_vlan_tag_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_vlan_tag_result,
cmdline_parse_token_num_t cmd_vf_tc_bw_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_tc_bw_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_vf_tc_bw_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_tc_bw_result,
- vf_id, UINT16);
+ vf_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_vf_tc_bw_tc_no =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_tc_bw_result,
- tc_no, UINT8);
+ tc_no, RTE_UINT8);
cmdline_parse_token_num_t cmd_vf_tc_bw_bw =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_tc_bw_result,
- bw, UINT32);
+ bw, RTE_UINT32);
cmdline_parse_token_string_t cmd_vf_tc_bw_bw_list =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_tc_bw_result,
cmdline_parse_token_num_t cmd_vf_tc_bw_tc_map =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_tc_bw_result,
- tc_map, UINT8);
+ tc_map, RTE_UINT8);
/* VF max bandwidth setting */
static void
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"vni");
cmdline_parse_token_num_t cmd_set_vxlan_vni_value =
- TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, vni, UINT32);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, vni, RTE_UINT32);
cmdline_parse_token_string_t cmd_set_vxlan_udp_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"udp-src");
cmdline_parse_token_num_t cmd_set_vxlan_udp_src_value =
- TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_src, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_src, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_vxlan_udp_dst =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"udp-dst");
cmdline_parse_token_num_t cmd_set_vxlan_udp_dst_value =
- TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_dst, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_dst, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_vxlan_ip_tos =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"ip-tos");
cmdline_parse_token_num_t cmd_set_vxlan_ip_tos_value =
- TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tos, UINT8);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tos, RTE_UINT8);
cmdline_parse_token_string_t cmd_set_vxlan_ip_ttl =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"ip-ttl");
cmdline_parse_token_num_t cmd_set_vxlan_ip_ttl_value =
- TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, ttl, UINT8);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, ttl, RTE_UINT8);
cmdline_parse_token_string_t cmd_set_vxlan_ip_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"ip-src");
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"vlan-tci");
cmdline_parse_token_num_t cmd_set_vxlan_vlan_value =
- TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tci, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tci, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_vxlan_eth_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"eth-src");
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
"tni");
cmdline_parse_token_num_t cmd_set_nvgre_tni_value =
- TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tni, UINT32);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tni, RTE_UINT32);
cmdline_parse_token_string_t cmd_set_nvgre_ip_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
"ip-src");
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
"vlan-tci");
cmdline_parse_token_num_t cmd_set_nvgre_vlan_value =
- TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tci, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tci, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_nvgre_eth_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
"eth-src");
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
"vlan-tci");
cmdline_parse_token_num_t cmd_set_l2_encap_vlan_value =
- TOKEN_NUM_INITIALIZER(struct cmd_set_l2_encap_result, tci, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_set_l2_encap_result, tci, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_l2_encap_eth_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
"eth-src");
pos_token, "label");
cmdline_parse_token_num_t cmd_set_mplsogre_encap_label_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsogre_encap_result, label,
- UINT32);
+ RTE_UINT32);
cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
pos_token, "ip-src");
pos_token, "vlan-tci");
cmdline_parse_token_num_t cmd_set_mplsogre_encap_vlan_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsogre_encap_result, tci,
- UINT16);
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_set_mplsogre_encap_eth_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
pos_token, "eth-src");
pos_token, "label");
cmdline_parse_token_num_t cmd_set_mplsoudp_encap_label_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, label,
- UINT32);
+ RTE_UINT32);
cmdline_parse_token_string_t cmd_set_mplsoudp_encap_udp_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
pos_token, "udp-src");
cmdline_parse_token_num_t cmd_set_mplsoudp_encap_udp_src_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, udp_src,
- UINT16);
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_set_mplsoudp_encap_udp_dst =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
pos_token, "udp-dst");
cmdline_parse_token_num_t cmd_set_mplsoudp_encap_udp_dst_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, udp_dst,
- UINT16);
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
pos_token, "ip-src");
pos_token, "vlan-tci");
cmdline_parse_token_num_t cmd_set_mplsoudp_encap_vlan_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, tci,
- UINT16);
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_set_mplsoudp_encap_eth_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
pos_token, "eth-src");
},
};
+/** Set connection tracking object common details */
+struct cmd_set_conntrack_common_result {
+ cmdline_fixed_string_t set;
+ cmdline_fixed_string_t conntrack;
+ cmdline_fixed_string_t common;
+ cmdline_fixed_string_t peer;
+ cmdline_fixed_string_t is_orig;
+ cmdline_fixed_string_t enable;
+ cmdline_fixed_string_t live;
+ cmdline_fixed_string_t sack;
+ cmdline_fixed_string_t cack;
+ cmdline_fixed_string_t last_dir;
+ cmdline_fixed_string_t liberal;
+ cmdline_fixed_string_t state;
+ cmdline_fixed_string_t max_ack_win;
+ cmdline_fixed_string_t retrans;
+ cmdline_fixed_string_t last_win;
+ cmdline_fixed_string_t last_seq;
+ cmdline_fixed_string_t last_ack;
+ cmdline_fixed_string_t last_end;
+ cmdline_fixed_string_t last_index;
+ uint8_t stat;
+ uint8_t factor;
+ uint16_t peer_port;
+ uint32_t is_original;
+ uint32_t en;
+ uint32_t is_live;
+ uint32_t s_ack;
+ uint32_t c_ack;
+ uint32_t ld;
+ uint32_t lb;
+ uint8_t re_num;
+ uint8_t li;
+ uint16_t lw;
+ uint32_t ls;
+ uint32_t la;
+ uint32_t le;
+};
+
+cmdline_parse_token_string_t cmd_set_conntrack_set =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ set, "set");
+cmdline_parse_token_string_t cmd_set_conntrack_conntrack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ conntrack, "conntrack");
+cmdline_parse_token_string_t cmd_set_conntrack_common_com =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ common, "com");
+cmdline_parse_token_string_t cmd_set_conntrack_common_peer =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ peer, "peer");
+cmdline_parse_token_num_t cmd_set_conntrack_common_peer_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ peer_port, RTE_UINT16);
+cmdline_parse_token_string_t cmd_set_conntrack_common_is_orig =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ is_orig, "is_orig");
+cmdline_parse_token_num_t cmd_set_conntrack_common_is_orig_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ is_original, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_enable =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ enable, "enable");
+cmdline_parse_token_num_t cmd_set_conntrack_common_enable_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ en, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_live =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ live, "live");
+cmdline_parse_token_num_t cmd_set_conntrack_common_live_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ is_live, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_sack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ sack, "sack");
+cmdline_parse_token_num_t cmd_set_conntrack_common_sack_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ s_ack, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_cack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ cack, "cack");
+cmdline_parse_token_num_t cmd_set_conntrack_common_cack_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ c_ack, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_dir =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_dir, "last_dir");
+cmdline_parse_token_num_t cmd_set_conntrack_common_last_dir_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ ld, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_liberal =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ liberal, "liberal");
+cmdline_parse_token_num_t cmd_set_conntrack_common_liberal_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ lb, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_state =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ state, "state");
+cmdline_parse_token_num_t cmd_set_conntrack_common_state_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ stat, RTE_UINT8);
+cmdline_parse_token_string_t cmd_set_conntrack_common_max_ackwin =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ max_ack_win, "max_ack_win");
+cmdline_parse_token_num_t cmd_set_conntrack_common_max_ackwin_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ factor, RTE_UINT8);
+cmdline_parse_token_string_t cmd_set_conntrack_common_retrans =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ retrans, "r_lim");
+cmdline_parse_token_num_t cmd_set_conntrack_common_retrans_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ re_num, RTE_UINT8);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_win =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_win, "last_win");
+cmdline_parse_token_num_t cmd_set_conntrack_common_last_win_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ lw, RTE_UINT16);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_seq =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_seq, "last_seq");
+cmdline_parse_token_num_t cmd_set_conntrack_common_last_seq_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ ls, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_ack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_ack, "last_ack");
+cmdline_parse_token_num_t cmd_set_conntrack_common_last_ack_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ la, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_end =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_end, "last_end");
+cmdline_parse_token_num_t cmd_set_conntrack_common_last_end_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ le, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_index =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_index, "last_index");
+cmdline_parse_token_num_t cmd_set_conntrack_common_last_index_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ li, RTE_UINT8);
+
+static void cmd_set_conntrack_common_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_conntrack_common_result *res = parsed_result;
+
+ /* No need to swap to big endian. */
+ conntrack_context.peer_port = res->peer_port;
+ conntrack_context.is_original_dir = res->is_original;
+ conntrack_context.enable = res->en;
+ conntrack_context.live_connection = res->is_live;
+ conntrack_context.selective_ack = res->s_ack;
+ conntrack_context.challenge_ack_passed = res->c_ack;
+ conntrack_context.last_direction = res->ld;
+ conntrack_context.liberal_mode = res->lb;
+ conntrack_context.state = (enum rte_flow_conntrack_state)res->stat;
+ conntrack_context.max_ack_window = res->factor;
+ conntrack_context.retransmission_limit = res->re_num;
+ conntrack_context.last_window = res->lw;
+ conntrack_context.last_index =
+ (enum rte_flow_conntrack_tcp_last_index)res->li;
+ conntrack_context.last_seq = res->ls;
+ conntrack_context.last_ack = res->la;
+ conntrack_context.last_end = res->le;
+}
+
+cmdline_parse_inst_t cmd_set_conntrack_common = {
+ .f = cmd_set_conntrack_common_parsed,
+ .data = NULL,
+ .help_str = "set conntrack com peer <port_id> is_orig <dir> enable <en>"
+ " live <ack_seen> sack <en> cack <passed> last_dir <dir>"
+ " liberal <en> state <s> max_ack_win <factor> r_lim <num>"
+ " last_win <win> last_seq <seq> last_ack <ack> last_end <end>"
+ " last_index <flag>",
+ .tokens = {
+ (void *)&cmd_set_conntrack_set,
+ (void *)&cmd_set_conntrack_conntrack,
+ (void *)&cmd_set_conntrack_common_com,
+ (void *)&cmd_set_conntrack_common_peer,
+ (void *)&cmd_set_conntrack_common_peer_value,
+ (void *)&cmd_set_conntrack_common_is_orig,
+ (void *)&cmd_set_conntrack_common_is_orig_value,
+ (void *)&cmd_set_conntrack_common_enable,
+ (void *)&cmd_set_conntrack_common_enable_value,
+ (void *)&cmd_set_conntrack_common_live,
+ (void *)&cmd_set_conntrack_common_live_value,
+ (void *)&cmd_set_conntrack_common_sack,
+ (void *)&cmd_set_conntrack_common_sack_value,
+ (void *)&cmd_set_conntrack_common_cack,
+ (void *)&cmd_set_conntrack_common_cack_value,
+ (void *)&cmd_set_conntrack_common_last_dir,
+ (void *)&cmd_set_conntrack_common_last_dir_value,
+ (void *)&cmd_set_conntrack_common_liberal,
+ (void *)&cmd_set_conntrack_common_liberal_value,
+ (void *)&cmd_set_conntrack_common_state,
+ (void *)&cmd_set_conntrack_common_state_value,
+ (void *)&cmd_set_conntrack_common_max_ackwin,
+ (void *)&cmd_set_conntrack_common_max_ackwin_value,
+ (void *)&cmd_set_conntrack_common_retrans,
+ (void *)&cmd_set_conntrack_common_retrans_value,
+ (void *)&cmd_set_conntrack_common_last_win,
+ (void *)&cmd_set_conntrack_common_last_win_value,
+ (void *)&cmd_set_conntrack_common_last_seq,
+ (void *)&cmd_set_conntrack_common_last_seq_value,
+ (void *)&cmd_set_conntrack_common_last_ack,
+ (void *)&cmd_set_conntrack_common_last_ack_value,
+ (void *)&cmd_set_conntrack_common_last_end,
+ (void *)&cmd_set_conntrack_common_last_end_value,
+ (void *)&cmd_set_conntrack_common_last_index,
+ (void *)&cmd_set_conntrack_common_last_index_value,
+ NULL,
+ },
+};
+
+/** Set connection tracking object both directions' details */
+struct cmd_set_conntrack_dir_result {
+ cmdline_fixed_string_t set;
+ cmdline_fixed_string_t conntrack;
+ cmdline_fixed_string_t dir;
+ cmdline_fixed_string_t scale;
+ cmdline_fixed_string_t fin;
+ cmdline_fixed_string_t ack_seen;
+ cmdline_fixed_string_t unack;
+ cmdline_fixed_string_t sent_end;
+ cmdline_fixed_string_t reply_end;
+ cmdline_fixed_string_t max_win;
+ cmdline_fixed_string_t max_ack;
+ uint32_t factor;
+ uint32_t f;
+ uint32_t as;
+ uint32_t un;
+ uint32_t se;
+ uint32_t re;
+ uint32_t mw;
+ uint32_t ma;
+};
+
+cmdline_parse_token_string_t cmd_set_conntrack_dir_set =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ set, "set");
+cmdline_parse_token_string_t cmd_set_conntrack_dir_conntrack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ conntrack, "conntrack");
+cmdline_parse_token_string_t cmd_set_conntrack_dir_dir =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ dir, "orig#rply");
+cmdline_parse_token_string_t cmd_set_conntrack_dir_scale =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ scale, "scale");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_scale_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ factor, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_fin =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ fin, "fin");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_fin_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ f, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_ack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ ack_seen, "acked");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_ack_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ as, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_unack_data =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ unack, "unack_data");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_unack_data_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ un, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_sent_end =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ sent_end, "sent_end");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_sent_end_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ se, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_reply_end =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ reply_end, "reply_end");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_reply_end_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ re, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_max_win =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ max_win, "max_win");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_max_win_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ mw, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_max_ack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ max_ack, "max_ack");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_max_ack_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ ma, RTE_UINT32);
+
+static void cmd_set_conntrack_dir_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_conntrack_dir_result *res = parsed_result;
+ struct rte_flow_tcp_dir_param *dir = NULL;
+
+ if (strcmp(res->dir, "orig") == 0)
+ dir = &conntrack_context.original_dir;
+ else if (strcmp(res->dir, "rply") == 0)
+ dir = &conntrack_context.reply_dir;
+ else
+ return;
+ dir->scale = res->factor;
+ dir->close_initiated = res->f;
+ dir->last_ack_seen = res->as;
+ dir->data_unacked = res->un;
+ dir->sent_end = res->se;
+ dir->reply_end = res->re;
+ dir->max_ack = res->ma;
+ dir->max_win = res->mw;
+}
+
+cmdline_parse_inst_t cmd_set_conntrack_dir = {
+ .f = cmd_set_conntrack_dir_parsed,
+ .data = NULL,
+ .help_str = "set conntrack orig|rply scale <factor> fin <sent>"
+ " acked <seen> unack_data <unack> sent_end <sent>"
+ " reply_end <reply> max_win <win> max_ack <ack>",
+ .tokens = {
+ (void *)&cmd_set_conntrack_set,
+ (void *)&cmd_set_conntrack_conntrack,
+ (void *)&cmd_set_conntrack_dir_dir,
+ (void *)&cmd_set_conntrack_dir_scale,
+ (void *)&cmd_set_conntrack_dir_scale_value,
+ (void *)&cmd_set_conntrack_dir_fin,
+ (void *)&cmd_set_conntrack_dir_fin_value,
+ (void *)&cmd_set_conntrack_dir_ack,
+ (void *)&cmd_set_conntrack_dir_ack_value,
+ (void *)&cmd_set_conntrack_dir_unack_data,
+ (void *)&cmd_set_conntrack_dir_unack_data_value,
+ (void *)&cmd_set_conntrack_dir_sent_end,
+ (void *)&cmd_set_conntrack_dir_sent_end_value,
+ (void *)&cmd_set_conntrack_dir_reply_end,
+ (void *)&cmd_set_conntrack_dir_reply_end_value,
+ (void *)&cmd_set_conntrack_dir_max_win,
+ (void *)&cmd_set_conntrack_dir_max_win_value,
+ (void *)&cmd_set_conntrack_dir_max_ack,
+ (void *)&cmd_set_conntrack_dir_max_ack_value,
+ NULL,
+ },
+};
+
/* Strict link priority scheduling mode setting */
static void
cmd_strict_link_prio_parsed(
cmdline_parse_token_string_t cmd_ddp_add_add =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, add, "add");
cmdline_parse_token_num_t cmd_ddp_add_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_ddp_add_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_ddp_add_result, port_id,
+ RTE_UINT16);
cmdline_parse_token_string_t cmd_ddp_add_filepath =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, filepath, NULL);
cmdline_parse_token_string_t cmd_ddp_del_del =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, del, "del");
cmdline_parse_token_num_t cmd_ddp_del_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_ddp_del_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_ddp_del_result, port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_ddp_del_filepath =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, filepath, NULL);
cmdline_parse_token_string_t cmd_ddp_get_list_list =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_get_list_result, list, "list");
cmdline_parse_token_num_t cmd_ddp_get_list_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_ddp_get_list_result, port_id, UINT16);
+ TOKEN_NUM_INITIALIZER(struct cmd_ddp_get_list_result, port_id,
+ RTE_UINT16);
static void
cmd_ddp_get_list_parsed(
cfg, "config");
cmdline_parse_token_num_t cmd_cfg_input_set_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_cfg_input_set_pctype =
TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
pctype, "pctype");
cmdline_parse_token_num_t cmd_cfg_input_set_pctype_id =
TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
- pctype_id, UINT8);
+ pctype_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_cfg_input_set_inset_type =
TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
inset_type,
field, "field");
cmdline_parse_token_num_t cmd_cfg_input_set_field_idx =
TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
- field_idx, UINT8);
+ field_idx, RTE_UINT8);
cmdline_parse_inst_t cmd_cfg_input_set = {
.f = cmd_cfg_input_set_parsed,
cfg, "config");
cmdline_parse_token_num_t cmd_clear_input_set_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_clear_input_set_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_clear_input_set_pctype =
TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
pctype, "pctype");
cmdline_parse_token_num_t cmd_clear_input_set_pctype_id =
TOKEN_NUM_INITIALIZER(struct cmd_clear_input_set_result,
- pctype_id, UINT8);
+ pctype_id, RTE_UINT8);
cmdline_parse_token_string_t cmd_clear_input_set_inset_type =
TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
inset_type,
cmdline_parse_token_num_t cmd_show_vf_stats_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_show_vf_stats_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_show_vf_stats_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_show_vf_stats_result,
- vf_id, UINT16);
+ vf_id, RTE_UINT16);
static void
cmd_show_vf_stats_parsed(
cmdline_parse_token_num_t cmd_clear_vf_stats_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_clear_vf_stats_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_clear_vf_stats_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_clear_vf_stats_result,
- vf_id, UINT16);
+ vf_id, RTE_UINT16);
static void
cmd_clear_vf_stats_parsed(
cmdline_parse_token_num_t cmd_pctype_mapping_reset_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_pctype_mapping_reset_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_pctype_mapping_reset_pctype =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_reset_result,
cmdline_parse_token_num_t cmd_pctype_mapping_get_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_pctype_mapping_get_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_pctype_mapping_get_pctype =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_get_result,
cmdline_parse_token_num_t cmd_pctype_mapping_update_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_pctype_mapping_update_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_pctype_mapping_update_pctype =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_update_result,
cmdline_parse_token_num_t cmd_pctype_mapping_update_flow_type =
TOKEN_NUM_INITIALIZER
(struct cmd_pctype_mapping_update_result,
- flow_type, UINT16);
+ flow_type, RTE_UINT16);
static void
cmd_pctype_mapping_update_parsed(
cmdline_parse_token_num_t cmd_ptype_mapping_get_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_get_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_ptype_mapping_get_valid_only =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_get_result,
- valid_only, UINT8);
+ valid_only, RTE_UINT8);
static void
cmd_ptype_mapping_get_parsed(
cmdline_parse_token_num_t cmd_ptype_mapping_replace_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_replace_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_ptype_mapping_replace_target =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_replace_result,
- target, UINT32);
+ target, RTE_UINT32);
cmdline_parse_token_num_t cmd_ptype_mapping_replace_mask =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_replace_result,
- mask, UINT8);
+ mask, RTE_UINT8);
cmdline_parse_token_num_t cmd_ptype_mapping_replace_pkt_type =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_replace_result,
- pkt_type, UINT32);
+ pkt_type, RTE_UINT32);
static void
cmd_ptype_mapping_replace_parsed(
cmdline_parse_token_num_t cmd_ptype_mapping_reset_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_reset_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
static void
cmd_ptype_mapping_reset_parsed(
cmdline_parse_token_num_t cmd_ptype_mapping_update_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_update_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_num_t cmd_ptype_mapping_update_hw_ptype =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_update_result,
- hw_ptype, UINT8);
+ hw_ptype, RTE_UINT8);
cmdline_parse_token_num_t cmd_ptype_mapping_update_sw_ptype =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_update_result,
- sw_ptype, UINT32);
+ sw_ptype, RTE_UINT32);
static void
cmd_ptype_mapping_update_parsed(
cmdline_parse_token_num_t cmd_rx_offload_get_capa_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_rx_offload_get_capa_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_rx_offload_get_capa_rx_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_rx_offload_get_capa_result,
cmdline_parse_token_num_t cmd_rx_offload_get_configuration_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_rx_offload_get_configuration_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_rx_offload_get_configuration_rx_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_rx_offload_get_configuration_result,
cmdline_parse_token_num_t cmd_config_per_port_rx_offload_result_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_config_per_port_rx_offload_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_rx_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_port_rx_offload_result,
cmdline_parse_token_num_t cmd_config_per_queue_rx_offload_result_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_config_per_queue_rx_offload_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_rxq =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_rx_offload_result,
cmdline_parse_token_num_t cmd_config_per_queue_rx_offload_result_queue_id =
TOKEN_NUM_INITIALIZER
(struct cmd_config_per_queue_rx_offload_result,
- queue_id, UINT16);
+ queue_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_rxoffload =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_rx_offload_result,
cmdline_parse_token_num_t cmd_tx_offload_get_capa_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_tx_offload_get_capa_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_tx_offload_get_capa_tx_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_offload_get_capa_result,
cmdline_parse_token_num_t cmd_tx_offload_get_configuration_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_tx_offload_get_configuration_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_tx_offload_get_configuration_tx_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_offload_get_configuration_result,
cmdline_parse_token_num_t cmd_config_per_port_tx_offload_result_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_config_per_port_tx_offload_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_tx_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_port_tx_offload_result,
cmdline_parse_token_num_t cmd_config_per_queue_tx_offload_result_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_config_per_queue_tx_offload_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_txq =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_tx_offload_result,
cmdline_parse_token_num_t cmd_config_per_queue_tx_offload_result_queue_id =
TOKEN_NUM_INITIALIZER
(struct cmd_config_per_queue_tx_offload_result,
- queue_id, UINT16);
+ queue_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_txoffload =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_tx_offload_result,
keyword, "config");
cmdline_parse_token_num_t cmd_config_tx_metadata_specific_id =
TOKEN_NUM_INITIALIZER(struct cmd_config_tx_metadata_specific_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_tx_metadata_specific_item =
TOKEN_STRING_INITIALIZER(struct cmd_config_tx_metadata_specific_result,
item, "tx_metadata");
cmdline_parse_token_num_t cmd_config_tx_metadata_specific_value =
TOKEN_NUM_INITIALIZER(struct cmd_config_tx_metadata_specific_result,
- value, UINT32);
+ value, RTE_UINT32);
cmdline_parse_inst_t cmd_config_tx_metadata_specific = {
.f = cmd_config_tx_metadata_specific_parsed,
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);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_config_tx_dynf_specific_item =
TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
item, "dynf");
cmd_port, "port");
cmdline_parse_token_num_t cmd_show_tx_metadata_pid =
TOKEN_NUM_INITIALIZER(struct cmd_show_tx_metadata_result,
- cmd_pid, UINT16);
+ cmd_pid, RTE_UINT16);
cmdline_parse_token_string_t cmd_show_tx_metadata_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_show_tx_metadata_result,
cmd_keyword, "tx_metadata");
__rte_unused struct cmdline *cl,
__rte_unused void *data)
{
-#define FEC_CAP_NUM 2
struct cmd_show_fec_capability_result *res = parsed_result;
- struct rte_eth_fec_capa speed_fec_capa[FEC_CAP_NUM];
- unsigned int num = FEC_CAP_NUM;
- unsigned int ret_num;
+ struct rte_eth_fec_capa *speed_fec_capa;
+ unsigned int num;
int ret;
if (!rte_eth_dev_is_valid_port(res->cmd_pid)) {
return;
}
- ret = rte_eth_fec_get_capability(res->cmd_pid, speed_fec_capa, num);
+ ret = rte_eth_fec_get_capability(res->cmd_pid, NULL, 0);
if (ret == -ENOTSUP) {
printf("Function not implemented\n");
return;
} else if (ret < 0) {
- printf("Get FEC capability failed\n");
+ printf("Get FEC capability failed: %d\n", ret);
+ return;
+ }
+
+ num = (unsigned int)ret;
+ speed_fec_capa = calloc(num, sizeof(*speed_fec_capa));
+ if (speed_fec_capa == NULL) {
+ printf("Failed to alloc FEC capability buffer\n");
return;
}
- ret_num = (unsigned int)ret;
- show_fec_capability(ret_num, speed_fec_capa);
+ ret = rte_eth_fec_get_capability(res->cmd_pid, speed_fec_capa, num);
+ if (ret < 0) {
+ printf("Error getting FEC capability: %d\n", ret);
+ goto out;
+ }
+
+ show_fec_capability(num, speed_fec_capa);
+out:
+ free(speed_fec_capa);
}
cmdline_parse_token_string_t cmd_show_fec_capability_show =
cmd_port, "port");
cmdline_parse_token_num_t cmd_show_fec_capability_pid =
TOKEN_NUM_INITIALIZER(struct cmd_show_fec_capability_result,
- cmd_pid, UINT16);
+ cmd_pid, RTE_UINT16);
cmdline_parse_token_string_t cmd_show_fec_capability_fec =
TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result,
cmd_fec, "fec");
cmd_port, "port");
cmdline_parse_token_num_t cmd_show_fec_mode_pid =
TOKEN_NUM_INITIALIZER(struct cmd_show_fec_metadata_result,
- cmd_pid, UINT16);
+ cmd_pid, RTE_UINT16);
cmdline_parse_token_string_t cmd_show_fec_mode_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_show_fec_metadata_result,
cmd_keyword, "fec_mode");
cmdline_parse_token_num_t cmd_set_port_fec_mode_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_port_fec_mode,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_port_fec_mode_str =
TOKEN_STRING_INITIALIZER
(struct cmd_set_port_fec_mode,
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);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_show_port_supported_ptypes_ptypes =
TOKEN_STRING_INITIALIZER
(struct cmd_show_port_supported_ptypes_result,
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);
+ printf("Invalid input: queue id = %d, desc id = %d\n",
+ res->cmd_qid, res->cmd_did);
return;
}
if (rc == RTE_ETH_RX_DESC_AVAIL)
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);
+ printf("Invalid input: queue id = %d, desc id = %d\n",
+ res->cmd_qid, res->cmd_did);
return;
}
if (rc == RTE_ETH_TX_DESC_FULL)
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);
+ cmd_pid, RTE_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);
+ cmd_qid, RTE_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);
+ cmd_did, RTE_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");
},
};
+/* *** display rx queue desc used count *** */
+struct cmd_show_rx_queue_desc_used_count_result {
+ cmdline_fixed_string_t cmd_show;
+ cmdline_fixed_string_t cmd_port;
+ cmdline_fixed_string_t cmd_rxq;
+ cmdline_fixed_string_t cmd_desc;
+ cmdline_fixed_string_t cmd_used;
+ cmdline_fixed_string_t cmd_count;
+ portid_t cmd_pid;
+ portid_t cmd_qid;
+};
+
+static void
+cmd_show_rx_queue_desc_used_count_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_show_rx_queue_desc_used_count_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;
+ }
+
+ rc = rte_eth_rx_queue_count(res->cmd_pid, res->cmd_qid);
+ if (rc < 0) {
+ printf("Invalid queueid = %d\n", res->cmd_qid);
+ return;
+ }
+ printf("Used desc count = %d\n", rc);
+}
+
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_show =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_rx_queue_desc_used_count_result,
+ cmd_show, "show");
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_port =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_rx_queue_desc_used_count_result,
+ cmd_port, "port");
+cmdline_parse_token_num_t cmd_show_rx_queue_desc_used_count_pid =
+ TOKEN_NUM_INITIALIZER
+ (struct cmd_show_rx_queue_desc_used_count_result,
+ cmd_pid, RTE_UINT16);
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_rxq =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_rx_queue_desc_used_count_result,
+ cmd_rxq, "rxq");
+cmdline_parse_token_num_t cmd_show_rx_queue_desc_used_count_qid =
+ TOKEN_NUM_INITIALIZER
+ (struct cmd_show_rx_queue_desc_used_count_result,
+ cmd_qid, RTE_UINT16);
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_desc =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_rx_queue_desc_used_count_result,
+ cmd_count, "desc");
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_used =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_rx_queue_desc_used_count_result,
+ cmd_count, "used");
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_count =
+ TOKEN_STRING_INITIALIZER
+ (struct cmd_show_rx_queue_desc_used_count_result,
+ cmd_count, "count");
+cmdline_parse_inst_t cmd_show_rx_queue_desc_used_count = {
+ .f = cmd_show_rx_queue_desc_used_count_parsed,
+ .data = NULL,
+ .help_str = "show port <port_id> rxq <queue_id> desc used count",
+ .tokens = {
+ (void *)&cmd_show_rx_queue_desc_used_count_show,
+ (void *)&cmd_show_rx_queue_desc_used_count_port,
+ (void *)&cmd_show_rx_queue_desc_used_count_pid,
+ (void *)&cmd_show_rx_queue_desc_used_count_rxq,
+ (void *)&cmd_show_rx_queue_desc_used_count_qid,
+ (void *)&cmd_show_rx_queue_desc_used_count_desc,
+ (void *)&cmd_show_rx_queue_desc_used_count_used,
+ (void *)&cmd_show_rx_queue_desc_used_count_count,
+ NULL,
+ },
+};
+
/* Common result structure for set port ptypes */
struct cmd_set_port_ptypes_result {
cmdline_fixed_string_t set;
cmdline_parse_token_num_t cmd_set_port_ptypes_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_port_ptypes_result,
- port_id, UINT16);
+ port_id, RTE_UINT16);
cmdline_parse_token_string_t cmd_set_port_ptypes_mask_str =
TOKEN_STRING_INITIALIZER
(struct cmd_set_port_ptypes_result,
cmdline_parse_token_num_t cmd_set_port_ptypes_mask_u32 =
TOKEN_NUM_INITIALIZER
(struct cmd_set_port_ptypes_result,
- mask, UINT32);
+ mask, RTE_UINT32);
static void
cmd_set_port_ptypes_parsed(
cmd_port, "port");
cmdline_parse_token_num_t cmd_showport_macs_pid =
TOKEN_NUM_INITIALIZER(struct cmd_showport_macs_result,
- cmd_pid, UINT16);
+ cmd_pid, RTE_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_set_uc_all_hash_filter,
(cmdline_parse_inst_t *)&cmd_vf_mac_addr_filter,
(cmdline_parse_inst_t *)&cmd_queue_rate_limit,
- (cmdline_parse_inst_t *)&cmd_tunnel_filter,
(cmdline_parse_inst_t *)&cmd_tunnel_udp_config,
- (cmdline_parse_inst_t *)&cmd_global_config,
(cmdline_parse_inst_t *)&cmd_set_mirror_mask,
(cmdline_parse_inst_t *)&cmd_set_mirror_link,
(cmdline_parse_inst_t *)&cmd_reset_mirror_rule,
(cmdline_parse_inst_t *)&cmd_config_rss_hash_key,
(cmdline_parse_inst_t *)&cmd_dump,
(cmdline_parse_inst_t *)&cmd_dump_one,
- (cmdline_parse_inst_t *)&cmd_add_del_ip_flow_director,
- (cmdline_parse_inst_t *)&cmd_add_del_udp_flow_director,
- (cmdline_parse_inst_t *)&cmd_add_del_sctp_flow_director,
- (cmdline_parse_inst_t *)&cmd_add_del_l2_flow_director,
- (cmdline_parse_inst_t *)&cmd_add_del_mac_vlan_flow_director,
- (cmdline_parse_inst_t *)&cmd_add_del_tunnel_flow_director,
+#ifdef RTE_NET_I40E
(cmdline_parse_inst_t *)&cmd_add_del_raw_flow_director,
- (cmdline_parse_inst_t *)&cmd_flush_flow_director,
+#endif
(cmdline_parse_inst_t *)&cmd_set_flow_director_ip_mask,
(cmdline_parse_inst_t *)&cmd_set_flow_director_mac_vlan_mask,
(cmdline_parse_inst_t *)&cmd_set_flow_director_tunnel_mask,
- (cmdline_parse_inst_t *)&cmd_set_flow_director_flex_mask,
(cmdline_parse_inst_t *)&cmd_set_flow_director_flex_payload,
- (cmdline_parse_inst_t *)&cmd_get_sym_hash_ena_per_port,
- (cmdline_parse_inst_t *)&cmd_set_sym_hash_ena_per_port,
- (cmdline_parse_inst_t *)&cmd_get_hash_global_config,
- (cmdline_parse_inst_t *)&cmd_set_hash_global_config,
- (cmdline_parse_inst_t *)&cmd_set_hash_input_set,
- (cmdline_parse_inst_t *)&cmd_set_fdir_input_set,
(cmdline_parse_inst_t *)&cmd_flow,
(cmdline_parse_inst_t *)&cmd_show_port_meter_cap,
(cmdline_parse_inst_t *)&cmd_add_port_meter_profile_srtcm,
(cmdline_parse_inst_t *)&cmd_enable_port_meter,
(cmdline_parse_inst_t *)&cmd_disable_port_meter,
(cmdline_parse_inst_t *)&cmd_del_port_meter,
+ (cmdline_parse_inst_t *)&cmd_del_port_meter_policy,
(cmdline_parse_inst_t *)&cmd_set_port_meter_profile,
(cmdline_parse_inst_t *)&cmd_set_port_meter_dscp_table,
- (cmdline_parse_inst_t *)&cmd_set_port_meter_policer_action,
(cmdline_parse_inst_t *)&cmd_set_port_meter_stats_mask,
(cmdline_parse_inst_t *)&cmd_show_port_meter_stats,
(cmdline_parse_inst_t *)&cmd_mcast_addr,
- (cmdline_parse_inst_t *)&cmd_config_l2_tunnel_eth_type_all,
- (cmdline_parse_inst_t *)&cmd_config_l2_tunnel_eth_type_specific,
- (cmdline_parse_inst_t *)&cmd_config_l2_tunnel_en_dis_all,
- (cmdline_parse_inst_t *)&cmd_config_l2_tunnel_en_dis_specific,
- (cmdline_parse_inst_t *)&cmd_config_e_tag_insertion_en,
- (cmdline_parse_inst_t *)&cmd_config_e_tag_insertion_dis,
- (cmdline_parse_inst_t *)&cmd_config_e_tag_stripping_en_dis,
- (cmdline_parse_inst_t *)&cmd_config_e_tag_forwarding_en_dis,
- (cmdline_parse_inst_t *)&cmd_config_e_tag_filter_add,
- (cmdline_parse_inst_t *)&cmd_config_e_tag_filter_del,
(cmdline_parse_inst_t *)&cmd_set_vf_vlan_anti_spoof,
(cmdline_parse_inst_t *)&cmd_set_vf_mac_anti_spoof,
(cmdline_parse_inst_t *)&cmd_set_vf_vlan_stripq,
(cmdline_parse_inst_t *)&cmd_set_mplsoudp_encap_with_vlan,
(cmdline_parse_inst_t *)&cmd_set_mplsoudp_decap,
(cmdline_parse_inst_t *)&cmd_set_mplsoudp_decap_with_vlan,
+ (cmdline_parse_inst_t *)&cmd_set_conntrack_common,
+ (cmdline_parse_inst_t *)&cmd_set_conntrack_dir,
(cmdline_parse_inst_t *)&cmd_ddp_add,
(cmdline_parse_inst_t *)&cmd_ddp_del,
(cmdline_parse_inst_t *)&cmd_ddp_get_list,
(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_show_rx_queue_desc_used_count,
(cmdline_parse_inst_t *)&cmd_set_raw,
(cmdline_parse_inst_t *)&cmd_show_set_raw,
(cmdline_parse_inst_t *)&cmd_show_set_raw_all,
void
prompt(void)
{
+ int ret;
/* initialize non-constant commands */
cmd_set_fwd_mode_init();
cmd_set_fwd_retry_mode_init();
testpmd_cl = cmdline_stdin_new(main_ctx, "testpmd> ");
if (testpmd_cl == NULL)
return;
+
+ ret = atexit(prompt_exit);
+ if (ret != 0)
+ printf("Cannot set exit function for cmdline\n");
+
cmdline_interact(testpmd_cl);
- cmdline_stdin_exit(testpmd_cl);
+ if (ret != 0)
+ cmdline_stdin_exit(testpmd_cl);
}
void
prompt_exit(void)
{
- if (testpmd_cl != NULL)
+ if (testpmd_cl != NULL) {
cmdline_quit(testpmd_cl);
+ cmdline_stdin_exit(testpmd_cl);
+ }
}
static void
git.droids-corp.org / dpdk.git / blobdiff