X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline.c;h=c43c85c591bd69c521e48d0144c3e9b6199500ef;hb=9da077adb34630d388e0ededdd7ce4214d764284;hp=1375f223ebcf38eef0b674e89f92d9e1bf143e72;hpb=611faa5f46cc67449f272e14450fc6a0a275767d;p=dpdk.git diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index 1375f223eb..c43c85c591 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -8,12 +8,8 @@ #include #include #include -#include #include #include -#include -#include - #include #include @@ -28,7 +24,6 @@ #include #include #include -#include #include #include #include @@ -39,7 +34,9 @@ #include #include #include +#ifdef RTE_LIB_GRO #include +#endif #include #include @@ -50,20 +47,20 @@ #include #include #include -#ifdef RTE_LIBRTE_PMD_BOND +#ifdef RTE_NET_BOND #include #include #endif -#if defined RTE_LIBRTE_DPAA_BUS && defined RTE_LIBRTE_DPAA_PMD +#if defined RTE_BUS_DPAA && defined RTE_NET_DPAA #include #endif -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE #include #endif -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E #include #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT #include #endif #include "testpmd.h" @@ -163,9 +160,15 @@ static void cmd_help_long_parsed(void *parsed_result, "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 info (port_id) representor\n" + " Show supported representors for a specific port\n\n" + + "show port port_id (module_eeprom|eeprom)\n" + " Display the module EEPROM or EEPROM information for port_id.\n\n" + "show port X rss reta (size) (mask0,mask1,...)\n" " Display the rss redirection table entry indicated" " by masks on port X. size is used to indicate the" @@ -174,13 +177,13 @@ static void cmd_help_long_parsed(void *parsed_result, "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" " Display information for configured RX/TX queue.\n\n" - "show config (rxtx|cores|fwd|txpkts)\n" + "show config (rxtx|cores|fwd|rxoffs|rxpkts|txpkts)\n" " Display the given configuration.\n\n" "read rxd (port_id) (queue_id) (rxd_id)\n" @@ -243,8 +246,24 @@ static void cmd_help_long_parsed(void *parsed_result, "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" + + "show port (port_id) flow transfer proxy\n" + " Display proxy port to manage transfer flows\n\n" + + "show port (port_id) fec capabilities" + " Show fec capabilities of a port.\n\n" + + "show port (port_id) fec_mode" + " Show fec mode of a port.\n\n" + + "show port (port_id) flow_ctrl" + " Show flow control info of a port.\n\n" ); } @@ -285,6 +304,18 @@ static void cmd_help_long_parsed(void *parsed_result, " Set the transmit delay time and number of retries," " effective when retry is enabled.\n\n" + "set rxoffs (x[,y]*)\n" + " Set the offset of each packet segment on" + " receiving if split feature is engaged." + " Affects only the queues configured with split" + " offloads.\n\n" + + "set rxpkts (x[,y]*)\n" + " Set the length of each segment to scatter" + " packets on receiving if split feature is engaged." + " Affects only the queues configured with split" + " offloads.\n\n" + "set txpkts (x[,y]*)\n" " Set the length of each segment of TXONLY" " and optionally CSUM packets.\n\n" @@ -294,6 +325,10 @@ static void cmd_help_long_parsed(void *parsed_result, " Right now only applicable for CSUM and TXONLY" " modes\n\n" + "set txtimes (x, y)\n" + " Set the scheduling on timestamps" + " timings for the TXONLY mode\n\n" + "set corelist (x[,y]*)\n" " Set the list of forwarding cores.\n\n" @@ -383,16 +418,6 @@ static void cmd_help_long_parsed(void *parsed_result, " 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" @@ -438,6 +463,7 @@ static void cmd_help_long_parsed(void *parsed_result, "tso show (portid)" " Display the status of TCP Segmentation Offload.\n\n" +#ifdef RTE_LIB_GRO "set port (port_id) gro on|off\n" " Enable or disable Generic Receive Offload in" " csum forwarding engine.\n\n" @@ -448,7 +474,9 @@ static void cmd_help_long_parsed(void *parsed_result, "set gro flush (cycles)\n" " Set the cycle to flush GROed packets from" " reassembly tables.\n\n" +#endif +#ifdef RTE_LIB_GSO "set port (port_id) gso (on|off)" " Enable or disable Generic Segmentation Offload in" " csum forwarding engine.\n\n" @@ -459,6 +487,7 @@ static void cmd_help_long_parsed(void *parsed_result, "show port (port_id) gso\n" " Show GSO configuration.\n\n" +#endif "set fwd (%s)\n" " Set packet forwarding mode.\n\n" @@ -525,14 +554,15 @@ static void cmd_help_long_parsed(void *parsed_result, " Set the option to hide the zero values" " for xstats display.\n" + "set record-core-cycles on|off\n" + " Set the option to enable measurement of CPU cycles.\n" + + "set record-burst-stats on|off\n" + " Set the option to enable display of RX and TX bursts.\n" + "set port (port_id) vf (vf_id) rx|tx on|off\n" " Enable/Disable a VF receive/tranmit from a port\n\n" - "set port (port_id) vf (vf_id) (mac_addr)" - " (exact-mac#exact-mac-vlan#hashmac|hashmac-vlan) on|off\n" - " Add/Remove unicast or multicast MAC addr filter" - " for a VF.\n\n" - "set port (port_id) vf (vf_id) rxmode (AUPE|ROPE|BAM" "|MPE) (on|off)\n" " AUPE:accepts untagged VLAN;" @@ -548,24 +578,6 @@ static void cmd_help_long_parsed(void *parsed_result, "queue_mask (queue_mask_value)\n" " Set rate limit for queues in VF of a port\n\n" - "set port (port_id) mirror-rule (rule_id)" - " (pool-mirror-up|pool-mirror-down|vlan-mirror)" - " (poolmask|vlanid[,vlanid]*) dst-pool (pool_id) (on|off)\n" - " Set pool or vlan type mirror rule on a port.\n" - " e.g., 'set port 0 mirror-rule 0 vlan-mirror 0,1" - " dst-pool 0 on' enable mirror traffic with vlan 0,1" - " to pool 0.\n\n" - - "set port (port_id) mirror-rule (rule_id)" - " (uplink-mirror|downlink-mirror) dst-pool" - " (pool_id) (on|off)\n" - " Set uplink or downlink type mirror rule on a port.\n" - " e.g., 'set port 0 mirror-rule 0 uplink-mirror dst-pool" - " 0 on' enable mirror income traffic to pool 0.\n\n" - - "reset port (port_id) mirror-rule (rule_id)\n" - " Reset a mirror rule.\n\n" - "set flush_rx (on|off)\n" " Flush (default) or don't flush RX streams before" " forwarding. Mainly used with PCAP drivers.\n\n" @@ -593,7 +605,7 @@ static void cmd_help_long_parsed(void *parsed_result, " Show the bypass configuration for a bypass enabled NIC" " using the lowest port on the NIC.\n\n" -#ifdef RTE_LIBRTE_PMD_BOND +#ifdef RTE_NET_BOND "create bonded device (mode) (socket)\n" " Create a new bonded device with specific bonding mode and socket.\n\n" @@ -612,13 +624,16 @@ static void cmd_help_long_parsed(void *parsed_result, "show bonding config (port_id)\n" " Show the bonding config for port_id.\n\n" + "show bonding lacp info (port_id)\n" + " Show the bonding lacp information for port_id.\n\n" + "set bonding mac_addr (port_id) (address)\n" " Set the MAC address of a bonded device.\n\n" "set bonding mode IEEE802.3AD aggregator policy (port_id) (agg_name)" " Set Aggregation mode for IEEE802.3AD (mode 4)" - "set bonding xmit_balance_policy (port_id) (l2|l23|l34)\n" + "set bonding balance_xmit_policy (port_id) (l2|l23|l34)\n" " Set the transmit balance policy for bonded device running in balance mode.\n\n" "set bonding mon_period (port_id) (value)\n" @@ -634,27 +649,6 @@ static void cmd_help_long_parsed(void *parsed_result, "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" @@ -694,21 +688,20 @@ static void cmd_help_long_parsed(void *parsed_result, "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" @@ -721,6 +714,13 @@ static void cmd_help_long_parsed(void *parsed_result, "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" @@ -738,6 +738,9 @@ static void cmd_help_long_parsed(void *parsed_result, "show port (port_id) queue-region\n" " show all queue region related configuration info\n\n" + "set port (port_id) fec_mode auto|off|rs|baser\n" + " set fec mode for a specific port\n\n" + , list_pkt_forwarding_modes() ); } @@ -769,7 +772,7 @@ static void cmd_help_long_parsed(void *parsed_result, " Detach physical or virtual dev by port_id\n\n" "port config (port_id|all)" - " speed (10|100|1000|10000|25000|40000|50000|100000|auto)" + " speed (10|100|1000|10000|25000|40000|50000|100000|200000|auto)" " duplex (half|full|auto)\n" " Set speed and duplex for all ports or port_id\n\n" @@ -790,7 +793,8 @@ static void cmd_help_long_parsed(void *parsed_result, "receive buffers available.\n\n" "port config all rss (all|default|ip|tcp|udp|sctp|" - "ether|port|vxlan|geneve|nvgre|vxlan-gpe|none|)\n" + "ether|port|vxlan|geneve|nvgre|vxlan-gpe|ecpri|mpls|none|level-default|" + "level-outer|level-inner|)\n" " Set the RSS mode.\n\n" "port config port-id rss reta (hash,queue)[,(hash,queue)]\n" @@ -830,14 +834,6 @@ static void cmd_help_long_parsed(void *parsed_result, "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" @@ -854,22 +850,22 @@ static void cmd_help_long_parsed(void *parsed_result, "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 rx_offload vlan_strip|" "ipv4_cksum|udp_cksum|tcp_cksum|tcp_lro|qinq_strip|" "outer_ipv4_cksum|macsec_strip|header_split|" - "vlan_filter|vlan_extend|jumbo_frame|" - "scatter|timestamp|security|keep_crc on|off\n" + "vlan_filter|vlan_extend|jumbo_frame|scatter|" + "buffer_split|timestamp|security|keep_crc on|off\n" " Enable or disable a per port Rx offloading" " on all Rx queues of a port\n\n" "port (port_id) rxq (queue_id) rx_offload vlan_strip|" "ipv4_cksum|udp_cksum|tcp_cksum|tcp_lro|qinq_strip|" "outer_ipv4_cksum|macsec_strip|header_split|" - "vlan_filter|vlan_extend|jumbo_frame|" - "scatter|timestamp|security|keep_crc on|off\n" + "vlan_filter|vlan_extend|jumbo_frame|scatter|" + "buffer_split|timestamp|security|keep_crc on|off\n" " Enable or disable a per queue Rx offloading" " only on a specific Rx queue\n\n" @@ -907,6 +903,9 @@ static void cmd_help_long_parsed(void *parsed_result, " Register a dynf and Set/clear this flag on Tx. " "Testpmd will set this value to any Tx packet " "sent from this port\n\n" + + "port cleanup (port_id) txq (queue_id) (free_cnt)\n" + " Cleanup txq mbufs for a specific Tx queue\n\n" ); } @@ -946,89 +945,12 @@ static void cmd_help_long_parsed(void *parsed_result, "filters:\n" "--------\n\n" - "ethertype_filter (port_id) (add|del)" - " (mac_addr|mac_ignr) (mac_address) ethertype" - " (ether_type) (drop|fwd) queue (queue_id)\n" - " Add/Del an ethertype filter.\n\n" - - "2tuple_filter (port_id) (add|del)" - " dst_port (dst_port_value) protocol (protocol_value)" - " mask (mask_value) tcp_flags (tcp_flags_value)" - " priority (prio_value) queue (queue_id)\n" - " Add/Del a 2tuple filter.\n\n" - - "5tuple_filter (port_id) (add|del)" - " dst_ip (dst_address) src_ip (src_address)" - " dst_port (dst_port_value) src_port (src_port_value)" - " protocol (protocol_value)" - " mask (mask_value) tcp_flags (tcp_flags_value)" - " priority (prio_value) queue (queue_id)\n" - " Add/Del a 5tuple filter.\n\n" - - "syn_filter (port_id) (add|del) priority (high|low) queue (queue_id)" - " Add/Del syn filter.\n\n" - - "flex_filter (port_id) (add|del) len (len_value)" - " bytes (bytes_value) mask (mask_value)" - " priority (prio_value) queue (queue_id)\n" - " Add/Del a flex filter.\n\n" - - "flow_director_filter (port_id) mode IP (add|del|update)" - " flow (ipv4-other|ipv4-frag|ipv6-other|ipv6-frag)" - " src (src_ip_address) dst (dst_ip_address)" - " 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)" @@ -1045,55 +967,10 @@ static void cmd_help_long_parsed(void *parsed_result, " 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|) (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]" @@ -1125,6 +1002,28 @@ static void cmd_help_long_parsed(void *parsed_result, " Restrict ingress traffic to the defined" " flow rules\n\n" + "flow aged {port_id} [destroy]\n" + " List and destroy aged flows" + " flow rules\n\n" + + "flow indirect_action {port_id} create" + " [action_id {indirect_action_id}]" + " [ingress] [egress]" + " action {action} / end\n" + " Create indirect action.\n\n" + + "flow indirect_action {port_id} update" + " {indirect_action_id} action {action} / end\n" + " Update indirect action.\n\n" + + "flow indirect_action {port_id} destroy" + " action_id {indirect_action_id} [...]\n" + " Destroy specific indirect actions.\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" " (ip-dst) eth-src (eth-src) eth-dst (eth-dst)\n" @@ -1182,14 +1081,9 @@ static void cmd_help_long_parsed(void *parsed_result, "show port tm node stats (port_id) (node_id) (clear)\n" " Display the port TM node stats.\n\n" -#if defined RTE_LIBRTE_PMD_SOFTNIC && defined RTE_LIBRTE_SCHED - "set port tm hierarchy default (port_id)\n" - " Set default traffic Management hierarchy on a port\n\n" -#endif - "add port tm node shaper profile (port_id) (shaper_profile_id)" " (cmit_tb_rate) (cmit_tb_size) (peak_tb_rate) (peak_tb_size)" - " (packet_length_adjust)\n" + " (packet_length_adjust) (packet_mode)\n" " Add port tm node private shaper profile.\n\n" "del port tm node shaper profile (port_id) (shaper_profile_id)\n" @@ -1221,6 +1115,12 @@ static void cmd_help_long_parsed(void *parsed_result, " [(shared_shaper_id_0) (shared_shaper_id_1)...]\n" " Add port tm nonleaf node.\n\n" + "add port tm nonleaf node pktmode (port_id) (node_id) (parent_node_id)" + " (priority) (weight) (level_id) (shaper_profile_id)" + " (n_sp_priorities) (stats_mask) (n_shared_shapers)" + " [(shared_shaper_id_0) (shared_shaper_id_1)...]\n" + " Add port tm nonleaf node with pkt mode enabled.\n\n" + "add port tm leaf node (port_id) (node_id) (parent_node_id)" " (priority) (weight) (level_id) (shaper_profile_id)" " (cman_mode) (wred_profile_id) (stats_mask) (n_shared_shapers)" @@ -1318,7 +1218,7 @@ static void cmd_operate_port_parsed(void *parsed_result, else if (!strcmp(res->name, "reset")) reset_port(RTE_PORT_ALL); else - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); } cmdline_parse_token_string_t cmd_operate_port_all_cmd = @@ -1333,7 +1233,7 @@ cmdline_parse_token_string_t cmd_operate_port_all_all = cmdline_parse_inst_t cmd_operate_port = { .f = cmd_operate_port_parsed, .data = NULL, - .help_str = "port start|stop|close all: Start/Stop/Close/Reset all ports", + .help_str = "port start|stop|close|reset all: Start/Stop/Close/Reset all ports", .tokens = { (void *)&cmd_operate_port_all_cmd, (void *)&cmd_operate_port_all_port, @@ -1364,7 +1264,7 @@ static void cmd_operate_specific_port_parsed(void *parsed_result, else if (!strcmp(res->name, "reset")) reset_port(res->value); else - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); } cmdline_parse_token_string_t cmd_operate_specific_port_cmd = @@ -1375,12 +1275,12 @@ cmdline_parse_token_string_t cmd_operate_specific_port_port = 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, .data = NULL, - .help_str = "port start|stop|close : Start/Stop/Close/Reset port_id", + .help_str = "port start|stop|close|reset : Start/Stop/Close/Reset port_id", .tokens = { (void *)&cmd_operate_specific_port_cmd, (void *)&cmd_operate_specific_port_port, @@ -1409,7 +1309,7 @@ static void cmd_set_port_setup_on_parsed(void *parsed_result, else if (strcmp(res->mode, "iterator") == 0) setup_on_probe_event = false; else - printf("Unknown mode\n"); + fprintf(stderr, "Unknown mode\n"); } cmdline_parse_token_string_t cmd_set_port_setup_on_set = @@ -1458,7 +1358,7 @@ static void cmd_operate_attach_port_parsed(void *parsed_result, if (!strcmp(res->keyword, "attach")) attach_port(res->identifier); else - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); } cmdline_parse_token_string_t cmd_operate_attach_port_port = @@ -1501,7 +1401,7 @@ static void cmd_operate_detach_port_parsed(void *parsed_result, RTE_ETH_VALID_PORTID_OR_RET(res->port_id); detach_port_device(res->port_id); } else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); } } @@ -1513,7 +1413,7 @@ cmdline_parse_token_string_t cmd_operate_detach_port_keyword = 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, @@ -1543,7 +1443,7 @@ static void cmd_operate_detach_device_parsed(void *parsed_result, if (!strcmp(res->keyword, "detach")) detach_devargs(res->identifier); else - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); } cmdline_parse_token_string_t cmd_operate_detach_device_device = @@ -1586,47 +1486,52 @@ parse_and_check_speed_duplex(char *speedstr, char *duplexstr, uint32_t *speed) int duplex; if (!strcmp(duplexstr, "half")) { - duplex = ETH_LINK_HALF_DUPLEX; + duplex = RTE_ETH_LINK_HALF_DUPLEX; } else if (!strcmp(duplexstr, "full")) { - duplex = ETH_LINK_FULL_DUPLEX; + duplex = RTE_ETH_LINK_FULL_DUPLEX; } else if (!strcmp(duplexstr, "auto")) { - duplex = ETH_LINK_FULL_DUPLEX; + duplex = RTE_ETH_LINK_FULL_DUPLEX; } else { - printf("Unknown duplex parameter\n"); + fprintf(stderr, "Unknown duplex parameter\n"); return -1; } if (!strcmp(speedstr, "10")) { - *speed = (duplex == ETH_LINK_HALF_DUPLEX) ? - ETH_LINK_SPEED_10M_HD : ETH_LINK_SPEED_10M; + *speed = (duplex == RTE_ETH_LINK_HALF_DUPLEX) ? + RTE_ETH_LINK_SPEED_10M_HD : RTE_ETH_LINK_SPEED_10M; } else if (!strcmp(speedstr, "100")) { - *speed = (duplex == ETH_LINK_HALF_DUPLEX) ? - ETH_LINK_SPEED_100M_HD : ETH_LINK_SPEED_100M; + *speed = (duplex == RTE_ETH_LINK_HALF_DUPLEX) ? + RTE_ETH_LINK_SPEED_100M_HD : RTE_ETH_LINK_SPEED_100M; } else { - if (duplex != ETH_LINK_FULL_DUPLEX) { - printf("Invalid speed/duplex parameters\n"); + if (duplex != RTE_ETH_LINK_FULL_DUPLEX) { + fprintf(stderr, "Invalid speed/duplex parameters\n"); return -1; } if (!strcmp(speedstr, "1000")) { - *speed = ETH_LINK_SPEED_1G; + *speed = RTE_ETH_LINK_SPEED_1G; } else if (!strcmp(speedstr, "10000")) { - *speed = ETH_LINK_SPEED_10G; + *speed = RTE_ETH_LINK_SPEED_10G; } else if (!strcmp(speedstr, "25000")) { - *speed = ETH_LINK_SPEED_25G; + *speed = RTE_ETH_LINK_SPEED_25G; } else if (!strcmp(speedstr, "40000")) { - *speed = ETH_LINK_SPEED_40G; + *speed = RTE_ETH_LINK_SPEED_40G; } else if (!strcmp(speedstr, "50000")) { - *speed = ETH_LINK_SPEED_50G; + *speed = RTE_ETH_LINK_SPEED_50G; } else if (!strcmp(speedstr, "100000")) { - *speed = ETH_LINK_SPEED_100G; + *speed = RTE_ETH_LINK_SPEED_100G; + } else if (!strcmp(speedstr, "200000")) { + *speed = RTE_ETH_LINK_SPEED_200G; } else if (!strcmp(speedstr, "auto")) { - *speed = ETH_LINK_SPEED_AUTONEG; + *speed = RTE_ETH_LINK_SPEED_AUTONEG; } else { - printf("Unknown speed parameter\n"); + fprintf(stderr, "Unknown speed parameter\n"); return -1; } } + if (*speed != RTE_ETH_LINK_SPEED_AUTONEG) + *speed |= RTE_ETH_LINK_SPEED_FIXED; + return 0; } @@ -1640,7 +1545,7 @@ cmd_config_speed_all_parsed(void *parsed_result, portid_t pid; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -1666,7 +1571,7 @@ cmdline_parse_token_string_t cmd_config_speed_all_item1 = TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, item1, "speed"); cmdline_parse_token_string_t cmd_config_speed_all_value1 = TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, value1, - "10#100#1000#10000#25000#40000#50000#100000#auto"); + "10#100#1000#10000#25000#40000#50000#100000#200000#auto"); cmdline_parse_token_string_t cmd_config_speed_all_item2 = TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, item2, "duplex"); cmdline_parse_token_string_t cmd_config_speed_all_value2 = @@ -1677,7 +1582,7 @@ cmdline_parse_inst_t cmd_config_speed_all = { .f = cmd_config_speed_all_parsed, .data = NULL, .help_str = "port config all speed " - "10|100|1000|10000|25000|40000|50000|100000|auto duplex " + "10|100|1000|10000|25000|40000|50000|100000|200000|auto duplex " "half|full|auto", .tokens = { (void *)&cmd_config_speed_all_port, @@ -1710,13 +1615,13 @@ cmd_config_speed_specific_parsed(void *parsed_result, struct cmd_config_speed_specific *res = parsed_result; uint32_t link_speed; - if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + if (port_id_is_invalid(res->id, ENABLED_WARN)) return; - } - if (port_id_is_invalid(res->id, ENABLED_WARN)) + if (!port_is_stopped(res->id)) { + fprintf(stderr, "Please stop port %d first\n", res->id); return; + } if (parse_and_check_speed_duplex(res->value1, res->value2, &link_speed) < 0) @@ -1735,13 +1640,13 @@ cmdline_parse_token_string_t cmd_config_speed_specific_keyword = 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"); cmdline_parse_token_string_t cmd_config_speed_specific_value1 = TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, value1, - "10#100#1000#10000#25000#40000#50000#100000#auto"); + "10#100#1000#10000#25000#40000#50000#100000#200000#auto"); cmdline_parse_token_string_t cmd_config_speed_specific_item2 = TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item2, "duplex"); @@ -1753,7 +1658,7 @@ cmdline_parse_inst_t cmd_config_speed_specific = { .f = cmd_config_speed_specific_parsed, .data = NULL, .help_str = "port config speed " - "10|100|1000|10000|25000|40000|50000|100000|auto duplex " + "10|100|1000|10000|25000|40000|50000|100000|200000|auto duplex " "half|full|auto", .tokens = { (void *)&cmd_config_speed_specific_port, @@ -1785,7 +1690,7 @@ cmd_config_loopback_all_parsed(void *parsed_result, portid_t pid; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -1807,7 +1712,7 @@ cmdline_parse_token_string_t cmd_config_loopback_all_item = 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, @@ -1843,7 +1748,7 @@ cmd_config_loopback_specific_parsed(void *parsed_result, return; if (!port_is_stopped(res->port_id)) { - printf("Please stop port %u first\n", res->port_id); + fprintf(stderr, "Please stop port %u first\n", res->port_id); return; } @@ -1861,13 +1766,13 @@ cmdline_parse_token_string_t cmd_config_loopback_specific_keyword = "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, @@ -1900,12 +1805,12 @@ cmd_config_rx_tx_parsed(void *parsed_result, struct cmd_config_rx_tx *res = parsed_result; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } if (!strcmp(res->name, "rxq")) { if (!res->value && !nb_txq) { - printf("Warning: Either rx or tx queues should be non zero\n"); + fprintf(stderr, "Warning: Either rx or tx queues should be non zero\n"); return; } if (check_nb_rxq(res->value) != 0) @@ -1914,7 +1819,7 @@ cmd_config_rx_tx_parsed(void *parsed_result, } else if (!strcmp(res->name, "txq")) { if (!res->value && !nb_rxq) { - printf("Warning: Either rx or tx queues should be non zero\n"); + fprintf(stderr, "Warning: Either rx or tx queues should be non zero\n"); return; } if (check_nb_txq(res->value) != 0) @@ -1931,7 +1836,7 @@ cmd_config_rx_tx_parsed(void *parsed_result, nb_txd = res->value; } else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -1952,7 +1857,7 @@ cmdline_parse_token_string_t cmd_config_rx_tx_name = 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, @@ -1983,36 +1888,38 @@ cmd_config_max_pkt_len_parsed(void *parsed_result, __rte_unused void *data) { struct cmd_config_max_pkt_len_result *res = parsed_result; - portid_t pid; + portid_t port_id; + int ret; + + if (strcmp(res->name, "max-pkt-len") != 0) { + printf("Unknown parameter\n"); + return; + } if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } - RTE_ETH_FOREACH_DEV(pid) { - struct rte_port *port = &ports[pid]; - uint64_t rx_offloads = port->dev_conf.rxmode.offloads; + RTE_ETH_FOREACH_DEV(port_id) { + struct rte_port *port = &ports[port_id]; - if (!strcmp(res->name, "max-pkt-len")) { - if (res->value < RTE_ETHER_MIN_LEN) { - printf("max-pkt-len can not be less than %d\n", - RTE_ETHER_MIN_LEN); - return; - } - if (res->value == port->dev_conf.rxmode.max_rx_pkt_len) - return; + if (res->value < RTE_ETHER_MIN_LEN) { + fprintf(stderr, + "max-pkt-len can not be less than %d\n", + RTE_ETHER_MIN_LEN); + return; + } - 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; - } else { - printf("Unknown parameter\n"); + ret = eth_dev_info_get_print_err(port_id, &port->dev_info); + if (ret != 0) { + fprintf(stderr, + "rte_eth_dev_info_get() failed for port %u\n", + port_id); return; } + + update_mtu_from_frame_size(port_id, res->value); } init_port_config(); @@ -2034,7 +1941,7 @@ cmdline_parse_token_string_t cmd_config_max_pkt_len_name = "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, @@ -2068,7 +1975,7 @@ cmd_config_max_lro_pkt_size_parsed(void *parsed_result, portid_t pid; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -2082,7 +1989,7 @@ cmd_config_max_lro_pkt_size_parsed(void *parsed_result, port->dev_conf.rxmode.max_lro_pkt_size = res->value; } else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } } @@ -2106,7 +2013,7 @@ cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_name = 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, @@ -2139,7 +2046,7 @@ cmd_config_mtu_parsed(void *parsed_result, struct cmd_config_mtu_result *res = parsed_result; if (res->value < RTE_ETHER_MIN_LEN) { - printf("mtu cannot be less than %d\n", RTE_ETHER_MIN_LEN); + fprintf(stderr, "mtu cannot be less than %d\n", RTE_ETHER_MIN_LEN); return; } port_mtu_set(res->port_id, res->value); @@ -2155,9 +2062,11 @@ cmdline_parse_token_string_t cmd_config_mtu_mtu = 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, @@ -2190,7 +2099,7 @@ cmd_config_rx_mode_flag_parsed(void *parsed_result, struct cmd_config_rx_mode_flag *res = parsed_result; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -2200,11 +2109,11 @@ cmd_config_rx_mode_flag_parsed(void *parsed_result, else if (!strcmp(res->value, "off")) rx_drop_en = 0; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } } else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -2265,61 +2174,93 @@ cmd_config_rss_parsed(void *parsed_result, int ret; if (!strcmp(res->value, "all")) - 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; + rss_conf.rss_hf = RTE_ETH_RSS_ETH | RTE_ETH_RSS_VLAN | RTE_ETH_RSS_IP | + RTE_ETH_RSS_TCP | RTE_ETH_RSS_UDP | RTE_ETH_RSS_SCTP | + RTE_ETH_RSS_L2_PAYLOAD | RTE_ETH_RSS_L2TPV3 | RTE_ETH_RSS_ESP | + RTE_ETH_RSS_AH | RTE_ETH_RSS_PFCP | RTE_ETH_RSS_GTPU | + RTE_ETH_RSS_ECPRI; else if (!strcmp(res->value, "eth")) - rss_conf.rss_hf = ETH_RSS_ETH; + rss_conf.rss_hf = RTE_ETH_RSS_ETH; else if (!strcmp(res->value, "vlan")) - rss_conf.rss_hf = ETH_RSS_VLAN; + rss_conf.rss_hf = RTE_ETH_RSS_VLAN; else if (!strcmp(res->value, "ip")) - rss_conf.rss_hf = ETH_RSS_IP; + rss_conf.rss_hf = RTE_ETH_RSS_IP; else if (!strcmp(res->value, "udp")) - rss_conf.rss_hf = ETH_RSS_UDP; + rss_conf.rss_hf = RTE_ETH_RSS_UDP; else if (!strcmp(res->value, "tcp")) - rss_conf.rss_hf = ETH_RSS_TCP; + rss_conf.rss_hf = RTE_ETH_RSS_TCP; else if (!strcmp(res->value, "sctp")) - rss_conf.rss_hf = ETH_RSS_SCTP; + rss_conf.rss_hf = RTE_ETH_RSS_SCTP; else if (!strcmp(res->value, "ether")) - rss_conf.rss_hf = ETH_RSS_L2_PAYLOAD; + rss_conf.rss_hf = RTE_ETH_RSS_L2_PAYLOAD; else if (!strcmp(res->value, "port")) - rss_conf.rss_hf = ETH_RSS_PORT; + rss_conf.rss_hf = RTE_ETH_RSS_PORT; else if (!strcmp(res->value, "vxlan")) - rss_conf.rss_hf = ETH_RSS_VXLAN; + rss_conf.rss_hf = RTE_ETH_RSS_VXLAN; else if (!strcmp(res->value, "geneve")) - rss_conf.rss_hf = ETH_RSS_GENEVE; + rss_conf.rss_hf = RTE_ETH_RSS_GENEVE; else if (!strcmp(res->value, "nvgre")) - rss_conf.rss_hf = ETH_RSS_NVGRE; + rss_conf.rss_hf = RTE_ETH_RSS_NVGRE; + else if (!strcmp(res->value, "l3-pre32")) + rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE32; + else if (!strcmp(res->value, "l3-pre40")) + rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE40; + else if (!strcmp(res->value, "l3-pre48")) + rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE48; + else if (!strcmp(res->value, "l3-pre56")) + rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE56; + else if (!strcmp(res->value, "l3-pre64")) + rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE64; + else if (!strcmp(res->value, "l3-pre96")) + rss_conf.rss_hf = RTE_ETH_RSS_L3_PRE96; else if (!strcmp(res->value, "l3-src-only")) - rss_conf.rss_hf = ETH_RSS_L3_SRC_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L3_SRC_ONLY; else if (!strcmp(res->value, "l3-dst-only")) - rss_conf.rss_hf = ETH_RSS_L3_DST_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L3_DST_ONLY; else if (!strcmp(res->value, "l4-src-only")) - rss_conf.rss_hf = ETH_RSS_L4_SRC_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L4_SRC_ONLY; else if (!strcmp(res->value, "l4-dst-only")) - rss_conf.rss_hf = ETH_RSS_L4_DST_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L4_DST_ONLY; else if (!strcmp(res->value, "l2-src-only")) - rss_conf.rss_hf = ETH_RSS_L2_SRC_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L2_SRC_ONLY; else if (!strcmp(res->value, "l2-dst-only")) - rss_conf.rss_hf = ETH_RSS_L2_DST_ONLY; + rss_conf.rss_hf = RTE_ETH_RSS_L2_DST_ONLY; else if (!strcmp(res->value, "l2tpv3")) - rss_conf.rss_hf = ETH_RSS_L2TPV3; + rss_conf.rss_hf = RTE_ETH_RSS_L2TPV3; else if (!strcmp(res->value, "esp")) - rss_conf.rss_hf = ETH_RSS_ESP; + rss_conf.rss_hf = RTE_ETH_RSS_ESP; else if (!strcmp(res->value, "ah")) - rss_conf.rss_hf = ETH_RSS_AH; + rss_conf.rss_hf = RTE_ETH_RSS_AH; else if (!strcmp(res->value, "pfcp")) - rss_conf.rss_hf = ETH_RSS_PFCP; + rss_conf.rss_hf = RTE_ETH_RSS_PFCP; + else if (!strcmp(res->value, "pppoe")) + rss_conf.rss_hf = RTE_ETH_RSS_PPPOE; + else if (!strcmp(res->value, "gtpu")) + rss_conf.rss_hf = RTE_ETH_RSS_GTPU; + else if (!strcmp(res->value, "ecpri")) + rss_conf.rss_hf = RTE_ETH_RSS_ECPRI; + else if (!strcmp(res->value, "mpls")) + rss_conf.rss_hf = RTE_ETH_RSS_MPLS; + else if (!strcmp(res->value, "ipv4-chksum")) + rss_conf.rss_hf = RTE_ETH_RSS_IPV4_CHKSUM; else if (!strcmp(res->value, "none")) rss_conf.rss_hf = 0; - else if (!strcmp(res->value, "default")) + else if (!strcmp(res->value, "level-default")) { + rss_hf &= (~RTE_ETH_RSS_LEVEL_MASK); + rss_conf.rss_hf = (rss_hf | RTE_ETH_RSS_LEVEL_PMD_DEFAULT); + } else if (!strcmp(res->value, "level-outer")) { + rss_hf &= (~RTE_ETH_RSS_LEVEL_MASK); + rss_conf.rss_hf = (rss_hf | RTE_ETH_RSS_LEVEL_OUTERMOST); + } else if (!strcmp(res->value, "level-inner")) { + rss_hf &= (~RTE_ETH_RSS_LEVEL_MASK); + rss_conf.rss_hf = (rss_hf | RTE_ETH_RSS_LEVEL_INNERMOST); + } else if (!strcmp(res->value, "default")) use_default = 1; else if (isdigit(res->value[0]) && atoi(res->value) > 0 && atoi(res->value) < 64) rss_conf.rss_hf = 1ULL << atoi(res->value); else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } rss_conf.rss_key = NULL; @@ -2345,8 +2286,8 @@ cmd_config_rss_parsed(void *parsed_result, diag = rte_eth_dev_rss_hash_update(i, &local_rss_conf); if (diag < 0) { all_updated = 0; - printf("Configuration of RSS hash at ethernet port %d " - "failed with error (%d): %s.\n", + fprintf(stderr, + "Configuration of RSS hash at ethernet port %d failed with error (%d): %s.\n", i, -diag, strerror(-diag)); } } @@ -2372,7 +2313,8 @@ cmdline_parse_inst_t cmd_config_rss = { .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|", + "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|ecpri|mpls|none|level-default|" + "level-outer|level-inner|ipv4-chksum|", .tokens = { (void *)&cmd_config_rss_port, (void *)&cmd_config_rss_keyword, @@ -2413,8 +2355,9 @@ parse_and_check_key_hexa_digit(char *key, int idx) hexa_v = hexa_digit_to_value(key[idx]); if (hexa_v == 0xFF) - printf("invalid key: character %c at position %d is not a " - "valid hexa digit\n", key[idx], idx); + fprintf(stderr, + "invalid key: character %c at position %d is not a valid hexa digit\n", + key[idx], idx); return hexa_v; } @@ -2441,15 +2384,16 @@ cmd_config_rss_hash_key_parsed(void *parsed_result, dev_info.hash_key_size <= sizeof(hash_key)) hash_key_size = dev_info.hash_key_size; else { - printf("dev_info did not provide a valid hash key size\n"); + fprintf(stderr, + "dev_info did not provide a valid hash key size\n"); return; } /* Check the length of the RSS hash key */ key_len = strlen(res->key); if (key_len != (hash_key_size * 2)) { - printf("key length: %d invalid - key must be a string of %d" - " hexa-decimal numbers\n", - (int) key_len, hash_key_size * 2); + fprintf(stderr, + "key length: %d invalid - key must be a string of %d hexa-decimal numbers\n", + (int)key_len, hash_key_size * 2); return; } /* Translate RSS hash key into binary representation */ @@ -2472,7 +2416,8 @@ cmdline_parse_token_string_t cmd_config_rss_hash_key_config = 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"); @@ -2484,7 +2429,7 @@ cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_type = "ipv6-tcp-ex#ipv6-udp-ex#" "l3-src-only#l3-dst-only#l4-src-only#l4-dst-only#" "l2-src-only#l2-dst-only#s-vlan#c-vlan#" - "l2tpv3#esp#ah#pfcp"); + "l2tpv3#esp#ah#pfcp#pppoe#gtpu#ecpri#mpls"); cmdline_parse_token_string_t cmd_config_rss_hash_key_value = TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, key, NULL); @@ -2497,7 +2442,7 @@ cmdline_parse_inst_t cmd_config_rss_hash_key = { "l2-payload|ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex|" "l3-src-only|l3-dst-only|l4-src-only|l4-dst-only|" "l2-src-only|l2-dst-only|s-vlan|c-vlan|" - "l2tpv3|esp|ah|pfcp " + "l2tpv3|esp|ah|pfcp|pppoe|gtpu|ecpri|mpls " "", .tokens = { (void *)&cmd_config_rss_hash_key_port, @@ -2510,6 +2455,90 @@ cmdline_parse_inst_t cmd_config_rss_hash_key = { }, }; +/* *** cleanup txq mbufs *** */ +struct cmd_cleanup_txq_mbufs_result { + cmdline_fixed_string_t port; + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t name; + uint16_t port_id; + uint16_t queue_id; + uint32_t free_cnt; +}; + +static void +cmd_cleanup_txq_mbufs_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_cleanup_txq_mbufs_result *res = parsed_result; + uint16_t port_id = res->port_id; + uint16_t queue_id = res->queue_id; + uint32_t free_cnt = res->free_cnt; + struct rte_eth_txq_info qinfo; + int ret; + + if (test_done == 0) { + fprintf(stderr, "Please stop forwarding first\n"); + return; + } + + if (rte_eth_tx_queue_info_get(port_id, queue_id, &qinfo)) { + fprintf(stderr, "Failed to get port %u Tx queue %u info\n", + port_id, queue_id); + return; + } + + if (qinfo.queue_state != RTE_ETH_QUEUE_STATE_STARTED) { + fprintf(stderr, "Tx queue %u not started\n", queue_id); + return; + } + + ret = rte_eth_tx_done_cleanup(port_id, queue_id, free_cnt); + if (ret < 0) { + fprintf(stderr, + "Failed to cleanup mbuf for port %u Tx queue %u error desc: %s(%d)\n", + port_id, queue_id, strerror(-ret), ret); + return; + } + + printf("Cleanup port %u Tx queue %u mbuf nums: %u\n", + port_id, queue_id, ret); +} + +cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_port = + TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, port, + "port"); +cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_cleanup = + TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, keyword, + "cleanup"); +cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_port_id = + TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, port_id, + RTE_UINT16); +cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_txq = + TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, name, + "txq"); +cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_queue_id = + TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, queue_id, + RTE_UINT16); +cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_free_cnt = + TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, free_cnt, + RTE_UINT32); + +cmdline_parse_inst_t cmd_cleanup_txq_mbufs = { + .f = cmd_cleanup_txq_mbufs_parsed, + .data = NULL, + .help_str = "port cleanup txq ", + .tokens = { + (void *)&cmd_cleanup_txq_mbufs_port, + (void *)&cmd_cleanup_txq_mbufs_cleanup, + (void *)&cmd_cleanup_txq_mbufs_port_id, + (void *)&cmd_cleanup_txq_mbufs_txq, + (void *)&cmd_cleanup_txq_mbufs_queue_id, + (void *)&cmd_cleanup_txq_mbufs_free_cnt, + NULL, + }, +}; + /* *** configure port rxq/txq ring size *** */ struct cmd_config_rxtx_ring_size { cmdline_fixed_string_t port; @@ -2534,7 +2563,7 @@ cmd_config_rxtx_ring_size_parsed(void *parsed_result, return; if (res->portid == (portid_t)RTE_PORT_ALL) { - printf("Invalid port id\n"); + fprintf(stderr, "Invalid port id\n"); return; } @@ -2545,7 +2574,7 @@ cmd_config_rxtx_ring_size_parsed(void *parsed_result, else if (!strcmp(res->rxtxq, "txq")) isrx = 0; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -2555,8 +2584,9 @@ cmd_config_rxtx_ring_size_parsed(void *parsed_result, return; if (isrx && res->size != 0 && res->size <= rx_free_thresh) { - printf("Invalid rx ring_size, must > rx_free_thresh: %d\n", - rx_free_thresh); + fprintf(stderr, + "Invalid rx ring_size, must > rx_free_thresh: %d\n", + rx_free_thresh); return; } @@ -2576,19 +2606,19 @@ cmdline_parse_token_string_t cmd_config_rxtx_ring_size_config = 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, @@ -2626,7 +2656,7 @@ cmd_config_rxtx_queue_parsed(void *parsed_result, int ret = 0; if (test_done == 0) { - printf("Please stop forwarding first\n"); + fprintf(stderr, "Please stop forwarding first\n"); return; } @@ -2634,7 +2664,7 @@ cmd_config_rxtx_queue_parsed(void *parsed_result, return; if (port_is_started(res->portid) != 1) { - printf("Please start port %u first\n", res->portid); + fprintf(stderr, "Please start port %u first\n", res->portid); return; } @@ -2643,7 +2673,7 @@ cmd_config_rxtx_queue_parsed(void *parsed_result, else if (!strcmp(res->rxtxq, "txq")) isrx = 0; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -2657,7 +2687,7 @@ cmd_config_rxtx_queue_parsed(void *parsed_result, else if (!strcmp(res->opname, "stop")) isstart = 0; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -2671,17 +2701,17 @@ cmd_config_rxtx_queue_parsed(void *parsed_result, ret = rte_eth_dev_tx_queue_stop(res->portid, res->qid); if (ret == -ENOTSUP) - printf("Function not supported in PMD driver\n"); + fprintf(stderr, "Function not supported in PMD driver\n"); } 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"); @@ -2725,7 +2755,7 @@ cmd_config_deferred_start_rxtx_queue_parsed(void *parsed_result, return; if (port_is_started(res->port_id) != 0) { - printf("Please stop port %u first\n", res->port_id); + fprintf(stderr, "Please stop port %u first\n", res->port_id); return; } @@ -2757,13 +2787,13 @@ cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_port = 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"); @@ -2799,11 +2829,11 @@ struct cmd_setup_rxtx_queue { 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"); @@ -2824,7 +2854,7 @@ cmd_setup_rxtx_queue_parsed( return; if (res->portid == (portid_t)RTE_PORT_ALL) { - printf("Invalid port id\n"); + fprintf(stderr, "Invalid port id\n"); return; } @@ -2833,15 +2863,15 @@ cmd_setup_rxtx_queue_parsed( else if (!strcmp(res->rxtxq, "txq")) isrx = 0; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } if (isrx && rx_queue_id_is_invalid(res->qid)) { - printf("Invalid rx queue\n"); + fprintf(stderr, "Invalid rx queue\n"); return; } else if (!isrx && tx_queue_id_is_invalid(res->qid)) { - printf("Invalid tx queue\n"); + fprintf(stderr, "Invalid tx queue\n"); return; } @@ -2851,34 +2881,38 @@ cmd_setup_rxtx_queue_parsed( if (!numa_support || socket_id == NUMA_NO_CONFIG) socket_id = port->socket_id; - mp = mbuf_pool_find(socket_id); + mp = mbuf_pool_find(socket_id, 0); if (mp == NULL) { - printf("Failed to setup RX queue: " - "No mempool allocation" - " on the socket %d\n", + fprintf(stderr, + "Failed to setup RX queue: No mempool allocation on the socket %d\n", rxring_numa[res->portid]); return; } - ret = rte_eth_rx_queue_setup(res->portid, - res->qid, - port->nb_rx_desc[res->qid], - socket_id, - &port->rx_conf[res->qid], - mp); + ret = rx_queue_setup(res->portid, + res->qid, + port->nb_rx_desc[res->qid], + socket_id, + &port->rx_conf[res->qid], + mp); if (ret) - printf("Failed to setup RX queue\n"); + fprintf(stderr, "Failed to setup RX queue\n"); } else { socket_id = txring_numa[res->portid]; if (!numa_support || socket_id == NUMA_NO_CONFIG) socket_id = port->socket_id; + if (port->nb_tx_desc[res->qid] < tx_pkt_nb_segs) { + fprintf(stderr, + "Failed to setup TX queue: not enough descriptors\n"); + return; + } ret = rte_eth_tx_queue_setup(res->portid, res->qid, port->nb_tx_desc[res->qid], socket_id, &port->tx_conf[res->qid]); if (ret) - printf("Failed to setup TX queue\n"); + fprintf(stderr, "Failed to setup TX queue\n"); } } @@ -2951,12 +2985,13 @@ parse_reta_config(const char *str, nb_queue = (uint16_t)int_fld[FLD_QUEUE]; if (hash_index >= nb_entries) { - printf("Invalid RETA hash index=%d\n", hash_index); + fprintf(stderr, "Invalid RETA hash index=%d\n", + hash_index); return -1; } - idx = hash_index / RTE_RETA_GROUP_SIZE; - shift = hash_index % RTE_RETA_GROUP_SIZE; + idx = hash_index / RTE_ETH_RETA_GROUP_SIZE; + shift = hash_index % RTE_ETH_RETA_GROUP_SIZE; reta_conf[idx].mask |= (1ULL << shift); reta_conf[idx].reta[shift] = nb_queue; } @@ -2979,15 +3014,16 @@ cmd_set_rss_reta_parsed(void *parsed_result, return; if (dev_info.reta_size == 0) { - printf("Redirection table size is 0 which is " - "invalid for RSS\n"); + fprintf(stderr, + "Redirection table size is 0 which is invalid for RSS\n"); return; } else printf("The reta size of port %d is %u\n", res->port_id, dev_info.reta_size); - if (dev_info.reta_size > ETH_RSS_RETA_SIZE_512) { - printf("Currently do not support more than %u entries of " - "redirection table\n", ETH_RSS_RETA_SIZE_512); + if (dev_info.reta_size > RTE_ETH_RSS_RETA_SIZE_512) { + fprintf(stderr, + "Currently do not support more than %u entries of redirection table\n", + RTE_ETH_RSS_RETA_SIZE_512); return; } @@ -2995,15 +3031,16 @@ cmd_set_rss_reta_parsed(void *parsed_result, if (!strcmp(res->list_name, "reta")) { if (parse_reta_config(res->list_of_items, reta_conf, dev_info.reta_size)) { - printf("Invalid RSS Redirection Table " - "config entered\n"); + fprintf(stderr, + "Invalid RSS Redirection Table config entered\n"); return; } ret = rte_eth_dev_rss_reta_update(res->port_id, reta_conf, dev_info.reta_size); if (ret != 0) - printf("Bad redirection table parameter, " - "return code = %d \n", ret); + fprintf(stderr, + "Bad redirection table parameter, return code = %d\n", + ret); } } @@ -3012,7 +3049,7 @@ cmdline_parse_token_string_t cmd_config_rss_reta_port = 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 = @@ -3057,8 +3094,8 @@ showport_parse_reta_config(struct rte_eth_rss_reta_entry64 *conf, char *end; char *str_fld[8]; uint16_t i; - uint16_t num = (nb_entries + RTE_RETA_GROUP_SIZE - 1) / - RTE_RETA_GROUP_SIZE; + uint16_t num = (nb_entries + RTE_ETH_RETA_GROUP_SIZE - 1) / + RTE_ETH_RETA_GROUP_SIZE; int ret; p = strchr(p0, '('); @@ -3070,14 +3107,16 @@ showport_parse_reta_config(struct rte_eth_rss_reta_entry64 *conf, return -1; size = p0 - p; if (size >= sizeof(s)) { - printf("The string size exceeds the internal buffer size\n"); + fprintf(stderr, + "The string size exceeds the internal buffer size\n"); return -1; } snprintf(s, sizeof(s), "%.*s", size, p); ret = rte_strsplit(s, sizeof(s), str_fld, num, ','); if (ret <= 0 || ret != num) { - printf("The bits of masks do not match the number of " - "reta entries: %u\n", num); + fprintf(stderr, + "The bits of masks do not match the number of reta entries: %u\n", + num); return -1; } for (i = 0; i < ret; i++) @@ -3101,9 +3140,9 @@ cmd_showport_reta_parsed(void *parsed_result, if (ret != 0) return; - max_reta_size = RTE_MIN(dev_info.reta_size, ETH_RSS_RETA_SIZE_512); + max_reta_size = RTE_MIN(dev_info.reta_size, RTE_ETH_RSS_RETA_SIZE_512); if (res->size == 0 || res->size > max_reta_size) { - printf("Invalid redirection table size: %u (1-%u)\n", + fprintf(stderr, "Invalid redirection table size: %u (1-%u)\n", res->size, max_reta_size); return; } @@ -3111,8 +3150,8 @@ cmd_showport_reta_parsed(void *parsed_result, memset(reta_conf, 0, sizeof(reta_conf)); if (showport_parse_reta_config(reta_conf, res->size, res->list_of_items) < 0) { - printf("Invalid string: %s for reta masks\n", - res->list_of_items); + fprintf(stderr, "Invalid string: %s for reta masks\n", + res->list_of_items); return; } port_rss_reta_info(res->port_id, reta_conf, res->size); @@ -3123,13 +3162,13 @@ cmdline_parse_token_string_t cmd_showport_reta_show = 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); @@ -3174,7 +3213,8 @@ cmdline_parse_token_string_t cmd_showport_rss_hash_show = 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"); @@ -3227,6 +3267,7 @@ cmd_config_dcb_parsed(void *parsed_result, __rte_unused void *data) { struct cmd_config_dcb *res = parsed_result; + struct rte_eth_dcb_info dcb_info; portid_t port_id = res->port_id; struct rte_port *port; uint8_t pfc_en; @@ -3235,20 +3276,29 @@ cmd_config_dcb_parsed(void *parsed_result, port = &ports[port_id]; /** Check if the port is not started **/ if (port->port_status != RTE_PORT_STOPPED) { - printf("Please stop port %d first\n", port_id); + fprintf(stderr, "Please stop port %d first\n", port_id); return; } - if ((res->num_tcs != ETH_4_TCS) && (res->num_tcs != ETH_8_TCS)) { - printf("The invalid number of traffic class," - " only 4 or 8 allowed.\n"); + if ((res->num_tcs != RTE_ETH_4_TCS) && (res->num_tcs != RTE_ETH_8_TCS)) { + fprintf(stderr, + "The invalid number of traffic class, only 4 or 8 allowed.\n"); return; } if (nb_fwd_lcores < res->num_tcs) { - printf("nb_cores shouldn't be less than number of TCs.\n"); + fprintf(stderr, + "nb_cores shouldn't be less than number of TCs.\n"); + return; + } + + /* Check whether the port supports the report of DCB info. */ + ret = rte_eth_dev_get_dcb_info(port_id, &dcb_info); + if (ret == -ENOTSUP) { + fprintf(stderr, "rte_eth_dev_get_dcb_info not supported.\n"); return; } + if (!strncmp(res->pfc_en, "on", 2)) pfc_en = 1; else @@ -3263,13 +3313,13 @@ cmd_config_dcb_parsed(void *parsed_result, ret = init_port_dcb_config(port_id, DCB_ENABLED, (enum rte_eth_nb_tcs)res->num_tcs, pfc_en); - - if (ret != 0) { - printf("Cannot initialize network ports.\n"); + fprintf(stderr, "Cannot initialize network ports.\n"); return; } + fwd_config_setup(); + cmd_reconfig_device_queue(port_id, 1, 1); } @@ -3278,7 +3328,7 @@ cmdline_parse_token_string_t cmd_config_dcb_port = 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 = @@ -3286,7 +3336,7 @@ 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 = @@ -3330,7 +3380,7 @@ cmd_config_burst_parsed(void *parsed_result, int ret; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -3362,12 +3412,13 @@ cmd_config_burst_parsed(void *parsed_result, rec_nb_pkts); nb_pkt_per_burst = rec_nb_pkts; } else if (res->value > MAX_PKT_BURST) { - printf("burst must be >= 1 && <= %d\n", MAX_PKT_BURST); + fprintf(stderr, "burst must be >= 1 && <= %d\n", + MAX_PKT_BURST); return; } else nb_pkt_per_burst = res->value; } else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -3385,7 +3436,7 @@ cmdline_parse_token_string_t cmd_config_burst_all = 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, @@ -3418,7 +3469,7 @@ cmd_config_thresh_parsed(void *parsed_result, struct cmd_config_thresh *res = parsed_result; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -3435,7 +3486,7 @@ cmd_config_thresh_parsed(void *parsed_result, else if(!strcmp(res->name, "rxwt")) rx_wthresh = res->value; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -3454,7 +3505,7 @@ cmdline_parse_token_string_t cmd_config_thresh_name = 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, @@ -3487,7 +3538,7 @@ cmd_config_threshold_parsed(void *parsed_result, struct cmd_config_threshold *res = parsed_result; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -3498,7 +3549,7 @@ cmd_config_threshold_parsed(void *parsed_result, else if (!strcmp(res->name, "rxfreet")) rx_free_thresh = res->value; else { - printf("Unknown parameter\n"); + fprintf(stderr, "Unknown parameter\n"); return; } @@ -3518,7 +3569,7 @@ cmdline_parse_token_string_t cmd_config_threshold_name = 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, @@ -3562,7 +3613,7 @@ cmdline_parse_inst_t cmd_stop = { /* *** SET CORELIST and PORTLIST CONFIGURATION *** */ unsigned int -parse_item_list(char* str, const char* item_name, unsigned int max_items, +parse_item_list(const char *str, const char *item_name, unsigned int max_items, unsigned int *parsed_items, int check_unique_values) { unsigned int nb_item; @@ -3586,11 +3637,11 @@ parse_item_list(char* str, const char* item_name, unsigned int max_items, continue; } if (c != ',') { - printf("character %c is not a decimal digit\n", c); + fprintf(stderr, "character %c is not a decimal digit\n", c); return 0; } if (! value_ok) { - printf("No valid value before comma\n"); + fprintf(stderr, "No valid value before comma\n"); return 0; } if (nb_item < max_items) { @@ -3601,8 +3652,8 @@ parse_item_list(char* str, const char* item_name, unsigned int max_items, nb_item++; } if (nb_item >= max_items) { - printf("Number of %s = %u > %u (maximum items)\n", - item_name, nb_item + 1, max_items); + fprintf(stderr, "Number of %s = %u > %u (maximum items)\n", + item_name, nb_item + 1, max_items); return 0; } parsed_items[nb_item++] = value; @@ -3610,14 +3661,15 @@ parse_item_list(char* str, const char* item_name, unsigned int max_items, return nb_item; /* - * Then, check that all values in the list are differents. + * Then, check that all values in the list are different. * No optimization here... */ for (i = 0; i < nb_item; i++) { for (j = i + 1; j < nb_item; j++) { if (parsed_items[j] == parsed_items[i]) { - printf("duplicated %s %u at index %u and %u\n", - item_name, parsed_items[i], i, j); + fprintf(stderr, + "duplicated %s %u at index %u and %u\n", + item_name, parsed_items[i], i, j); return 0; } } @@ -3643,7 +3695,7 @@ static void cmd_set_list_parsed(void *parsed_result, unsigned int nb_item; if (test_done == 0) { - printf("Please stop forwarding first\n"); + fprintf(stderr, "Please stop forwarding first\n"); return; } @@ -3706,7 +3758,7 @@ static void cmd_set_mask_parsed(void *parsed_result, struct cmd_setmask_result *res = parsed_result; if (test_done == 0) { - printf("Please stop forwarding first\n"); + fprintf(stderr, "Please stop forwarding first\n"); return; } if (!strcmp(res->mask, "coremask")) { @@ -3724,7 +3776,7 @@ cmdline_parse_token_string_t cmd_setmask_mask = 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, @@ -3770,7 +3822,7 @@ cmdline_parse_token_string_t cmd_set_what = 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, @@ -3807,7 +3859,7 @@ cmd_set_log_parsed(void *parsed_result, else { ret = rte_log_set_level_regexp(res->type, res->level); if (ret < 0) - printf("Unable to set log level\n"); + fprintf(stderr, "Unable to set log level\n"); } } @@ -3818,7 +3870,7 @@ cmdline_parse_token_string_t cmd_set_log_log = 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, @@ -3833,6 +3885,100 @@ cmdline_parse_inst_t cmd_set_log = { }, }; +/* *** SET SEGMENT OFFSETS OF RX PACKETS SPLIT *** */ + +struct cmd_set_rxoffs_result { + cmdline_fixed_string_t cmd_keyword; + cmdline_fixed_string_t rxoffs; + cmdline_fixed_string_t seg_offsets; +}; + +static void +cmd_set_rxoffs_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_set_rxoffs_result *res; + unsigned int seg_offsets[MAX_SEGS_BUFFER_SPLIT]; + unsigned int nb_segs; + + res = parsed_result; + nb_segs = parse_item_list(res->seg_offsets, "segment offsets", + MAX_SEGS_BUFFER_SPLIT, seg_offsets, 0); + if (nb_segs > 0) + set_rx_pkt_offsets(seg_offsets, nb_segs); + cmd_reconfig_device_queue(RTE_PORT_ALL, 0, 1); +} + +cmdline_parse_token_string_t cmd_set_rxoffs_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result, + cmd_keyword, "set"); +cmdline_parse_token_string_t cmd_set_rxoffs_name = + TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result, + rxoffs, "rxoffs"); +cmdline_parse_token_string_t cmd_set_rxoffs_offsets = + TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result, + seg_offsets, NULL); + +cmdline_parse_inst_t cmd_set_rxoffs = { + .f = cmd_set_rxoffs_parsed, + .data = NULL, + .help_str = "set rxoffs ", + .tokens = { + (void *)&cmd_set_rxoffs_keyword, + (void *)&cmd_set_rxoffs_name, + (void *)&cmd_set_rxoffs_offsets, + NULL, + }, +}; + +/* *** SET SEGMENT LENGTHS OF RX PACKETS SPLIT *** */ + +struct cmd_set_rxpkts_result { + cmdline_fixed_string_t cmd_keyword; + cmdline_fixed_string_t rxpkts; + cmdline_fixed_string_t seg_lengths; +}; + +static void +cmd_set_rxpkts_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_set_rxpkts_result *res; + unsigned int seg_lengths[MAX_SEGS_BUFFER_SPLIT]; + unsigned int nb_segs; + + res = parsed_result; + nb_segs = parse_item_list(res->seg_lengths, "segment lengths", + MAX_SEGS_BUFFER_SPLIT, seg_lengths, 0); + if (nb_segs > 0) + set_rx_pkt_segments(seg_lengths, nb_segs); + cmd_reconfig_device_queue(RTE_PORT_ALL, 0, 1); +} + +cmdline_parse_token_string_t cmd_set_rxpkts_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result, + cmd_keyword, "set"); +cmdline_parse_token_string_t cmd_set_rxpkts_name = + TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result, + rxpkts, "rxpkts"); +cmdline_parse_token_string_t cmd_set_rxpkts_lengths = + TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result, + seg_lengths, NULL); + +cmdline_parse_inst_t cmd_set_rxpkts = { + .f = cmd_set_rxpkts_parsed, + .data = NULL, + .help_str = "set rxpkts ", + .tokens = { + (void *)&cmd_set_rxpkts_keyword, + (void *)&cmd_set_rxpkts_name, + (void *)&cmd_set_rxpkts_lengths, + NULL, + }, +}; + /* *** SET SEGMENT LENGTHS OF TXONLY PACKETS *** */ struct cmd_set_txpkts_result { @@ -3920,6 +4066,52 @@ cmdline_parse_inst_t cmd_set_txsplit = { }, }; +/* *** SET TIMES FOR TXONLY PACKETS SCHEDULING ON TIMESTAMPS *** */ + +struct cmd_set_txtimes_result { + cmdline_fixed_string_t cmd_keyword; + cmdline_fixed_string_t txtimes; + cmdline_fixed_string_t tx_times; +}; + +static void +cmd_set_txtimes_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_set_txtimes_result *res; + unsigned int tx_times[2] = {0, 0}; + unsigned int n_times; + + res = parsed_result; + n_times = parse_item_list(res->tx_times, "tx times", + 2, tx_times, 0); + if (n_times == 2) + set_tx_pkt_times(tx_times); +} + +cmdline_parse_token_string_t cmd_set_txtimes_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_set_txtimes_result, + cmd_keyword, "set"); +cmdline_parse_token_string_t cmd_set_txtimes_name = + TOKEN_STRING_INITIALIZER(struct cmd_set_txtimes_result, + txtimes, "txtimes"); +cmdline_parse_token_string_t cmd_set_txtimes_value = + TOKEN_STRING_INITIALIZER(struct cmd_set_txtimes_result, + tx_times, NULL); + +cmdline_parse_inst_t cmd_set_txtimes = { + .f = cmd_set_txtimes_parsed, + .data = NULL, + .help_str = "set txtimes ,", + .tokens = { + (void *)&cmd_set_txtimes_keyword, + (void *)&cmd_set_txtimes_name, + (void *)&cmd_set_txtimes_value, + NULL, + }, +}; + /* *** ADD/REMOVE ALL VLAN IDENTIFIERS TO/FROM A PORT VLAN RX FILTER *** */ struct cmd_rx_vlan_filter_all_result { cmdline_fixed_string_t rx_vlan; @@ -3952,7 +4144,7 @@ cmdline_parse_token_string_t cmd_rx_vlan_filter_all_all = 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, @@ -4020,7 +4212,7 @@ cmd_vlan_offload_parsed(void *parsed_result, /* No queue_id, return */ if(i + 1 >= len) { - printf("must specify (port,queue_id)\n"); + fprintf(stderr, "must specify (port,queue_id)\n"); return; } tmp = strtoul(str + i + 1, NULL, 0); @@ -4092,11 +4284,11 @@ cmd_vlan_tpid_parsed(void *parsed_result, enum rte_vlan_type vlan_type; if (!strcmp(res->vlan_type, "inner")) - vlan_type = ETH_VLAN_TYPE_INNER; + vlan_type = RTE_ETH_VLAN_TYPE_INNER; else if (!strcmp(res->vlan_type, "outer")) - vlan_type = ETH_VLAN_TYPE_OUTER; + vlan_type = RTE_ETH_VLAN_TYPE_OUTER; else { - printf("Unknown vlan type\n"); + fprintf(stderr, "Unknown vlan type\n"); return; } vlan_tpid_set(res->port_id, vlan_type, res->tp_id); @@ -4116,10 +4308,10 @@ cmdline_parse_token_string_t cmd_vlan_tpid_what = 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, @@ -4166,10 +4358,10 @@ cmdline_parse_token_string_t cmd_rx_vlan_filter_what = 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, @@ -4201,8 +4393,11 @@ cmd_tx_vlan_set_parsed(void *parsed_result, { struct cmd_tx_vlan_set_result *res = parsed_result; + if (port_id_is_invalid(res->port_id, ENABLED_WARN)) + return; + if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4219,10 +4414,10 @@ cmdline_parse_token_string_t cmd_tx_vlan_set_set = 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, @@ -4255,8 +4450,11 @@ cmd_tx_vlan_set_qinq_parsed(void *parsed_result, { struct cmd_tx_vlan_set_qinq_result *res = parsed_result; + if (port_id_is_invalid(res->port_id, ENABLED_WARN)) + return; + if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4273,13 +4471,13 @@ cmdline_parse_token_string_t cmd_tx_vlan_set_qinq_set = 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, @@ -4331,10 +4529,10 @@ cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_pvid = 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"); @@ -4368,8 +4566,11 @@ cmd_tx_vlan_reset_parsed(void *parsed_result, { struct cmd_tx_vlan_reset_result *res = parsed_result; + if (port_id_is_invalid(res->port_id, ENABLED_WARN)) + return; + if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4386,7 +4587,7 @@ cmdline_parse_token_string_t cmd_tx_vlan_reset_reset = 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, @@ -4422,53 +4623,59 @@ csum_show(int port_id) printf("Parse tunnel is %s\n", (ports[port_id].parse_tunnel) ? "on" : "off"); printf("IP checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_IPV4_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_IPV4_CKSUM) ? "hw" : "sw"); printf("UDP checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_UDP_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_UDP_CKSUM) ? "hw" : "sw"); printf("TCP checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_TCP_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_TCP_CKSUM) ? "hw" : "sw"); printf("SCTP checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_SCTP_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_SCTP_CKSUM) ? "hw" : "sw"); printf("Outer-Ip checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM) ? "hw" : "sw"); printf("Outer-Udp checksum offload is %s\n", - (tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) ? "hw" : "sw"); + (tx_offloads & RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM) ? "hw" : "sw"); /* display warnings if configuration is not supported by the NIC */ ret = eth_dev_info_get_print_err(port_id, &dev_info); if (ret != 0) return; - if ((tx_offloads & DEV_TX_OFFLOAD_IPV4_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IPV4_CKSUM) == 0) { - printf("Warning: hardware IP checksum enabled but not " - "supported by port %d\n", port_id); - } - if ((tx_offloads & DEV_TX_OFFLOAD_UDP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_UDP_CKSUM) == 0) { - printf("Warning: hardware UDP checksum enabled but not " - "supported by port %d\n", port_id); - } - if ((tx_offloads & DEV_TX_OFFLOAD_TCP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_CKSUM) == 0) { - printf("Warning: hardware TCP checksum enabled but not " - "supported by port %d\n", port_id); - } - if ((tx_offloads & DEV_TX_OFFLOAD_SCTP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_SCTP_CKSUM) == 0) { - printf("Warning: hardware SCTP checksum enabled but not " - "supported by port %d\n", port_id); - } - if ((tx_offloads & DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM) == 0) { - printf("Warning: hardware outer IP checksum enabled but not " - "supported by port %d\n", port_id); - } - if ((tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_IPV4_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_IPV4_CKSUM) == 0) { + fprintf(stderr, + "Warning: hardware IP checksum enabled but not supported by port %d\n", + port_id); + } + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_UDP_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_UDP_CKSUM) == 0) { + fprintf(stderr, + "Warning: hardware UDP checksum enabled but not supported by port %d\n", + port_id); + } + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_TCP_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_TCP_CKSUM) == 0) { + fprintf(stderr, + "Warning: hardware TCP checksum enabled but not supported by port %d\n", + port_id); + } + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_SCTP_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_SCTP_CKSUM) == 0) { + fprintf(stderr, + "Warning: hardware SCTP checksum enabled but not supported by port %d\n", + port_id); + } + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM) == 0) { + fprintf(stderr, + "Warning: hardware outer IP checksum enabled but not supported by port %d\n", + port_id); + } + if ((tx_offloads & RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM) && + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM) == 0) { - printf("Warning: hardware outer UDP checksum enabled but not " - "supported by port %d\n", port_id); + fprintf(stderr, + "Warning: hardware outer UDP checksum enabled but not supported by port %d\n", + port_id); } } @@ -4478,7 +4685,7 @@ cmd_config_queue_tx_offloads(struct rte_port *port) int k; /* Apply queue tx offloads configuration */ - for (k = 0; k < port->dev_info.max_rx_queues; k++) + for (k = 0; k < port->dev_info.max_tx_queues; k++) port->tx_conf[k].offloads = port->dev_conf.txmode.offloads; } @@ -4495,11 +4702,11 @@ cmd_csum_parsed(void *parsed_result, int ret; if (port_id_is_invalid(res->port_id, ENABLED_WARN)) { - printf("invalid port %d\n", res->port_id); + fprintf(stderr, "invalid port %d\n", res->port_id); return; } if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4514,53 +4721,59 @@ cmd_csum_parsed(void *parsed_result, if (!strcmp(res->proto, "ip")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_IPV4_CKSUM)) { - csum_offloads |= DEV_TX_OFFLOAD_IPV4_CKSUM; + RTE_ETH_TX_OFFLOAD_IPV4_CKSUM)) { + csum_offloads |= RTE_ETH_TX_OFFLOAD_IPV4_CKSUM; } else { - printf("IP checksum offload is not supported " - "by port %u\n", res->port_id); + fprintf(stderr, + "IP checksum offload is not supported by port %u\n", + res->port_id); } } else if (!strcmp(res->proto, "udp")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_UDP_CKSUM)) { - csum_offloads |= DEV_TX_OFFLOAD_UDP_CKSUM; + RTE_ETH_TX_OFFLOAD_UDP_CKSUM)) { + csum_offloads |= RTE_ETH_TX_OFFLOAD_UDP_CKSUM; } else { - printf("UDP checksum offload is not supported " - "by port %u\n", res->port_id); + fprintf(stderr, + "UDP checksum offload is not supported by port %u\n", + res->port_id); } } else if (!strcmp(res->proto, "tcp")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_TCP_CKSUM)) { - csum_offloads |= DEV_TX_OFFLOAD_TCP_CKSUM; + RTE_ETH_TX_OFFLOAD_TCP_CKSUM)) { + csum_offloads |= RTE_ETH_TX_OFFLOAD_TCP_CKSUM; } else { - printf("TCP checksum offload is not supported " - "by port %u\n", res->port_id); + fprintf(stderr, + "TCP checksum offload is not supported by port %u\n", + res->port_id); } } else if (!strcmp(res->proto, "sctp")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_SCTP_CKSUM)) { - csum_offloads |= DEV_TX_OFFLOAD_SCTP_CKSUM; + RTE_ETH_TX_OFFLOAD_SCTP_CKSUM)) { + csum_offloads |= RTE_ETH_TX_OFFLOAD_SCTP_CKSUM; } else { - printf("SCTP checksum offload is not supported " - "by port %u\n", res->port_id); + fprintf(stderr, + "SCTP checksum offload is not supported by port %u\n", + res->port_id); } } else if (!strcmp(res->proto, "outer-ip")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM)) { + RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM)) { csum_offloads |= - DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM; + RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM; } else { - printf("Outer IP checksum offload is not " - "supported by port %u\n", res->port_id); + fprintf(stderr, + "Outer IP checksum offload is not supported by port %u\n", + res->port_id); } } else if (!strcmp(res->proto, "outer-udp")) { if (hw == 0 || (dev_info.tx_offload_capa & - DEV_TX_OFFLOAD_OUTER_UDP_CKSUM)) { + RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM)) { csum_offloads |= - DEV_TX_OFFLOAD_OUTER_UDP_CKSUM; + RTE_ETH_TX_OFFLOAD_OUTER_UDP_CKSUM; } else { - printf("Outer UDP checksum offload is not " - "supported by port %u\n", res->port_id); + fprintf(stderr, + "Outer UDP checksum offload is not supported by port %u\n", + res->port_id); } } @@ -4592,7 +4805,7 @@ cmdline_parse_token_string_t cmd_csum_hwsw = 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, @@ -4663,7 +4876,7 @@ cmdline_parse_token_string_t cmd_csum_tunnel_onoff = 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, @@ -4699,7 +4912,7 @@ cmd_tso_set_parsed(void *parsed_result, if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4711,19 +4924,19 @@ cmd_tso_set_parsed(void *parsed_result, return; if ((ports[res->port_id].tso_segsz != 0) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_TSO) == 0) { - printf("Error: TSO is not supported by port %d\n", - res->port_id); + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_TCP_TSO) == 0) { + fprintf(stderr, "Error: TSO is not supported by port %d\n", + res->port_id); return; } if (ports[res->port_id].tso_segsz == 0) { ports[res->port_id].dev_conf.txmode.offloads &= - ~DEV_TX_OFFLOAD_TCP_TSO; + ~RTE_ETH_TX_OFFLOAD_TCP_TSO; printf("TSO for non-tunneled packets is disabled\n"); } else { ports[res->port_id].dev_conf.txmode.offloads |= - DEV_TX_OFFLOAD_TCP_TSO; + RTE_ETH_TX_OFFLOAD_TCP_TSO; printf("TSO segment size for non-tunneled packets is %d\n", ports[res->port_id].tso_segsz); } @@ -4735,9 +4948,10 @@ cmd_tso_set_parsed(void *parsed_result, return; if ((ports[res->port_id].tso_segsz != 0) && - (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_TSO) == 0) { - printf("Warning: TSO enabled but not " - "supported by port %d\n", res->port_id); + (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_TCP_TSO) == 0) { + fprintf(stderr, + "Warning: TSO enabled but not supported by port %d\n", + res->port_id); } cmd_reconfig_device_queue(res->port_id, 1, 1); @@ -4751,10 +4965,10 @@ cmdline_parse_token_string_t cmd_tso_set_mode = 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, @@ -4805,24 +5019,30 @@ check_tunnel_tso_nic_support(portid_t port_id) if (eth_dev_info_get_print_err(port_id, &dev_info) != 0) return dev_info; - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_VXLAN_TNL_TSO)) - printf("Warning: VXLAN TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_GRE_TNL_TSO)) - printf("Warning: GRE TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IPIP_TNL_TSO)) - printf("Warning: IPIP TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_GENEVE_TNL_TSO)) - printf("Warning: GENEVE TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IP_TNL_TSO)) - printf("Warning: IP TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); - if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_UDP_TNL_TSO)) - printf("Warning: UDP TUNNEL TSO not supported therefore " - "not enabled for port %d\n", port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO)) + fprintf(stderr, + "Warning: VXLAN TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_GRE_TNL_TSO)) + fprintf(stderr, + "Warning: GRE TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_IPIP_TNL_TSO)) + fprintf(stderr, + "Warning: IPIP TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_GENEVE_TNL_TSO)) + fprintf(stderr, + "Warning: GENEVE TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_IP_TNL_TSO)) + fprintf(stderr, + "Warning: IP TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); + if (!(dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_UDP_TNL_TSO)) + fprintf(stderr, + "Warning: UDP TUNNEL TSO not supported therefore not enabled for port %d\n", + port_id); return dev_info; } @@ -4837,7 +5057,7 @@ cmd_tunnel_tso_set_parsed(void *parsed_result, if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; if (!port_is_stopped(res->port_id)) { - printf("Please stop port %d first\n", res->port_id); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -4847,20 +5067,20 @@ cmd_tunnel_tso_set_parsed(void *parsed_result, dev_info = check_tunnel_tso_nic_support(res->port_id); if (ports[res->port_id].tunnel_tso_segsz == 0) { ports[res->port_id].dev_conf.txmode.offloads &= - ~(DEV_TX_OFFLOAD_VXLAN_TNL_TSO | - DEV_TX_OFFLOAD_GRE_TNL_TSO | - DEV_TX_OFFLOAD_IPIP_TNL_TSO | - DEV_TX_OFFLOAD_GENEVE_TNL_TSO | - DEV_TX_OFFLOAD_IP_TNL_TSO | - DEV_TX_OFFLOAD_UDP_TNL_TSO); + ~(RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO | + RTE_ETH_TX_OFFLOAD_GRE_TNL_TSO | + RTE_ETH_TX_OFFLOAD_IPIP_TNL_TSO | + RTE_ETH_TX_OFFLOAD_GENEVE_TNL_TSO | + RTE_ETH_TX_OFFLOAD_IP_TNL_TSO | + RTE_ETH_TX_OFFLOAD_UDP_TNL_TSO); printf("TSO for tunneled packets is disabled\n"); } else { - uint64_t tso_offloads = (DEV_TX_OFFLOAD_VXLAN_TNL_TSO | - DEV_TX_OFFLOAD_GRE_TNL_TSO | - DEV_TX_OFFLOAD_IPIP_TNL_TSO | - DEV_TX_OFFLOAD_GENEVE_TNL_TSO | - DEV_TX_OFFLOAD_IP_TNL_TSO | - DEV_TX_OFFLOAD_UDP_TNL_TSO); + uint64_t tso_offloads = (RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO | + RTE_ETH_TX_OFFLOAD_GRE_TNL_TSO | + RTE_ETH_TX_OFFLOAD_IPIP_TNL_TSO | + RTE_ETH_TX_OFFLOAD_GENEVE_TNL_TSO | + RTE_ETH_TX_OFFLOAD_IP_TNL_TSO | + RTE_ETH_TX_OFFLOAD_UDP_TNL_TSO); ports[res->port_id].dev_conf.txmode.offloads |= (tso_offloads & dev_info.tx_offload_capa); @@ -4880,12 +5100,12 @@ cmd_tunnel_tso_set_parsed(void *parsed_result, */ if (!ports[res->port_id].parse_tunnel) - printf("Warning: csum parse_tunnel must be set " - "so that tunneled packets are recognized\n"); + fprintf(stderr, + "Warning: csum parse_tunnel must be set so that tunneled packets are recognized\n"); if (!(ports[res->port_id].dev_conf.txmode.offloads & - DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM)) - printf("Warning: csum set outer-ip must be set to hw " - "if outer L3 is IPv4; not necessary for IPv6\n"); + RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM)) + fprintf(stderr, + "Warning: csum set outer-ip must be set to hw if outer L3 is IPv4; not necessary for IPv6\n"); } cmd_config_queue_tx_offloads(&ports[res->port_id]); @@ -4900,10 +5120,10 @@ cmdline_parse_token_string_t cmd_tunnel_tso_set_mode = 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, @@ -4938,6 +5158,7 @@ cmdline_parse_inst_t cmd_tunnel_tso_show = { }, }; +#ifdef RTE_LIB_GRO /* *** SET GRO FOR A PORT *** */ struct cmd_gro_enable_result { cmdline_fixed_string_t cmd_set; @@ -4967,7 +5188,7 @@ cmdline_parse_token_string_t cmd_gro_enable_port = 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"); @@ -5017,7 +5238,7 @@ cmdline_parse_token_string_t cmd_gro_show_port = 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"); @@ -5067,7 +5288,7 @@ cmdline_parse_token_string_t cmd_gro_flush_flush = 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, @@ -5081,7 +5302,9 @@ cmdline_parse_inst_t cmd_gro_flush = { NULL, }, }; +#endif /* RTE_LIB_GRO */ +#ifdef RTE_LIB_GSO /* *** ENABLE/DISABLE GSO *** */ struct cmd_gso_enable_result { cmdline_fixed_string_t cmd_set; @@ -5117,7 +5340,7 @@ cmdline_parse_token_string_t cmd_gso_enable_mode = 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, @@ -5149,17 +5372,17 @@ cmd_gso_size_parsed(void *parsed_result, struct cmd_gso_size_result *res = parsed_result; if (test_done == 0) { - printf("Before setting GSO segsz, please first" - " stop forwarding\n"); + fprintf(stderr, + "Before setting GSO segsz, please first stop forwarding\n"); return; } if (!strcmp(res->cmd_keyword, "gso") && !strcmp(res->cmd_segsz, "segsz")) { if (res->cmd_size < RTE_GSO_SEG_SIZE_MIN) - printf("gso_size should be larger than %zu." - " Please input a legal value\n", - RTE_GSO_SEG_SIZE_MIN); + fprintf(stderr, + "gso_size should be larger than %zu. Please input a legal value\n", + RTE_GSO_SEG_SIZE_MIN); else gso_max_segment_size = res->cmd_size; } @@ -5176,7 +5399,7 @@ cmdline_parse_token_string_t cmd_gso_size_segsz = 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, @@ -5207,7 +5430,7 @@ cmd_gso_show_parsed(void *parsed_result, struct cmd_gso_show_result *res = parsed_result; if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { - printf("invalid port id %u\n", res->cmd_pid); + fprintf(stderr, "invalid port id %u\n", res->cmd_pid); return; } if (!strcmp(res->cmd_keyword, "gso")) { @@ -5234,7 +5457,7 @@ cmdline_parse_token_string_t cmd_gso_show_keyword = 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, @@ -5248,6 +5471,7 @@ cmdline_parse_inst_t cmd_gso_show = { NULL, }, }; +#endif /* RTE_LIB_GSO */ /* *** ENABLE/DISABLE FLUSH ON RX STREAMS *** */ struct cmd_set_flush_rx { @@ -5262,6 +5486,12 @@ cmd_set_flush_rx_parsed(void *parsed_result, __rte_unused void *data) { struct cmd_set_flush_rx *res = parsed_result; + + if (num_procs > 1 && (strcmp(res->mode, "on") == 0)) { + printf("multi-process doesn't support to flush Rx queues.\n"); + return; + } + no_flush_rx = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1); } @@ -5346,7 +5576,7 @@ cmd_set_bypass_mode_parsed(void *parsed_result, portid_t port_id = res->port_id; int32_t rc = -EINVAL; -#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS +#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS uint32_t bypass_mode = RTE_PMD_IXGBE_BYPASS_MODE_NORMAL; if (!strcmp(res->value, "bypass")) @@ -5360,7 +5590,8 @@ cmd_set_bypass_mode_parsed(void *parsed_result, rc = rte_pmd_ixgbe_bypass_state_set(port_id, &bypass_mode); #endif if (rc != 0) - printf("\t Failed to set bypass mode for port = %d.\n", port_id); + fprintf(stderr, "\t Failed to set bypass mode for port = %d.\n", + port_id); } cmdline_parse_token_string_t cmd_setbypass_mode_set = @@ -5377,7 +5608,7 @@ cmdline_parse_token_string_t cmd_setbypass_mode_value = 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, @@ -5414,7 +5645,7 @@ cmd_set_bypass_event_parsed(void *parsed_result, struct cmd_set_bypass_event_result *res = parsed_result; portid_t port_id = res->port_id; -#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS +#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS uint32_t bypass_event = RTE_PMD_IXGBE_BYPASS_EVENT_NONE; uint32_t bypass_mode = RTE_PMD_IXGBE_BYPASS_MODE_NORMAL; @@ -5447,9 +5678,9 @@ cmd_set_bypass_event_parsed(void *parsed_result, bypass_timeout); } if (rc != 0) { - printf("Failed to set timeout value %u " - "for port %d, errto code: %d.\n", - bypass_timeout, port_id, rc); + fprintf(stderr, + "Failed to set timeout value %u for port %d, errto code: %d.\n", + bypass_timeout, port_id, rc); } } @@ -5459,8 +5690,8 @@ cmd_set_bypass_event_parsed(void *parsed_result, #endif if (rc != 0) - printf("\t Failed to set bypass event for port = %d.\n", - port_id); + fprintf(stderr, "\t Failed to set bypass event for port = %d.\n", + port_id); } cmdline_parse_token_string_t cmd_setbypass_event_set = @@ -5483,7 +5714,7 @@ cmdline_parse_token_string_t cmd_setbypass_event_mode_value = 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, @@ -5519,7 +5750,7 @@ cmd_set_bypass_timeout_parsed(void *parsed_result, { __rte_unused struct cmd_set_bypass_timeout_result *res = parsed_result; -#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS +#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS if (!strcmp(res->value, "1.5")) bypass_timeout = RTE_PMD_IXGBE_BYPASS_TMT_1_5_SEC; else if (!strcmp(res->value, "2")) @@ -5582,7 +5813,7 @@ cmd_show_bypass_config_parsed(void *parsed_result, struct cmd_show_bypass_config_result *res = parsed_result; portid_t port_id = res->port_id; int rc = -EINVAL; -#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS +#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS uint32_t event_mode; uint32_t bypass_mode; uint32_t timeout = bypass_timeout; @@ -5602,7 +5833,8 @@ cmd_show_bypass_config_parsed(void *parsed_result, /* Display the bypass mode.*/ if (rte_pmd_ixgbe_bypass_state_show(port_id, &bypass_mode) != 0) { - printf("\tFailed to get bypass mode for port = %d\n", port_id); + fprintf(stderr, "\tFailed to get bypass mode for port = %d\n", + port_id); return; } else { @@ -5622,7 +5854,8 @@ cmd_show_bypass_config_parsed(void *parsed_result, for (i = RTE_PMD_IXGBE_BYPASS_EVENT_START; i < RTE_DIM(events); i++) { if (rte_pmd_ixgbe_bypass_event_show(port_id, i, &event_mode)) { - printf("\tFailed to get bypass mode for event = %s\n", + fprintf(stderr, + "\tFailed to get bypass mode for event = %s\n", events[i]); } else { if (!RTE_PMD_IXGBE_BYPASS_MODE_VALID(event_mode)) @@ -5634,7 +5867,8 @@ cmd_show_bypass_config_parsed(void *parsed_result, } #endif if (rc != 0) - printf("\tFailed to get bypass configuration for port = %d\n", + fprintf(stderr, + "\tFailed to get bypass configuration for port = %d\n", port_id); } @@ -5649,7 +5883,7 @@ cmdline_parse_token_string_t cmd_showbypass_config_config = 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, @@ -5665,7 +5899,7 @@ cmdline_parse_inst_t cmd_show_bypass_config = { }, }; -#ifdef RTE_LIBRTE_PMD_BOND +#ifdef RTE_NET_BOND /* *** SET BONDING MODE *** */ struct cmd_set_bonding_mode_result { cmdline_fixed_string_t set; @@ -5684,7 +5918,8 @@ static void cmd_set_bonding_mode_parsed(void *parsed_result, /* Set the bonding mode for the relevant port. */ if (0 != rte_eth_bond_mode_set(port_id, res->value)) - printf("\t Failed to set bonding mode for port = %d.\n", port_id); + fprintf(stderr, "\t Failed to set bonding mode for port = %d.\n", + port_id); } cmdline_parse_token_string_t cmd_setbonding_mode_set = @@ -5698,10 +5933,10 @@ TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_mode_result, 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, @@ -5740,7 +5975,7 @@ static void cmd_set_bonding_lacp_dedicated_queues_parsed(void *parsed_result, /** Check if the port is not started **/ if (port->port_status != RTE_PORT_STOPPED) { - printf("Please stop port %d first\n", port_id); + fprintf(stderr, "Please stop port %d first\n", port_id); return; } @@ -5775,7 +6010,7 @@ TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_lacp_dedicated_queues_result, 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"); @@ -5821,14 +6056,15 @@ static void cmd_set_bonding_balance_xmit_policy_parsed(void *parsed_result, } else if (!strcmp(res->policy, "l34")) { policy = BALANCE_XMIT_POLICY_LAYER34; } else { - printf("\t Invalid xmit policy selection"); + fprintf(stderr, "\t Invalid xmit policy selection"); return; } /* Set the bonding mode for the relevant port. */ if (0 != rte_eth_bond_xmit_policy_set(port_id, policy)) { - printf("\t Failed to set bonding balance xmit policy for port = %d.\n", - port_id); + fprintf(stderr, + "\t Failed to set bonding balance xmit policy for port = %d.\n", + port_id); } } @@ -5843,7 +6079,7 @@ TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result, 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"); @@ -5864,42 +6100,225 @@ cmdline_parse_inst_t cmd_set_balance_xmit_policy = { } }; -/* *** SHOW NIC BONDING CONFIGURATION *** */ -struct cmd_show_bonding_config_result { +/* *** SHOW IEEE802.3 BONDING INFORMATION *** */ +struct cmd_show_bonding_lacp_info_result { cmdline_fixed_string_t show; cmdline_fixed_string_t bonding; - cmdline_fixed_string_t config; + cmdline_fixed_string_t lacp; + cmdline_fixed_string_t info; portid_t port_id; }; -static void cmd_show_bonding_config_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) +static void port_param_show(struct port_params *params) { - struct cmd_show_bonding_config_result *res = parsed_result; - int bonding_mode, agg_mode; - portid_t slaves[RTE_MAX_ETHPORTS]; - int num_slaves, num_active_slaves; - int primary_id; - int i; - portid_t port_id = res->port_id; + char buf[RTE_ETHER_ADDR_FMT_SIZE]; + + printf("\t\tsystem priority: %u\n", params->system_priority); + rte_ether_format_addr(buf, RTE_ETHER_ADDR_FMT_SIZE, ¶ms->system); + printf("\t\tsystem mac address: %s\n", buf); + printf("\t\tport key: %u\n", params->key); + printf("\t\tport priority: %u\n", params->port_priority); + printf("\t\tport number: %u\n", params->port_number); +} - /* Display the bonding mode.*/ - bonding_mode = rte_eth_bond_mode_get(port_id); - if (bonding_mode < 0) { - printf("\tFailed to get bonding mode for port = %d\n", port_id); - return; - } else - printf("\tBonding mode: %d\n", bonding_mode); +static void lacp_slave_info_show(struct rte_eth_bond_8023ad_slave_info *info) +{ + char a_state[256] = { 0 }; + char p_state[256] = { 0 }; + int a_len = 0; + int p_len = 0; + uint32_t i; - if (bonding_mode == BONDING_MODE_BALANCE) { - int balance_xmit_policy; + static const char * const state[] = { + "ACTIVE", + "TIMEOUT", + "AGGREGATION", + "SYNCHRONIZATION", + "COLLECTING", + "DISTRIBUTING", + "DEFAULTED", + "EXPIRED" + }; + static const char * const selection[] = { + "UNSELECTED", + "STANDBY", + "SELECTED" + }; - balance_xmit_policy = rte_eth_bond_xmit_policy_get(port_id); - if (balance_xmit_policy < 0) { - printf("\tFailed to get balance xmit policy for port = %d\n", - port_id); - return; + for (i = 0; i < RTE_DIM(state); i++) { + if ((info->actor_state >> i) & 1) + a_len += snprintf(&a_state[a_len], + RTE_DIM(a_state) - a_len, "%s ", + state[i]); + + if ((info->partner_state >> i) & 1) + p_len += snprintf(&p_state[p_len], + RTE_DIM(p_state) - p_len, "%s ", + state[i]); + } + printf("\tAggregator port id: %u\n", info->agg_port_id); + printf("\tselection: %s\n", selection[info->selected]); + printf("\tActor detail info:\n"); + port_param_show(&info->actor); + printf("\t\tport state: %s\n", a_state); + printf("\tPartner detail info:\n"); + port_param_show(&info->partner); + printf("\t\tport state: %s\n", p_state); + printf("\n"); +} + +static void lacp_conf_show(struct rte_eth_bond_8023ad_conf *conf) +{ + printf("\tfast period: %u ms\n", conf->fast_periodic_ms); + printf("\tslow period: %u ms\n", conf->slow_periodic_ms); + printf("\tshort timeout: %u ms\n", conf->short_timeout_ms); + printf("\tlong timeout: %u ms\n", conf->long_timeout_ms); + printf("\taggregate wait timeout: %u ms\n", + conf->aggregate_wait_timeout_ms); + printf("\ttx period: %u ms\n", conf->tx_period_ms); + printf("\trx marker period: %u ms\n", conf->rx_marker_period_ms); + printf("\tupdate timeout: %u ms\n", conf->update_timeout_ms); + switch (conf->agg_selection) { + case AGG_BANDWIDTH: + printf("\taggregation mode: bandwidth\n"); + break; + case AGG_STABLE: + printf("\taggregation mode: stable\n"); + break; + case AGG_COUNT: + printf("\taggregation mode: count\n"); + break; + default: + printf("\taggregation mode: invalid\n"); + break; + } + + printf("\n"); +} + +static void cmd_show_bonding_lacp_info_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_show_bonding_lacp_info_result *res = parsed_result; + struct rte_eth_bond_8023ad_slave_info slave_info; + struct rte_eth_bond_8023ad_conf port_conf; + portid_t slaves[RTE_MAX_ETHPORTS]; + portid_t port_id = res->port_id; + int num_active_slaves; + int bonding_mode; + int i; + int ret; + + bonding_mode = rte_eth_bond_mode_get(port_id); + if (bonding_mode != BONDING_MODE_8023AD) { + fprintf(stderr, "\tBonding mode is not mode 4\n"); + return; + } + + num_active_slaves = rte_eth_bond_active_slaves_get(port_id, slaves, + RTE_MAX_ETHPORTS); + if (num_active_slaves < 0) { + fprintf(stderr, "\tFailed to get active slave list for port = %u\n", + port_id); + return; + } + if (num_active_slaves == 0) + fprintf(stderr, "\tIEEE802.3 port %u has no active slave\n", + port_id); + + printf("\tIEEE802.3 port: %u\n", port_id); + ret = rte_eth_bond_8023ad_conf_get(port_id, &port_conf); + if (ret) { + fprintf(stderr, "\tGet bonded device %u info failed\n", + port_id); + return; + } + lacp_conf_show(&port_conf); + + for (i = 0; i < num_active_slaves; i++) { + ret = rte_eth_bond_8023ad_slave_info(port_id, slaves[i], + &slave_info); + if (ret) { + fprintf(stderr, "\tGet slave device %u info failed\n", + slaves[i]); + return; + } + printf("\tSlave Port: %u\n", slaves[i]); + lacp_slave_info_show(&slave_info); + } +} + +cmdline_parse_token_string_t cmd_show_bonding_lacp_info_show = +TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, + show, "show"); +cmdline_parse_token_string_t cmd_show_bonding_lacp_info_bonding = +TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, + bonding, "bonding"); +cmdline_parse_token_string_t cmd_show_bonding_lacp_info_lacp = +TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, + bonding, "lacp"); +cmdline_parse_token_string_t cmd_show_bonding_lacp_info_info = +TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result, + info, "info"); +cmdline_parse_token_num_t cmd_show_bonding_lacp_info_port_id = +TOKEN_NUM_INITIALIZER(struct cmd_show_bonding_lacp_info_result, + port_id, RTE_UINT16); + +cmdline_parse_inst_t cmd_show_bonding_lacp_info = { + .f = cmd_show_bonding_lacp_info_parsed, + .help_str = "show bonding lacp info : " + "Show bonding IEEE802.3 information for port_id", + .data = NULL, + .tokens = { + (void *)&cmd_show_bonding_lacp_info_show, + (void *)&cmd_show_bonding_lacp_info_bonding, + (void *)&cmd_show_bonding_lacp_info_lacp, + (void *)&cmd_show_bonding_lacp_info_info, + (void *)&cmd_show_bonding_lacp_info_port_id, + NULL + } +}; + +/* *** SHOW NIC BONDING CONFIGURATION *** */ +struct cmd_show_bonding_config_result { + cmdline_fixed_string_t show; + cmdline_fixed_string_t bonding; + cmdline_fixed_string_t config; + portid_t port_id; +}; + +static void cmd_show_bonding_config_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_show_bonding_config_result *res = parsed_result; + int bonding_mode, agg_mode; + portid_t slaves[RTE_MAX_ETHPORTS]; + int num_slaves, num_active_slaves; + int primary_id; + int i; + portid_t port_id = res->port_id; + + /* Display the bonding mode.*/ + bonding_mode = rte_eth_bond_mode_get(port_id); + if (bonding_mode < 0) { + fprintf(stderr, "\tFailed to get bonding mode for port = %d\n", + port_id); + return; + } else + printf("\tBonding mode: %d\n", bonding_mode); + + if (bonding_mode == BONDING_MODE_BALANCE || + bonding_mode == BONDING_MODE_8023AD) { + int balance_xmit_policy; + + balance_xmit_policy = rte_eth_bond_xmit_policy_get(port_id); + if (balance_xmit_policy < 0) { + fprintf(stderr, + "\tFailed to get balance xmit policy for port = %d\n", + port_id); + return; } else { printf("\tBalance Xmit Policy: "); @@ -5938,7 +6357,8 @@ static void cmd_show_bonding_config_parsed(void *parsed_result, num_slaves = rte_eth_bond_slaves_get(port_id, slaves, RTE_MAX_ETHPORTS); if (num_slaves < 0) { - printf("\tFailed to get slave list for port = %d\n", port_id); + fprintf(stderr, "\tFailed to get slave list for port = %d\n", + port_id); return; } if (num_slaves > 0) { @@ -5956,7 +6376,9 @@ static void cmd_show_bonding_config_parsed(void *parsed_result, RTE_MAX_ETHPORTS); if (num_active_slaves < 0) { - printf("\tFailed to get active slave list for port = %d\n", port_id); + fprintf(stderr, + "\tFailed to get active slave list for port = %d\n", + port_id); return; } if (num_active_slaves > 0) { @@ -5973,7 +6395,8 @@ static void cmd_show_bonding_config_parsed(void *parsed_result, primary_id = rte_eth_bond_primary_get(port_id); if (primary_id < 0) { - printf("\tFailed to get primary slave for port = %d\n", port_id); + fprintf(stderr, "\tFailed to get primary slave for port = %d\n", + port_id); return; } else printf("\tPrimary: [%d]\n", primary_id); @@ -5991,7 +6414,7 @@ TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_config_result, 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, @@ -6026,8 +6449,8 @@ static void cmd_set_bonding_primary_parsed(void *parsed_result, /* Set the primary slave for a bonded device. */ if (0 != rte_eth_bond_primary_set(master_port_id, slave_port_id)) { - printf("\t Failed to set primary slave for port = %d.\n", - master_port_id); + fprintf(stderr, "\t Failed to set primary slave for port = %d.\n", + master_port_id); return; } init_port_config(); @@ -6044,10 +6467,10 @@ TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_primary_result, 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, @@ -6083,8 +6506,9 @@ static void cmd_add_bonding_slave_parsed(void *parsed_result, /* add the slave for a bonded device. */ if (0 != rte_eth_bond_slave_add(master_port_id, slave_port_id)) { - printf("\t Failed to add slave %d to master port = %d.\n", - slave_port_id, master_port_id); + fprintf(stderr, + "\t Failed to add slave %d to master port = %d.\n", + slave_port_id, master_port_id); return; } init_port_config(); @@ -6102,10 +6526,10 @@ TOKEN_STRING_INITIALIZER(struct cmd_add_bonding_slave_result, 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, @@ -6141,8 +6565,9 @@ static void cmd_remove_bonding_slave_parsed(void *parsed_result, /* remove the slave from a bonded device. */ if (0 != rte_eth_bond_slave_remove(master_port_id, slave_port_id)) { - printf("\t Failed to remove slave %d from master port = %d.\n", - slave_port_id, master_port_id); + fprintf(stderr, + "\t Failed to remove slave %d from master port = %d.\n", + slave_port_id, master_port_id); return; } init_port_config(); @@ -6160,10 +6585,10 @@ cmdline_parse_token_string_t cmd_removebonding_slave_slave = 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, @@ -6201,7 +6626,7 @@ static void cmd_create_bonded_device_parsed(void *parsed_result, int ret; if (test_done == 0) { - printf("Please stop forwarding first\n"); + fprintf(stderr, "Please stop forwarding first\n"); return; } @@ -6211,7 +6636,7 @@ static void cmd_create_bonded_device_parsed(void *parsed_result, /* Create a new bonded device. */ port_id = rte_eth_bond_create(ethdev_name, res->mode, res->socket); if (port_id < 0) { - printf("\t Failed to create bonded device.\n"); + fprintf(stderr, "\t Failed to create bonded device.\n"); return; } else { printf("Created new bonded device %s on (port %d).\n", ethdev_name, @@ -6222,7 +6647,8 @@ static void cmd_create_bonded_device_parsed(void *parsed_result, reconfig(port_id, res->socket); ret = rte_eth_promiscuous_enable(port_id); if (ret != 0) - printf("Failed to enable promiscuous mode for port %u: %s - ignore\n", + fprintf(stderr, + "Failed to enable promiscuous mode for port %u: %s - ignore\n", port_id, rte_strerror(-ret)); ports[port_id].need_setup = 0; @@ -6242,10 +6668,10 @@ cmdline_parse_token_string_t cmd_createbonded_device_device = 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, @@ -6285,7 +6711,8 @@ static void cmd_set_bond_mac_addr_parsed(void *parsed_result, /* check the return value and print it if is < 0 */ if (ret < 0) - printf("set_bond_mac_addr error: (%s)\n", strerror(-ret)); + fprintf(stderr, "set_bond_mac_addr error: (%s)\n", + strerror(-ret)); } cmdline_parse_token_string_t cmd_set_bond_mac_addr_set = @@ -6298,7 +6725,7 @@ cmdline_parse_token_string_t cmd_set_bond_mac_addr_mac = "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); @@ -6337,7 +6764,8 @@ static void cmd_set_bond_mon_period_parsed(void *parsed_result, /* check the return value and print it if is < 0 */ if (ret < 0) - printf("set_bond_mac_addr error: (%s)\n", strerror(-ret)); + fprintf(stderr, "set_bond_mac_addr error: (%s)\n", + strerror(-ret)); } cmdline_parse_token_string_t cmd_set_bond_mon_period_set = @@ -6351,10 +6779,10 @@ cmdline_parse_token_string_t cmd_set_bond_mon_period_mon_period = 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, @@ -6413,7 +6841,7 @@ cmdline_parse_token_string_t cmd_set_bonding_agg_mode_agg_mode = 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( @@ -6435,7 +6863,7 @@ cmdline_parse_inst_t cmd_set_bonding_agg_mode_policy = { }; -#endif /* RTE_LIBRTE_PMD_BOND */ +#endif /* RTE_NET_BOND */ /* *** SET FORWARDING MODE *** */ struct cmd_set_fwd_mode_result { @@ -6601,11 +7029,13 @@ cmdline_parse_token_string_t cmd_set_burst_tx_retry_tx = 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, @@ -6663,7 +7093,7 @@ cmdline_parse_token_string_t cmd_setpromisc_portall = "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"); @@ -6737,7 +7167,7 @@ cmdline_parse_token_string_t cmd_setallmulti_portall = "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"); @@ -6769,6 +7199,81 @@ cmdline_parse_inst_t cmd_set_allmulti_mode_one = { }, }; +/* *** GET CURRENT ETHERNET LINK FLOW CONTROL *** */ +struct cmd_link_flow_ctrl_show { + cmdline_fixed_string_t show; + cmdline_fixed_string_t port; + portid_t port_id; + cmdline_fixed_string_t flow_ctrl; +}; + +cmdline_parse_token_string_t cmd_lfc_show_show = + TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_show, + show, "show"); +cmdline_parse_token_string_t cmd_lfc_show_port = + TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_show, + port, "port"); +cmdline_parse_token_num_t cmd_lfc_show_portid = + TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_show, + port_id, RTE_UINT16); +cmdline_parse_token_string_t cmd_lfc_show_flow_ctrl = + TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_show, + flow_ctrl, "flow_ctrl"); + +static void +cmd_link_flow_ctrl_show_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_link_flow_ctrl_show *res = parsed_result; + static const char *info_border = "*********************"; + struct rte_eth_fc_conf fc_conf; + bool rx_fc_en = false; + bool tx_fc_en = false; + int ret; + + ret = rte_eth_dev_flow_ctrl_get(res->port_id, &fc_conf); + if (ret != 0) { + fprintf(stderr, + "Failed to get current flow ctrl information: err = %d\n", + ret); + return; + } + + if (fc_conf.mode == RTE_ETH_FC_RX_PAUSE || fc_conf.mode == RTE_ETH_FC_FULL) + rx_fc_en = true; + if (fc_conf.mode == RTE_ETH_FC_TX_PAUSE || fc_conf.mode == RTE_ETH_FC_FULL) + tx_fc_en = true; + + printf("\n%s Flow control infos for port %-2d %s\n", + info_border, res->port_id, info_border); + printf("FC mode:\n"); + printf(" Rx pause: %s\n", rx_fc_en ? "on" : "off"); + printf(" Tx pause: %s\n", tx_fc_en ? "on" : "off"); + printf("Autoneg: %s\n", fc_conf.autoneg ? "on" : "off"); + printf("Pause time: 0x%x\n", fc_conf.pause_time); + printf("High waterline: 0x%x\n", fc_conf.high_water); + printf("Low waterline: 0x%x\n", fc_conf.low_water); + printf("Send XON: %s\n", fc_conf.send_xon ? "on" : "off"); + printf("Forward MAC control frames: %s\n", + fc_conf.mac_ctrl_frame_fwd ? "on" : "off"); + printf("\n%s************** End ***********%s\n", + info_border, info_border); +} + +cmdline_parse_inst_t cmd_link_flow_control_show = { + .f = cmd_link_flow_ctrl_show_parsed, + .data = NULL, + .help_str = "show port flow_ctrl", + .tokens = { + (void *)&cmd_lfc_show_show, + (void *)&cmd_lfc_show_port, + (void *)&cmd_lfc_show_portid, + (void *)&cmd_lfc_show_flow_ctrl, + NULL, + }, +}; + /* *** SETUP ETHERNET LINK FLOW CONTROL *** */ struct cmd_link_flow_ctrl_set_result { cmdline_fixed_string_t set; @@ -6815,25 +7320,25 @@ cmdline_parse_token_string_t cmd_lfc_set_high_water_str = 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"); @@ -6848,7 +7353,7 @@ cmdline_parse_token_string_t cmd_lfc_set_autoneg = 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 @@ -7015,28 +7520,29 @@ cmd_link_flow_ctrl_set_parsed(void *parsed_result, /* * Rx on/off, flow control is enabled/disabled on RX side. This can indicate - * the RTE_FC_TX_PAUSE, Transmit pause frame at the Rx side. + * the RTE_ETH_FC_TX_PAUSE, Transmit pause frame at the Rx side. * Tx on/off, flow control is enabled/disabled on TX side. This can indicate - * the RTE_FC_RX_PAUSE, Respond to the pause frame at the Tx side. + * the RTE_ETH_FC_RX_PAUSE, Respond to the pause frame at the Tx side. */ static enum rte_eth_fc_mode rx_tx_onoff_2_lfc_mode[2][2] = { - {RTE_FC_NONE, RTE_FC_TX_PAUSE}, {RTE_FC_RX_PAUSE, RTE_FC_FULL} + {RTE_ETH_FC_NONE, RTE_ETH_FC_TX_PAUSE}, {RTE_ETH_FC_RX_PAUSE, RTE_ETH_FC_FULL} }; /* Partial command line, retrieve current configuration */ if (cmd) { ret = rte_eth_dev_flow_ctrl_get(res->port_id, &fc_conf); if (ret != 0) { - printf("cannot get current flow ctrl parameters, return" - "code = %d\n", ret); + fprintf(stderr, + "cannot get current flow ctrl parameters, return code = %d\n", + ret); return; } - if ((fc_conf.mode == RTE_FC_RX_PAUSE) || - (fc_conf.mode == RTE_FC_FULL)) + if ((fc_conf.mode == RTE_ETH_FC_RX_PAUSE) || + (fc_conf.mode == RTE_ETH_FC_FULL)) rx_fc_en = 1; - if ((fc_conf.mode == RTE_FC_TX_PAUSE) || - (fc_conf.mode == RTE_FC_FULL)) + if ((fc_conf.mode == RTE_ETH_FC_TX_PAUSE) || + (fc_conf.mode == RTE_ETH_FC_FULL)) tx_fc_en = 1; } @@ -7072,7 +7578,9 @@ cmd_link_flow_ctrl_set_parsed(void *parsed_result, ret = rte_eth_dev_flow_ctrl_set(res->port_id, &fc_conf); if (ret != 0) - printf("bad flow contrl parameter, return code = %d \n", ret); + fprintf(stderr, + "bad flow control parameter, return code = %d\n", + ret); } /* *** SETUP ETHERNET PRIORITY FLOW CONTROL *** */ @@ -7102,12 +7610,12 @@ cmd_priority_flow_ctrl_set_parsed(void *parsed_result, /* * Rx on/off, flow control is enabled/disabled on RX side. This can indicate - * the RTE_FC_TX_PAUSE, Transmit pause frame at the Rx side. + * the RTE_ETH_FC_TX_PAUSE, Transmit pause frame at the Rx side. * Tx on/off, flow control is enabled/disabled on TX side. This can indicate - * the RTE_FC_RX_PAUSE, Respond to the pause frame at the Tx side. + * the RTE_ETH_FC_RX_PAUSE, Respond to the pause frame at the Tx side. */ static enum rte_eth_fc_mode rx_tx_onoff_2_pfc_mode[2][2] = { - {RTE_FC_NONE, RTE_FC_TX_PAUSE}, {RTE_FC_RX_PAUSE, RTE_FC_FULL} + {RTE_ETH_FC_NONE, RTE_ETH_FC_TX_PAUSE}, {RTE_ETH_FC_RX_PAUSE, RTE_ETH_FC_FULL} }; memset(&pfc_conf, 0, sizeof(struct rte_eth_pfc_conf)); @@ -7121,7 +7629,9 @@ cmd_priority_flow_ctrl_set_parsed(void *parsed_result, ret = rte_eth_dev_priority_flow_ctrl_set(res->port_id, &pfc_conf); if (ret != 0) - printf("bad priority flow contrl parameter, return code = %d \n", ret); + fprintf(stderr, + "bad priority flow control parameter, return code = %d\n", + ret); } cmdline_parse_token_string_t cmd_pfc_set_set = @@ -7144,19 +7654,19 @@ cmdline_parse_token_string_t cmd_pfc_set_tx_mode = 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, @@ -7294,7 +7804,7 @@ cmdline_parse_token_string_t cmd_start_tx_first_n_tx_first = 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, @@ -7325,7 +7835,8 @@ cmdline_parse_token_string_t cmd_set_link_up_link_up = 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, @@ -7364,7 +7875,8 @@ cmdline_parse_token_string_t cmd_set_link_down_link_down = 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, @@ -7406,8 +7918,14 @@ static void cmd_showcfg_parsed(void *parsed_result, fwd_lcores_config_display(); else if (!strcmp(res->what, "fwd")) pkt_fwd_config_display(&cur_fwd_config); + else if (!strcmp(res->what, "rxoffs")) + show_rx_pkt_offsets(); + else if (!strcmp(res->what, "rxpkts")) + show_rx_pkt_segments(); else if (!strcmp(res->what, "txpkts")) show_tx_pkt_segments(); + else if (!strcmp(res->what, "txtimes")) + show_tx_pkt_times(); } cmdline_parse_token_string_t cmd_showcfg_show = @@ -7416,12 +7934,12 @@ cmdline_parse_token_string_t cmd_showcfg_port = TOKEN_STRING_INITIALIZER(struct cmd_showcfg_result, cfg, "config"); cmdline_parse_token_string_t cmd_showcfg_what = TOKEN_STRING_INITIALIZER(struct cmd_showcfg_result, what, - "rxtx#cores#fwd#txpkts"); + "rxtx#cores#fwd#rxoffs#rxpkts#txpkts#txtimes"); cmdline_parse_inst_t cmd_showcfg = { .f = cmd_showcfg_parsed, .data = NULL, - .help_str = "show config rxtx|cores|fwd|txpkts", + .help_str = "show config rxtx|cores|fwd|rxoffs|rxpkts|txpkts|txtimes", .tokens = { (void *)&cmd_showcfg_show, (void *)&cmd_showcfg_port, @@ -7466,18 +7984,14 @@ static void cmd_showportall_parsed(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 = @@ -7487,14 +8001,14 @@ cmdline_parse_token_string_t cmd_showportall_port = 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, @@ -7532,14 +8046,12 @@ static void cmd_showport_parsed(void *parsed_result, 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 = @@ -7549,15 +8061,15 @@ cmdline_parse_token_string_t cmd_showport_port = 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 " "", .tokens = { (void *)&cmd_showport_show, @@ -7568,6 +8080,137 @@ cmdline_parse_inst_t cmd_showport = { }, }; +/* *** show port representors information *** */ +struct cmd_representor_info_result { + cmdline_fixed_string_t cmd_show; + cmdline_fixed_string_t cmd_port; + cmdline_fixed_string_t cmd_info; + cmdline_fixed_string_t cmd_keyword; + portid_t cmd_pid; +}; + +static void +cmd_representor_info_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_representor_info_result *res = parsed_result; + struct rte_eth_representor_info *info; + struct rte_eth_representor_range *range; + uint32_t range_diff; + uint32_t i; + int ret; + int num; + + if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { + fprintf(stderr, "Invalid port id %u\n", res->cmd_pid); + return; + } + + ret = rte_eth_representor_info_get(res->cmd_pid, NULL); + if (ret < 0) { + fprintf(stderr, + "Failed to get the number of representor info ranges for port %hu: %s\n", + res->cmd_pid, rte_strerror(-ret)); + return; + } + num = ret; + + info = calloc(1, sizeof(*info) + num * sizeof(info->ranges[0])); + if (info == NULL) { + fprintf(stderr, + "Failed to allocate memory for representor info for port %hu\n", + res->cmd_pid); + return; + } + info->nb_ranges_alloc = num; + + ret = rte_eth_representor_info_get(res->cmd_pid, info); + if (ret < 0) { + fprintf(stderr, + "Failed to get the representor info for port %hu: %s\n", + res->cmd_pid, rte_strerror(-ret)); + free(info); + return; + } + + printf("Port controller: %hu\n", info->controller); + printf("Port PF: %hu\n", info->pf); + + printf("Ranges: %u\n", info->nb_ranges); + for (i = 0; i < info->nb_ranges; i++) { + range = &info->ranges[i]; + range_diff = range->id_end - range->id_base; + + printf("%u. ", i + 1); + printf("'%s' ", range->name); + if (range_diff > 0) + printf("[%u-%u]: ", range->id_base, range->id_end); + else + printf("[%u]: ", range->id_base); + + printf("Controller %d, PF %d", range->controller, range->pf); + + switch (range->type) { + case RTE_ETH_REPRESENTOR_NONE: + printf(", NONE\n"); + break; + case RTE_ETH_REPRESENTOR_VF: + if (range_diff > 0) + printf(", VF %d..%d\n", range->vf, + range->vf + range_diff); + else + printf(", VF %d\n", range->vf); + break; + case RTE_ETH_REPRESENTOR_SF: + printf(", SF %d\n", range->sf); + break; + case RTE_ETH_REPRESENTOR_PF: + if (range_diff > 0) + printf("..%d\n", range->pf + range_diff); + else + printf("\n"); + break; + default: + printf(", UNKNOWN TYPE %d\n", range->type); + break; + } + } + + free(info); +} + +cmdline_parse_token_string_t cmd_representor_info_show = + TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result, + cmd_show, "show"); +cmdline_parse_token_string_t cmd_representor_info_port = + TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result, + cmd_port, "port"); +cmdline_parse_token_string_t cmd_representor_info_info = + TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result, + cmd_info, "info"); +cmdline_parse_token_num_t cmd_representor_info_pid = + TOKEN_NUM_INITIALIZER(struct cmd_representor_info_result, + cmd_pid, RTE_UINT16); +cmdline_parse_token_string_t cmd_representor_info_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result, + cmd_keyword, "representor"); + +cmdline_parse_inst_t cmd_representor_info = { + .f = cmd_representor_info_parsed, + .data = NULL, + .help_str = "show port info representor", + .tokens = { + (void *)&cmd_representor_info_show, + (void *)&cmd_representor_info_port, + (void *)&cmd_representor_info_info, + (void *)&cmd_representor_info_pid, + (void *)&cmd_representor_info_keyword, + NULL, + }, +}; + + /* *** SHOW DEVICE INFO *** */ struct cmd_showdevice_result { cmdline_fixed_string_t show; @@ -7613,6 +8256,52 @@ cmdline_parse_inst_t cmd_showdevice = { NULL, }, }; + +/* *** SHOW MODULE EEPROM/EEPROM port INFO *** */ +struct cmd_showeeprom_result { + cmdline_fixed_string_t show; + cmdline_fixed_string_t port; + uint16_t portnum; + cmdline_fixed_string_t type; +}; + +static void cmd_showeeprom_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_showeeprom_result *res = parsed_result; + + if (!strcmp(res->type, "eeprom")) + port_eeprom_display(res->portnum); + else if (!strcmp(res->type, "module_eeprom")) + port_module_eeprom_display(res->portnum); + else + fprintf(stderr, "Unknown argument\n"); +} + +cmdline_parse_token_string_t cmd_showeeprom_show = + TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, show, "show"); +cmdline_parse_token_string_t cmd_showeeprom_port = + TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, port, "port"); +cmdline_parse_token_num_t cmd_showeeprom_portnum = + TOKEN_NUM_INITIALIZER(struct cmd_showeeprom_result, portnum, + RTE_UINT16); +cmdline_parse_token_string_t cmd_showeeprom_type = + TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, type, "module_eeprom#eeprom"); + +cmdline_parse_inst_t cmd_showeeprom = { + .f = cmd_showeeprom_parsed, + .data = NULL, + .help_str = "show port module_eeprom|eeprom", + .tokens = { + (void *)&cmd_showeeprom_show, + (void *)&cmd_showeeprom_port, + (void *)&cmd_showeeprom_portnum, + (void *)&cmd_showeeprom_type, + NULL, + }, +}; + /* *** SHOW QUEUE INFO *** */ struct cmd_showqueue_result { cmdline_fixed_string_t show; @@ -7642,9 +8331,11 @@ cmdline_parse_token_string_t cmd_showqueue_type = 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, @@ -7725,9 +8416,9 @@ cmdline_parse_token_string_t cmd_read_reg_read = 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, @@ -7770,16 +8461,16 @@ cmdline_parse_token_string_t cmd_read_reg_bit_field_regfield = 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, @@ -7821,11 +8512,14 @@ cmdline_parse_token_string_t cmd_read_reg_bit_regbit = 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, @@ -7864,11 +8558,11 @@ cmdline_parse_token_string_t cmd_write_reg_write = 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, @@ -7913,19 +8607,19 @@ cmdline_parse_token_string_t cmd_write_reg_bit_field_regfield = 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, @@ -7971,13 +8665,17 @@ cmdline_parse_token_string_t cmd_write_reg_bit_regbit = 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, @@ -8023,11 +8721,14 @@ cmdline_parse_token_string_t cmd_read_rxd_txd_rxd_txd = 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, @@ -8093,7 +8794,7 @@ static void cmd_mac_addr_parsed(void *parsed_result, /* check the return value and print it if is < 0 */ if(ret < 0) - printf("mac_addr_cmd error: (%s)\n", strerror(-ret)); + fprintf(stderr, "mac_addr_cmd error: (%s)\n", strerror(-ret)); } @@ -8105,7 +8806,7 @@ cmdline_parse_token_string_t cmd_mac_addr_what = "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); @@ -8138,7 +8839,7 @@ static void cmd_set_eth_peer_parsed(void *parsed_result, struct cmd_eth_peer_result *res = parsed_result; if (test_done == 0) { - printf("Please stop forwarding first\n"); + fprintf(stderr, "Please stop forwarding first\n"); return; } if (!strcmp(res->eth_peer, "eth-peer")) { @@ -8151,7 +8852,8 @@ cmdline_parse_token_string_t cmd_eth_peer_set = 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); @@ -8200,13 +8902,13 @@ cmdline_parse_token_string_t cmd_setqmap_what = 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, @@ -8266,6 +8968,90 @@ cmdline_parse_inst_t cmd_set_xstats_hide_zero = { }, }; +/* *** SET OPTION TO ENABLE MEASUREMENT OF CPU CYCLES *** */ +struct cmd_set_record_core_cycles_result { + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t name; + cmdline_fixed_string_t on_off; +}; + +static void +cmd_set_record_core_cycles_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_set_record_core_cycles_result *res; + uint16_t on_off = 0; + + res = parsed_result; + on_off = !strcmp(res->on_off, "on") ? 1 : 0; + set_record_core_cycles(on_off); +} + +cmdline_parse_token_string_t cmd_set_record_core_cycles_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result, + keyword, "set"); +cmdline_parse_token_string_t cmd_set_record_core_cycles_name = + TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result, + name, "record-core-cycles"); +cmdline_parse_token_string_t cmd_set_record_core_cycles_on_off = + TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result, + on_off, "on#off"); + +cmdline_parse_inst_t cmd_set_record_core_cycles = { + .f = cmd_set_record_core_cycles_parsed, + .data = NULL, + .help_str = "set record-core-cycles on|off", + .tokens = { + (void *)&cmd_set_record_core_cycles_keyword, + (void *)&cmd_set_record_core_cycles_name, + (void *)&cmd_set_record_core_cycles_on_off, + NULL, + }, +}; + +/* *** SET OPTION TO ENABLE DISPLAY OF RX AND TX BURSTS *** */ +struct cmd_set_record_burst_stats_result { + cmdline_fixed_string_t keyword; + cmdline_fixed_string_t name; + cmdline_fixed_string_t on_off; +}; + +static void +cmd_set_record_burst_stats_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_set_record_burst_stats_result *res; + uint16_t on_off = 0; + + res = parsed_result; + on_off = !strcmp(res->on_off, "on") ? 1 : 0; + set_record_burst_stats(on_off); +} + +cmdline_parse_token_string_t cmd_set_record_burst_stats_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_set_record_burst_stats_result, + keyword, "set"); +cmdline_parse_token_string_t cmd_set_record_burst_stats_name = + TOKEN_STRING_INITIALIZER(struct cmd_set_record_burst_stats_result, + name, "record-burst-stats"); +cmdline_parse_token_string_t cmd_set_record_burst_stats_on_off = + TOKEN_STRING_INITIALIZER(struct cmd_set_record_burst_stats_result, + on_off, "on#off"); + +cmdline_parse_inst_t cmd_set_record_burst_stats = { + .f = cmd_set_record_burst_stats_parsed, + .data = NULL, + .help_str = "set record-burst-stats on|off", + .tokens = { + (void *)&cmd_set_record_burst_stats_keyword, + (void *)&cmd_set_record_burst_stats_name, + (void *)&cmd_set_record_burst_stats_on_off, + NULL, + }, +}; + /* *** CONFIGURE UNICAST HASH TABLE *** */ struct cmd_set_uc_hash_table { cmdline_fixed_string_t set; @@ -8290,7 +9076,9 @@ cmd_set_uc_hash_parsed(void *parsed_result, ret = rte_eth_dev_uc_hash_table_set(res->port_id, &res->address,(uint8_t)is_on); if (ret < 0) - printf("bad unicast hash table parameter, return code = %d \n", ret); + fprintf(stderr, + "bad unicast hash table parameter, return code = %d\n", + ret); } @@ -8302,7 +9090,7 @@ cmdline_parse_token_string_t cmd_set_uc_hash_port = 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"); @@ -8351,8 +9139,9 @@ cmd_set_uc_all_hash_parsed(void *parsed_result, (strcmp(res->value, "all") == 0)) ret = rte_eth_dev_uc_all_hash_table_set(res->port_id,(uint8_t) is_on); if (ret < 0) - printf("bad unicast hash table parameter," - "return code = %d \n", ret); + fprintf(stderr, + "bad unicast hash table parameter, return code = %d\n", + ret); } cmdline_parse_token_string_t cmd_set_uc_all_hash_set = @@ -8363,7 +9152,7 @@ cmdline_parse_token_string_t cmd_set_uc_all_hash_port = 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"); @@ -8389,132 +9178,28 @@ cmdline_parse_inst_t cmd_set_uc_all_hash_filter = { }, }; -/* *** CONFIGURE MACVLAN FILTER FOR VF(s) *** */ -struct cmd_set_vf_macvlan_filter { +/* *** CONFIGURE VF TRAFFIC CONTROL *** */ +struct cmd_set_vf_traffic { cmdline_fixed_string_t set; cmdline_fixed_string_t port; portid_t port_id; cmdline_fixed_string_t vf; uint8_t vf_id; - struct rte_ether_addr address; - cmdline_fixed_string_t filter_type; + cmdline_fixed_string_t what; cmdline_fixed_string_t mode; }; static void -cmd_set_vf_macvlan_parsed(void *parsed_result, +cmd_set_vf_traffic_parsed(void *parsed_result, __rte_unused struct cmdline *cl, __rte_unused void *data) { - int is_on, ret = 0; - struct cmd_set_vf_macvlan_filter *res = parsed_result; - struct rte_eth_mac_filter filter; - - memset(&filter, 0, sizeof(struct rte_eth_mac_filter)); - - rte_memcpy(&filter.mac_addr, &res->address, RTE_ETHER_ADDR_LEN); - - /* set VF MAC filter */ - filter.is_vf = 1; - - /* set VF ID */ - filter.dst_id = res->vf_id; + struct cmd_set_vf_traffic *res = parsed_result; + int is_rx = (strcmp(res->what, "rx") == 0) ? 1 : 0; + int is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0; - if (!strcmp(res->filter_type, "exact-mac")) - filter.filter_type = RTE_MAC_PERFECT_MATCH; - else if (!strcmp(res->filter_type, "exact-mac-vlan")) - filter.filter_type = RTE_MACVLAN_PERFECT_MATCH; - else if (!strcmp(res->filter_type, "hashmac")) - filter.filter_type = RTE_MAC_HASH_MATCH; - else if (!strcmp(res->filter_type, "hashmac-vlan")) - filter.filter_type = RTE_MACVLAN_HASH_MATCH; - - is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0; - - if (is_on) - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_MACVLAN, - RTE_ETH_FILTER_ADD, - &filter); - else - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_MACVLAN, - RTE_ETH_FILTER_DELETE, - &filter); - - if (ret < 0) - printf("bad set MAC hash parameter, return code = %d\n", ret); - -} - -cmdline_parse_token_string_t cmd_set_vf_macvlan_set = - TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter, - set, "set"); -cmdline_parse_token_string_t cmd_set_vf_macvlan_port = - TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter, - port, "port"); -cmdline_parse_token_num_t cmd_set_vf_macvlan_portid = - TOKEN_NUM_INITIALIZER(struct cmd_set_vf_macvlan_filter, - port_id, UINT16); -cmdline_parse_token_string_t cmd_set_vf_macvlan_vf = - TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter, - vf, "vf"); -cmdline_parse_token_num_t cmd_set_vf_macvlan_vf_id = - TOKEN_NUM_INITIALIZER(struct cmd_set_vf_macvlan_filter, - vf_id, UINT8); -cmdline_parse_token_etheraddr_t cmd_set_vf_macvlan_mac = - TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vf_macvlan_filter, - address); -cmdline_parse_token_string_t cmd_set_vf_macvlan_filter_type = - TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter, - filter_type, "exact-mac#exact-mac-vlan" - "#hashmac#hashmac-vlan"); -cmdline_parse_token_string_t cmd_set_vf_macvlan_mode = - TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter, - mode, "on#off"); - -cmdline_parse_inst_t cmd_set_vf_macvlan_filter = { - .f = cmd_set_vf_macvlan_parsed, - .data = NULL, - .help_str = "set port vf " - "exact-mac|exact-mac-vlan|hashmac|hashmac-vlan on|off: " - "Exact match rule: exact match of MAC or MAC and VLAN; " - "hash match rule: hash match of MAC and exact match of VLAN", - .tokens = { - (void *)&cmd_set_vf_macvlan_set, - (void *)&cmd_set_vf_macvlan_port, - (void *)&cmd_set_vf_macvlan_portid, - (void *)&cmd_set_vf_macvlan_vf, - (void *)&cmd_set_vf_macvlan_vf_id, - (void *)&cmd_set_vf_macvlan_mac, - (void *)&cmd_set_vf_macvlan_filter_type, - (void *)&cmd_set_vf_macvlan_mode, - NULL, - }, -}; - -/* *** CONFIGURE VF TRAFFIC CONTROL *** */ -struct cmd_set_vf_traffic { - cmdline_fixed_string_t set; - cmdline_fixed_string_t port; - portid_t port_id; - cmdline_fixed_string_t vf; - uint8_t vf_id; - cmdline_fixed_string_t what; - cmdline_fixed_string_t mode; -}; - -static void -cmd_set_vf_traffic_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - struct cmd_set_vf_traffic *res = parsed_result; - int is_rx = (strcmp(res->what, "rx") == 0) ? 1 : 0; - int is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0; - - set_vf_traffic(res->port_id, (uint8_t)is_rx, res->vf_id,(uint8_t) is_on); -} + set_vf_traffic(res->port_id, (uint8_t)is_rx, res->vf_id,(uint8_t) is_on); +} cmdline_parse_token_string_t cmd_setvf_traffic_set = TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic, @@ -8524,13 +9209,13 @@ cmdline_parse_token_string_t cmd_setvf_traffic_port = 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"); @@ -8578,30 +9263,31 @@ cmd_set_vf_rxmode_parsed(void *parsed_result, int is_on = (strcmp(res->on, "on") == 0) ? 1 : 0; if (!strcmp(res->what,"rxmode")) { if (!strcmp(res->mode, "AUPE")) - vf_rxmode |= ETH_VMDQ_ACCEPT_UNTAG; + vf_rxmode |= RTE_ETH_VMDQ_ACCEPT_UNTAG; else if (!strcmp(res->mode, "ROPE")) - vf_rxmode |= ETH_VMDQ_ACCEPT_HASH_UC; + vf_rxmode |= RTE_ETH_VMDQ_ACCEPT_HASH_UC; else if (!strcmp(res->mode, "BAM")) - vf_rxmode |= ETH_VMDQ_ACCEPT_BROADCAST; + vf_rxmode |= RTE_ETH_VMDQ_ACCEPT_BROADCAST; else if (!strncmp(res->mode, "MPE",3)) - vf_rxmode |= ETH_VMDQ_ACCEPT_MULTICAST; + vf_rxmode |= RTE_ETH_VMDQ_ACCEPT_MULTICAST; } RTE_SET_USED(is_on); -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE if (ret == -ENOTSUP) ret = rte_pmd_ixgbe_set_vf_rxmode(res->port_id, res->vf_id, vf_rxmode, (uint8_t)is_on); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_set_vf_rxmode(res->port_id, res->vf_id, vf_rxmode, (uint8_t)is_on); #endif if (ret < 0) - printf("bad VF receive mode parameter, return code = %d \n", - ret); + fprintf(stderr, + "bad VF receive mode parameter, return code = %d\n", + ret); } cmdline_parse_token_string_t cmd_set_vf_rxmode_set = @@ -8612,13 +9298,13 @@ cmdline_parse_token_string_t cmd_set_vf_rxmode_port = 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"); @@ -8668,19 +9354,19 @@ static void cmd_vf_mac_addr_parsed(void *parsed_result, if (strcmp(res->what, "add") != 0) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_add_vf_mac_addr(res->port_num, res->vf_num, &res->address); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_mac_addr_add(res->port_num, &res->address, res->vf_num); #endif if(ret < 0) - printf("vf_mac_addr_cmd error: (%s)\n", strerror(-ret)); + fprintf(stderr, "vf_mac_addr_cmd error: (%s)\n", strerror(-ret)); } @@ -8695,13 +9381,13 @@ cmdline_parse_token_string_t cmd_vf_mac_addr_port = 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); @@ -8744,17 +9430,17 @@ cmd_vf_rx_vlan_filter_parsed(void *parsed_result, __rte_unused int is_add = (strcmp(res->what, "add") == 0) ? 1 : 0; -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE if (ret == -ENOTSUP) ret = rte_pmd_ixgbe_set_vf_vlan_filter(res->port_id, res->vlan_id, res->vf_mask, is_add); #endif -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_set_vf_vlan_filter(res->port_id, res->vlan_id, res->vf_mask, is_add); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_set_vf_vlan_filter(res->port_id, res->vlan_id, res->vf_mask, is_add); @@ -8764,17 +9450,17 @@ cmd_vf_rx_vlan_filter_parsed(void *parsed_result, case 0: break; case -EINVAL: - printf("invalid vlan_id %d or vf_mask %"PRIu64"\n", - res->vlan_id, res->vf_mask); + fprintf(stderr, "invalid vlan_id %d or vf_mask %"PRIu64"\n", + res->vlan_id, res->vf_mask); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -8786,19 +9472,19 @@ cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_what = 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, @@ -8841,7 +9527,8 @@ static void cmd_queue_rate_limit_parsed(void *parsed_result, ret = set_queue_rate_limit(res->port_num, res->queue_num, res->rate_num); if (ret < 0) - printf("queue_rate_limit_cmd error: (%s)\n", strerror(-ret)); + fprintf(stderr, "queue_rate_limit_cmd error: (%s)\n", + strerror(-ret)); } @@ -8853,19 +9540,19 @@ cmdline_parse_token_string_t cmd_queue_rate_limit_port = 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, @@ -8911,7 +9598,8 @@ static void cmd_vf_rate_limit_parsed(void *parsed_result, ret = set_vf_rate_limit(res->port_num, res->vf_num, res->rate_num, res->q_msk_val); if (ret < 0) - printf("vf_rate_limit_cmd error: (%s)\n", strerror(-ret)); + fprintf(stderr, "vf_rate_limit_cmd error: (%s)\n", + strerror(-ret)); } @@ -8923,25 +9611,25 @@ cmdline_parse_token_string_t cmd_vf_rate_limit_port = 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, @@ -8963,160 +9651,9 @@ cmdline_parse_inst_t cmd_vf_rate_limit = { }, }; -/* *** 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 " - " vxlan|nvgre|ipingre oip|iip|imac-ivlan|" - "imac-ivlan-tenid|imac-tenid|imac|omac-imac-tenid " - ": 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; @@ -9132,9 +9669,7 @@ cmd_tunnel_udp_config_parsed(void *parsed_result, 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_ETH_TUNNEL_TYPE_VXLAN; if (!strcmp(res->what, "add")) ret = rte_eth_dev_udp_tunnel_port_add(res->port_id, @@ -9144,21 +9679,22 @@ cmd_tunnel_udp_config_parsed(void *parsed_result, &tunnel_udp); if (ret < 0) - printf("udp tunneling add error: (%s)\n", strerror(-ret)); + fprintf(stderr, "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, @@ -9166,7 +9702,7 @@ cmdline_parse_inst_t cmd_tunnel_udp_config = { .help_str = "rx_vxlan_port add|rm : " "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, @@ -9199,13 +9735,15 @@ cmd_cfg_tunnel_udp_port_parsed(void *parsed_result, tunnel_udp.udp_port = res->udp_port; if (!strcmp(res->tunnel_type, "vxlan")) { - tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN; + tunnel_udp.prot_type = RTE_ETH_TUNNEL_TYPE_VXLAN; } else if (!strcmp(res->tunnel_type, "geneve")) { - tunnel_udp.prot_type = RTE_TUNNEL_TYPE_GENEVE; + tunnel_udp.prot_type = RTE_ETH_TUNNEL_TYPE_GENEVE; } else if (!strcmp(res->tunnel_type, "vxlan-gpe")) { - tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN_GPE; + tunnel_udp.prot_type = RTE_ETH_TUNNEL_TYPE_VXLAN_GPE; + } else if (!strcmp(res->tunnel_type, "ecpri")) { + tunnel_udp.prot_type = RTE_ETH_TUNNEL_TYPE_ECPRI; } else { - printf("Invalid tunnel type\n"); + fprintf(stderr, "Invalid tunnel type\n"); return; } @@ -9217,7 +9755,8 @@ cmd_cfg_tunnel_udp_port_parsed(void *parsed_result, &tunnel_udp); if (ret < 0) - printf("udp tunneling port add error: (%s)\n", strerror(-ret)); + fprintf(stderr, "udp tunneling port add error: (%s)\n", + strerror(-ret)); } cmdline_parse_token_string_t cmd_config_tunnel_udp_port_port = @@ -9228,7 +9767,7 @@ cmdline_parse_token_string_t cmd_config_tunnel_udp_port_config = "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, @@ -9238,15 +9777,16 @@ cmdline_parse_token_string_t cmd_config_tunnel_udp_port_action = "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 udp_tunnel_port add|rm vxlan|geneve|vxlan-gpe ", + .help_str = "port config udp_tunnel_port add|rm vxlan|" + "geneve|vxlan-gpe|ecpri ", .tokens = { (void *)&cmd_config_tunnel_udp_port_port, (void *)&cmd_config_tunnel_udp_port_config, @@ -9259,316 +9799,6 @@ cmdline_parse_inst_t cmd_cfg_tunnel_udp_port = { }, }; -/* *** 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); - 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 gre-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; - cmdline_fixed_string_t port; - portid_t port_id; - cmdline_fixed_string_t mirror; - uint8_t rule_id; - cmdline_fixed_string_t what; - cmdline_fixed_string_t value; - cmdline_fixed_string_t dstpool; - uint8_t dstpool_id; - cmdline_fixed_string_t on; -}; - -cmdline_parse_token_string_t cmd_mirror_mask_set = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - set, "set"); -cmdline_parse_token_string_t cmd_mirror_mask_port = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - port, "port"); -cmdline_parse_token_num_t cmd_mirror_mask_portid = - TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result, - port_id, 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); -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" - "#vlan-mirror"); -cmdline_parse_token_string_t cmd_mirror_mask_value = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - value, NULL); -cmdline_parse_token_string_t cmd_mirror_mask_dstpool = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - dstpool, "dst-pool"); -cmdline_parse_token_num_t cmd_mirror_mask_poolid = - TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result, - dstpool_id, UINT8); -cmdline_parse_token_string_t cmd_mirror_mask_on = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, - on, "on#off"); - -static void -cmd_set_mirror_mask_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - int ret,nb_item,i; - struct cmd_set_mirror_mask_result *res = parsed_result; - struct rte_eth_mirror_conf mr_conf; - - memset(&mr_conf, 0, sizeof(struct rte_eth_mirror_conf)); - - unsigned int vlan_list[ETH_MIRROR_MAX_VLANS]; - - mr_conf.dst_pool = res->dstpool_id; - - if (!strcmp(res->what, "pool-mirror-up")) { - mr_conf.pool_mask = strtoull(res->value, NULL, 16); - mr_conf.rule_type = ETH_MIRROR_VIRTUAL_POOL_UP; - } else if (!strcmp(res->what, "pool-mirror-down")) { - mr_conf.pool_mask = strtoull(res->value, NULL, 16); - mr_conf.rule_type = ETH_MIRROR_VIRTUAL_POOL_DOWN; - } else if (!strcmp(res->what, "vlan-mirror")) { - mr_conf.rule_type = ETH_MIRROR_VLAN; - nb_item = parse_item_list(res->value, "vlan", - ETH_MIRROR_MAX_VLANS, vlan_list, 1); - if (nb_item <= 0) - return; - - for (i = 0; i < nb_item; i++) { - if (vlan_list[i] > RTE_ETHER_MAX_VLAN_ID) { - printf("Invalid vlan_id: must be < 4096\n"); - return; - } - - mr_conf.vlan.vlan_id[i] = (uint16_t)vlan_list[i]; - mr_conf.vlan.vlan_mask |= 1ULL << i; - } - } - - if (!strcmp(res->on, "on")) - ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, - res->rule_id, 1); - else - ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, - res->rule_id, 0); - if (ret < 0) - printf("mirror rule add error: (%s)\n", strerror(-ret)); -} - -cmdline_parse_inst_t cmd_set_mirror_mask = { - .f = cmd_set_mirror_mask_parsed, - .data = NULL, - .help_str = "set port mirror-rule " - "pool-mirror-up|pool-mirror-down|vlan-mirror " - " dst-pool on|off", - .tokens = { - (void *)&cmd_mirror_mask_set, - (void *)&cmd_mirror_mask_port, - (void *)&cmd_mirror_mask_portid, - (void *)&cmd_mirror_mask_mirror, - (void *)&cmd_mirror_mask_ruleid, - (void *)&cmd_mirror_mask_what, - (void *)&cmd_mirror_mask_value, - (void *)&cmd_mirror_mask_dstpool, - (void *)&cmd_mirror_mask_poolid, - (void *)&cmd_mirror_mask_on, - NULL, - }, -}; - -/* *** CONFIGURE VM MIRROR UPLINK/DOWNLINK RULE *** */ -struct cmd_set_mirror_link_result { - cmdline_fixed_string_t set; - cmdline_fixed_string_t port; - portid_t port_id; - cmdline_fixed_string_t mirror; - uint8_t rule_id; - cmdline_fixed_string_t what; - cmdline_fixed_string_t dstpool; - uint8_t dstpool_id; - cmdline_fixed_string_t on; -}; - -cmdline_parse_token_string_t cmd_mirror_link_set = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, - set, "set"); -cmdline_parse_token_string_t cmd_mirror_link_port = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, - port, "port"); -cmdline_parse_token_num_t cmd_mirror_link_portid = - TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result, - port_id, 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); -cmdline_parse_token_string_t cmd_mirror_link_what = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, - what, "uplink-mirror#downlink-mirror"); -cmdline_parse_token_string_t cmd_mirror_link_dstpool = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, - dstpool, "dst-pool"); -cmdline_parse_token_num_t cmd_mirror_link_poolid = - TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result, - dstpool_id, UINT8); -cmdline_parse_token_string_t cmd_mirror_link_on = - TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, - on, "on#off"); - -static void -cmd_set_mirror_link_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - int ret; - struct cmd_set_mirror_link_result *res = parsed_result; - struct rte_eth_mirror_conf mr_conf; - - memset(&mr_conf, 0, sizeof(struct rte_eth_mirror_conf)); - if (!strcmp(res->what, "uplink-mirror")) - mr_conf.rule_type = ETH_MIRROR_UPLINK_PORT; - else - mr_conf.rule_type = ETH_MIRROR_DOWNLINK_PORT; - - mr_conf.dst_pool = res->dstpool_id; - - if (!strcmp(res->on, "on")) - ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, - res->rule_id, 1); - else - ret = rte_eth_mirror_rule_set(res->port_id, &mr_conf, - res->rule_id, 0); - - /* check the return value and print it if is < 0 */ - if (ret < 0) - printf("mirror rule add error: (%s)\n", strerror(-ret)); - -} - -cmdline_parse_inst_t cmd_set_mirror_link = { - .f = cmd_set_mirror_link_parsed, - .data = NULL, - .help_str = "set port mirror-rule " - "uplink-mirror|downlink-mirror dst-pool on|off", - .tokens = { - (void *)&cmd_mirror_link_set, - (void *)&cmd_mirror_link_port, - (void *)&cmd_mirror_link_portid, - (void *)&cmd_mirror_link_mirror, - (void *)&cmd_mirror_link_ruleid, - (void *)&cmd_mirror_link_what, - (void *)&cmd_mirror_link_dstpool, - (void *)&cmd_mirror_link_poolid, - (void *)&cmd_mirror_link_on, - NULL, - }, -}; - -/* *** RESET VM MIRROR RULE *** */ -struct cmd_rm_mirror_rule_result { - cmdline_fixed_string_t reset; - cmdline_fixed_string_t port; - portid_t port_id; - cmdline_fixed_string_t mirror; - uint8_t rule_id; -}; - -cmdline_parse_token_string_t cmd_rm_mirror_rule_reset = - TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result, - reset, "reset"); -cmdline_parse_token_string_t cmd_rm_mirror_rule_port = - TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result, - port, "port"); -cmdline_parse_token_num_t cmd_rm_mirror_rule_portid = - TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result, - port_id, 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); - -static void -cmd_reset_mirror_rule_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - int ret; - struct cmd_set_mirror_link_result *res = parsed_result; - /* check rule_id */ - ret = rte_eth_mirror_rule_reset(res->port_id,res->rule_id); - if(ret < 0) - printf("mirror rule remove error: (%s)\n", strerror(-ret)); -} - -cmdline_parse_inst_t cmd_reset_mirror_rule = { - .f = cmd_reset_mirror_rule_parsed, - .data = NULL, - .help_str = "reset port mirror-rule ", - .tokens = { - (void *)&cmd_rm_mirror_rule_reset, - (void *)&cmd_rm_mirror_rule_port, - (void *)&cmd_rm_mirror_rule_portid, - (void *)&cmd_rm_mirror_rule_mirror, - (void *)&cmd_rm_mirror_rule_ruleid, - NULL, - }, -}; - /* ******************************************************************************** */ struct cmd_dump_result { @@ -9624,7 +9854,7 @@ dump_socket_mem(FILE *f) fprintf(f, "Total : size(M) total: %.6lf alloc: %.6lf(%.3lf%%) free: %.6lf \tcount alloc: %-4u free: %u\n", (double)total / (1024 * 1024), (double)alloc / (1024 * 1024), - (double)alloc * 100 / (double)total, + total ? ((double)alloc * 100 / (double)total) : 0, (double)free / (1024 * 1024), n_alloc, n_free); if (last_allocs) @@ -9729,97 +9959,6 @@ cmdline_parse_inst_t cmd_dump_one = { }, }; -/* *** Add/Del syn filter *** */ -struct cmd_syn_filter_result { - cmdline_fixed_string_t filter; - portid_t port_id; - cmdline_fixed_string_t ops; - cmdline_fixed_string_t priority; - cmdline_fixed_string_t high; - cmdline_fixed_string_t queue; - uint16_t queue_id; -}; - -static void -cmd_syn_filter_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - struct cmd_syn_filter_result *res = parsed_result; - struct rte_eth_syn_filter syn_filter; - int ret = 0; - - ret = rte_eth_dev_filter_supported(res->port_id, - RTE_ETH_FILTER_SYN); - if (ret < 0) { - printf("syn filter is not supported on port %u.\n", - res->port_id); - return; - } - - memset(&syn_filter, 0, sizeof(syn_filter)); - - if (!strcmp(res->ops, "add")) { - if (!strcmp(res->high, "high")) - syn_filter.hig_pri = 1; - else - syn_filter.hig_pri = 0; - - syn_filter.queue = res->queue_id; - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_SYN, - RTE_ETH_FILTER_ADD, - &syn_filter); - } else - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_SYN, - RTE_ETH_FILTER_DELETE, - &syn_filter); - - if (ret < 0) - printf("syn filter programming error: (%s)\n", - strerror(-ret)); -} - -cmdline_parse_token_string_t cmd_syn_filter_filter = - TOKEN_STRING_INITIALIZER(struct cmd_syn_filter_result, - filter, "syn_filter"); -cmdline_parse_token_num_t cmd_syn_filter_port_id = - TOKEN_NUM_INITIALIZER(struct cmd_syn_filter_result, - port_id, UINT16); -cmdline_parse_token_string_t cmd_syn_filter_ops = - TOKEN_STRING_INITIALIZER(struct cmd_syn_filter_result, - ops, "add#del"); -cmdline_parse_token_string_t cmd_syn_filter_priority = - TOKEN_STRING_INITIALIZER(struct cmd_syn_filter_result, - priority, "priority"); -cmdline_parse_token_string_t cmd_syn_filter_high = - TOKEN_STRING_INITIALIZER(struct cmd_syn_filter_result, - high, "high#low"); -cmdline_parse_token_string_t cmd_syn_filter_queue = - TOKEN_STRING_INITIALIZER(struct cmd_syn_filter_result, - queue, "queue"); -cmdline_parse_token_num_t cmd_syn_filter_queue_id = - TOKEN_NUM_INITIALIZER(struct cmd_syn_filter_result, - queue_id, UINT16); - -cmdline_parse_inst_t cmd_syn_filter = { - .f = cmd_syn_filter_parsed, - .data = NULL, - .help_str = "syn_filter add|del priority high|low queue " - ": Add/Delete syn filter", - .tokens = { - (void *)&cmd_syn_filter_filter, - (void *)&cmd_syn_filter_port_id, - (void *)&cmd_syn_filter_ops, - (void *)&cmd_syn_filter_priority, - (void *)&cmd_syn_filter_high, - (void *)&cmd_syn_filter_queue, - (void *)&cmd_syn_filter_queue_id, - NULL, - }, -}; - /* *** queue region set *** */ struct cmd_queue_region_result { cmdline_fixed_string_t set; @@ -9841,7 +9980,7 @@ cmd_queue_region_parsed(void *parsed_result, { struct cmd_queue_region_result *res = parsed_result; int ret = -ENOTSUP; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E struct rte_pmd_i40e_queue_region_conf region_conf; enum rte_pmd_i40e_queue_region_op op_type; #endif @@ -9849,7 +9988,7 @@ cmd_queue_region_parsed(void *parsed_result, if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E memset(®ion_conf, 0, sizeof(region_conf)); op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_SET; region_conf.region_id = res->region_id; @@ -9864,10 +10003,11 @@ cmd_queue_region_parsed(void *parsed_result, case 0: break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("queue region config error: (%s)\n", strerror(-ret)); + fprintf(stderr, "queue region config error: (%s)\n", + strerror(-ret)); } } @@ -9878,7 +10018,7 @@ cmdline_parse_token_string_t cmd_queue_region_port = 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"); @@ -9887,19 +10027,19 @@ cmdline_parse_token_string_t cmd_queue_region_id = 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, @@ -9940,7 +10080,7 @@ cmd_region_flowtype_parsed(void *parsed_result, { struct cmd_region_flowtype_result *res = parsed_result; int ret = -ENOTSUP; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E struct rte_pmd_i40e_queue_region_conf region_conf; enum rte_pmd_i40e_queue_region_op op_type; #endif @@ -9948,7 +10088,7 @@ cmd_region_flowtype_parsed(void *parsed_result, if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E memset(®ion_conf, 0, sizeof(region_conf)); op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_FLOWTYPE_SET; @@ -9963,10 +10103,11 @@ cmd_region_flowtype_parsed(void *parsed_result, case 0: break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("region flowtype config error: (%s)\n", strerror(-ret)); + fprintf(stderr, "region flowtype config error: (%s)\n", + strerror(-ret)); } } @@ -9978,7 +10119,7 @@ cmdline_parse_token_string_t cmd_region_flowtype_port = 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"); @@ -9987,13 +10128,13 @@ cmdline_parse_token_string_t cmd_region_flowtype_index = 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, @@ -10031,7 +10172,7 @@ cmd_user_priority_region_parsed(void *parsed_result, { struct cmd_user_priority_region_result *res = parsed_result; int ret = -ENOTSUP; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E struct rte_pmd_i40e_queue_region_conf region_conf; enum rte_pmd_i40e_queue_region_op op_type; #endif @@ -10039,7 +10180,7 @@ cmd_user_priority_region_parsed(void *parsed_result, if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E memset(®ion_conf, 0, sizeof(region_conf)); op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_USER_PRIORITY_SET; region_conf.user_priority = res->user_priority_id; @@ -10053,11 +10194,11 @@ cmd_user_priority_region_parsed(void *parsed_result, case 0: break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("user_priority region config error: (%s)\n", - strerror(-ret)); + fprintf(stderr, "user_priority region config error: (%s)\n", + strerror(-ret)); } } @@ -10069,7 +10210,7 @@ cmdline_parse_token_string_t cmd_user_priority_region_port = 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"); @@ -10078,13 +10219,13 @@ cmdline_parse_token_string_t cmd_user_priority_region_UP = 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, @@ -10122,7 +10263,7 @@ cmd_flush_queue_region_parsed(void *parsed_result, { struct cmd_flush_queue_region_result *res = parsed_result; int ret = -ENOTSUP; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E struct rte_pmd_i40e_queue_region_conf region_conf; enum rte_pmd_i40e_queue_region_op op_type; #endif @@ -10130,7 +10271,7 @@ cmd_flush_queue_region_parsed(void *parsed_result, if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E memset(®ion_conf, 0, sizeof(region_conf)); if (strcmp(res->what, "on") == 0) @@ -10146,11 +10287,11 @@ cmd_flush_queue_region_parsed(void *parsed_result, case 0: break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("queue region config flush error: (%s)\n", - strerror(-ret)); + fprintf(stderr, "queue region config flush error: (%s)\n", + strerror(-ret)); } } @@ -10162,7 +10303,7 @@ cmdline_parse_token_string_t cmd_flush_queue_region_port = 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"); @@ -10204,7 +10345,7 @@ cmd_show_queue_region_info_parsed(void *parsed_result, { struct cmd_show_queue_region_info *res = parsed_result; int ret = -ENOTSUP; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E struct rte_pmd_i40e_queue_regions rte_pmd_regions; enum rte_pmd_i40e_queue_region_op op_type; #endif @@ -10212,7 +10353,7 @@ cmd_show_queue_region_info_parsed(void *parsed_result, if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E memset(&rte_pmd_regions, 0, sizeof(rte_pmd_regions)); op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_INFO_GET; @@ -10227,11 +10368,11 @@ cmd_show_queue_region_info_parsed(void *parsed_result, case 0: break; case -ENOTSUP: - printf("function not implemented or supported\n"); + fprintf(stderr, "function not implemented or supported\n"); break; default: - printf("queue region config info show error: (%s)\n", - strerror(-ret)); + fprintf(stderr, "queue region config info show error: (%s)\n", + strerror(-ret)); } } @@ -10243,7 +10384,7 @@ cmdline_parse_token_string_t cmd_show_queue_region_info_port = 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"); @@ -10262,3149 +10403,589 @@ cmdline_parse_inst_t cmd_show_queue_region_info_all = { }, }; -/* *** ADD/REMOVE A 2tuple FILTER *** */ -struct cmd_2tuple_filter_result { - cmdline_fixed_string_t filter; - portid_t port_id; - cmdline_fixed_string_t ops; - cmdline_fixed_string_t dst_port; - uint16_t dst_port_value; - cmdline_fixed_string_t protocol; - uint8_t protocol_value; - cmdline_fixed_string_t mask; - uint8_t mask_value; - cmdline_fixed_string_t tcp_flags; - uint8_t tcp_flags_value; - cmdline_fixed_string_t priority; - uint8_t priority_value; - cmdline_fixed_string_t queue; - uint16_t queue_id; -}; - -static void -cmd_2tuple_filter_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - struct rte_eth_ntuple_filter filter; - struct cmd_2tuple_filter_result *res = parsed_result; - int ret = 0; +/* *** Filters Control *** */ - ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_NTUPLE); - if (ret < 0) { - printf("ntuple filter is not supported on port %u.\n", - res->port_id); - return; - } +#define IPV4_ADDR_TO_UINT(ip_addr, ip) \ +do { \ + if ((ip_addr).family == AF_INET) \ + (ip) = (ip_addr).addr.ipv4.s_addr; \ + else { \ + fprintf(stderr, "invalid parameter.\n"); \ + return; \ + } \ +} while (0) - memset(&filter, 0, sizeof(struct rte_eth_ntuple_filter)); +#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 { \ + fprintf(stderr, "invalid parameter.\n"); \ + return; \ + } \ +} while (0) - filter.flags = RTE_2TUPLE_FLAGS; - filter.dst_port_mask = (res->mask_value & 0x02) ? UINT16_MAX : 0; - filter.proto_mask = (res->mask_value & 0x01) ? UINT8_MAX : 0; - filter.proto = res->protocol_value; - filter.priority = res->priority_value; - if (res->tcp_flags_value != 0 && filter.proto != IPPROTO_TCP) { - printf("nonzero tcp_flags is only meaningful" - " when protocol is TCP.\n"); - return; - } - if (res->tcp_flags_value > RTE_NTUPLE_TCP_FLAGS_MASK) { - printf("invalid TCP flags.\n"); - return; - } +#ifdef RTE_NET_I40E - if (res->tcp_flags_value != 0) { - filter.flags |= RTE_NTUPLE_FLAGS_TCP_FLAG; - filter.tcp_flags = res->tcp_flags_value; - } +static uint16_t +str2flowtype(char *string) +{ + uint8_t i = 0; + static const struct { + char str[32]; + uint16_t type; + } flowtype_str[] = { + {"raw", RTE_ETH_FLOW_RAW}, + {"ipv4", RTE_ETH_FLOW_IPV4}, + {"ipv4-frag", RTE_ETH_FLOW_FRAG_IPV4}, + {"ipv4-tcp", RTE_ETH_FLOW_NONFRAG_IPV4_TCP}, + {"ipv4-udp", RTE_ETH_FLOW_NONFRAG_IPV4_UDP}, + {"ipv4-sctp", RTE_ETH_FLOW_NONFRAG_IPV4_SCTP}, + {"ipv4-other", RTE_ETH_FLOW_NONFRAG_IPV4_OTHER}, + {"ipv6", RTE_ETH_FLOW_IPV6}, + {"ipv6-frag", RTE_ETH_FLOW_FRAG_IPV6}, + {"ipv6-tcp", RTE_ETH_FLOW_NONFRAG_IPV6_TCP}, + {"ipv6-udp", RTE_ETH_FLOW_NONFRAG_IPV6_UDP}, + {"ipv6-sctp", RTE_ETH_FLOW_NONFRAG_IPV6_SCTP}, + {"ipv6-other", RTE_ETH_FLOW_NONFRAG_IPV6_OTHER}, + {"l2_payload", RTE_ETH_FLOW_L2_PAYLOAD}, + {"ipv6-ex", RTE_ETH_FLOW_IPV6_EX}, + {"ipv6-tcp-ex", RTE_ETH_FLOW_IPV6_TCP_EX}, + {"ipv6-udp-ex", RTE_ETH_FLOW_IPV6_UDP_EX}, + {"gtpu", RTE_ETH_FLOW_GTPU}, + }; - /* need convert to big endian. */ - filter.dst_port = rte_cpu_to_be_16(res->dst_port_value); - filter.queue = res->queue_id; + for (i = 0; i < RTE_DIM(flowtype_str); i++) { + if (!strcmp(flowtype_str[i].str, string)) + return flowtype_str[i].type; + } - if (!strcmp(res->ops, "add")) - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_NTUPLE, - RTE_ETH_FILTER_ADD, - &filter); - else - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_NTUPLE, - RTE_ETH_FILTER_DELETE, - &filter); - if (ret < 0) - printf("2tuple filter programming error: (%s)\n", - strerror(-ret)); + if (isdigit(string[0]) && atoi(string) > 0 && atoi(string) < 64) + return (uint16_t)atoi(string); + return RTE_ETH_FLOW_UNKNOWN; } -cmdline_parse_token_string_t cmd_2tuple_filter_filter = - TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result, - filter, "2tuple_filter"); -cmdline_parse_token_num_t cmd_2tuple_filter_port_id = - TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result, - port_id, UINT16); -cmdline_parse_token_string_t cmd_2tuple_filter_ops = - TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result, - ops, "add#del"); -cmdline_parse_token_string_t cmd_2tuple_filter_dst_port = - TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result, - dst_port, "dst_port"); -cmdline_parse_token_num_t cmd_2tuple_filter_dst_port_value = - TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result, - dst_port_value, UINT16); -cmdline_parse_token_string_t cmd_2tuple_filter_protocol = - TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result, - protocol, "protocol"); -cmdline_parse_token_num_t cmd_2tuple_filter_protocol_value = - TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result, - protocol_value, UINT8); -cmdline_parse_token_string_t cmd_2tuple_filter_mask = - TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result, - mask, "mask"); -cmdline_parse_token_num_t cmd_2tuple_filter_mask_value = - TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result, - mask_value, INT8); -cmdline_parse_token_string_t cmd_2tuple_filter_tcp_flags = - TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result, - tcp_flags, "tcp_flags"); -cmdline_parse_token_num_t cmd_2tuple_filter_tcp_flags_value = - TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result, - tcp_flags_value, UINT8); -cmdline_parse_token_string_t cmd_2tuple_filter_priority = - TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result, - priority, "priority"); -cmdline_parse_token_num_t cmd_2tuple_filter_priority_value = - TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result, - priority_value, UINT8); -cmdline_parse_token_string_t cmd_2tuple_filter_queue = - TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result, - queue, "queue"); -cmdline_parse_token_num_t cmd_2tuple_filter_queue_id = - TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result, - queue_id, UINT16); - -cmdline_parse_inst_t cmd_2tuple_filter = { - .f = cmd_2tuple_filter_parsed, - .data = NULL, - .help_str = "2tuple_filter add|del dst_port protocol " - " mask tcp_flags priority queue " - ": Add a 2tuple filter", - .tokens = { - (void *)&cmd_2tuple_filter_filter, - (void *)&cmd_2tuple_filter_port_id, - (void *)&cmd_2tuple_filter_ops, - (void *)&cmd_2tuple_filter_dst_port, - (void *)&cmd_2tuple_filter_dst_port_value, - (void *)&cmd_2tuple_filter_protocol, - (void *)&cmd_2tuple_filter_protocol_value, - (void *)&cmd_2tuple_filter_mask, - (void *)&cmd_2tuple_filter_mask_value, - (void *)&cmd_2tuple_filter_tcp_flags, - (void *)&cmd_2tuple_filter_tcp_flags_value, - (void *)&cmd_2tuple_filter_priority, - (void *)&cmd_2tuple_filter_priority_value, - (void *)&cmd_2tuple_filter_queue, - (void *)&cmd_2tuple_filter_queue_id, - NULL, - }, -}; - -/* *** ADD/REMOVE A 5tuple FILTER *** */ -struct cmd_5tuple_filter_result { - cmdline_fixed_string_t filter; +/* *** 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 dst_ip; - cmdline_ipaddr_t dst_ip_value; - cmdline_fixed_string_t src_ip; - cmdline_ipaddr_t src_ip_value; - cmdline_fixed_string_t dst_port; - uint16_t dst_port_value; - cmdline_fixed_string_t src_port; - uint16_t src_port_value; - cmdline_fixed_string_t protocol; - uint8_t protocol_value; - cmdline_fixed_string_t mask; - uint8_t mask_value; - cmdline_fixed_string_t tcp_flags; - uint8_t tcp_flags_value; - cmdline_fixed_string_t priority; - uint8_t priority_value; + 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_5tuple_filter_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) +cmd_flow_director_filter_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) { - struct rte_eth_ntuple_filter filter; - struct cmd_5tuple_filter_result *res = parsed_result; + struct cmd_flow_director_result *res = parsed_result; 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_NTUPLE); - if (ret < 0) { - printf("ntuple filter is not supported on port %u.\n", - res->port_id); - return; - } - - memset(&filter, 0, sizeof(struct rte_eth_ntuple_filter)); + memset(&conf, 0, sizeof(conf)); - filter.flags = RTE_5TUPLE_FLAGS; - filter.dst_ip_mask = (res->mask_value & 0x10) ? UINT32_MAX : 0; - filter.src_ip_mask = (res->mask_value & 0x08) ? UINT32_MAX : 0; - filter.dst_port_mask = (res->mask_value & 0x04) ? UINT16_MAX : 0; - filter.src_port_mask = (res->mask_value & 0x02) ? UINT16_MAX : 0; - filter.proto_mask = (res->mask_value & 0x01) ? UINT8_MAX : 0; - filter.proto = res->protocol_value; - filter.priority = res->priority_value; - if (res->tcp_flags_value != 0 && filter.proto != IPPROTO_TCP) { - printf("nonzero tcp_flags is only meaningful" - " when protocol is TCP.\n"); + if (flow_type == RTE_ETH_FLOW_UNKNOWN) { + fprintf(stderr, "Invalid flow type specified.\n"); return; } - if (res->tcp_flags_value > RTE_NTUPLE_TCP_FLAGS_MASK) { - printf("invalid TCP flags.\n"); + ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id, + mapping); + if (ret) + return; + if (mapping[flow_type].pctype == 0ULL) { + fprintf(stderr, "Invalid flow type specified.\n"); return; } - - if (res->tcp_flags_value != 0) { - filter.flags |= RTE_NTUPLE_FLAGS_TCP_FLAG; - filter.tcp_flags = res->tcp_flags_value; - } - - if (res->dst_ip_value.family == AF_INET) - /* no need to convert, already big endian. */ - filter.dst_ip = res->dst_ip_value.addr.ipv4.s_addr; - else { - if (filter.dst_ip_mask == 0) { - printf("can not support ipv6 involved compare.\n"); - return; + for (i = 0; i < RTE_PMD_I40E_PCTYPE_MAX; i++) { + if (mapping[flow_type].pctype & (1ULL << i)) { + conf.input.pctype = i; + break; } - filter.dst_ip = 0; } - if (res->src_ip_value.family == AF_INET) - /* no need to convert, already big endian. */ - filter.src_ip = res->src_ip_value.addr.ipv4.s_addr; - else { - if (filter.src_ip_mask == 0) { - printf("can not support ipv6 involved compare.\n"); - return; - } - filter.src_ip = 0; - } - /* need convert to big endian. */ - filter.dst_port = rte_cpu_to_be_16(res->dst_port_value); - filter.src_port = rte_cpu_to_be_16(res->src_port_value); - filter.queue = res->queue_id; - - if (!strcmp(res->ops, "add")) - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_NTUPLE, - RTE_ETH_FILTER_ADD, - &filter); + 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 - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_NTUPLE, - RTE_ETH_FILTER_DELETE, - &filter); + 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("5tuple filter programming error: (%s)\n", + fprintf(stderr, "flow director config error: (%s)\n", strerror(-ret)); + close_file(conf.input.packet); } -cmdline_parse_token_string_t cmd_5tuple_filter_filter = - TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result, - filter, "5tuple_filter"); -cmdline_parse_token_num_t cmd_5tuple_filter_port_id = - TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result, - port_id, UINT16); -cmdline_parse_token_string_t cmd_5tuple_filter_ops = - TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result, - ops, "add#del"); -cmdline_parse_token_string_t cmd_5tuple_filter_dst_ip = - TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result, - dst_ip, "dst_ip"); -cmdline_parse_token_ipaddr_t cmd_5tuple_filter_dst_ip_value = - TOKEN_IPADDR_INITIALIZER(struct cmd_5tuple_filter_result, - dst_ip_value); -cmdline_parse_token_string_t cmd_5tuple_filter_src_ip = - TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result, - src_ip, "src_ip"); -cmdline_parse_token_ipaddr_t cmd_5tuple_filter_src_ip_value = - TOKEN_IPADDR_INITIALIZER(struct cmd_5tuple_filter_result, - src_ip_value); -cmdline_parse_token_string_t cmd_5tuple_filter_dst_port = - TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result, - dst_port, "dst_port"); -cmdline_parse_token_num_t cmd_5tuple_filter_dst_port_value = - TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result, - dst_port_value, UINT16); -cmdline_parse_token_string_t cmd_5tuple_filter_src_port = - TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result, - src_port, "src_port"); -cmdline_parse_token_num_t cmd_5tuple_filter_src_port_value = - TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result, - src_port_value, UINT16); -cmdline_parse_token_string_t cmd_5tuple_filter_protocol = - TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result, - protocol, "protocol"); -cmdline_parse_token_num_t cmd_5tuple_filter_protocol_value = - TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result, - protocol_value, UINT8); -cmdline_parse_token_string_t cmd_5tuple_filter_mask = - TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result, - mask, "mask"); -cmdline_parse_token_num_t cmd_5tuple_filter_mask_value = - TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result, - mask_value, INT8); -cmdline_parse_token_string_t cmd_5tuple_filter_tcp_flags = - TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result, - tcp_flags, "tcp_flags"); -cmdline_parse_token_num_t cmd_5tuple_filter_tcp_flags_value = - TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result, - tcp_flags_value, UINT8); -cmdline_parse_token_string_t cmd_5tuple_filter_priority = - TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result, - priority, "priority"); -cmdline_parse_token_num_t cmd_5tuple_filter_priority_value = - TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result, - priority_value, UINT8); -cmdline_parse_token_string_t cmd_5tuple_filter_queue = - TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result, - queue, "queue"); -cmdline_parse_token_num_t cmd_5tuple_filter_queue_id = - TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result, - queue_id, UINT16); +cmdline_parse_token_string_t cmd_flow_director_filter = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + 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, 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 = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + flow, "flow"); +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_drop = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + drop, "drop#fwd"); +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, 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, 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_raw = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + mode_value, "raw"); +cmdline_parse_token_string_t cmd_flow_director_packet = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + packet, "packet"); +cmdline_parse_token_string_t cmd_flow_director_filepath = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, + filepath, NULL); -cmdline_parse_inst_t cmd_5tuple_filter = { - .f = cmd_5tuple_filter_parsed, +cmdline_parse_inst_t cmd_add_del_raw_flow_director = { + .f = cmd_flow_director_filter_parsed, .data = NULL, - .help_str = "5tuple_filter add|del dst_ip " - "src_ip dst_port src_port " - "protocol mask tcp_flags " - "priority queue : Add/Del a 5tuple filter", + .help_str = "flow_director_filter ... : Add or delete a raw flow " + "director entry on NIC", .tokens = { - (void *)&cmd_5tuple_filter_filter, - (void *)&cmd_5tuple_filter_port_id, - (void *)&cmd_5tuple_filter_ops, - (void *)&cmd_5tuple_filter_dst_ip, - (void *)&cmd_5tuple_filter_dst_ip_value, - (void *)&cmd_5tuple_filter_src_ip, - (void *)&cmd_5tuple_filter_src_ip_value, - (void *)&cmd_5tuple_filter_dst_port, - (void *)&cmd_5tuple_filter_dst_port_value, - (void *)&cmd_5tuple_filter_src_port, - (void *)&cmd_5tuple_filter_src_port_value, - (void *)&cmd_5tuple_filter_protocol, - (void *)&cmd_5tuple_filter_protocol_value, - (void *)&cmd_5tuple_filter_mask, - (void *)&cmd_5tuple_filter_mask_value, - (void *)&cmd_5tuple_filter_tcp_flags, - (void *)&cmd_5tuple_filter_tcp_flags_value, - (void *)&cmd_5tuple_filter_priority, - (void *)&cmd_5tuple_filter_priority_value, - (void *)&cmd_5tuple_filter_queue, - (void *)&cmd_5tuple_filter_queue_id, + (void *)&cmd_flow_director_filter, + (void *)&cmd_flow_director_port_id, + (void *)&cmd_flow_director_mode, + (void *)&cmd_flow_director_mode_raw, + (void *)&cmd_flow_director_ops, + (void *)&cmd_flow_director_flow, + (void *)&cmd_flow_director_flow_type, + (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, + (void *)&cmd_flow_director_packet, + (void *)&cmd_flow_director_filepath, NULL, }, }; -/* *** ADD/REMOVE A flex FILTER *** */ -struct cmd_flex_filter_result { - cmdline_fixed_string_t filter; - cmdline_fixed_string_t ops; +#endif /* RTE_NET_I40E */ + +/* *** deal with flow director mask *** */ +struct cmd_flow_director_mask_result { + cmdline_fixed_string_t flow_director_mask; portid_t port_id; - cmdline_fixed_string_t len; - uint8_t len_value; - cmdline_fixed_string_t bytes; - cmdline_fixed_string_t bytes_value; - cmdline_fixed_string_t mask; - cmdline_fixed_string_t mask_value; - cmdline_fixed_string_t priority; - uint8_t priority_value; - cmdline_fixed_string_t queue; - uint16_t queue_id; + cmdline_fixed_string_t mode; + cmdline_fixed_string_t mode_value; + cmdline_fixed_string_t vlan; + uint16_t vlan_mask; + cmdline_fixed_string_t src_mask; + cmdline_ipaddr_t ipv4_src; + cmdline_ipaddr_t ipv6_src; + uint16_t port_src; + cmdline_fixed_string_t dst_mask; + cmdline_ipaddr_t ipv4_dst; + cmdline_ipaddr_t ipv6_dst; + uint16_t port_dst; + cmdline_fixed_string_t mac; + uint8_t mac_addr_byte_mask; + cmdline_fixed_string_t tunnel_id; + uint32_t tunnel_id_mask; + cmdline_fixed_string_t tunnel_type; + uint8_t tunnel_type_mask; }; -static int xdigit2val(unsigned char c) -{ - int val; - if (isdigit(c)) - val = c - '0'; - else if (isupper(c)) - val = c - 'A' + 10; - else - val = c - 'a' + 10; - return val; -} - static void -cmd_flex_filter_parsed(void *parsed_result, +cmd_flow_director_mask_parsed(void *parsed_result, __rte_unused struct cmdline *cl, __rte_unused void *data) { - int ret = 0; - struct rte_eth_flex_filter filter; - struct cmd_flex_filter_result *res = parsed_result; - char *bytes_ptr, *mask_ptr; - uint16_t len, i, j = 0; - char c; - int val; - uint8_t byte = 0; + struct cmd_flow_director_mask_result *res = parsed_result; + struct rte_eth_fdir_masks *mask; + struct rte_port *port; - if (res->len_value > RTE_FLEX_FILTER_MAXLEN) { - printf("the len exceed the max length 128\n"); - return; - } - memset(&filter, 0, sizeof(struct rte_eth_flex_filter)); - filter.len = res->len_value; - filter.priority = res->priority_value; - filter.queue = res->queue_id; - bytes_ptr = res->bytes_value; - mask_ptr = res->mask_value; - - /* translate bytes string to array. */ - if (bytes_ptr[0] == '0' && ((bytes_ptr[1] == 'x') || - (bytes_ptr[1] == 'X'))) - bytes_ptr += 2; - len = strnlen(bytes_ptr, res->len_value * 2); - if (len == 0 || (len % 8 != 0)) { - printf("please check len and bytes input\n"); + port = &ports[res->port_id]; + /** Check if the port is not started **/ + if (port->port_status != RTE_PORT_STOPPED) { + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } - for (i = 0; i < len; i++) { - c = bytes_ptr[i]; - if (isxdigit(c) == 0) { - /* invalid characters. */ - printf("invalid input\n"); + + mask = &port->dev_conf.fdir_conf.mask; + + if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) { + if (strcmp(res->mode_value, "MAC-VLAN")) { + fprintf(stderr, "Please set mode to MAC-VLAN.\n"); return; } - val = xdigit2val(c); - if (i % 2) { - byte |= val; - filter.bytes[j] = byte; - printf("bytes[%d]:%02x ", j, filter.bytes[j]); - j++; - byte = 0; - } else - byte |= val << 4; - } - printf("\n"); - /* translate mask string to uint8_t array. */ - if (mask_ptr[0] == '0' && ((mask_ptr[1] == 'x') || - (mask_ptr[1] == 'X'))) - mask_ptr += 2; - len = strnlen(mask_ptr, (res->len_value + 3) / 4); - if (len == 0) { - printf("invalid input\n"); - return; - } - j = 0; - byte = 0; - for (i = 0; i < len; i++) { - c = mask_ptr[i]; - if (isxdigit(c) == 0) { - /* invalid characters. */ - printf("invalid input\n"); + + mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask); + } else if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) { + if (strcmp(res->mode_value, "Tunnel")) { + fprintf(stderr, "Please set mode to Tunnel.\n"); return; } - val = xdigit2val(c); - if (i % 2) { - byte |= val; - filter.mask[j] = byte; - printf("mask[%d]:%02x ", j, filter.mask[j]); - j++; - byte = 0; - } else - byte |= val << 4; - } - printf("\n"); - - if (!strcmp(res->ops, "add")) - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_FLEXIBLE, - RTE_ETH_FILTER_ADD, - &filter); - else - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_FLEXIBLE, - RTE_ETH_FILTER_DELETE, - &filter); - - if (ret < 0) - printf("flex filter setting error: (%s)\n", strerror(-ret)); -} - -cmdline_parse_token_string_t cmd_flex_filter_filter = - TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result, - filter, "flex_filter"); -cmdline_parse_token_num_t cmd_flex_filter_port_id = - TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result, - port_id, UINT16); -cmdline_parse_token_string_t cmd_flex_filter_ops = - TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result, - ops, "add#del"); -cmdline_parse_token_string_t cmd_flex_filter_len = - TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result, - len, "len"); -cmdline_parse_token_num_t cmd_flex_filter_len_value = - TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result, - len_value, UINT8); -cmdline_parse_token_string_t cmd_flex_filter_bytes = - TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result, - bytes, "bytes"); -cmdline_parse_token_string_t cmd_flex_filter_bytes_value = - TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result, - bytes_value, NULL); -cmdline_parse_token_string_t cmd_flex_filter_mask = - TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result, - mask, "mask"); -cmdline_parse_token_string_t cmd_flex_filter_mask_value = - TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result, - mask_value, NULL); -cmdline_parse_token_string_t cmd_flex_filter_priority = - TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result, - priority, "priority"); -cmdline_parse_token_num_t cmd_flex_filter_priority_value = - TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result, - priority_value, UINT8); -cmdline_parse_token_string_t cmd_flex_filter_queue = - TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result, - queue, "queue"); -cmdline_parse_token_num_t cmd_flex_filter_queue_id = - TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result, - queue_id, UINT16); -cmdline_parse_inst_t cmd_flex_filter = { - .f = cmd_flex_filter_parsed, - .data = NULL, - .help_str = "flex_filter add|del len bytes " - " mask priority queue : " - "Add/Del a flex filter", - .tokens = { - (void *)&cmd_flex_filter_filter, - (void *)&cmd_flex_filter_port_id, - (void *)&cmd_flex_filter_ops, - (void *)&cmd_flex_filter_len, - (void *)&cmd_flex_filter_len_value, - (void *)&cmd_flex_filter_bytes, - (void *)&cmd_flex_filter_bytes_value, - (void *)&cmd_flex_filter_mask, - (void *)&cmd_flex_filter_mask_value, - (void *)&cmd_flex_filter_priority, - (void *)&cmd_flex_filter_priority_value, - (void *)&cmd_flex_filter_queue, - (void *)&cmd_flex_filter_queue_id, - NULL, - }, -}; - -/* *** Filters Control *** */ - -/* *** deal with ethertype filter *** */ -struct cmd_ethertype_filter_result { - cmdline_fixed_string_t filter; - portid_t port_id; - cmdline_fixed_string_t ops; - cmdline_fixed_string_t mac; - struct rte_ether_addr mac_addr; - cmdline_fixed_string_t ethertype; - uint16_t ethertype_value; - cmdline_fixed_string_t drop; - cmdline_fixed_string_t queue; - uint16_t queue_id; -}; - -cmdline_parse_token_string_t cmd_ethertype_filter_filter = - TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result, - filter, "ethertype_filter"); -cmdline_parse_token_num_t cmd_ethertype_filter_port_id = - TOKEN_NUM_INITIALIZER(struct cmd_ethertype_filter_result, - port_id, UINT16); -cmdline_parse_token_string_t cmd_ethertype_filter_ops = - TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result, - ops, "add#del"); -cmdline_parse_token_string_t cmd_ethertype_filter_mac = - TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result, - mac, "mac_addr#mac_ignr"); -cmdline_parse_token_etheraddr_t cmd_ethertype_filter_mac_addr = - TOKEN_ETHERADDR_INITIALIZER(struct cmd_ethertype_filter_result, - mac_addr); -cmdline_parse_token_string_t cmd_ethertype_filter_ethertype = - TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result, - ethertype, "ethertype"); -cmdline_parse_token_num_t cmd_ethertype_filter_ethertype_value = - TOKEN_NUM_INITIALIZER(struct cmd_ethertype_filter_result, - ethertype_value, UINT16); -cmdline_parse_token_string_t cmd_ethertype_filter_drop = - TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result, - drop, "drop#fwd"); -cmdline_parse_token_string_t cmd_ethertype_filter_queue = - TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result, - queue, "queue"); -cmdline_parse_token_num_t cmd_ethertype_filter_queue_id = - TOKEN_NUM_INITIALIZER(struct cmd_ethertype_filter_result, - queue_id, UINT16); -static void -cmd_ethertype_filter_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - struct cmd_ethertype_filter_result *res = parsed_result; - struct rte_eth_ethertype_filter filter; - int ret = 0; + mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask); + mask->mac_addr_byte_mask = res->mac_addr_byte_mask; + mask->tunnel_id_mask = rte_cpu_to_be_32(res->tunnel_id_mask); + mask->tunnel_type_mask = res->tunnel_type_mask; + } else { + if (strcmp(res->mode_value, "IP")) { + fprintf(stderr, "Please set mode to IP.\n"); + return; + } - ret = rte_eth_dev_filter_supported(res->port_id, - RTE_ETH_FILTER_ETHERTYPE); - if (ret < 0) { - printf("ethertype filter is not supported on port %u.\n", - res->port_id); - return; + mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask); + IPV4_ADDR_TO_UINT(res->ipv4_src, mask->ipv4_mask.src_ip); + IPV4_ADDR_TO_UINT(res->ipv4_dst, mask->ipv4_mask.dst_ip); + IPV6_ADDR_TO_ARRAY(res->ipv6_src, mask->ipv6_mask.src_ip); + IPV6_ADDR_TO_ARRAY(res->ipv6_dst, mask->ipv6_mask.dst_ip); + mask->src_port_mask = rte_cpu_to_be_16(res->port_src); + mask->dst_port_mask = rte_cpu_to_be_16(res->port_dst); } - memset(&filter, 0, sizeof(filter)); - if (!strcmp(res->mac, "mac_addr")) { - filter.flags |= RTE_ETHTYPE_FLAGS_MAC; - rte_memcpy(&filter.mac_addr, &res->mac_addr, - sizeof(struct rte_ether_addr)); - } - if (!strcmp(res->drop, "drop")) - filter.flags |= RTE_ETHTYPE_FLAGS_DROP; - filter.ether_type = res->ethertype_value; - filter.queue = res->queue_id; - - if (!strcmp(res->ops, "add")) - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_ETHERTYPE, - RTE_ETH_FILTER_ADD, - &filter); - else - ret = rte_eth_dev_filter_ctrl(res->port_id, - RTE_ETH_FILTER_ETHERTYPE, - RTE_ETH_FILTER_DELETE, - &filter); - if (ret < 0) - printf("ethertype filter programming error: (%s)\n", - strerror(-ret)); + cmd_reconfig_device_queue(res->port_id, 1, 1); } -cmdline_parse_inst_t cmd_ethertype_filter = { - .f = cmd_ethertype_filter_parsed, - .data = NULL, - .help_str = "ethertype_filter add|del mac_addr|mac_ignr " - " ethertype drop|fw queue : " - "Add or delete an ethertype filter entry", - .tokens = { - (void *)&cmd_ethertype_filter_filter, - (void *)&cmd_ethertype_filter_port_id, - (void *)&cmd_ethertype_filter_ops, - (void *)&cmd_ethertype_filter_mac, - (void *)&cmd_ethertype_filter_mac_addr, - (void *)&cmd_ethertype_filter_ethertype, - (void *)&cmd_ethertype_filter_ethertype_value, - (void *)&cmd_ethertype_filter_drop, - (void *)&cmd_ethertype_filter_queue, - (void *)&cmd_ethertype_filter_queue_id, - NULL, - }, -}; - -/* *** deal with flow director filter *** */ -struct cmd_flow_director_result { - cmdline_fixed_string_t flow_director_filter; - 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; - - 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 > UINT8_MAX) - return -1; - flexbytes[i] = (uint8_t)int_fld; - } - return ret; -} - -static uint16_t -str2flowtype(char *string) -{ - uint8_t i = 0; - static const struct { - char str[32]; - uint16_t type; - } flowtype_str[] = { - {"raw", RTE_ETH_FLOW_RAW}, - {"ipv4", RTE_ETH_FLOW_IPV4}, - {"ipv4-frag", RTE_ETH_FLOW_FRAG_IPV4}, - {"ipv4-tcp", RTE_ETH_FLOW_NONFRAG_IPV4_TCP}, - {"ipv4-udp", RTE_ETH_FLOW_NONFRAG_IPV4_UDP}, - {"ipv4-sctp", RTE_ETH_FLOW_NONFRAG_IPV4_SCTP}, - {"ipv4-other", RTE_ETH_FLOW_NONFRAG_IPV4_OTHER}, - {"ipv6", RTE_ETH_FLOW_IPV6}, - {"ipv6-frag", RTE_ETH_FLOW_FRAG_IPV6}, - {"ipv6-tcp", RTE_ETH_FLOW_NONFRAG_IPV6_TCP}, - {"ipv6-udp", RTE_ETH_FLOW_NONFRAG_IPV6_UDP}, - {"ipv6-sctp", RTE_ETH_FLOW_NONFRAG_IPV6_SCTP}, - {"ipv6-other", RTE_ETH_FLOW_NONFRAG_IPV6_OTHER}, - {"l2_payload", RTE_ETH_FLOW_L2_PAYLOAD}, - }; - - for (i = 0; i < RTE_DIM(flowtype_str); i++) { - if (!strcmp(flowtype_str[i].str, string)) - return flowtype_str[i].type; - } - - if (isdigit(string[0]) && atoi(string) > 0 && atoi(string) < 64) - return (uint16_t)atoi(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) - -static void -cmd_flow_director_filter_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __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; - - 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; - } - 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_LIBRTE_I40E_PMD - 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; - } - 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"); - 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); - else - ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR, - RTE_ETH_FILTER_UPDATE, &entry); - if (ret < 0) - printf("flow director programming error: (%s)\n", - strerror(-ret)); -} - -cmdline_parse_token_string_t cmd_flow_director_filter = - TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, - 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); -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 = - TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result, - flow, "flow"); -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); -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); - -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"); -cmdline_parse_token_string_t cmd_flow_director_filepath = - 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 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 dst tos " - "proto ttl vlan " - "flexbytes drop|fw queue " - "fd_id : " - "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, - .help_str = "flow_director_filter ... : Add or delete a raw 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_raw, - (void *)&cmd_flow_director_ops, - (void *)&cmd_flow_director_flow, - (void *)&cmd_flow_director_flow_type, - (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, - (void *)&cmd_flow_director_packet, - (void *)&cmd_flow_director_filepath, - 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 : " - "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, - }, -}; - -/* *** deal with flow director mask *** */ -struct cmd_flow_director_mask_result { - cmdline_fixed_string_t flow_director_mask; - portid_t port_id; - cmdline_fixed_string_t mode; - cmdline_fixed_string_t mode_value; - cmdline_fixed_string_t vlan; - uint16_t vlan_mask; - cmdline_fixed_string_t src_mask; - cmdline_ipaddr_t ipv4_src; - cmdline_ipaddr_t ipv6_src; - uint16_t port_src; - cmdline_fixed_string_t dst_mask; - cmdline_ipaddr_t ipv4_dst; - cmdline_ipaddr_t ipv6_dst; - uint16_t port_dst; - cmdline_fixed_string_t mac; - uint8_t mac_addr_byte_mask; - cmdline_fixed_string_t tunnel_id; - uint32_t tunnel_id_mask; - cmdline_fixed_string_t tunnel_type; - uint8_t tunnel_type_mask; -}; - -static void -cmd_flow_director_mask_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - struct cmd_flow_director_mask_result *res = parsed_result; - struct rte_eth_fdir_masks *mask; - struct rte_port *port; - - 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; - } - - mask = &port->dev_conf.fdir_conf.mask; - - 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; - } - - mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask); - } else if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) { - if (strcmp(res->mode_value, "Tunnel")) { - printf("Please set mode to Tunnel.\n"); - return; - } - - mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask); - mask->mac_addr_byte_mask = res->mac_addr_byte_mask; - mask->tunnel_id_mask = rte_cpu_to_be_32(res->tunnel_id_mask); - mask->tunnel_type_mask = res->tunnel_type_mask; - } else { - if (strcmp(res->mode_value, "IP")) { - printf("Please set mode to IP.\n"); - return; - } - - mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask); - IPV4_ADDR_TO_UINT(res->ipv4_src, mask->ipv4_mask.src_ip); - IPV4_ADDR_TO_UINT(res->ipv4_dst, mask->ipv4_mask.dst_ip); - IPV6_ADDR_TO_ARRAY(res->ipv6_src, mask->ipv6_mask.src_ip); - IPV6_ADDR_TO_ARRAY(res->ipv6_dst, mask->ipv6_mask.dst_ip); - mask->src_port_mask = rte_cpu_to_be_16(res->port_src); - mask->dst_port_mask = rte_cpu_to_be_16(res->port_dst); - } - - cmd_reconfig_device_queue(res->port_id, 1, 1); -} - -cmdline_parse_token_string_t cmd_flow_director_mask = - TOKEN_STRING_INITIALIZER(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); -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); -cmdline_parse_token_string_t cmd_flow_director_mask_src = - TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, - src_mask, "src_mask"); -cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv4_src = - TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result, - ipv4_src); -cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv6_src = - TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result, - 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); -cmdline_parse_token_string_t cmd_flow_director_mask_dst = - TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, - dst_mask, "dst_mask"); -cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv4_dst = - TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result, - ipv4_dst); -cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv6_dst = - TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result, - 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); - -cmdline_parse_token_string_t cmd_flow_director_mask_mode = - TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, - mode, "mode"); -cmdline_parse_token_string_t cmd_flow_director_mask_mode_ip = - TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, - mode_value, "IP"); -cmdline_parse_token_string_t cmd_flow_director_mask_mode_mac_vlan = - TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, - mode_value, "MAC-VLAN"); -cmdline_parse_token_string_t cmd_flow_director_mask_mode_tunnel = - TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, - mode_value, "Tunnel"); -cmdline_parse_token_string_t cmd_flow_director_mask_mac = - 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); -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); -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); - -cmdline_parse_inst_t cmd_set_flow_director_ip_mask = { - .f = cmd_flow_director_mask_parsed, - .data = NULL, - .help_str = "flow_director_mask ... : " - "Set IP mode flow director's mask on NIC", - .tokens = { - (void *)&cmd_flow_director_mask, - (void *)&cmd_flow_director_mask_port_id, - (void *)&cmd_flow_director_mask_mode, - (void *)&cmd_flow_director_mask_mode_ip, - (void *)&cmd_flow_director_mask_vlan, - (void *)&cmd_flow_director_mask_vlan_value, - (void *)&cmd_flow_director_mask_src, - (void *)&cmd_flow_director_mask_ipv4_src, - (void *)&cmd_flow_director_mask_ipv6_src, - (void *)&cmd_flow_director_mask_port_src, - (void *)&cmd_flow_director_mask_dst, - (void *)&cmd_flow_director_mask_ipv4_dst, - (void *)&cmd_flow_director_mask_ipv6_dst, - (void *)&cmd_flow_director_mask_port_dst, - NULL, - }, -}; - -cmdline_parse_inst_t cmd_set_flow_director_mac_vlan_mask = { - .f = cmd_flow_director_mask_parsed, - .data = NULL, - .help_str = "flow_director_mask ... : Set MAC VLAN mode " - "flow director's mask on NIC", - .tokens = { - (void *)&cmd_flow_director_mask, - (void *)&cmd_flow_director_mask_port_id, - (void *)&cmd_flow_director_mask_mode, - (void *)&cmd_flow_director_mask_mode_mac_vlan, - (void *)&cmd_flow_director_mask_vlan, - (void *)&cmd_flow_director_mask_vlan_value, - NULL, - }, -}; - -cmdline_parse_inst_t cmd_set_flow_director_tunnel_mask = { - .f = cmd_flow_director_mask_parsed, - .data = NULL, - .help_str = "flow_director_mask ... : Set tunnel mode " - "flow director's mask on NIC", - .tokens = { - (void *)&cmd_flow_director_mask, - (void *)&cmd_flow_director_mask_port_id, - (void *)&cmd_flow_director_mask_mode, - (void *)&cmd_flow_director_mask_mode_tunnel, - (void *)&cmd_flow_director_mask_vlan, - (void *)&cmd_flow_director_mask_vlan_value, - (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 ", - .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 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 ", - .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 " - "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 " - "ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|" - "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload| " - "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 " - "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 : " - "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 ", - .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 l2-tunnel E-tag ether-type ", - .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); +cmdline_parse_token_string_t cmd_flow_director_mask = + TOKEN_STRING_INITIALIZER(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, 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, 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"); +cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv4_src = + TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result, + ipv4_src); +cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv6_src = + TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result, + ipv6_src); +cmdline_parse_token_num_t cmd_flow_director_mask_port_src = + TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result, + 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"); +cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv4_dst = + TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result, + ipv4_dst); +cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv6_dst = + TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result, + ipv6_dst); +cmdline_parse_token_num_t cmd_flow_director_mask_port_dst = + TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result, + port_dst, RTE_UINT16); - 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_token_string_t cmd_flow_director_mask_mode = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, + mode, "mode"); +cmdline_parse_token_string_t cmd_flow_director_mask_mode_ip = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, + mode_value, "IP"); +cmdline_parse_token_string_t cmd_flow_director_mask_mode_mac_vlan = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, + mode_value, "MAC-VLAN"); +cmdline_parse_token_string_t cmd_flow_director_mask_mode_tunnel = + TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result, + mode_value, "Tunnel"); +cmdline_parse_token_string_t cmd_flow_director_mask_mac = + 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, 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, 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, RTE_UINT32); -cmdline_parse_inst_t cmd_config_l2_tunnel_en_dis_specific = { - .f = cmd_config_l2_tunnel_en_dis_specific_parsed, +cmdline_parse_inst_t cmd_set_flow_director_ip_mask = { + .f = cmd_flow_director_mask_parsed, .data = NULL, - .help_str = "port config l2-tunnel E-tag enable|disable", + .help_str = "flow_director_mask ... : " + "Set IP mode flow director's mask on NIC", .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, + (void *)&cmd_flow_director_mask, + (void *)&cmd_flow_director_mask_port_id, + (void *)&cmd_flow_director_mask_mode, + (void *)&cmd_flow_director_mask_mode_ip, + (void *)&cmd_flow_director_mask_vlan, + (void *)&cmd_flow_director_mask_vlan_value, + (void *)&cmd_flow_director_mask_src, + (void *)&cmd_flow_director_mask_ipv4_src, + (void *)&cmd_flow_director_mask_ipv6_src, + (void *)&cmd_flow_director_mask_port_src, + (void *)&cmd_flow_director_mask_dst, + (void *)&cmd_flow_director_mask_ipv4_dst, + (void *)&cmd_flow_director_mask_ipv6_dst, + (void *)&cmd_flow_director_mask_port_dst, 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, +cmdline_parse_inst_t cmd_set_flow_director_mac_vlan_mask = { + .f = cmd_flow_director_mask_parsed, .data = NULL, - .help_str = "E-tag ... : E-tag insertion enable", + .help_str = "flow_director_mask ... : Set MAC VLAN mode " + "flow director's mask on NIC", .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, + (void *)&cmd_flow_director_mask, + (void *)&cmd_flow_director_mask_port_id, + (void *)&cmd_flow_director_mask_mode, + (void *)&cmd_flow_director_mask_mode_mac_vlan, + (void *)&cmd_flow_director_mask_vlan, + (void *)&cmd_flow_director_mask_vlan_value, NULL, }, }; -cmdline_parse_inst_t cmd_config_e_tag_insertion_dis = { - .f = cmd_config_e_tag_insertion_dis_parsed, +cmdline_parse_inst_t cmd_set_flow_director_tunnel_mask = { + .f = cmd_flow_director_mask_parsed, .data = NULL, - .help_str = "E-tag ... : E-tag insertion disable", + .help_str = "flow_director_mask ... : Set tunnel mode " + "flow director's mask on NIC", .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, + (void *)&cmd_flow_director_mask, + (void *)&cmd_flow_director_mask_port_id, + (void *)&cmd_flow_director_mask_mode, + (void *)&cmd_flow_director_mask_mode_tunnel, + (void *)&cmd_flow_director_mask_vlan, + (void *)&cmd_flow_director_mask_vlan_value, + (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, }, }; -/* 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, - 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; }; -/* E-tag forwarding configuration */ -static void -cmd_config_e_tag_forwarding_parsed( - void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) +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) { + fprintf(stderr, "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); + fprintf(stderr, "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)) { + fprintf(stderr, + "Invalid multicast addr " RTE_ETHER_ADDR_PRT_FMT "\n", + RTE_ETHER_ADDR_BYTES(&res->mc_addr)); 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 : " + "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, }, }; @@ -13442,11 +11023,11 @@ cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_antispoof = 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, @@ -13466,17 +11047,17 @@ cmd_set_vf_vlan_anti_spoof_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE if (ret == -ENOTSUP) ret = rte_pmd_ixgbe_set_vf_vlan_anti_spoof(res->port_id, res->vf_id, is_on); #endif -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_set_vf_vlan_anti_spoof(res->port_id, res->vf_id, is_on); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_set_vf_vlan_anti_spoof(res->port_id, res->vf_id, is_on); @@ -13486,16 +11067,16 @@ cmd_set_vf_vlan_anti_spoof_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -13548,11 +11129,11 @@ cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_antispoof = 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, @@ -13572,17 +11153,17 @@ cmd_set_vf_mac_anti_spoof_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE if (ret == -ENOTSUP) ret = rte_pmd_ixgbe_set_vf_mac_anti_spoof(res->port_id, res->vf_id, is_on); #endif -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_set_vf_mac_anti_spoof(res->port_id, res->vf_id, is_on); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_set_vf_mac_anti_spoof(res->port_id, res->vf_id, is_on); @@ -13592,16 +11173,17 @@ cmd_set_vf_mac_anti_spoof_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on); + fprintf(stderr, "invalid vf_id %d or is_on %d\n", + res->vf_id, is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -13654,11 +11236,11 @@ cmdline_parse_token_string_t cmd_vf_vlan_stripq_stripq = 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, @@ -13678,17 +11260,17 @@ cmd_set_vf_vlan_stripq_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE if (ret == -ENOTSUP) ret = rte_pmd_ixgbe_set_vf_vlan_stripq(res->port_id, res->vf_id, is_on); #endif -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_set_vf_vlan_stripq(res->port_id, res->vf_id, is_on); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_set_vf_vlan_stripq(res->port_id, res->vf_id, is_on); @@ -13698,16 +11280,17 @@ cmd_set_vf_vlan_stripq_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on); + fprintf(stderr, "invalid vf_id %d or is_on %d\n", + res->vf_id, is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -13760,15 +11343,15 @@ cmdline_parse_token_string_t cmd_vf_vlan_insert_insert = 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( @@ -13782,17 +11365,17 @@ cmd_set_vf_vlan_insert_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE if (ret == -ENOTSUP) ret = rte_pmd_ixgbe_set_vf_vlan_insert(res->port_id, res->vf_id, res->vlan_id); #endif -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_set_vf_vlan_insert(res->port_id, res->vf_id, res->vlan_id); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_set_vf_vlan_insert(res->port_id, res->vf_id, res->vlan_id); @@ -13802,16 +11385,17 @@ cmd_set_vf_vlan_insert_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or vlan_id %d\n", res->vf_id, res->vlan_id); + fprintf(stderr, "invalid vf_id %d or vlan_id %d\n", + res->vf_id, res->vlan_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -13858,7 +11442,7 @@ cmdline_parse_token_string_t cmd_tx_loopback_loopback = 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, @@ -13878,19 +11462,19 @@ cmd_set_tx_loopback_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE if (ret == -ENOTSUP) ret = rte_pmd_ixgbe_set_tx_loopback(res->port_id, is_on); #endif -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_set_tx_loopback(res->port_id, is_on); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_set_tx_loopback(res->port_id, is_on); #endif -#if defined RTE_LIBRTE_DPAA_BUS && defined RTE_LIBRTE_DPAA_PMD +#if defined RTE_BUS_DPAA && defined RTE_NET_DPAA if (ret == -ENOTSUP) ret = rte_pmd_dpaa_set_tx_loopback(res->port_id, is_on); #endif @@ -13899,16 +11483,16 @@ cmd_set_tx_loopback_parsed( case 0: break; case -EINVAL: - printf("invalid is_on %d\n", is_on); + fprintf(stderr, "invalid is_on %d\n", is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -13958,7 +11542,7 @@ cmdline_parse_token_string_t cmd_all_queues_drop_en_drop = 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, @@ -13977,11 +11561,11 @@ cmd_set_all_queues_drop_en_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE if (ret == -ENOTSUP) ret = rte_pmd_ixgbe_set_all_queues_drop_en(res->port_id, is_on); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_set_all_queues_drop_en(res->port_id, is_on); #endif @@ -13989,16 +11573,16 @@ cmd_set_all_queues_drop_en_parsed( case 0: break; case -EINVAL: - printf("invalid is_on %d\n", is_on); + fprintf(stderr, "invalid is_on %d\n", is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14050,11 +11634,11 @@ cmdline_parse_token_string_t cmd_vf_split_drop_en_drop = 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, @@ -14073,7 +11657,7 @@ cmd_set_vf_split_drop_en_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE ret = rte_pmd_ixgbe_set_vf_split_drop_en(res->port_id, res->vf_id, is_on); #endif @@ -14081,16 +11665,17 @@ cmd_set_vf_split_drop_en_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on); + fprintf(stderr, "invalid vf_id %d or is_on %d\n", + res->vf_id, is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("not supported on port %d\n", res->port_id); + fprintf(stderr, "not supported on port %d\n", res->port_id); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14144,11 +11729,11 @@ cmdline_parse_token_string_t cmd_set_vf_mac_addr_addr = 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); @@ -14165,17 +11750,17 @@ cmd_set_vf_mac_addr_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE if (ret == -ENOTSUP) ret = rte_pmd_ixgbe_set_vf_mac_addr(res->port_id, res->vf_id, &res->mac_addr); #endif -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_set_vf_mac_addr(res->port_id, res->vf_id, &res->mac_addr); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_set_vf_mac_addr(res->port_id, res->vf_id, &res->mac_addr); @@ -14185,16 +11770,16 @@ cmd_set_vf_mac_addr_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or mac_addr\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d or mac_addr\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14245,7 +11830,7 @@ cmdline_parse_token_string_t cmd_macsec_offload_on_offload = 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, @@ -14283,7 +11868,7 @@ cmd_set_macsec_offload_on_parsed( if (port_id_is_invalid(port_id, ENABLED_WARN)) return; if (!port_is_stopped(port_id)) { - printf("Please stop port %d first\n", port_id); + fprintf(stderr, "Please stop port %d first\n", port_id); return; } @@ -14291,8 +11876,8 @@ cmd_set_macsec_offload_on_parsed( if (ret != 0) return; - if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) { -#ifdef RTE_LIBRTE_IXGBE_PMD + if (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_MACSEC_INSERT) { +#ifdef RTE_NET_IXGBE ret = rte_pmd_ixgbe_macsec_enable(port_id, en, rp); #endif } @@ -14302,17 +11887,17 @@ cmd_set_macsec_offload_on_parsed( switch (ret) { case 0: ports[port_id].dev_conf.txmode.offloads |= - DEV_TX_OFFLOAD_MACSEC_INSERT; + RTE_ETH_TX_OFFLOAD_MACSEC_INSERT; cmd_reconfig_device_queue(port_id, 1, 1); break; case -ENODEV: - printf("invalid port_id %d\n", port_id); + fprintf(stderr, "invalid port_id %d\n", port_id); break; case -ENOTSUP: - printf("not supported on port %d\n", port_id); + fprintf(stderr, "not supported on port %d\n", port_id); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14360,7 +11945,7 @@ cmdline_parse_token_string_t cmd_macsec_offload_off_offload = 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, @@ -14380,7 +11965,7 @@ cmd_set_macsec_offload_off_parsed( if (port_id_is_invalid(port_id, ENABLED_WARN)) return; if (!port_is_stopped(port_id)) { - printf("Please stop port %d first\n", port_id); + fprintf(stderr, "Please stop port %d first\n", port_id); return; } @@ -14388,25 +11973,25 @@ cmd_set_macsec_offload_off_parsed( if (ret != 0) return; - if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) { -#ifdef RTE_LIBRTE_IXGBE_PMD + if (dev_info.tx_offload_capa & RTE_ETH_TX_OFFLOAD_MACSEC_INSERT) { +#ifdef RTE_NET_IXGBE ret = rte_pmd_ixgbe_macsec_disable(port_id); #endif } switch (ret) { case 0: ports[port_id].dev_conf.txmode.offloads &= - ~DEV_TX_OFFLOAD_MACSEC_INSERT; + ~RTE_ETH_TX_OFFLOAD_MACSEC_INSERT; cmd_reconfig_device_queue(port_id, 1, 1); break; case -ENODEV: - printf("invalid port_id %d\n", port_id); + fprintf(stderr, "invalid port_id %d\n", port_id); break; case -ENOTSUP: - printf("not supported on port %d\n", port_id); + fprintf(stderr, "not supported on port %d\n", port_id); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14455,7 +12040,7 @@ cmdline_parse_token_string_t cmd_macsec_sc_tx_rx = 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, @@ -14463,7 +12048,7 @@ cmdline_parse_token_etheraddr_t cmd_macsec_sc_mac = 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( @@ -14475,7 +12060,7 @@ cmd_set_macsec_sc_parsed( int ret = -ENOTSUP; int is_tx = (strcmp(res->tx_rx, "tx") == 0) ? 1 : 0; -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE ret = is_tx ? rte_pmd_ixgbe_macsec_config_txsc(res->port_id, res->mac.addr_bytes) : @@ -14488,13 +12073,13 @@ cmd_set_macsec_sc_parsed( case 0: break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("not supported on port %d\n", res->port_id); + fprintf(stderr, "not supported on port %d\n", res->port_id); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14547,19 +12132,19 @@ cmdline_parse_token_string_t cmd_macsec_sa_tx_rx = 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, @@ -14594,7 +12179,7 @@ cmd_set_macsec_sa_parsed( key[i] = (uint8_t) ((xdgt0 * 16) + xdgt1); } -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE ret = is_tx ? rte_pmd_ixgbe_macsec_select_txsa(res->port_id, res->idx, res->an, res->pn, key) : @@ -14608,16 +12193,16 @@ cmd_set_macsec_sa_parsed( case 0: break; case -EINVAL: - printf("invalid idx %d or an %d\n", res->idx, res->an); + fprintf(stderr, "invalid idx %d or an %d\n", res->idx, res->an); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("not supported on port %d\n", res->port_id); + fprintf(stderr, "not supported on port %d\n", res->port_id); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14667,11 +12252,11 @@ cmdline_parse_token_string_t cmd_vf_promisc_promisc = 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, @@ -14691,7 +12276,7 @@ cmd_set_vf_promisc_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_set_vf_unicast_promisc(res->port_id, res->vf_id, is_on); #endif @@ -14700,16 +12285,16 @@ cmd_set_vf_promisc_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14757,11 +12342,11 @@ cmdline_parse_token_string_t cmd_vf_allmulti_allmulti = 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, @@ -14781,7 +12366,7 @@ cmd_set_vf_allmulti_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_set_vf_multicast_promisc(res->port_id, res->vf_id, is_on); #endif @@ -14790,16 +12375,16 @@ cmd_set_vf_allmulti_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14847,11 +12432,11 @@ cmdline_parse_token_string_t cmd_set_vf_broadcast_broadcast = 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, @@ -14871,7 +12456,7 @@ cmd_set_vf_broadcast_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_set_vf_broadcast(res->port_id, res->vf_id, is_on); #endif @@ -14880,16 +12465,17 @@ cmd_set_vf_broadcast_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on); + fprintf(stderr, "invalid vf_id %d or is_on %d\n", + res->vf_id, is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -14941,11 +12527,11 @@ cmdline_parse_token_string_t cmd_set_vf_vlan_tag_tag = 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, @@ -14965,7 +12551,7 @@ cmd_set_vf_vlan_tag_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_set_vf_vlan_tag(res->port_id, res->vf_id, is_on); #endif @@ -14974,16 +12560,17 @@ cmd_set_vf_vlan_tag_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or is_on %d\n", res->vf_id, is_on); + fprintf(stderr, "invalid vf_id %d or is_on %d\n", + res->vf_id, is_on); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -15051,19 +12638,19 @@ cmdline_parse_token_string_t cmd_vf_tc_bw_max_bw = 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, @@ -15071,7 +12658,7 @@ cmdline_parse_token_string_t cmd_vf_tc_bw_bw_list = 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 @@ -15086,7 +12673,7 @@ cmd_vf_max_bw_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_set_vf_max_bw(res->port_id, res->vf_id, res->bw); #endif @@ -15095,17 +12682,17 @@ cmd_vf_max_bw_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or bandwidth %d\n", - res->vf_id, res->bw); + fprintf(stderr, "invalid vf_id %d or bandwidth %d\n", + res->vf_id, res->bw); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -15140,24 +12727,27 @@ vf_tc_min_bw_parse_bw_list(uint8_t *bw_list, p = strchr(p0, '('); if (p == NULL) { - printf("The bandwidth-list should be '(bw1, bw2, ...)'\n"); + fprintf(stderr, + "The bandwidth-list should be '(bw1, bw2, ...)'\n"); return -1; } p++; p0 = strchr(p, ')'); if (p0 == NULL) { - printf("The bandwidth-list should be '(bw1, bw2, ...)'\n"); + fprintf(stderr, + "The bandwidth-list should be '(bw1, bw2, ...)'\n"); return -1; } size = p0 - p; if (size >= sizeof(s)) { - printf("The string size exceeds the internal buffer size\n"); + fprintf(stderr, + "The string size exceeds the internal buffer size\n"); return -1; } snprintf(s, sizeof(s), "%.*s", size, p); ret = rte_strsplit(s, sizeof(s), str_fld, 16, ','); if (ret <= 0) { - printf("Failed to get the bandwidth list. "); + fprintf(stderr, "Failed to get the bandwidth list.\n"); return -1; } *tc_num = ret; @@ -15186,7 +12776,7 @@ cmd_vf_tc_min_bw_parsed( if (ret) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_set_vf_tc_bw_alloc(res->port_id, res->vf_id, tc_num, bw); #endif @@ -15195,16 +12785,16 @@ cmd_vf_tc_min_bw_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d or bandwidth\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d or bandwidth\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -15244,7 +12834,7 @@ cmd_tc_min_bw_parsed( 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); + fprintf(stderr, "Please stop port %d first\n", res->port_id); return; } @@ -15252,7 +12842,7 @@ cmd_tc_min_bw_parsed( if (ret) return; -#ifdef RTE_LIBRTE_IXGBE_PMD +#ifdef RTE_NET_IXGBE ret = rte_pmd_ixgbe_set_tc_bw_alloc(res->port_id, tc_num, bw); #endif @@ -15260,16 +12850,16 @@ cmd_tc_min_bw_parsed( case 0: break; case -EINVAL: - printf("invalid bandwidth\n"); + fprintf(stderr, "invalid bandwidth\n"); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -15301,121 +12891,48 @@ cmd_vf_tc_max_bw_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_set_vf_tc_max_bw(res->port_id, res->vf_id, res->tc_no, res->bw); #endif - switch (ret) { - case 0: - break; - case -EINVAL: - printf("invalid vf_id %d, tc_no %d or bandwidth %d\n", - res->vf_id, res->tc_no, res->bw); - break; - case -ENODEV: - printf("invalid port_id %d\n", res->port_id); - break; - case -ENOTSUP: - printf("function not implemented\n"); - break; - default: - printf("programming error: (%s)\n", strerror(-ret)); - } -} - -cmdline_parse_inst_t cmd_vf_tc_max_bw = { - .f = cmd_vf_tc_max_bw_parsed, - .data = NULL, - .help_str = "set vf tc tx max-bandwidth " - " ", - .tokens = { - (void *)&cmd_vf_tc_bw_set, - (void *)&cmd_vf_tc_bw_vf, - (void *)&cmd_vf_tc_bw_tc, - (void *)&cmd_vf_tc_bw_tx, - (void *)&cmd_vf_tc_bw_max_bw, - (void *)&cmd_vf_tc_bw_port_id, - (void *)&cmd_vf_tc_bw_vf_id, - (void *)&cmd_vf_tc_bw_tc_no, - (void *)&cmd_vf_tc_bw_bw, - NULL, - }, -}; - - -#if defined RTE_LIBRTE_PMD_SOFTNIC && defined RTE_LIBRTE_SCHED - -/* *** Set Port default Traffic Management Hierarchy *** */ -struct cmd_set_port_tm_hierarchy_default_result { - cmdline_fixed_string_t set; - cmdline_fixed_string_t port; - cmdline_fixed_string_t tm; - cmdline_fixed_string_t hierarchy; - cmdline_fixed_string_t def; - portid_t port_id; -}; - -cmdline_parse_token_string_t cmd_set_port_tm_hierarchy_default_set = - TOKEN_STRING_INITIALIZER( - struct cmd_set_port_tm_hierarchy_default_result, set, "set"); -cmdline_parse_token_string_t cmd_set_port_tm_hierarchy_default_port = - TOKEN_STRING_INITIALIZER( - struct cmd_set_port_tm_hierarchy_default_result, port, "port"); -cmdline_parse_token_string_t cmd_set_port_tm_hierarchy_default_tm = - TOKEN_STRING_INITIALIZER( - struct cmd_set_port_tm_hierarchy_default_result, tm, "tm"); -cmdline_parse_token_string_t cmd_set_port_tm_hierarchy_default_hierarchy = - TOKEN_STRING_INITIALIZER( - struct cmd_set_port_tm_hierarchy_default_result, - hierarchy, "hierarchy"); -cmdline_parse_token_string_t cmd_set_port_tm_hierarchy_default_default = - TOKEN_STRING_INITIALIZER( - struct cmd_set_port_tm_hierarchy_default_result, - def, "default"); -cmdline_parse_token_num_t cmd_set_port_tm_hierarchy_default_port_id = - TOKEN_NUM_INITIALIZER( - struct cmd_set_port_tm_hierarchy_default_result, - port_id, UINT16); - -static void cmd_set_port_tm_hierarchy_default_parsed(void *parsed_result, - __rte_unused struct cmdline *cl, - __rte_unused void *data) -{ - struct cmd_set_port_tm_hierarchy_default_result *res = parsed_result; - struct rte_port *p; - portid_t port_id = res->port_id; - - if (port_id_is_invalid(port_id, ENABLED_WARN)) - return; - - p = &ports[port_id]; - - /* Forward mode: tm */ - if (strcmp(cur_fwd_config.fwd_eng->fwd_mode_name, "softnic")) { - printf(" softnicfwd mode not enabled(error)\n"); - return; + switch (ret) { + case 0: + break; + case -EINVAL: + fprintf(stderr, + "invalid vf_id %d, tc_no %d or bandwidth %d\n", + res->vf_id, res->tc_no, res->bw); + break; + case -ENODEV: + fprintf(stderr, "invalid port_id %d\n", res->port_id); + break; + case -ENOTSUP: + fprintf(stderr, "function not implemented\n"); + break; + default: + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } - - /* Set the default tm hierarchy */ - p->softport.default_tm_hierarchy_enable = 1; } -cmdline_parse_inst_t cmd_set_port_tm_hierarchy_default = { - .f = cmd_set_port_tm_hierarchy_default_parsed, +cmdline_parse_inst_t cmd_vf_tc_max_bw = { + .f = cmd_vf_tc_max_bw_parsed, .data = NULL, - .help_str = "set port tm hierarchy default ", + .help_str = "set vf tc tx max-bandwidth " + " ", .tokens = { - (void *)&cmd_set_port_tm_hierarchy_default_set, - (void *)&cmd_set_port_tm_hierarchy_default_port, - (void *)&cmd_set_port_tm_hierarchy_default_tm, - (void *)&cmd_set_port_tm_hierarchy_default_hierarchy, - (void *)&cmd_set_port_tm_hierarchy_default_default, - (void *)&cmd_set_port_tm_hierarchy_default_port_id, + (void *)&cmd_vf_tc_bw_set, + (void *)&cmd_vf_tc_bw_vf, + (void *)&cmd_vf_tc_bw_tc, + (void *)&cmd_vf_tc_bw_tx, + (void *)&cmd_vf_tc_bw_max_bw, + (void *)&cmd_vf_tc_bw_port_id, + (void *)&cmd_vf_tc_bw_vf_id, + (void *)&cmd_vf_tc_bw_tc_no, + (void *)&cmd_vf_tc_bw_bw, NULL, }, }; -#endif /** Set VXLAN encapsulation details */ struct cmd_set_vxlan_result { @@ -15456,27 +12973,27 @@ cmdline_parse_token_string_t cmd_set_vxlan_vni = 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"); @@ -15491,7 +13008,7 @@ cmdline_parse_token_string_t cmd_set_vxlan_vlan = 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"); @@ -15676,7 +13193,7 @@ cmdline_parse_token_string_t cmd_set_nvgre_tni = 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"); @@ -15691,7 +13208,7 @@ cmdline_parse_token_string_t cmd_set_nvgre_vlan = 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"); @@ -15822,7 +13339,7 @@ cmdline_parse_token_string_t cmd_set_l2_encap_vlan = 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"); @@ -15982,7 +13499,7 @@ cmdline_parse_token_string_t cmd_set_mplsogre_encap_label = 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"); @@ -15998,7 +13515,7 @@ cmdline_parse_token_string_t cmd_set_mplsogre_encap_vlan = 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"); @@ -16206,19 +13723,19 @@ cmdline_parse_token_string_t cmd_set_mplsoudp_encap_label = 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"); @@ -16234,7 +13751,7 @@ cmdline_parse_token_string_t cmd_set_mplsoudp_encap_vlan = 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"); @@ -16416,6 +13933,359 @@ cmdline_parse_inst_t cmd_set_mplsoudp_decap_with_vlan = { }, }; +/** 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 is_orig enable " + " live sack cack last_dir " + " liberal state max_ack_win r_lim " + " last_win last_seq last_ack last_end " + " last_index ", + .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 fin " + " acked unack_data sent_end " + " reply_end max_win max_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( @@ -16429,7 +14299,7 @@ cmd_strict_link_prio_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_set_tc_strict_prio(res->port_id, res->tc_map); #endif @@ -16437,16 +14307,16 @@ cmd_strict_link_prio_parsed( case 0: break; case -EINVAL: - printf("invalid tc_bitmap 0x%x\n", res->tc_map); + fprintf(stderr, "invalid tc_bitmap 0x%x\n", res->tc_map); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -16477,7 +14347,8 @@ cmdline_parse_token_string_t cmd_ddp_add_ddp = 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); @@ -16496,13 +14367,13 @@ cmd_ddp_add_parsed( int ret = -ENOTSUP; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } filepath = strdup(res->filepath); if (filepath == NULL) { - printf("Failed to allocate memory\n"); + fprintf(stderr, "Failed to allocate memory\n"); return; } file_num = rte_strsplit(filepath, strlen(filepath), file_fld, 2, ','); @@ -16513,7 +14384,7 @@ cmd_ddp_add_parsed( return; } -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_process_ddp_package(res->port_id, buff, size, @@ -16521,9 +14392,9 @@ cmd_ddp_add_parsed( #endif if (ret == -EEXIST) - printf("Profile has already existed.\n"); + fprintf(stderr, "Profile has already existed.\n"); else if (ret < 0) - printf("Failed to load profile.\n"); + fprintf(stderr, "Failed to load profile.\n"); else if (file_num == 2) save_file(file_fld[1], buff, size); @@ -16557,7 +14428,7 @@ cmdline_parse_token_string_t cmd_ddp_del_ddp = 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); @@ -16573,7 +14444,7 @@ cmd_ddp_del_parsed( int ret = -ENOTSUP; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } @@ -16581,7 +14452,7 @@ cmd_ddp_del_parsed( if (!buff) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_process_ddp_package(res->port_id, buff, size, @@ -16589,9 +14460,9 @@ cmd_ddp_del_parsed( #endif if (ret == -EACCES) - printf("Profile does not exist.\n"); + fprintf(stderr, "Profile does not exist.\n"); else if (ret < 0) - printf("Failed to delete profile.\n"); + fprintf(stderr, "Failed to delete profile.\n"); close_file(buff); } @@ -16636,7 +14507,7 @@ cmd_ddp_info_parsed( uint8_t *pkg; uint32_t pkg_size; int ret = -ENOTSUP; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E uint32_t i, j, n; uint8_t *buff; uint32_t buff_size = 0; @@ -16657,7 +14528,7 @@ cmd_ddp_info_parsed( if (!pkg) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size, (uint8_t *)&info, sizeof(info), RTE_PMD_I40E_PKG_INFO_GLOBAL_HEADER); @@ -16829,7 +14700,7 @@ no_print_return: free(proto); #endif if (ret == -ENOTSUP) - printf("Function not supported in PMD driver\n"); + fprintf(stderr, "Function not supported in PMD driver\n"); close_file(pkg); } @@ -16864,7 +14735,8 @@ cmdline_parse_token_string_t cmd_ddp_get_list_get = 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( @@ -16872,7 +14744,7 @@ cmd_ddp_get_list_parsed( __rte_unused struct cmdline *cl, __rte_unused void *data) { -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E struct cmd_ddp_get_list_result *res = parsed_result; struct rte_pmd_i40e_profile_list *p_list; struct rte_pmd_i40e_profile_info *p_info; @@ -16882,11 +14754,13 @@ cmd_ddp_get_list_parsed( #endif int ret = -ENOTSUP; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E size = PROFILE_INFO_SIZE * MAX_PROFILE_NUM + 4; p_list = (struct rte_pmd_i40e_profile_list *)malloc(size); - if (!p_list) - printf("%s: Failed to malloc buffer\n", __func__); + if (!p_list) { + fprintf(stderr, "%s: Failed to malloc buffer\n", __func__); + return; + } if (ret == -ENOTSUP) ret = rte_pmd_i40e_get_ddp_list(res->port_id, @@ -16913,7 +14787,7 @@ cmd_ddp_get_list_parsed( #endif if (ret < 0) - printf("Failed to get ddp list\n"); + fprintf(stderr, "Failed to get ddp list\n"); } cmdline_parse_inst_t cmd_ddp_get_list = { @@ -16948,7 +14822,7 @@ cmd_cfg_input_set_parsed( __rte_unused struct cmdline *cl, __rte_unused void *data) { -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E struct cmd_cfg_input_set_result *res = parsed_result; enum rte_pmd_i40e_inset_type inset_type = INSET_NONE; struct rte_pmd_i40e_inset inset; @@ -16956,11 +14830,11 @@ cmd_cfg_input_set_parsed( int ret = -ENOTSUP; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (!strcmp(res->inset_type, "hash_inset")) inset_type = INSET_HASH; else if (!strcmp(res->inset_type, "fdir_inset")) @@ -16970,7 +14844,7 @@ cmd_cfg_input_set_parsed( ret = rte_pmd_i40e_inset_get(res->port_id, res->pctype_id, &inset, inset_type); if (ret) { - printf("Failed to get input set.\n"); + fprintf(stderr, "Failed to get input set.\n"); return; } @@ -16989,20 +14863,20 @@ cmd_cfg_input_set_parsed( ret = rte_pmd_i40e_inset_field_clear(&inset.inset, res->field_idx); if (ret) { - printf("Failed to configure input set field.\n"); + fprintf(stderr, "Failed to configure input set field.\n"); return; } ret = rte_pmd_i40e_inset_set(res->port_id, res->pctype_id, &inset, inset_type); if (ret) { - printf("Failed to set input set.\n"); + fprintf(stderr, "Failed to set input set.\n"); return; } #endif if (ret == -ENOTSUP) - printf("Function not supported\n"); + fprintf(stderr, "Function not supported\n"); } cmdline_parse_token_string_t cmd_cfg_input_set_port = @@ -17013,13 +14887,13 @@ cmdline_parse_token_string_t cmd_cfg_input_set_cfg = 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, @@ -17032,7 +14906,7 @@ cmdline_parse_token_string_t cmd_cfg_input_set_field = 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, @@ -17071,7 +14945,7 @@ cmd_clear_input_set_parsed( __rte_unused struct cmdline *cl, __rte_unused void *data) { -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E struct cmd_clear_input_set_result *res = parsed_result; enum rte_pmd_i40e_inset_type inset_type = INSET_NONE; struct rte_pmd_i40e_inset inset; @@ -17079,11 +14953,11 @@ cmd_clear_input_set_parsed( int ret = -ENOTSUP; if (!all_ports_stopped()) { - printf("Please stop all ports first\n"); + fprintf(stderr, "Please stop all ports first\n"); return; } -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (!strcmp(res->inset_type, "hash_inset")) inset_type = INSET_HASH; else if (!strcmp(res->inset_type, "fdir_inset")) @@ -17096,14 +14970,14 @@ cmd_clear_input_set_parsed( ret = rte_pmd_i40e_inset_set(res->port_id, res->pctype_id, &inset, inset_type); if (ret) { - printf("Failed to clear input set.\n"); + fprintf(stderr, "Failed to clear input set.\n"); return; } #endif if (ret == -ENOTSUP) - printf("Function not supported\n"); + fprintf(stderr, "Function not supported\n"); } cmdline_parse_token_string_t cmd_clear_input_set_port = @@ -17114,13 +14988,13 @@ cmdline_parse_token_string_t cmd_clear_input_set_cfg = 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, @@ -17177,11 +15051,11 @@ cmdline_parse_token_string_t cmd_show_vf_stats_stats = 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( @@ -17199,13 +15073,13 @@ cmd_show_vf_stats_parsed( memset(&stats, 0, sizeof(stats)); -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_get_vf_stats(res->port_id, res->vf_id, &stats); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_get_vf_stats(res->port_id, res->vf_id, @@ -17216,16 +15090,16 @@ cmd_show_vf_stats_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } printf("\n %s NIC statistics for port %-2d vf %-2d %s\n", @@ -17286,11 +15160,11 @@ cmdline_parse_token_string_t cmd_clear_vf_stats_stats = 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( @@ -17304,12 +15178,12 @@ cmd_clear_vf_stats_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (ret == -ENOTSUP) ret = rte_pmd_i40e_reset_vf_stats(res->port_id, res->vf_id); #endif -#ifdef RTE_LIBRTE_BNXT_PMD +#ifdef RTE_NET_BNXT if (ret == -ENOTSUP) ret = rte_pmd_bnxt_reset_vf_stats(res->port_id, res->vf_id); @@ -17319,16 +15193,16 @@ cmd_clear_vf_stats_parsed( case 0: break; case -EINVAL: - printf("invalid vf_id %d\n", res->vf_id); + fprintf(stderr, "invalid vf_id %d\n", res->vf_id); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -17370,7 +15244,7 @@ cmdline_parse_token_string_t cmd_pctype_mapping_reset_config = 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, @@ -17396,7 +15270,7 @@ cmd_pctype_mapping_reset_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_flow_type_mapping_reset(res->port_id); #endif @@ -17404,13 +15278,13 @@ cmd_pctype_mapping_reset_parsed( case 0: break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -17452,7 +15326,7 @@ cmdline_parse_token_string_t cmd_pctype_mapping_get_port = 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, @@ -17470,7 +15344,7 @@ cmd_pctype_mapping_get_parsed( { struct cmd_pctype_mapping_get_result *res = parsed_result; int ret = -ENOTSUP; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E struct rte_pmd_i40e_flow_type_mapping mapping[RTE_PMD_I40E_FLOW_TYPE_MAX]; int i, j, first_pctype; @@ -17479,7 +15353,7 @@ cmd_pctype_mapping_get_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id, mapping); #endif @@ -17487,17 +15361,17 @@ cmd_pctype_mapping_get_parsed( case 0: break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); return; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); return; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); return; } -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E for (i = 0; i < RTE_PMD_I40E_FLOW_TYPE_MAX; i++) { if (mapping[i].pctype != 0ULL) { first_pctype = 1; @@ -17556,7 +15430,7 @@ cmdline_parse_token_string_t cmd_pctype_mapping_update_config = 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, @@ -17576,7 +15450,7 @@ cmdline_parse_token_string_t cmd_pctype_mapping_update_pc_type = 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( @@ -17586,7 +15460,7 @@ cmd_pctype_mapping_update_parsed( { struct cmd_pctype_mapping_update_result *res = parsed_result; int ret = -ENOTSUP; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E struct rte_pmd_i40e_flow_type_mapping mapping; unsigned int i; unsigned int nb_item; @@ -17596,7 +15470,7 @@ cmd_pctype_mapping_update_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E nb_item = parse_item_list(res->pctype_list, "pctypes", RTE_PMD_I40E_PCTYPE_MAX, pctype_list, 1); mapping.flow_type = res->flow_type; @@ -17612,16 +15486,16 @@ cmd_pctype_mapping_update_parsed( case 0: break; case -EINVAL: - printf("invalid pctype or flow type\n"); + fprintf(stderr, "invalid pctype or flow type\n"); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -17670,11 +15544,11 @@ cmdline_parse_token_string_t cmd_ptype_mapping_get_get = 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( @@ -17684,7 +15558,7 @@ cmd_ptype_mapping_get_parsed( { struct cmd_ptype_mapping_get_result *res = parsed_result; int ret = -ENOTSUP; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E int max_ptype_num = 256; struct rte_pmd_i40e_ptype_mapping mapping[max_ptype_num]; uint16_t count; @@ -17694,7 +15568,7 @@ cmd_ptype_mapping_get_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_ptype_mapping_get(res->port_id, mapping, max_ptype_num, @@ -17706,16 +15580,16 @@ cmd_ptype_mapping_get_parsed( case 0: break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E if (!ret) { for (i = 0; i < count; i++) printf("%3d\t0x%08x\n", @@ -17767,19 +15641,19 @@ cmdline_parse_token_string_t cmd_ptype_mapping_replace_replace = 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( @@ -17793,7 +15667,7 @@ cmd_ptype_mapping_replace_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_ptype_mapping_replace(res->port_id, res->target, res->mask, @@ -17804,17 +15678,17 @@ cmd_ptype_mapping_replace_parsed( case 0: break; case -EINVAL: - printf("invalid ptype 0x%8x or 0x%8x\n", - res->target, res->pkt_type); + fprintf(stderr, "invalid ptype 0x%8x or 0x%8x\n", + res->target, res->pkt_type); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -17861,7 +15735,7 @@ cmdline_parse_token_string_t cmd_ptype_mapping_reset_reset = 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( @@ -17875,7 +15749,7 @@ cmd_ptype_mapping_reset_parsed( if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E ret = rte_pmd_i40e_ptype_mapping_reset(res->port_id); #endif @@ -17883,13 +15757,13 @@ cmd_ptype_mapping_reset_parsed( case 0: break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -17934,15 +15808,15 @@ cmdline_parse_token_string_t cmd_ptype_mapping_update_update = 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( @@ -17952,13 +15826,13 @@ cmd_ptype_mapping_update_parsed( { struct cmd_ptype_mapping_update_result *res = parsed_result; int ret = -ENOTSUP; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E struct rte_pmd_i40e_ptype_mapping mapping; #endif if (port_id_is_invalid(res->port_id, ENABLED_WARN)) return; -#ifdef RTE_LIBRTE_I40E_PMD +#ifdef RTE_NET_I40E mapping.hw_ptype = res->hw_ptype; mapping.sw_ptype = res->sw_ptype; ret = rte_pmd_i40e_ptype_mapping_update(res->port_id, @@ -17971,16 +15845,16 @@ cmd_ptype_mapping_update_parsed( case 0: break; case -EINVAL: - printf("invalid ptype 0x%8x\n", res->sw_ptype); + fprintf(stderr, "invalid ptype 0x%8x\n", res->sw_ptype); break; case -ENODEV: - printf("invalid port_id %d\n", res->port_id); + fprintf(stderr, "invalid port_id %d\n", res->port_id); break; case -ENOTSUP: - printf("function not implemented\n"); + fprintf(stderr, "function not implemented\n"); break; default: - printf("programming error: (%s)\n", strerror(-ret)); + fprintf(stderr, "programming error: (%s)\n", strerror(-ret)); } } @@ -18053,7 +15927,7 @@ cmdline_parse_token_string_t cmd_rx_offload_get_capa_port = 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, @@ -18150,7 +16024,7 @@ cmdline_parse_token_string_t cmd_rx_offload_get_configuration_port = 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, @@ -18170,6 +16044,7 @@ cmd_rx_offload_get_configuration_parsed( struct rte_eth_dev_info dev_info; portid_t port_id = res->port_id; struct rte_port *port = &ports[port_id]; + struct rte_eth_conf dev_conf; uint64_t port_offloads; uint64_t queue_offloads; uint16_t nb_rx_queues; @@ -18178,7 +16053,11 @@ cmd_rx_offload_get_configuration_parsed( printf("Rx Offloading Configuration of port %d :\n", port_id); - port_offloads = port->dev_conf.rxmode.offloads; + ret = eth_dev_conf_get_print_err(port_id, &dev_conf); + if (ret != 0) + return; + + port_offloads = dev_conf.rxmode.offloads; printf(" Port :"); print_rx_offloads(port_offloads); printf("\n"); @@ -18232,7 +16111,7 @@ cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_config = 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, @@ -18243,7 +16122,8 @@ cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_offload = offload, "vlan_strip#ipv4_cksum#udp_cksum#tcp_cksum#tcp_lro#" "qinq_strip#outer_ipv4_cksum#macsec_strip#" "header_split#vlan_filter#vlan_extend#jumbo_frame#" - "scatter#timestamp#security#keep_crc#rss_hash"); + "scatter#buffer_split#timestamp#security#" + "keep_crc#rss_hash"); cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_on_off = TOKEN_STRING_INITIALIZER (struct cmd_config_per_port_rx_offload_result, @@ -18288,14 +16168,15 @@ cmd_config_per_port_rx_offload_parsed(void *parsed_result, int ret; if (port->port_status != RTE_PORT_STOPPED) { - printf("Error: Can't config offload when Port %d " - "is not stopped\n", port_id); + fprintf(stderr, + "Error: Can't config offload when Port %d is not stopped\n", + port_id); return; } single_offload = search_rx_offload(res->offload); if (single_offload == 0) { - printf("Unknown offload name: %s\n", res->offload); + fprintf(stderr, "Unknown offload name: %s\n", res->offload); return; } @@ -18323,8 +16204,8 @@ cmdline_parse_inst_t cmd_config_per_port_rx_offload = { .help_str = "port config rx_offload vlan_strip|ipv4_cksum|" "udp_cksum|tcp_cksum|tcp_lro|qinq_strip|outer_ipv4_cksum|" "macsec_strip|header_split|vlan_filter|vlan_extend|" - "jumbo_frame|scatter|timestamp|security|keep_crc|rss_hash " - "on|off", + "jumbo_frame|scatter|buffer_split|timestamp|security|" + "keep_crc|rss_hash on|off", .tokens = { (void *)&cmd_config_per_port_rx_offload_result_port, (void *)&cmd_config_per_port_rx_offload_result_config, @@ -18354,7 +16235,7 @@ cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_port = 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, @@ -18362,7 +16243,7 @@ cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_rxq = 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, @@ -18373,7 +16254,7 @@ cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_offload = offload, "vlan_strip#ipv4_cksum#udp_cksum#tcp_cksum#tcp_lro#" "qinq_strip#outer_ipv4_cksum#macsec_strip#" "header_split#vlan_filter#vlan_extend#jumbo_frame#" - "scatter#timestamp#security#keep_crc"); + "scatter#buffer_split#timestamp#security#keep_crc"); cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_on_off = TOKEN_STRING_INITIALIZER (struct cmd_config_per_queue_rx_offload_result, @@ -18393,8 +16274,9 @@ cmd_config_per_queue_rx_offload_parsed(void *parsed_result, int ret; if (port->port_status != RTE_PORT_STOPPED) { - printf("Error: Can't config offload when Port %d " - "is not stopped\n", port_id); + fprintf(stderr, + "Error: Can't config offload when Port %d is not stopped\n", + port_id); return; } @@ -18403,14 +16285,15 @@ cmd_config_per_queue_rx_offload_parsed(void *parsed_result, return; if (queue_id >= dev_info.nb_rx_queues) { - printf("Error: input queue_id should be 0 ... " - "%d\n", dev_info.nb_rx_queues - 1); + fprintf(stderr, + "Error: input queue_id should be 0 ... %d\n", + dev_info.nb_rx_queues - 1); return; } single_offload = search_rx_offload(res->offload); if (single_offload == 0) { - printf("Unknown offload name: %s\n", res->offload); + fprintf(stderr, "Unknown offload name: %s\n", res->offload); return; } @@ -18429,8 +16312,8 @@ cmdline_parse_inst_t cmd_config_per_queue_rx_offload = { "vlan_strip|ipv4_cksum|" "udp_cksum|tcp_cksum|tcp_lro|qinq_strip|outer_ipv4_cksum|" "macsec_strip|header_split|vlan_filter|vlan_extend|" - "jumbo_frame|scatter|timestamp|security|keep_crc " - "on|off", + "jumbo_frame|scatter|buffer_split|timestamp|security|" + "keep_crc on|off", .tokens = { (void *)&cmd_config_per_queue_rx_offload_result_port, (void *)&cmd_config_per_queue_rx_offload_result_port_id, @@ -18463,7 +16346,7 @@ cmdline_parse_token_string_t cmd_tx_offload_get_capa_port = 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, @@ -18560,7 +16443,7 @@ cmdline_parse_token_string_t cmd_tx_offload_get_configuration_port = 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, @@ -18580,6 +16463,7 @@ cmd_tx_offload_get_configuration_parsed( struct rte_eth_dev_info dev_info; portid_t port_id = res->port_id; struct rte_port *port = &ports[port_id]; + struct rte_eth_conf dev_conf; uint64_t port_offloads; uint64_t queue_offloads; uint16_t nb_tx_queues; @@ -18588,7 +16472,11 @@ cmd_tx_offload_get_configuration_parsed( printf("Tx Offloading Configuration of port %d :\n", port_id); - port_offloads = port->dev_conf.txmode.offloads; + ret = eth_dev_conf_get_print_err(port_id, &dev_conf); + if (ret != 0) + return; + + port_offloads = dev_conf.txmode.offloads; printf(" Port :"); print_tx_offloads(port_offloads); printf("\n"); @@ -18642,7 +16530,7 @@ cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_config = 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, @@ -18654,7 +16542,8 @@ cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_offload = "sctp_cksum#tcp_tso#udp_tso#outer_ipv4_cksum#" "qinq_insert#vxlan_tnl_tso#gre_tnl_tso#" "ipip_tnl_tso#geneve_tnl_tso#macsec_insert#" - "mt_lockfree#multi_segs#mbuf_fast_free#security"); + "mt_lockfree#multi_segs#mbuf_fast_free#security#" + "send_on_timestamp"); cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_on_off = TOKEN_STRING_INITIALIZER (struct cmd_config_per_port_tx_offload_result, @@ -18702,14 +16591,15 @@ cmd_config_per_port_tx_offload_parsed(void *parsed_result, int ret; if (port->port_status != RTE_PORT_STOPPED) { - printf("Error: Can't config offload when Port %d " - "is not stopped\n", port_id); + fprintf(stderr, + "Error: Can't config offload when Port %d is not stopped\n", + port_id); return; } single_offload = search_tx_offload(res->offload); if (single_offload == 0) { - printf("Unknown offload name: %s\n", res->offload); + fprintf(stderr, "Unknown offload name: %s\n", res->offload); return; } @@ -18739,7 +16629,8 @@ cmdline_parse_inst_t cmd_config_per_port_tx_offload = { "sctp_cksum|tcp_tso|udp_tso|outer_ipv4_cksum|" "qinq_insert|vxlan_tnl_tso|gre_tnl_tso|" "ipip_tnl_tso|geneve_tnl_tso|macsec_insert|" - "mt_lockfree|multi_segs|mbuf_fast_free|security on|off", + "mt_lockfree|multi_segs|mbuf_fast_free|security|" + "send_on_timestamp on|off", .tokens = { (void *)&cmd_config_per_port_tx_offload_result_port, (void *)&cmd_config_per_port_tx_offload_result_config, @@ -18769,7 +16660,7 @@ cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_port = 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, @@ -18777,7 +16668,7 @@ cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_txq = 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, @@ -18809,8 +16700,9 @@ cmd_config_per_queue_tx_offload_parsed(void *parsed_result, int ret; if (port->port_status != RTE_PORT_STOPPED) { - printf("Error: Can't config offload when Port %d " - "is not stopped\n", port_id); + fprintf(stderr, + "Error: Can't config offload when Port %d is not stopped\n", + port_id); return; } @@ -18819,14 +16711,15 @@ cmd_config_per_queue_tx_offload_parsed(void *parsed_result, return; if (queue_id >= dev_info.nb_tx_queues) { - printf("Error: input queue_id should be 0 ... " - "%d\n", dev_info.nb_tx_queues - 1); + fprintf(stderr, + "Error: input queue_id should be 0 ... %d\n", + dev_info.nb_tx_queues - 1); return; } single_offload = search_tx_offload(res->offload); if (single_offload == 0) { - printf("Unknown offload name: %s\n", res->offload); + fprintf(stderr, "Unknown offload name: %s\n", res->offload); return; } @@ -18895,13 +16788,13 @@ cmdline_parse_token_string_t cmd_config_tx_metadata_specific_keyword = 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, @@ -18943,13 +16836,13 @@ cmd_config_dynf_specific_parsed(void *parsed_result, if (flag <= 0) { if (strlcpy(desc_flag.name, res->name, RTE_MBUF_DYN_NAMESIZE) >= RTE_MBUF_DYN_NAMESIZE) { - printf("Flag name too long\n"); + fprintf(stderr, "Flag name too long\n"); return; } desc_flag.flags = 0; flag = rte_mbuf_dynflag_register(&desc_flag); if (flag < 0) { - printf("Can't register flag\n"); + fprintf(stderr, "Can't register flag\n"); return; } strcpy(dynf_names[flag], desc_flag.name); @@ -18974,7 +16867,7 @@ cmdline_parse_token_string_t cmd_config_tx_dynf_specific_keyword = 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"); @@ -19016,7 +16909,7 @@ cmd_show_tx_metadata_parsed(void *parsed_result, struct cmd_show_tx_metadata_result *res = parsed_result; if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { - printf("invalid port id %u\n", res->cmd_pid); + fprintf(stderr, "invalid port id %u\n", res->cmd_pid); return; } if (!strcmp(res->cmd_keyword, "tx_metadata")) { @@ -19033,7 +16926,7 @@ cmdline_parse_token_string_t cmd_show_tx_metadata_port = 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"); @@ -19051,6 +16944,238 @@ cmdline_parse_inst_t cmd_show_tx_metadata = { }, }; +/* *** show fec capability per port configuration *** */ +struct cmd_show_fec_capability_result { + cmdline_fixed_string_t cmd_show; + cmdline_fixed_string_t cmd_port; + cmdline_fixed_string_t cmd_fec; + cmdline_fixed_string_t cmd_keyword; + portid_t cmd_pid; +}; + +static void +cmd_show_fec_capability_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_show_fec_capability_result *res = parsed_result; + struct rte_eth_fec_capa *speed_fec_capa; + unsigned int num; + int ret; + + if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { + fprintf(stderr, "Invalid port id %u\n", res->cmd_pid); + return; + } + + ret = rte_eth_fec_get_capability(res->cmd_pid, NULL, 0); + if (ret == -ENOTSUP) { + fprintf(stderr, "Function not implemented\n"); + return; + } else if (ret < 0) { + fprintf(stderr, "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) { + fprintf(stderr, "Failed to alloc FEC capability buffer\n"); + return; + } + + ret = rte_eth_fec_get_capability(res->cmd_pid, speed_fec_capa, num); + if (ret < 0) { + fprintf(stderr, "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 = + TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result, + cmd_show, "show"); +cmdline_parse_token_string_t cmd_show_fec_capability_port = + TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result, + cmd_port, "port"); +cmdline_parse_token_num_t cmd_show_fec_capability_pid = + TOKEN_NUM_INITIALIZER(struct cmd_show_fec_capability_result, + cmd_pid, RTE_UINT16); +cmdline_parse_token_string_t cmd_show_fec_capability_fec = + TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result, + cmd_fec, "fec"); +cmdline_parse_token_string_t cmd_show_fec_capability_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result, + cmd_keyword, "capabilities"); + +cmdline_parse_inst_t cmd_show_capability = { + .f = cmd_show_fec_capability_parsed, + .data = NULL, + .help_str = "show port fec capabilities", + .tokens = { + (void *)&cmd_show_fec_capability_show, + (void *)&cmd_show_fec_capability_port, + (void *)&cmd_show_fec_capability_pid, + (void *)&cmd_show_fec_capability_fec, + (void *)&cmd_show_fec_capability_keyword, + NULL, + }, +}; + +/* *** show fec mode per port configuration *** */ +struct cmd_show_fec_metadata_result { + cmdline_fixed_string_t cmd_show; + cmdline_fixed_string_t cmd_port; + cmdline_fixed_string_t cmd_keyword; + portid_t cmd_pid; +}; + +static void +cmd_show_fec_mode_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ +#define FEC_NAME_SIZE 16 + struct cmd_show_fec_metadata_result *res = parsed_result; + uint32_t mode; + char buf[FEC_NAME_SIZE]; + int ret; + + if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { + fprintf(stderr, "Invalid port id %u\n", res->cmd_pid); + return; + } + ret = rte_eth_fec_get(res->cmd_pid, &mode); + if (ret == -ENOTSUP) { + fprintf(stderr, "Function not implemented\n"); + return; + } else if (ret < 0) { + fprintf(stderr, "Get FEC mode failed\n"); + return; + } + + switch (mode) { + case RTE_ETH_FEC_MODE_CAPA_MASK(NOFEC): + strlcpy(buf, "off", sizeof(buf)); + break; + case RTE_ETH_FEC_MODE_CAPA_MASK(AUTO): + strlcpy(buf, "auto", sizeof(buf)); + break; + case RTE_ETH_FEC_MODE_CAPA_MASK(BASER): + strlcpy(buf, "baser", sizeof(buf)); + break; + case RTE_ETH_FEC_MODE_CAPA_MASK(RS): + strlcpy(buf, "rs", sizeof(buf)); + break; + default: + return; + } + + printf("%s\n", buf); +} + +cmdline_parse_token_string_t cmd_show_fec_mode_show = + TOKEN_STRING_INITIALIZER(struct cmd_show_fec_metadata_result, + cmd_show, "show"); +cmdline_parse_token_string_t cmd_show_fec_mode_port = + TOKEN_STRING_INITIALIZER(struct cmd_show_fec_metadata_result, + cmd_port, "port"); +cmdline_parse_token_num_t cmd_show_fec_mode_pid = + TOKEN_NUM_INITIALIZER(struct cmd_show_fec_metadata_result, + cmd_pid, 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_inst_t cmd_show_fec_mode = { + .f = cmd_show_fec_mode_parsed, + .data = NULL, + .help_str = "show port fec_mode", + .tokens = { + (void *)&cmd_show_fec_mode_show, + (void *)&cmd_show_fec_mode_port, + (void *)&cmd_show_fec_mode_pid, + (void *)&cmd_show_fec_mode_keyword, + NULL, + }, +}; + +/* *** set fec mode per port configuration *** */ +struct cmd_set_port_fec_mode { + cmdline_fixed_string_t set; + cmdline_fixed_string_t port; + portid_t port_id; + cmdline_fixed_string_t fec_mode; + cmdline_fixed_string_t fec_value; +}; + +/* Common CLI fields for set fec mode */ +cmdline_parse_token_string_t cmd_set_port_fec_mode_set = + TOKEN_STRING_INITIALIZER + (struct cmd_set_port_fec_mode, + set, "set"); +cmdline_parse_token_string_t cmd_set_port_fec_mode_port = + TOKEN_STRING_INITIALIZER + (struct cmd_set_port_fec_mode, + port, "port"); +cmdline_parse_token_num_t cmd_set_port_fec_mode_port_id = + TOKEN_NUM_INITIALIZER + (struct cmd_set_port_fec_mode, + port_id, RTE_UINT16); +cmdline_parse_token_string_t cmd_set_port_fec_mode_str = + TOKEN_STRING_INITIALIZER + (struct cmd_set_port_fec_mode, + fec_mode, "fec_mode"); +cmdline_parse_token_string_t cmd_set_port_fec_mode_value = + TOKEN_STRING_INITIALIZER + (struct cmd_set_port_fec_mode, + fec_value, NULL); + +static void +cmd_set_port_fec_mode_parsed( + void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_set_port_fec_mode *res = parsed_result; + uint16_t port_id = res->port_id; + uint32_t fec_capa; + int ret; + + ret = parse_fec_mode(res->fec_value, &fec_capa); + if (ret < 0) { + fprintf(stderr, "Unknown fec mode: %s for port %d\n", + res->fec_value, port_id); + return; + } + + ret = rte_eth_fec_set(port_id, fec_capa); + if (ret == -ENOTSUP) { + fprintf(stderr, "Function not implemented\n"); + return; + } else if (ret < 0) { + fprintf(stderr, "Set FEC mode failed\n"); + return; + } +} + +cmdline_parse_inst_t cmd_set_fec_mode = { + .f = cmd_set_port_fec_mode_parsed, + .data = NULL, + .help_str = "set port fec_mode auto|off|rs|baser", + .tokens = { + (void *)&cmd_set_port_fec_mode_set, + (void *)&cmd_set_port_fec_mode_port, + (void *)&cmd_set_port_fec_mode_port_id, + (void *)&cmd_set_port_fec_mode_str, + (void *)&cmd_set_port_fec_mode_value, + NULL, + }, +}; + /* show port supported ptypes */ /* Common result structure for show port ptypes */ @@ -19073,7 +17198,7 @@ cmdline_parse_token_string_t cmd_show_port_supported_ptypes_port = cmdline_parse_token_num_t cmd_show_port_supported_ptypes_port_id = TOKEN_NUM_INITIALIZER (struct cmd_show_port_supported_ptypes_result, - port_id, UINT16); + 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, @@ -19180,7 +17305,7 @@ cmd_show_rx_tx_desc_status_parsed(void *parsed_result, int rc; if (!rte_eth_dev_is_valid_port(res->cmd_pid)) { - printf("invalid port id %u\n", res->cmd_pid); + fprintf(stderr, "invalid port id %u\n", res->cmd_pid); return; } @@ -19188,7 +17313,9 @@ cmd_show_rx_tx_desc_status_parsed(void *parsed_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); + fprintf(stderr, + "Invalid input: queue id = %d, desc id = %d\n", + res->cmd_qid, res->cmd_did); return; } if (rc == RTE_ETH_RX_DESC_AVAIL) @@ -19201,7 +17328,9 @@ cmd_show_rx_tx_desc_status_parsed(void *parsed_result, 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); + fprintf(stderr, + "Invalid input: queue id = %d, desc id = %d\n", + res->cmd_qid, res->cmd_did); return; } if (rc == RTE_ETH_TX_DESC_FULL) @@ -19221,19 +17350,19 @@ cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_port = 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"); @@ -19255,6 +17384,88 @@ cmdline_parse_inst_t cmd_show_rx_tx_desc_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)) { + fprintf(stderr, "invalid port id %u\n", res->cmd_pid); + return; + } + + rc = rte_eth_rx_queue_count(res->cmd_pid, res->cmd_qid); + if (rc < 0) { + fprintf(stderr, "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 rxq 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; @@ -19276,7 +17487,7 @@ cmdline_parse_token_string_t cmd_set_port_ptypes_port = 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, @@ -19284,7 +17495,7 @@ cmdline_parse_token_string_t cmd_set_port_ptypes_mask_str = 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( @@ -19302,7 +17513,8 @@ cmd_set_port_ptypes_parsed( ret = rte_eth_dev_get_supported_ptypes(port_id, RTE_PTYPE_ALL_MASK, NULL, 0); if (ret <= 0) { - printf("Port %d doesn't support any ptypes.\n", port_id); + fprintf(stderr, "Port %d doesn't support any ptypes.\n", + port_id); return; } @@ -19310,7 +17522,8 @@ cmd_set_port_ptypes_parsed( ret = rte_eth_dev_set_ptypes(port_id, ptype_mask, ptypes, ret); if (ret < 0) { - printf("Unable to set requested ptypes for Port %d\n", port_id); + fprintf(stderr, "Unable to set requested ptypes for Port %d\n", + port_id); return; } @@ -19369,7 +17582,7 @@ cmdline_parse_token_string_t cmd_showport_macs_port = 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"); @@ -19387,6 +17600,77 @@ cmdline_parse_inst_t cmd_showport_macs = { }, }; +/* *** show flow transfer proxy port ID for the given port *** */ +struct cmd_show_port_flow_transfer_proxy_result { + cmdline_fixed_string_t show; + cmdline_fixed_string_t port; + portid_t port_id; + cmdline_fixed_string_t flow; + cmdline_fixed_string_t transfer; + cmdline_fixed_string_t proxy; +}; + +cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_show = + TOKEN_STRING_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + show, "show"); +cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_port = + TOKEN_STRING_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + port, "port"); +cmdline_parse_token_num_t cmd_show_port_flow_transfer_proxy_port_id = + TOKEN_NUM_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + port_id, RTE_UINT16); +cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_flow = + TOKEN_STRING_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + flow, "flow"); +cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_transfer = + TOKEN_STRING_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + transfer, "transfer"); +cmdline_parse_token_string_t cmd_show_port_flow_transfer_proxy_proxy = + TOKEN_STRING_INITIALIZER + (struct cmd_show_port_flow_transfer_proxy_result, + proxy, "proxy"); + +static void +cmd_show_port_flow_transfer_proxy_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_show_port_flow_transfer_proxy_result *res = parsed_result; + portid_t proxy_port_id; + int ret; + + printf("\n"); + + ret = rte_flow_pick_transfer_proxy(res->port_id, &proxy_port_id, NULL); + if (ret != 0) { + fprintf(stderr, "Failed to pick transfer proxy: %s\n", + rte_strerror(-ret)); + return; + } + + printf("Transfer proxy port ID: %u\n\n", proxy_port_id); +} + +cmdline_parse_inst_t cmd_show_port_flow_transfer_proxy = { + .f = cmd_show_port_flow_transfer_proxy_parsed, + .data = NULL, + .help_str = "show port flow transfer proxy", + .tokens = { + (void *)&cmd_show_port_flow_transfer_proxy_show, + (void *)&cmd_show_port_flow_transfer_proxy_port, + (void *)&cmd_show_port_flow_transfer_proxy_port_id, + (void *)&cmd_show_port_flow_transfer_proxy_flow, + (void *)&cmd_show_port_flow_transfer_proxy_transfer, + (void *)&cmd_show_port_flow_transfer_proxy_proxy, + NULL, + } +}; + /* ******************************************************************************** */ /* list of instructions */ @@ -19397,7 +17681,9 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_load_from_file, (cmdline_parse_inst_t *)&cmd_showport, (cmdline_parse_inst_t *)&cmd_showqueue, + (cmdline_parse_inst_t *)&cmd_showeeprom, (cmdline_parse_inst_t *)&cmd_showportall, + (cmdline_parse_inst_t *)&cmd_representor_info, (cmdline_parse_inst_t *)&cmd_showdevice, (cmdline_parse_inst_t *)&cmd_showcfg, (cmdline_parse_inst_t *)&cmd_showfwdall, @@ -19409,8 +17695,11 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_reset, (cmdline_parse_inst_t *)&cmd_set_numbers, (cmdline_parse_inst_t *)&cmd_set_log, + (cmdline_parse_inst_t *)&cmd_set_rxoffs, + (cmdline_parse_inst_t *)&cmd_set_rxpkts, (cmdline_parse_inst_t *)&cmd_set_txpkts, (cmdline_parse_inst_t *)&cmd_set_txsplit, + (cmdline_parse_inst_t *)&cmd_set_txtimes, (cmdline_parse_inst_t *)&cmd_set_fwd_list, (cmdline_parse_inst_t *)&cmd_set_fwd_mask, (cmdline_parse_inst_t *)&cmd_set_fwd_mode, @@ -19426,9 +17715,10 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_set_bypass_event, (cmdline_parse_inst_t *)&cmd_set_bypass_timeout, (cmdline_parse_inst_t *)&cmd_show_bypass_config, -#ifdef RTE_LIBRTE_PMD_BOND +#ifdef RTE_NET_BOND (cmdline_parse_inst_t *) &cmd_set_bonding_mode, (cmdline_parse_inst_t *) &cmd_show_bonding_config, + (cmdline_parse_inst_t *) &cmd_show_bonding_lacp_info, (cmdline_parse_inst_t *) &cmd_set_bonding_primary, (cmdline_parse_inst_t *) &cmd_add_bonding_slave, (cmdline_parse_inst_t *) &cmd_remove_bonding_slave, @@ -19454,12 +17744,16 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_tso_show, (cmdline_parse_inst_t *)&cmd_tunnel_tso_set, (cmdline_parse_inst_t *)&cmd_tunnel_tso_show, +#ifdef RTE_LIB_GRO (cmdline_parse_inst_t *)&cmd_gro_enable, (cmdline_parse_inst_t *)&cmd_gro_flush, (cmdline_parse_inst_t *)&cmd_gro_show, +#endif +#ifdef RTE_LIB_GSO (cmdline_parse_inst_t *)&cmd_gso_enable, (cmdline_parse_inst_t *)&cmd_gso_size, (cmdline_parse_inst_t *)&cmd_gso_show, +#endif (cmdline_parse_inst_t *)&cmd_link_flow_control_set, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_rx, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_tx, @@ -19469,6 +17763,7 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_link_flow_control_set_xon, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_macfwd, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_autoneg, + (cmdline_parse_inst_t *)&cmd_link_flow_control_show, (cmdline_parse_inst_t *)&cmd_priority_flow_control_set, (cmdline_parse_inst_t *)&cmd_config_dcb, (cmdline_parse_inst_t *)&cmd_read_reg, @@ -19483,6 +17778,8 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_set_fwd_eth_peer, (cmdline_parse_inst_t *)&cmd_set_qmap, (cmdline_parse_inst_t *)&cmd_set_xstats_hide_zero, + (cmdline_parse_inst_t *)&cmd_set_record_core_cycles, + (cmdline_parse_inst_t *)&cmd_set_record_burst_stats, (cmdline_parse_inst_t *)&cmd_operate_port, (cmdline_parse_inst_t *)&cmd_operate_specific_port, (cmdline_parse_inst_t *)&cmd_operate_attach_port, @@ -19506,49 +17803,28 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_config_rss_reta, (cmdline_parse_inst_t *)&cmd_showport_reta, (cmdline_parse_inst_t *)&cmd_showport_macs, + (cmdline_parse_inst_t *)&cmd_show_port_flow_transfer_proxy, (cmdline_parse_inst_t *)&cmd_config_burst, (cmdline_parse_inst_t *)&cmd_config_thresh, (cmdline_parse_inst_t *)&cmd_config_threshold, (cmdline_parse_inst_t *)&cmd_set_uc_hash_filter, (cmdline_parse_inst_t *)&cmd_set_uc_all_hash_filter, (cmdline_parse_inst_t *)&cmd_vf_mac_addr_filter, - (cmdline_parse_inst_t *)&cmd_set_vf_macvlan_filter, (cmdline_parse_inst_t *)&cmd_queue_rate_limit, - (cmdline_parse_inst_t *)&cmd_tunnel_filter, (cmdline_parse_inst_t *)&cmd_tunnel_udp_config, - (cmdline_parse_inst_t *)&cmd_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_showport_rss_hash, (cmdline_parse_inst_t *)&cmd_showport_rss_hash_key, (cmdline_parse_inst_t *)&cmd_config_rss_hash_key, + (cmdline_parse_inst_t *)&cmd_cleanup_txq_mbufs, (cmdline_parse_inst_t *)&cmd_dump, (cmdline_parse_inst_t *)&cmd_dump_one, - (cmdline_parse_inst_t *)&cmd_ethertype_filter, - (cmdline_parse_inst_t *)&cmd_syn_filter, - (cmdline_parse_inst_t *)&cmd_2tuple_filter, - (cmdline_parse_inst_t *)&cmd_5tuple_filter, - (cmdline_parse_inst_t *)&cmd_flex_filter, - (cmdline_parse_inst_t *)&cmd_add_del_ip_flow_director, - (cmdline_parse_inst_t *)&cmd_add_del_udp_flow_director, - (cmdline_parse_inst_t *)&cmd_add_del_sctp_flow_director, - (cmdline_parse_inst_t *)&cmd_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, @@ -19558,22 +17834,12 @@ cmdline_parse_ctx_t main_ctx[] = { (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, @@ -19599,9 +17865,6 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_vf_tc_max_bw, (cmdline_parse_inst_t *)&cmd_strict_link_prio, (cmdline_parse_inst_t *)&cmd_tc_min_bw, -#if defined RTE_LIBRTE_PMD_SOFTNIC && defined RTE_LIBRTE_SCHED - (cmdline_parse_inst_t *)&cmd_set_port_tm_hierarchy_default, -#endif (cmdline_parse_inst_t *)&cmd_set_vxlan, (cmdline_parse_inst_t *)&cmd_set_vxlan_tos_ttl, (cmdline_parse_inst_t *)&cmd_set_vxlan_with_vlan, @@ -19619,6 +17882,8 @@ cmdline_parse_ctx_t main_ctx[] = { (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, @@ -19655,6 +17920,7 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_del_port_tm_node_wred_profile, (cmdline_parse_inst_t *)&cmd_set_port_tm_node_shaper_profile, (cmdline_parse_inst_t *)&cmd_add_port_tm_nonleaf_node, + (cmdline_parse_inst_t *)&cmd_add_port_tm_nonleaf_node_pmode, (cmdline_parse_inst_t *)&cmd_add_port_tm_leaf_node, (cmdline_parse_inst_t *)&cmd_del_port_tm_node, (cmdline_parse_inst_t *)&cmd_set_port_tm_node_parent, @@ -19673,17 +17939,23 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_tx_offload_get_configuration, (cmdline_parse_inst_t *)&cmd_config_per_port_tx_offload, (cmdline_parse_inst_t *)&cmd_config_per_queue_tx_offload, -#ifdef RTE_LIBRTE_BPF +#ifdef RTE_LIB_BPF (cmdline_parse_inst_t *)&cmd_operate_bpf_ld_parse, (cmdline_parse_inst_t *)&cmd_operate_bpf_unld_parse, #endif (cmdline_parse_inst_t *)&cmd_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, (cmdline_parse_inst_t *)&cmd_config_tx_dynf_specific, + (cmdline_parse_inst_t *)&cmd_show_fec_mode, + (cmdline_parse_inst_t *)&cmd_set_fec_mode, + (cmdline_parse_inst_t *)&cmd_show_capability, + (cmdline_parse_inst_t *)&cmd_set_flex_is_pattern, + (cmdline_parse_inst_t *)&cmd_set_flex_spec_pattern, NULL, }; @@ -19695,8 +17967,9 @@ cmdline_read_from_file(const char *filename) cl = cmdline_file_new(main_ctx, "testpmd> ", filename); if (cl == NULL) { - printf("Failed to create file based cmdline context: %s\n", - filename); + fprintf(stderr, + "Failed to create file based cmdline context: %s\n", + filename); return; } @@ -19708,10 +17981,11 @@ cmdline_read_from_file(const char *filename) printf("Read CLI commands from %s\n", filename); } -/* prompt function, called from main on MASTER lcore */ +/* prompt function, called from main on MAIN lcore */ void prompt(void) { + int ret; /* initialize non-constant commands */ cmd_set_fwd_mode_init(); cmd_set_fwd_retry_mode_init(); @@ -19719,15 +17993,23 @@ prompt(void) testpmd_cl = cmdline_stdin_new(main_ctx, "testpmd> "); if (testpmd_cl == NULL) return; + + ret = atexit(prompt_exit); + if (ret != 0) + fprintf(stderr, "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