#include <stdio.h>
#include <stdint.h>
#include <string.h>
-#include <termios.h>
#include <unistd.h>
#include <inttypes.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-
#include <sys/queue.h>
#include <rte_common.h>
#include <rte_eal.h>
#include <rte_per_lcore.h>
#include <rte_lcore.h>
-#include <rte_atomic.h>
#include <rte_branch_prediction.h>
#include <rte_ring.h>
#include <rte_mempool.h>
#include <rte_string_fns.h>
#include <rte_devargs.h>
#include <rte_flow.h>
+#ifdef RTE_LIB_GRO
#include <rte_gro.h>
+#endif
#include <rte_mbuf_dyn.h>
#include <cmdline_rdline.h>
#include "bpf_cmd.h"
static struct cmdline *testpmd_cl;
+static cmdline_parse_ctx_t *main_ctx;
+static TAILQ_HEAD(, testpmd_driver_commands) driver_commands_head =
+ TAILQ_HEAD_INITIALIZER(driver_commands_head);
static void cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue);
" help registers : Reading and setting port registers.\n"
" help filters : Filters configuration help.\n"
" help traffic_management : Traffic Management commands.\n"
- " help devices : Device related cmds.\n"
+ " help devices : Device related commands.\n"
+ " help drivers : Driver specific commands.\n"
" help all : All of the above sections.\n\n"
);
}
-cmdline_parse_token_string_t cmd_help_brief_help =
+static cmdline_parse_token_string_t cmd_help_brief_help =
TOKEN_STRING_INITIALIZER(struct cmd_help_brief_result, help, "help");
-cmdline_parse_inst_t cmd_help_brief = {
+static cmdline_parse_inst_t cmd_help_brief = {
.f = cmd_help_brief_parsed,
.data = NULL,
.help_str = "help: Show help",
"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 (port_id) rss-hash [key]\n"
" Display the RSS hash functions and RSS hash key of port\n\n"
- "clear port (info|stats|xstats|fdir|stat_qmap) (port_id|all)\n"
+ "clear port (info|stats|xstats|fdir) (port_id|all)\n"
" Clear information for port_id, or all.\n\n"
"show (rxq|txq) info (port_id) (queue_id)\n"
"show port (port_id) rxq|txq (queue_id) desc (desc_id) status"
" Show status of rx|tx descriptor.\n\n"
+ "show port (port_id) rxq (queue_id) desc used count\n"
+ " Show current number of filled receive"
+ " packet descriptors.\n\n"
+
"show port (port_id) macs|mcast_macs"
" Display list of mac addresses added to port.\n\n"
+ "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"
);
}
"tso show (portid)"
" Display the status of TCP Segmentation Offload.\n\n"
+#ifdef RTE_LIB_GRO
"set port (port_id) gro on|off\n"
" Enable or disable Generic Receive Offload in"
" csum forwarding engine.\n\n"
"set gro flush (cycles)\n"
" Set the cycle to flush GROed packets from"
" reassembly tables.\n\n"
+#endif
+#ifdef RTE_LIB_GSO
"set port (port_id) gso (on|off)"
" Enable or disable Generic Segmentation Offload in"
" csum forwarding engine.\n\n"
"show port (port_id) gso\n"
" Show GSO configuration.\n\n"
+#endif
"set fwd (%s)\n"
" Set packet forwarding mode.\n\n"
" Set the priority flow control parameter on a"
" port.\n\n"
+ "set pfc_queue_ctrl (port_id) rx (on|off) (tx_qid)"
+ " (tx_tc) tx (on|off) (rx_qid) (rx_tc) (pause_time)\n"
+ " Set the queue priority flow control parameter on a"
+ " given Rx and Tx queues of a port.\n\n"
+
+ "set port (port_id) rxq (queue_id) avail_thresh (0..99)>\n "
+ " set available descriptors threshold for Rx queue\n\n"
+
"set stat_qmap (tx|rx) (port_id) (queue_id) (qmapping)\n"
" Set statistics mapping (qmapping 0..15) for RX/TX"
" queue on port.\n"
" Set the option to enable display of RX and TX bursts.\n"
"set port (port_id) vf (vf_id) rx|tx on|off\n"
- " Enable/Disable a VF receive/tranmit from a port\n\n"
+ " Enable/Disable a VF receive/transmit from a port\n\n"
"set port (port_id) vf (vf_id) rxmode (AUPE|ROPE|BAM"
"|MPE) (on|off)\n"
"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"
"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 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"
-
"ddp add (port_id) (profile_path[,backup_profile_path])\n"
" Load a profile package on a port\n\n"
"show port meter cap (port_id)\n"
" Show port meter capability information\n\n"
- "add port meter profile srtcm_rfc2697 (port_id) (profile_id) (cir) (cbs) (ebs)\n"
+ "add port meter profile srtcm_rfc2697 (port_id) (profile_id) (cir) (cbs) (ebs) (packet_mode)\n"
" meter profile add - srtcm rfc 2697\n\n"
- "add port meter profile trtcm_rfc2698 (port_id) (profile_id) (cir) (pir) (cbs) (pbs)\n"
+ "add port meter profile trtcm_rfc2698 (port_id) (profile_id) (cir) (pir) (cbs) (pbs) (packet_mode)\n"
" meter profile add - trtcm rfc 2698\n\n"
- "add port meter profile trtcm_rfc4115 (port_id) (profile_id) (cir) (eir) (cbs) (ebs)\n"
+ "add port meter profile trtcm_rfc4115 (port_id) (profile_id) (cir) (eir) (cbs) (ebs) (packet_mode)\n"
" meter profile add - trtcm rfc 4115\n\n"
"del port meter profile (port_id) (profile_id)\n"
" meter profile delete\n\n"
- "create port meter (port_id) (mtr_id) (profile_id) (meter_enable)\n"
- "(g_action) (y_action) (r_action) (stats_mask) (shared)\n"
- "(use_pre_meter_color) [(dscp_tbl_entry0) (dscp_tbl_entry1)...\n"
+ "create port meter (port_id) (mtr_id) (profile_id) (policy_id) (meter_enable)\n"
+ "(stats_mask) (shared) (use_pre_meter_color) [(dscp_tbl_entry0) (dscp_tbl_entry1)...\n"
"(dscp_tbl_entry63)]\n"
" meter create\n\n"
"del port meter (port_id) (mtr_id)\n"
" meter delete\n\n"
+ "add port meter policy (port_id) (policy_id) g_actions (actions)\n"
+ "y_actions (actions) r_actions (actions)\n"
+ " meter policy add\n\n"
+
+ "del port meter policy (port_id) (policy_id)\n"
+ " meter policy delete\n\n"
+
"set port meter profile (port_id) (mtr_id) (profile_id)\n"
" meter update meter profile\n\n"
"receive buffers available.\n\n"
"port config all rss (all|default|ip|tcp|udp|sctp|"
- "ether|port|vxlan|geneve|nvgre|vxlan-gpe|none|level-default|"
- "level-outer|level-inner|<flowtype_id>)\n"
+ "ether|port|vxlan|geneve|nvgre|vxlan-gpe|ecpri|mpls|ipv4-chksum|l2tpv2|"
+ "none|level-default|level-outer|level-inner|<flowtype_id>)\n"
" Set the RSS mode.\n\n"
"port config port-id rss reta (hash,queue)[,(hash,queue)]\n"
"port (port_id) (rxq|txq) (queue_id) setup\n"
" Setup a rx/tx queue of port X.\n\n"
- "port config (port_id|all) l2-tunnel E-tag ether-type"
- " (value)\n"
- " Set the value of E-tag ether-type.\n\n"
-
- "port config (port_id|all) l2-tunnel E-tag"
- " (enable|disable)\n"
- " Enable/disable the E-tag support.\n\n"
-
"port config (port_id) pctype mapping reset\n"
" Reset flow type to pctype mapping on a port\n\n"
"fdir_inset|fdir_flx_inset clear all"
" Clear RSS|FDIR|FDIR_FLX input set completely for some pctype\n\n"
- "port config (port_id) udp_tunnel_port add|rm vxlan|geneve (udp_port)\n\n"
+ "port config (port_id) udp_tunnel_port add|rm vxlan|geneve|ecpri (udp_port)\n\n"
" Add/remove UDP tunnel port for tunneling offload\n\n"
"port config <port_id> rx_offload vlan_strip|"
" 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"
);
}
"filters:\n"
"--------\n\n"
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow (ipv4-other|ipv4-frag|ipv6-other|ipv6-frag)"
- " src (src_ip_address) dst (dst_ip_address)"
- " tos (tos_value) proto (proto_value) ttl (ttl_value)"
- " vlan (vlan_value) flexbytes (flexbytes_value)"
- " (drop|fwd) pf|vf(vf_id) queue (queue_id)"
- " fd_id (fd_id_value)\n"
- " Add/Del an IP type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow (ipv4-tcp|ipv4-udp|ipv6-tcp|ipv6-udp)"
- " src (src_ip_address) (src_port)"
- " dst (dst_ip_address) (dst_port)"
- " tos (tos_value) ttl (ttl_value)"
- " vlan (vlan_value) flexbytes (flexbytes_value)"
- " (drop|fwd) pf|vf(vf_id) queue (queue_id)"
- " fd_id (fd_id_value)\n"
- " Add/Del an UDP/TCP type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow (ipv4-sctp|ipv6-sctp)"
- " src (src_ip_address) (src_port)"
- " dst (dst_ip_address) (dst_port)"
- " tag (verification_tag) "
- " tos (tos_value) ttl (ttl_value)"
- " vlan (vlan_value)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " pf|vf(vf_id) queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a SCTP type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode IP (add|del|update)"
- " flow l2_payload ether (ethertype)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " pf|vf(vf_id) queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a l2 payload type flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode MAC-VLAN (add|del|update)"
- " mac (mac_address) vlan (vlan_value)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a MAC-VLAN flow director filter.\n\n"
-
- "flow_director_filter (port_id) mode Tunnel (add|del|update)"
- " mac (mac_address) vlan (vlan_value)"
- " tunnel (NVGRE|VxLAN) tunnel-id (tunnel_id_value)"
- " flexbytes (flexbytes_value) (drop|fwd)"
- " queue (queue_id) fd_id (fd_id_value)\n"
- " Add/Del a Tunnel flow director filter.\n\n"
-
+#ifdef RTE_NET_I40E
"flow_director_filter (port_id) mode raw (add|del|update)"
" flow (flow_id) (drop|fwd) queue (queue_id)"
" fd_id (fd_id_value) packet (packet file name)\n"
" Add/Del a raw type flow director filter.\n\n"
-
- "flush_flow_director (port_id)\n"
- " Flush all flow director entries of a device.\n\n"
+#endif
"flow_director_mask (port_id) mode IP vlan (vlan_value)"
" src_mask (ipv4_src) (ipv6_src) (src_port)"
" tunnel-id (tunnel_id_value)\n"
" Set flow director Tunnel mask.\n\n"
- "flow_director_flex_mask (port_id)"
- " flow (none|ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|"
- "ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|l2_payload|all)"
- " (mask)\n"
- " Configure mask of flex payload.\n\n"
-
"flow_director_flex_payload (port_id)"
" (raw|l2|l3|l4) (config)\n"
" Configure flex payload selection.\n\n"
- "set_fdir_input_set (port_id) "
- "(ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
- "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|"
- "l2_payload) (ivlan|ethertype|src-ipv4|dst-ipv4|src-ipv6|"
- "dst-ipv6|ipv4-tos|ipv4-proto|ipv4-ttl|ipv6-tc|"
- "ipv6-next-header|ipv6-hop-limits|udp-src-port|"
- "udp-dst-port|tcp-src-port|tcp-dst-port|"
- "sctp-src-port|sctp-dst-port|sctp-veri-tag|none)"
- " (select|add)\n"
- " Set the input set for FDir.\n\n"
-
"flow validate {port_id}"
" [group {group_id}] [priority {level}]"
" [ingress] [egress]"
" List and destroy aged flows"
" flow rules\n\n"
- "flow shared_action {port_id} create"
- " [action_id {shared_action_id}]"
+ "flow indirect_action {port_id} create"
+ " [action_id {indirect_action_id}]"
" [ingress] [egress]"
" action {action} / end\n"
- " Create shared action.\n\n"
+ " Create indirect action.\n\n"
- "flow shared_action {port_id} update"
- " {shared_action_id} action {action} / end\n"
- " Update shared action.\n\n"
+ "flow indirect_action {port_id} update"
+ " {indirect_action_id} action {action} / end\n"
+ " Update indirect action.\n\n"
- "flow shared_action {port_id} destroy"
- " action_id {shared_action_id} [...]\n"
- " Destroy specific shared actions.\n\n"
+ "flow indirect_action {port_id} destroy"
+ " action_id {indirect_action_id} [...]\n"
+ " Destroy specific indirect actions.\n\n"
- "flow shared_action {port_id} query"
- " {shared_action_id}\n"
- " Query an existing shared action.\n\n"
+ "flow indirect_action {port_id} query"
+ " {indirect_action_id}\n"
+ " Query an existing indirect action.\n\n"
"set vxlan ip-version (ipv4|ipv6) vni (vni) udp-src"
" (udp-src) udp-dst (udp-dst) ip-src (ip-src) ip-dst"
);
}
+ if (show_all || !strcmp(res->section, "drivers")) {
+ struct testpmd_driver_commands *c;
+ unsigned int i;
+
+ cmdline_printf(
+ cl,
+ "\n"
+ "Driver specific:\n"
+ "----------------\n"
+ );
+ TAILQ_FOREACH(c, &driver_commands_head, next) {
+ for (i = 0; c->commands[i].ctx != NULL; i++)
+ cmdline_printf(cl, "%s\n", c->commands[i].help);
+ }
+ }
}
-cmdline_parse_token_string_t cmd_help_long_help =
+static cmdline_parse_token_string_t cmd_help_long_help =
TOKEN_STRING_INITIALIZER(struct cmd_help_long_result, help, "help");
-cmdline_parse_token_string_t cmd_help_long_section =
+static cmdline_parse_token_string_t cmd_help_long_section =
TOKEN_STRING_INITIALIZER(struct cmd_help_long_result, section,
- "all#control#display#config#"
- "ports#registers#filters#traffic_management#devices");
+ "all#control#display#config#ports#registers#"
+ "filters#traffic_management#devices#drivers");
-cmdline_parse_inst_t cmd_help_long = {
+static cmdline_parse_inst_t cmd_help_long = {
.f = cmd_help_long_parsed,
.data = NULL,
.help_str = "help all|control|display|config|ports|register|"
- "filters|traffic_management|devices: "
+ "filters|traffic_management|devices|drivers: "
"Show help",
.tokens = {
(void *)&cmd_help_long_help,
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 =
+static cmdline_parse_token_string_t cmd_operate_port_all_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, keyword,
"port");
-cmdline_parse_token_string_t cmd_operate_port_all_port =
+static cmdline_parse_token_string_t cmd_operate_port_all_port =
TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, name,
"start#stop#close#reset");
-cmdline_parse_token_string_t cmd_operate_port_all_all =
+static cmdline_parse_token_string_t cmd_operate_port_all_all =
TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, value, "all");
-cmdline_parse_inst_t cmd_operate_port = {
+static 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,
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 =
+static cmdline_parse_token_string_t cmd_operate_specific_port_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_operate_specific_port_result,
keyword, "port");
-cmdline_parse_token_string_t cmd_operate_specific_port_port =
+static cmdline_parse_token_string_t cmd_operate_specific_port_port =
TOKEN_STRING_INITIALIZER(struct cmd_operate_specific_port_result,
name, "start#stop#close#reset");
-cmdline_parse_token_num_t cmd_operate_specific_port_id =
+static 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 = {
+static cmdline_parse_inst_t cmd_operate_specific_port = {
.f = cmd_operate_specific_port_parsed,
.data = NULL,
- .help_str = "port start|stop|close <port_id>: Start/Stop/Close/Reset port_id",
+ .help_str = "port start|stop|close
|reset <port_id>: Start/Stop/Close/Reset port_id",
.tokens = {
(void *)&cmd_operate_specific_port_cmd,
(void *)&cmd_operate_specific_port_port,
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 =
+static cmdline_parse_token_string_t cmd_set_port_setup_on_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_port_setup_on_result,
set, "set");
-cmdline_parse_token_string_t cmd_set_port_setup_on_port =
+static cmdline_parse_token_string_t cmd_set_port_setup_on_port =
TOKEN_STRING_INITIALIZER(struct cmd_set_port_setup_on_result,
port, "port");
-cmdline_parse_token_string_t cmd_set_port_setup_on_setup =
+static cmdline_parse_token_string_t cmd_set_port_setup_on_setup =
TOKEN_STRING_INITIALIZER(struct cmd_set_port_setup_on_result,
setup, "setup");
-cmdline_parse_token_string_t cmd_set_port_setup_on_on =
+static cmdline_parse_token_string_t cmd_set_port_setup_on_on =
TOKEN_STRING_INITIALIZER(struct cmd_set_port_setup_on_result,
on, "on");
-cmdline_parse_token_string_t cmd_set_port_setup_on_mode =
+static cmdline_parse_token_string_t cmd_set_port_setup_on_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_port_setup_on_result,
mode, "iterator#event");
-cmdline_parse_inst_t cmd_set_port_setup_on = {
+static cmdline_parse_inst_t cmd_set_port_setup_on = {
.f = cmd_set_port_setup_on_parsed,
.data = NULL,
.help_str = "set port setup on iterator|event",
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 =
+static cmdline_parse_token_string_t cmd_operate_attach_port_port =
TOKEN_STRING_INITIALIZER(struct cmd_operate_attach_port_result,
port, "port");
-cmdline_parse_token_string_t cmd_operate_attach_port_keyword =
+static cmdline_parse_token_string_t cmd_operate_attach_port_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_operate_attach_port_result,
keyword, "attach");
-cmdline_parse_token_string_t cmd_operate_attach_port_identifier =
+static cmdline_parse_token_string_t cmd_operate_attach_port_identifier =
TOKEN_STRING_INITIALIZER(struct cmd_operate_attach_port_result,
identifier, TOKEN_STRING_MULTI);
-cmdline_parse_inst_t cmd_operate_attach_port = {
+static cmdline_parse_inst_t cmd_operate_attach_port = {
.f = cmd_operate_attach_port_parsed,
.data = NULL,
.help_str = "port attach <identifier>: "
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");
}
}
-cmdline_parse_token_string_t cmd_operate_detach_port_port =
+static cmdline_parse_token_string_t cmd_operate_detach_port_port =
TOKEN_STRING_INITIALIZER(struct cmd_operate_detach_port_result,
port, "port");
-cmdline_parse_token_string_t cmd_operate_detach_port_keyword =
+static cmdline_parse_token_string_t cmd_operate_detach_port_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_operate_detach_port_result,
keyword, "detach");
-cmdline_parse_token_num_t cmd_operate_detach_port_port_id =
+static 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 = {
+static cmdline_parse_inst_t cmd_operate_detach_port = {
.f = cmd_operate_detach_port_parsed,
.data = NULL,
.help_str = "port detach <port_id>",
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 =
+static cmdline_parse_token_string_t cmd_operate_detach_device_device =
TOKEN_STRING_INITIALIZER(struct cmd_operate_detach_device_result,
device, "device");
-cmdline_parse_token_string_t cmd_operate_detach_device_keyword =
+static cmdline_parse_token_string_t cmd_operate_detach_device_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_operate_detach_device_result,
keyword, "detach");
-cmdline_parse_token_string_t cmd_operate_detach_device_identifier =
+static cmdline_parse_token_string_t cmd_operate_detach_device_identifier =
TOKEN_STRING_INITIALIZER(struct cmd_operate_detach_device_result,
identifier, NULL);
-cmdline_parse_inst_t cmd_operate_detach_device = {
+static cmdline_parse_inst_t cmd_operate_detach_device = {
.f = cmd_operate_detach_device_parsed,
.data = NULL,
.help_str = "device detach <identifier>:"
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 = ETH_LINK_SPEED_200G;
+ *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;
}
portid_t pid;
if (!all_ports_stopped()) {
- printf("Please stop all ports first\n");
+ fprintf(stderr, "Please stop all ports first\n");
return;
}
cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}
-cmdline_parse_token_string_t cmd_config_speed_all_port =
+static cmdline_parse_token_string_t cmd_config_speed_all_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, port, "port");
-cmdline_parse_token_string_t cmd_config_speed_all_keyword =
+static cmdline_parse_token_string_t cmd_config_speed_all_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, keyword,
"config");
-cmdline_parse_token_string_t cmd_config_speed_all_all =
+static cmdline_parse_token_string_t cmd_config_speed_all_all =
TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, all, "all");
-cmdline_parse_token_string_t cmd_config_speed_all_item1 =
+static 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 =
+static 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#200000#auto");
-cmdline_parse_token_string_t cmd_config_speed_all_item2 =
+static 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 =
+static cmdline_parse_token_string_t cmd_config_speed_all_value2 =
TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, value2,
"half#full#auto");
-cmdline_parse_inst_t cmd_config_speed_all = {
+static cmdline_parse_inst_t cmd_config_speed_all = {
.f = cmd_config_speed_all_parsed,
.data = NULL,
.help_str = "port config all speed "
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)
}
-cmdline_parse_token_string_t cmd_config_speed_specific_port =
+static cmdline_parse_token_string_t cmd_config_speed_specific_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, port,
"port");
-cmdline_parse_token_string_t cmd_config_speed_specific_keyword =
+static 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);
-cmdline_parse_token_string_t cmd_config_speed_specific_item1 =
+static cmdline_parse_token_num_t cmd_config_speed_specific_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_speed_specific, id, RTE_UINT16);
+static 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 =
+static 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#200000#auto");
-cmdline_parse_token_string_t cmd_config_speed_specific_item2 =
+static cmdline_parse_token_string_t cmd_config_speed_specific_item2 =
TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item2,
"duplex");
-cmdline_parse_token_string_t cmd_config_speed_specific_value2 =
+static cmdline_parse_token_string_t cmd_config_speed_specific_value2 =
TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, value2,
"half#full#auto");
-cmdline_parse_inst_t cmd_config_speed_specific = {
+static cmdline_parse_inst_t cmd_config_speed_specific = {
.f = cmd_config_speed_specific_parsed,
.data = NULL,
.help_str = "port config <port_id> speed "
portid_t pid;
if (!all_ports_stopped()) {
- printf("Please stop all ports first\n");
+ fprintf(stderr, "Please stop all ports first\n");
return;
}
cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}
-cmdline_parse_token_string_t cmd_config_loopback_all_port =
+static cmdline_parse_token_string_t cmd_config_loopback_all_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_all, port, "port");
-cmdline_parse_token_string_t cmd_config_loopback_all_keyword =
+static cmdline_parse_token_string_t cmd_config_loopback_all_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_all, keyword,
"config");
-cmdline_parse_token_string_t cmd_config_loopback_all_all =
+static cmdline_parse_token_string_t cmd_config_loopback_all_all =
TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_all, all, "all");
-cmdline_parse_token_string_t cmd_config_loopback_all_item =
+static 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);
+static cmdline_parse_token_num_t cmd_config_loopback_all_mode =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_all, mode, RTE_UINT32);
-cmdline_parse_inst_t cmd_config_loopback_all = {
+static cmdline_parse_inst_t cmd_config_loopback_all = {
.f = cmd_config_loopback_all_parsed,
.data = NULL,
.help_str = "port config all loopback <mode>",
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;
}
}
-cmdline_parse_token_string_t cmd_config_loopback_specific_port =
+static cmdline_parse_token_string_t cmd_config_loopback_specific_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_specific, port,
"port");
-cmdline_parse_token_string_t cmd_config_loopback_specific_keyword =
+static cmdline_parse_token_string_t cmd_config_loopback_specific_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_specific, keyword,
"config");
-cmdline_parse_token_num_t cmd_config_loopback_specific_id =
+static cmdline_parse_token_num_t cmd_config_loopback_specific_id =
TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_specific, port_id,
- UINT16);
-cmdline_parse_token_string_t cmd_config_loopback_specific_item =
+ RTE_UINT16);
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_config_loopback_specific = {
.f = cmd_config_loopback_specific_parsed,
.data = NULL,
.help_str = "port config <port_id> loopback <mode>",
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)
}
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)
nb_txd = res->value;
} else {
- printf("Unknown parameter\n");
+ fprintf(stderr, "Unknown parameter\n");
return;
}
cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}
-cmdline_parse_token_string_t cmd_config_rx_tx_port =
+static cmdline_parse_token_string_t cmd_config_rx_tx_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, port, "port");
-cmdline_parse_token_string_t cmd_config_rx_tx_keyword =
+static cmdline_parse_token_string_t cmd_config_rx_tx_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, keyword, "config");
-cmdline_parse_token_string_t cmd_config_rx_tx_all =
+static cmdline_parse_token_string_t cmd_config_rx_tx_all =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, all, "all");
-cmdline_parse_token_string_t cmd_config_rx_tx_name =
+static 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);
+static cmdline_parse_token_num_t cmd_config_rx_tx_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_rx_tx, value, RTE_UINT16);
-cmdline_parse_inst_t cmd_config_rx_tx = {
+static cmdline_parse_inst_t cmd_config_rx_tx = {
.f = cmd_config_rx_tx_parsed,
.data = NULL,
.help_str = "port config all rxq|txq|rxd|txd <value>",
__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();
cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}
-cmdline_parse_token_string_t cmd_config_max_pkt_len_port =
+static cmdline_parse_token_string_t cmd_config_max_pkt_len_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, port,
"port");
-cmdline_parse_token_string_t cmd_config_max_pkt_len_keyword =
+static cmdline_parse_token_string_t cmd_config_max_pkt_len_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, keyword,
"config");
-cmdline_parse_token_string_t cmd_config_max_pkt_len_all =
+static cmdline_parse_token_string_t cmd_config_max_pkt_len_all =
TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, all,
"all");
-cmdline_parse_token_string_t cmd_config_max_pkt_len_name =
+static cmdline_parse_token_string_t cmd_config_max_pkt_len_name =
TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, name,
"max-pkt-len");
-cmdline_parse_token_num_t cmd_config_max_pkt_len_value =
+static 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 = {
+static cmdline_parse_inst_t cmd_config_max_pkt_len = {
.f = cmd_config_max_pkt_len_parsed,
.data = NULL,
.help_str = "port config all max-pkt-len <value>",
portid_t pid;
if (!all_ports_stopped()) {
- printf("Please stop all ports first\n");
+ fprintf(stderr, "Please stop all ports first\n");
return;
}
port->dev_conf.rxmode.max_lro_pkt_size = res->value;
} else {
- printf("Unknown parameter\n");
+ fprintf(stderr, "Unknown parameter\n");
return;
}
}
cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}
-cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_port =
+static cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
port, "port");
-cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_keyword =
+static cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
keyword, "config");
-cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_all =
+static cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_all =
TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
all, "all");
-cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_name =
+static cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_name =
TOKEN_STRING_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
name, "max-lro-pkt-size");
-cmdline_parse_token_num_t cmd_config_max_lro_pkt_size_value =
+static 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 = {
+static cmdline_parse_inst_t cmd_config_max_lro_pkt_size = {
.f = cmd_config_max_lro_pkt_size_parsed,
.data = NULL,
.help_str = "port config all max-lro-pkt-size <value>",
{
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);
- return;
- }
port_mtu_set(res->port_id, res->value);
}
-cmdline_parse_token_string_t cmd_config_mtu_port =
+static cmdline_parse_token_string_t cmd_config_mtu_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_mtu_result, port,
"port");
-cmdline_parse_token_string_t cmd_config_mtu_keyword =
+static cmdline_parse_token_string_t cmd_config_mtu_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_mtu_result, keyword,
"config");
-cmdline_parse_token_string_t cmd_config_mtu_mtu =
+static 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);
-cmdline_parse_token_num_t cmd_config_mtu_value =
- TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, value, UINT16);
-
-cmdline_parse_inst_t cmd_config_mtu = {
+static cmdline_parse_token_num_t cmd_config_mtu_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, port_id,
+ RTE_UINT16);
+static cmdline_parse_token_num_t cmd_config_mtu_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, value,
+ RTE_UINT16);
+
+static cmdline_parse_inst_t cmd_config_mtu = {
.f = cmd_config_mtu_parsed,
.data = NULL,
.help_str = "port config mtu <port_id> <value>",
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;
}
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;
}
cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}
-cmdline_parse_token_string_t cmd_config_rx_mode_flag_port =
+static cmdline_parse_token_string_t cmd_config_rx_mode_flag_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, port, "port");
-cmdline_parse_token_string_t cmd_config_rx_mode_flag_keyword =
+static cmdline_parse_token_string_t cmd_config_rx_mode_flag_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, keyword,
"config");
-cmdline_parse_token_string_t cmd_config_rx_mode_flag_all =
+static cmdline_parse_token_string_t cmd_config_rx_mode_flag_all =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, all, "all");
-cmdline_parse_token_string_t cmd_config_rx_mode_flag_name =
+static cmdline_parse_token_string_t cmd_config_rx_mode_flag_name =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, name,
"drop-en");
-cmdline_parse_token_string_t cmd_config_rx_mode_flag_value =
+static cmdline_parse_token_string_t cmd_config_rx_mode_flag_value =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, value,
"on#off");
-cmdline_parse_inst_t cmd_config_rx_mode_flag = {
+static cmdline_parse_inst_t cmd_config_rx_mode_flag = {
.f = cmd_config_rx_mode_flag_parsed,
.data = NULL,
.help_str = "port config all drop-en on|off",
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 | ETH_RSS_GTPU;
+ 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 | RTE_ETH_RSS_L2TPV2;
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"))
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 = ETH_RSS_PPPOE;
+ rss_conf.rss_hf = RTE_ETH_RSS_PPPOE;
else if (!strcmp(res->value, "gtpu"))
- rss_conf.rss_hf = ETH_RSS_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, "l2tpv2"))
+ rss_conf.rss_hf = RTE_ETH_RSS_L2TPV2;
else if (!strcmp(res->value, "none"))
rss_conf.rss_hf = 0;
else if (!strcmp(res->value, "level-default")) {
- rss_hf &= (~ETH_RSS_LEVEL_MASK);
- rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_PMD_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 &= (~ETH_RSS_LEVEL_MASK);
- rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_OUTERMOST);
+ 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 &= (~ETH_RSS_LEVEL_MASK);
- rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_INNERMOST);
+ 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;
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));
}
}
}
}
-cmdline_parse_token_string_t cmd_config_rss_port =
+static cmdline_parse_token_string_t cmd_config_rss_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss, port, "port");
-cmdline_parse_token_string_t cmd_config_rss_keyword =
+static cmdline_parse_token_string_t cmd_config_rss_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss, keyword, "config");
-cmdline_parse_token_string_t cmd_config_rss_all =
+static cmdline_parse_token_string_t cmd_config_rss_all =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss, all, "all");
-cmdline_parse_token_string_t cmd_config_rss_name =
+static cmdline_parse_token_string_t cmd_config_rss_name =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss, name, "rss");
-cmdline_parse_token_string_t cmd_config_rss_value =
+static cmdline_parse_token_string_t cmd_config_rss_value =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss, value, NULL);
-cmdline_parse_inst_t cmd_config_rss = {
+static cmdline_parse_inst_t cmd_config_rss = {
.f = cmd_config_rss_parsed,
.data = NULL,
.help_str = "port config all rss "
"all|default|eth|vlan|ip|tcp|udp|sctp|ether|port|vxlan|geneve|"
- "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|none|level-default|"
- "level-outer|level-inner|<flowtype_id>",
+ "nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|ecpri|mpls|ipv4-chksum|l2tpv2|"
+ "none|level-default|level-outer|level-inner|<flowtype_id>",
.tokens = {
(void *)&cmd_config_rss_port,
(void *)&cmd_config_rss_keyword,
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;
}
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 */
hash_key_size);
}
-cmdline_parse_token_string_t cmd_config_rss_hash_key_port =
+static cmdline_parse_token_string_t cmd_config_rss_hash_key_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, port, "port");
-cmdline_parse_token_string_t cmd_config_rss_hash_key_config =
+static 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);
-cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_hash_key =
+static cmdline_parse_token_num_t cmd_config_rss_hash_key_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_rss_hash_key, port_id,
+ RTE_UINT16);
+static 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");
-cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_type =
+static cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_type =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, rss_type,
"ipv4#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
"ipv4-other#ipv6#ipv6-frag#ipv6-tcp#ipv6-udp#"
"ipv6-tcp-ex#ipv6-udp-ex#"
"l3-src-only#l3-dst-only#l4-src-only#l4-dst-only#"
"l2-src-only#l2-dst-only#s-vlan#c-vlan#"
- "l2tpv3#esp#ah#pfcp#pppoe#gtpu");
-cmdline_parse_token_string_t cmd_config_rss_hash_key_value =
+ "l2tpv3#esp#ah#pfcp#pppoe#gtpu#ecpri#mpls#l2tpv2");
+static cmdline_parse_token_string_t cmd_config_rss_hash_key_value =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, key, NULL);
-cmdline_parse_inst_t cmd_config_rss_hash_key = {
+static cmdline_parse_inst_t cmd_config_rss_hash_key = {
.f = cmd_config_rss_hash_key_parsed,
.data = NULL,
.help_str = "port config <port_id> 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|pppoe|gtpu "
+ "l2tpv3|esp|ah|pfcp|pppoe|gtpu|ecpri|mpls|l2tpv2 "
"<string of hex digits (variable length, NIC dependent)>",
.tokens = {
(void *)&cmd_config_rss_hash_key_port,
},
};
+/* *** 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);
+}
+
+static cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, port,
+ "port");
+static cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_cleanup =
+ TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, keyword,
+ "cleanup");
+static cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, port_id,
+ RTE_UINT16);
+static cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_txq =
+ TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, name,
+ "txq");
+static cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_queue_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, queue_id,
+ RTE_UINT16);
+static cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_free_cnt =
+ TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, free_cnt,
+ RTE_UINT32);
+
+static cmdline_parse_inst_t cmd_cleanup_txq_mbufs = {
+ .f = cmd_cleanup_txq_mbufs_parsed,
+ .data = NULL,
+ .help_str = "port cleanup <port_id> txq <queue_id> <free_cnt>",
+ .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;
return;
if (res->portid == (portid_t)RTE_PORT_ALL) {
- printf("Invalid port id\n");
+ fprintf(stderr, "Invalid port id\n");
return;
}
else if (!strcmp(res->rxtxq, "txq"))
isrx = 0;
else {
- printf("Unknown parameter\n");
+ fprintf(stderr, "Unknown parameter\n");
return;
}
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;
}
cmd_reconfig_device_queue(res->portid, 0, 1);
}
-cmdline_parse_token_string_t cmd_config_rxtx_ring_size_port =
+static cmdline_parse_token_string_t cmd_config_rxtx_ring_size_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_ring_size,
port, "port");
-cmdline_parse_token_string_t cmd_config_rxtx_ring_size_config =
+static cmdline_parse_token_string_t cmd_config_rxtx_ring_size_config =
TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_ring_size,
config, "config");
-cmdline_parse_token_num_t cmd_config_rxtx_ring_size_portid =
+static cmdline_parse_token_num_t cmd_config_rxtx_ring_size_portid =
TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_ring_size,
- portid, UINT16);
-cmdline_parse_token_string_t cmd_config_rxtx_ring_size_rxtxq =
+ portid, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_config_rxtx_ring_size_qid =
TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_ring_size,
- qid, UINT16);
-cmdline_parse_token_string_t cmd_config_rxtx_ring_size_rsize =
+ qid, RTE_UINT16);
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_config_rxtx_ring_size = {
.f = cmd_config_rxtx_ring_size_parsed,
.data = NULL,
.help_str = "port config <port_id> rxq|txq <queue_id> ring_size <value>",
__rte_unused void *data)
{
struct cmd_config_rxtx_queue *res = parsed_result;
+ struct rte_port *port;
uint8_t isrx;
uint8_t isstart;
+ uint8_t *state;
int ret = 0;
if (test_done == 0) {
- printf("Please stop forwarding first\n");
+ fprintf(stderr, "Please stop forwarding first\n");
return;
}
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;
}
else if (!strcmp(res->rxtxq, "txq"))
isrx = 0;
else {
- printf("Unknown parameter\n");
+ fprintf(stderr, "Unknown parameter\n");
return;
}
else if (!strcmp(res->opname, "stop"))
isstart = 0;
else {
- printf("Unknown parameter\n");
+ fprintf(stderr, "Unknown parameter\n");
return;
}
else
ret = rte_eth_dev_tx_queue_stop(res->portid, res->qid);
- if (ret == -ENOTSUP)
- printf("Function not supported in PMD driver\n");
+ if (ret == -ENOTSUP) {
+ fprintf(stderr, "Function not supported in PMD\n");
+ return;
+ }
+
+ port = &ports[res->portid];
+ state = isrx ? &port->rxq[res->qid].state : &port->txq[res->qid].state;
+ *state = isstart ? RTE_ETH_QUEUE_STATE_STARTED :
+ RTE_ETH_QUEUE_STATE_STOPPED;
}
-cmdline_parse_token_string_t cmd_config_rxtx_queue_port =
+static 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);
-cmdline_parse_token_string_t cmd_config_rxtx_queue_rxtxq =
+static cmdline_parse_token_num_t cmd_config_rxtx_queue_portid =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, portid, RTE_UINT16);
+static 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);
-cmdline_parse_token_string_t cmd_config_rxtx_queue_opname =
+static cmdline_parse_token_num_t cmd_config_rxtx_queue_qid =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, qid, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_config_rxtx_queue_opname =
TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_queue, opname,
"start#stop");
-cmdline_parse_inst_t cmd_config_rxtx_queue = {
+static cmdline_parse_inst_t cmd_config_rxtx_queue = {
.f = cmd_config_rxtx_queue_parsed,
.data = NULL,
.help_str = "port <port_id> rxq|txq <queue_id> start|stop",
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;
}
ison = !strcmp(res->state, "on");
- if (isrx && port->rx_conf[res->qid].rx_deferred_start != ison) {
- port->rx_conf[res->qid].rx_deferred_start = ison;
+ if (isrx && port->rxq[res->qid].conf.rx_deferred_start != ison) {
+ port->rxq[res->qid].conf.rx_deferred_start = ison;
needreconfig = 1;
- } else if (!isrx && port->tx_conf[res->qid].tx_deferred_start != ison) {
- port->tx_conf[res->qid].tx_deferred_start = ison;
+ } else if (!isrx && port->txq[res->qid].conf.tx_deferred_start != ison) {
+ port->txq[res->qid].conf.tx_deferred_start = ison;
needreconfig = 1;
}
cmd_reconfig_device_queue(res->port_id, 0, 1);
}
-cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_port =
+static cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
port, "port");
-cmdline_parse_token_num_t cmd_config_deferred_start_rxtx_queue_port_id =
+static 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);
-cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_rxtxq =
+ port_id, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_config_deferred_start_rxtx_queue_qid =
TOKEN_NUM_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
- qid, UINT16);
-cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_opname =
+ qid, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_opname =
TOKEN_STRING_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
opname, "deferred_start");
-cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_state =
+static cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_state =
TOKEN_STRING_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
state, "on#off");
-cmdline_parse_inst_t cmd_config_deferred_start_rxtx_queue = {
+static cmdline_parse_inst_t cmd_config_deferred_start_rxtx_queue = {
.f = cmd_config_deferred_start_rxtx_queue_parsed,
.data = NULL,
.help_str = "port <port_id> rxq|txq <queue_id> deferred_start on|off",
};
/* Common CLI fields for queue setup */
-cmdline_parse_token_string_t cmd_setup_rxtx_queue_port =
+static 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);
-cmdline_parse_token_string_t cmd_setup_rxtx_queue_rxtxq =
+static cmdline_parse_token_num_t cmd_setup_rxtx_queue_portid =
+ TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, portid, RTE_UINT16);
+static 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);
-cmdline_parse_token_string_t cmd_setup_rxtx_queue_setup =
+static cmdline_parse_token_num_t cmd_setup_rxtx_queue_qid =
+ TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, qid, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_setup_rxtx_queue_setup =
TOKEN_STRING_INITIALIZER(struct cmd_setup_rxtx_queue, setup, "setup");
static void
return;
if (res->portid == (portid_t)RTE_PORT_ALL) {
- printf("Invalid port id\n");
+ fprintf(stderr, "Invalid port id\n");
return;
}
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;
}
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;
}
res->qid,
port->nb_rx_desc[res->qid],
socket_id,
- &port->rx_conf[res->qid],
+ &port->rxq[res->qid].conf,
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]);
+ &port->txq[res->qid].conf);
if (ret)
- printf("Failed to setup TX queue\n");
+ fprintf(stderr, "Failed to setup TX queue\n");
}
}
-cmdline_parse_inst_t cmd_setup_rxtx_queue = {
+static cmdline_parse_inst_t cmd_setup_rxtx_queue = {
.f = cmd_setup_rxtx_queue_parsed,
.data = NULL,
.help_str = "port <port_id> rxq|txq <queue_idx> setup",
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;
}
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;
}
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);
}
}
-cmdline_parse_token_string_t cmd_config_rss_reta_port =
+static cmdline_parse_token_string_t cmd_config_rss_reta_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, port, "port");
-cmdline_parse_token_string_t cmd_config_rss_reta_keyword =
+static 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);
-cmdline_parse_token_string_t cmd_config_rss_reta_name =
+static cmdline_parse_token_num_t cmd_config_rss_reta_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_rss_reta, port_id, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_string_t cmd_config_rss_reta_list_name =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, list_name, "reta");
-cmdline_parse_token_string_t cmd_config_rss_reta_list_of_items =
+static cmdline_parse_token_string_t cmd_config_rss_reta_list_of_items =
TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, list_of_items,
NULL);
-cmdline_parse_inst_t cmd_config_rss_reta = {
+static cmdline_parse_inst_t cmd_config_rss_reta = {
.f = cmd_set_rss_reta_parsed,
.data = NULL,
.help_str = "port config <port_id> rss reta <hash,queue[,hash,queue]*>",
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, '(');
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++)
- conf[i].mask = (uint64_t)strtoul(str_fld[i], &end, 0);
+ conf[i].mask = (uint64_t)strtoull(str_fld[i], &end, 0);
return 0;
}
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;
}
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);
}
-cmdline_parse_token_string_t cmd_showport_reta_show =
+static cmdline_parse_token_string_t cmd_showport_reta_show =
TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, show, "show");
-cmdline_parse_token_string_t cmd_showport_reta_port =
+static 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);
-cmdline_parse_token_string_t cmd_showport_reta_rss =
+static cmdline_parse_token_num_t cmd_showport_reta_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, port_id, RTE_UINT16);
+static 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 =
+static 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);
-cmdline_parse_token_string_t cmd_showport_reta_list_of_items =
+static cmdline_parse_token_num_t cmd_showport_reta_size =
+ TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, size, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_showport_reta_list_of_items =
TOKEN_STRING_INITIALIZER(struct cmd_showport_reta,
list_of_items, NULL);
-cmdline_parse_inst_t cmd_showport_reta = {
+static cmdline_parse_inst_t cmd_showport_reta = {
.f = cmd_showport_reta_parsed,
.data = NULL,
.help_str = "show port <port_id> rss reta <size> <mask0[,mask1]*>",
port_rss_hash_conf_show(res->port_id, show_rss_key != NULL);
}
-cmdline_parse_token_string_t cmd_showport_rss_hash_show =
+static cmdline_parse_token_string_t cmd_showport_rss_hash_show =
TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, show, "show");
-cmdline_parse_token_string_t cmd_showport_rss_hash_port =
+static 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);
-cmdline_parse_token_string_t cmd_showport_rss_hash_rss_hash =
+static cmdline_parse_token_num_t cmd_showport_rss_hash_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_showport_rss_hash, port_id,
+ RTE_UINT16);
+static cmdline_parse_token_string_t cmd_showport_rss_hash_rss_hash =
TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, rss_hash,
"rss-hash");
-cmdline_parse_token_string_t cmd_showport_rss_hash_rss_key =
+static cmdline_parse_token_string_t cmd_showport_rss_hash_rss_key =
TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, key, "key");
-cmdline_parse_inst_t cmd_showport_rss_hash = {
+static cmdline_parse_inst_t cmd_showport_rss_hash = {
.f = cmd_showport_rss_hash_parsed,
.data = NULL,
.help_str = "show port <port_id> rss-hash",
},
};
-cmdline_parse_inst_t cmd_showport_rss_hash_key = {
+static cmdline_parse_inst_t cmd_showport_rss_hash_key = {
.f = cmd_showport_rss_hash_parsed,
.data = (void *)1,
.help_str = "show port <port_id> rss-hash key",
__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;
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
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);
}
-cmdline_parse_token_string_t cmd_config_dcb_port =
+static cmdline_parse_token_string_t cmd_config_dcb_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, port, "port");
-cmdline_parse_token_string_t cmd_config_dcb_config =
+static 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);
-cmdline_parse_token_string_t cmd_config_dcb_dcb =
+static cmdline_parse_token_num_t cmd_config_dcb_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, port_id, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_string_t cmd_config_dcb_vt =
TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, vt, "vt");
-cmdline_parse_token_string_t cmd_config_dcb_vt_en =
+static 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);
-cmdline_parse_token_string_t cmd_config_dcb_pfc=
+static cmdline_parse_token_num_t cmd_config_dcb_num_tcs =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, num_tcs, RTE_UINT8);
+static 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 =
+static cmdline_parse_token_string_t cmd_config_dcb_pfc_en =
TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, pfc_en, "on#off");
-cmdline_parse_inst_t cmd_config_dcb = {
+static cmdline_parse_inst_t cmd_config_dcb = {
.f = cmd_config_dcb_parsed,
.data = NULL,
.help_str = "port config <port-id> dcb vt on|off <num_tcs> pfc on|off",
int ret;
if (!all_ports_stopped()) {
- printf("Please stop all ports first\n");
+ fprintf(stderr, "Please stop all ports first\n");
return;
}
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;
}
cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}
-cmdline_parse_token_string_t cmd_config_burst_port =
+static cmdline_parse_token_string_t cmd_config_burst_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_burst, port, "port");
-cmdline_parse_token_string_t cmd_config_burst_keyword =
+static cmdline_parse_token_string_t cmd_config_burst_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_burst, keyword, "config");
-cmdline_parse_token_string_t cmd_config_burst_all =
+static cmdline_parse_token_string_t cmd_config_burst_all =
TOKEN_STRING_INITIALIZER(struct cmd_config_burst, all, "all");
-cmdline_parse_token_string_t cmd_config_burst_name =
+static 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);
+static cmdline_parse_token_num_t cmd_config_burst_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_burst, value, RTE_UINT16);
-cmdline_parse_inst_t cmd_config_burst = {
+static cmdline_parse_inst_t cmd_config_burst = {
.f = cmd_config_burst_parsed,
.data = NULL,
.help_str = "port config all burst <value>",
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;
}
else if(!strcmp(res->name, "rxwt"))
rx_wthresh = res->value;
else {
- printf("Unknown parameter\n");
+ fprintf(stderr, "Unknown parameter\n");
return;
}
cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}
-cmdline_parse_token_string_t cmd_config_thresh_port =
+static cmdline_parse_token_string_t cmd_config_thresh_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, port, "port");
-cmdline_parse_token_string_t cmd_config_thresh_keyword =
+static cmdline_parse_token_string_t cmd_config_thresh_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, keyword, "config");
-cmdline_parse_token_string_t cmd_config_thresh_all =
+static cmdline_parse_token_string_t cmd_config_thresh_all =
TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, all, "all");
-cmdline_parse_token_string_t cmd_config_thresh_name =
+static 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);
+static cmdline_parse_token_num_t cmd_config_thresh_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_thresh, value, RTE_UINT8);
-cmdline_parse_inst_t cmd_config_thresh = {
+static cmdline_parse_inst_t cmd_config_thresh = {
.f = cmd_config_thresh_parsed,
.data = NULL,
.help_str = "port config all txpt|txht|txwt|rxpt|rxht|rxwt <value>",
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;
}
else if (!strcmp(res->name, "rxfreet"))
rx_free_thresh = res->value;
else {
- printf("Unknown parameter\n");
+ fprintf(stderr, "Unknown parameter\n");
return;
}
cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1);
}
-cmdline_parse_token_string_t cmd_config_threshold_port =
+static cmdline_parse_token_string_t cmd_config_threshold_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, port, "port");
-cmdline_parse_token_string_t cmd_config_threshold_keyword =
+static cmdline_parse_token_string_t cmd_config_threshold_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, keyword,
"config");
-cmdline_parse_token_string_t cmd_config_threshold_all =
+static cmdline_parse_token_string_t cmd_config_threshold_all =
TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, all, "all");
-cmdline_parse_token_string_t cmd_config_threshold_name =
+static 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);
+static cmdline_parse_token_num_t cmd_config_threshold_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_config_threshold, value, RTE_UINT16);
-cmdline_parse_inst_t cmd_config_threshold = {
+static cmdline_parse_inst_t cmd_config_threshold = {
.f = cmd_config_threshold_parsed,
.data = NULL,
.help_str = "port config all txfreet|txrst|rxfreet <value>",
stop_packet_forwarding();
}
-cmdline_parse_token_string_t cmd_stop_stop =
+static cmdline_parse_token_string_t cmd_stop_stop =
TOKEN_STRING_INITIALIZER(struct cmd_stop_result, stop, "stop");
-cmdline_parse_inst_t cmd_stop = {
+static cmdline_parse_inst_t cmd_stop = {
.f = cmd_stop_parsed,
.data = NULL,
.help_str = "stop: Stop packet forwarding",
/* *** 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;
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) {
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;
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;
}
}
unsigned int nb_item;
if (test_done == 0) {
- printf("Please stop forwarding first\n");
+ fprintf(stderr, "Please stop forwarding first\n");
return;
}
}
}
-cmdline_parse_token_string_t cmd_set_list_keyword =
+static cmdline_parse_token_string_t cmd_set_list_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_set_list_result, cmd_keyword,
"set");
-cmdline_parse_token_string_t cmd_set_list_name =
+static cmdline_parse_token_string_t cmd_set_list_name =
TOKEN_STRING_INITIALIZER(struct cmd_set_list_result, list_name,
"corelist#portlist");
-cmdline_parse_token_string_t cmd_set_list_of_items =
+static cmdline_parse_token_string_t cmd_set_list_of_items =
TOKEN_STRING_INITIALIZER(struct cmd_set_list_result, list_of_items,
NULL);
-cmdline_parse_inst_t cmd_set_fwd_list = {
+static cmdline_parse_inst_t cmd_set_fwd_list = {
.f = cmd_set_list_parsed,
.data = NULL,
.help_str = "set corelist|portlist <list0[,list1]*>",
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")) {
}
}
-cmdline_parse_token_string_t cmd_setmask_set =
+static cmdline_parse_token_string_t cmd_setmask_set =
TOKEN_STRING_INITIALIZER(struct cmd_setmask_result, set, "set");
-cmdline_parse_token_string_t cmd_setmask_mask =
+static 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);
+static cmdline_parse_token_num_t cmd_setmask_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_setmask_result, hexavalue, RTE_UINT64);
-cmdline_parse_inst_t cmd_set_fwd_mask = {
+static cmdline_parse_inst_t cmd_set_fwd_mask = {
.f = cmd_set_mask_parsed,
.data = NULL,
.help_str = "set coremask|portmask <hexadecimal value>",
set_verbose_level(res->value);
}
-cmdline_parse_token_string_t cmd_set_set =
+static cmdline_parse_token_string_t cmd_set_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_result, set, "set");
-cmdline_parse_token_string_t cmd_set_what =
+static 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);
+static cmdline_parse_token_num_t cmd_set_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_result, value, RTE_UINT16);
-cmdline_parse_inst_t cmd_set_numbers = {
+static cmdline_parse_inst_t cmd_set_numbers = {
.f = cmd_set_parsed,
.data = NULL,
.help_str = "set nbport|nbcore|burst|verbose <value>",
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");
}
}
-cmdline_parse_token_string_t cmd_set_log_set =
+static cmdline_parse_token_string_t cmd_set_log_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_log_result, set, "set");
-cmdline_parse_token_string_t cmd_set_log_log =
+static cmdline_parse_token_string_t cmd_set_log_log =
TOKEN_STRING_INITIALIZER(struct cmd_set_log_result, log, "log");
-cmdline_parse_token_string_t cmd_set_log_type =
+static 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);
+static cmdline_parse_token_num_t cmd_set_log_level =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_log_result, level, RTE_UINT32);
-cmdline_parse_inst_t cmd_set_log = {
+static cmdline_parse_inst_t cmd_set_log = {
.f = cmd_set_log_parsed,
.data = NULL,
.help_str = "set log global|<type> <level>",
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 =
+static 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 =
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_set_rxoffs = {
.f = cmd_set_rxoffs_parsed,
.data = NULL,
.help_str = "set rxoffs <len0[,len1]*>",
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 =
+static 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 =
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_set_rxpkts = {
.f = cmd_set_rxpkts_parsed,
.data = NULL,
.help_str = "set rxpkts <len0[,len1]*>",
set_tx_pkt_segments(seg_lengths, nb_segs);
}
-cmdline_parse_token_string_t cmd_set_txpkts_keyword =
+static cmdline_parse_token_string_t cmd_set_txpkts_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_set_txpkts_result,
cmd_keyword, "set");
-cmdline_parse_token_string_t cmd_set_txpkts_name =
+static cmdline_parse_token_string_t cmd_set_txpkts_name =
TOKEN_STRING_INITIALIZER(struct cmd_set_txpkts_result,
txpkts, "txpkts");
-cmdline_parse_token_string_t cmd_set_txpkts_lengths =
+static cmdline_parse_token_string_t cmd_set_txpkts_lengths =
TOKEN_STRING_INITIALIZER(struct cmd_set_txpkts_result,
seg_lengths, NULL);
-cmdline_parse_inst_t cmd_set_txpkts = {
+static cmdline_parse_inst_t cmd_set_txpkts = {
.f = cmd_set_txpkts_parsed,
.data = NULL,
.help_str = "set txpkts <len0[,len1]*>",
set_tx_pkt_split(res->mode);
}
-cmdline_parse_token_string_t cmd_set_txsplit_keyword =
+static cmdline_parse_token_string_t cmd_set_txsplit_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_set_txsplit_result,
cmd_keyword, "set");
-cmdline_parse_token_string_t cmd_set_txsplit_name =
+static cmdline_parse_token_string_t cmd_set_txsplit_name =
TOKEN_STRING_INITIALIZER(struct cmd_set_txsplit_result,
txsplit, "txsplit");
-cmdline_parse_token_string_t cmd_set_txsplit_mode =
+static cmdline_parse_token_string_t cmd_set_txsplit_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_txsplit_result,
mode, NULL);
-cmdline_parse_inst_t cmd_set_txsplit = {
+static cmdline_parse_inst_t cmd_set_txsplit = {
.f = cmd_set_txsplit_parsed,
.data = NULL,
.help_str = "set txsplit on|off|rand",
set_tx_pkt_times(tx_times);
}
-cmdline_parse_token_string_t cmd_set_txtimes_keyword =
+static 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 =
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_set_txtimes = {
.f = cmd_set_txtimes_parsed,
.data = NULL,
.help_str = "set txtimes <inter_burst>,<intra_burst>",
rx_vlan_all_filter_set(res->port_id, 0);
}
-cmdline_parse_token_string_t cmd_rx_vlan_filter_all_rx_vlan =
+static cmdline_parse_token_string_t cmd_rx_vlan_filter_all_rx_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_rx_vlan_filter_all_result,
rx_vlan, "rx_vlan");
-cmdline_parse_token_string_t cmd_rx_vlan_filter_all_what =
+static cmdline_parse_token_string_t cmd_rx_vlan_filter_all_what =
TOKEN_STRING_INITIALIZER(struct cmd_rx_vlan_filter_all_result,
what, "add#rm");
-cmdline_parse_token_string_t cmd_rx_vlan_filter_all_all =
+static cmdline_parse_token_string_t cmd_rx_vlan_filter_all_all =
TOKEN_STRING_INITIALIZER(struct cmd_rx_vlan_filter_all_result,
all, "all");
-cmdline_parse_token_num_t cmd_rx_vlan_filter_all_portid =
+static 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 = {
+static cmdline_parse_inst_t cmd_rx_vlan_filter_all = {
.f = cmd_rx_vlan_filter_all_parsed,
.data = NULL,
.help_str = "rx_vlan add|rm all <port_id>: "
/* 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);
return;
}
-cmdline_parse_token_string_t cmd_vlan_offload_vlan =
+static cmdline_parse_token_string_t cmd_vlan_offload_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result,
vlan, "vlan");
-cmdline_parse_token_string_t cmd_vlan_offload_set =
+static cmdline_parse_token_string_t cmd_vlan_offload_set =
TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result,
set, "set");
-cmdline_parse_token_string_t cmd_vlan_offload_what =
+static cmdline_parse_token_string_t cmd_vlan_offload_what =
TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result,
what, "strip#filter#qinq_strip#extend#stripq");
-cmdline_parse_token_string_t cmd_vlan_offload_on =
+static cmdline_parse_token_string_t cmd_vlan_offload_on =
TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result,
on, "on#off");
-cmdline_parse_token_string_t cmd_vlan_offload_portid =
+static cmdline_parse_token_string_t cmd_vlan_offload_portid =
TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result,
port_id, NULL);
-cmdline_parse_inst_t cmd_vlan_offload = {
+static cmdline_parse_inst_t cmd_vlan_offload = {
.f = cmd_vlan_offload_parsed,
.data = NULL,
.help_str = "vlan set strip|filter|qinq_strip|extend|stripq on|off "
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);
}
-cmdline_parse_token_string_t cmd_vlan_tpid_vlan =
+static cmdline_parse_token_string_t cmd_vlan_tpid_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_vlan_tpid_result,
vlan, "vlan");
-cmdline_parse_token_string_t cmd_vlan_tpid_set =
+static cmdline_parse_token_string_t cmd_vlan_tpid_set =
TOKEN_STRING_INITIALIZER(struct cmd_vlan_tpid_result,
set, "set");
-cmdline_parse_token_string_t cmd_vlan_type =
+static cmdline_parse_token_string_t cmd_vlan_type =
TOKEN_STRING_INITIALIZER(struct cmd_vlan_tpid_result,
vlan_type, "inner#outer");
-cmdline_parse_token_string_t cmd_vlan_tpid_what =
+static cmdline_parse_token_string_t cmd_vlan_tpid_what =
TOKEN_STRING_INITIALIZER(struct cmd_vlan_tpid_result,
what, "tpid");
-cmdline_parse_token_num_t cmd_vlan_tpid_tpid =
+static cmdline_parse_token_num_t cmd_vlan_tpid_tpid =
TOKEN_NUM_INITIALIZER(struct cmd_vlan_tpid_result,
- tp_id, UINT16);
-cmdline_parse_token_num_t cmd_vlan_tpid_portid =
+ tp_id, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_vlan_tpid = {
.f = cmd_vlan_tpid_parsed,
.data = NULL,
.help_str = "vlan set inner|outer tpid <tp_id> <port_id>: "
rx_vft_set(res->port_id, res->vlan_id, 0);
}
-cmdline_parse_token_string_t cmd_rx_vlan_filter_rx_vlan =
+static cmdline_parse_token_string_t cmd_rx_vlan_filter_rx_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_rx_vlan_filter_result,
rx_vlan, "rx_vlan");
-cmdline_parse_token_string_t cmd_rx_vlan_filter_what =
+static cmdline_parse_token_string_t cmd_rx_vlan_filter_what =
TOKEN_STRING_INITIALIZER(struct cmd_rx_vlan_filter_result,
what, "add#rm");
-cmdline_parse_token_num_t cmd_rx_vlan_filter_vlanid =
+static cmdline_parse_token_num_t cmd_rx_vlan_filter_vlanid =
TOKEN_NUM_INITIALIZER(struct cmd_rx_vlan_filter_result,
- vlan_id, UINT16);
-cmdline_parse_token_num_t cmd_rx_vlan_filter_portid =
+ vlan_id, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_rx_vlan_filter = {
.f = cmd_rx_vlan_filter_parsed,
.data = NULL,
.help_str = "rx_vlan add|rm <vlan_id> <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;
}
cmd_reconfig_device_queue(res->port_id, 1, 1);
}
-cmdline_parse_token_string_t cmd_tx_vlan_set_tx_vlan =
+static cmdline_parse_token_string_t cmd_tx_vlan_set_tx_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_result,
tx_vlan, "tx_vlan");
-cmdline_parse_token_string_t cmd_tx_vlan_set_set =
+static cmdline_parse_token_string_t cmd_tx_vlan_set_set =
TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_result,
set, "set");
-cmdline_parse_token_num_t cmd_tx_vlan_set_portid =
+static cmdline_parse_token_num_t cmd_tx_vlan_set_portid =
TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_tx_vlan_set_vlanid =
+ port_id, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_tx_vlan_set = {
.f = cmd_tx_vlan_set_parsed,
.data = NULL,
.help_str = "tx_vlan set <port_id> <vlan_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;
}
cmd_reconfig_device_queue(res->port_id, 1, 1);
}
-cmdline_parse_token_string_t cmd_tx_vlan_set_qinq_tx_vlan =
+static cmdline_parse_token_string_t cmd_tx_vlan_set_qinq_tx_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_qinq_result,
tx_vlan, "tx_vlan");
-cmdline_parse_token_string_t cmd_tx_vlan_set_qinq_set =
+static cmdline_parse_token_string_t cmd_tx_vlan_set_qinq_set =
TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_qinq_result,
set, "set");
-cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_portid =
+static cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_portid =
TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_qinq_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_vlanid =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_vlanid =
TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_qinq_result,
- vlan_id, UINT16);
-cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_vlanid_outer =
+ vlan_id, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_tx_vlan_set_qinq = {
.f = cmd_tx_vlan_set_qinq_parsed,
.data = NULL,
.help_str = "tx_vlan set <port_id> <vlan_id> <outer_vlan_id>: "
tx_vlan_pvid_set(res->port_id, res->vlan_id, 0);
}
-cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_tx_vlan =
+static cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_tx_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_pvid_result,
tx_vlan, "tx_vlan");
-cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_set =
+static cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_set =
TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_pvid_result,
set, "set");
-cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_pvid =
+static cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_pvid =
TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_pvid_result,
pvid, "pvid");
-cmdline_parse_token_num_t cmd_tx_vlan_set_pvid_port_id =
+static 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);
-cmdline_parse_token_num_t cmd_tx_vlan_set_pvid_vlan_id =
+ port_id, RTE_UINT16);
+static 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);
-cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_mode =
+ vlan_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_mode =
TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_pvid_result,
mode, "on#off");
-cmdline_parse_inst_t cmd_tx_vlan_set_pvid = {
+static cmdline_parse_inst_t cmd_tx_vlan_set_pvid = {
.f = cmd_tx_vlan_set_pvid_parsed,
.data = NULL,
.help_str = "tx_vlan set pvid <port_id> <vlan_id> on|off",
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;
}
cmd_reconfig_device_queue(res->port_id, 1, 1);
}
-cmdline_parse_token_string_t cmd_tx_vlan_reset_tx_vlan =
+static cmdline_parse_token_string_t cmd_tx_vlan_reset_tx_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_reset_result,
tx_vlan, "tx_vlan");
-cmdline_parse_token_string_t cmd_tx_vlan_reset_reset =
+static cmdline_parse_token_string_t cmd_tx_vlan_reset_reset =
TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_reset_result,
reset, "reset");
-cmdline_parse_token_num_t cmd_tx_vlan_reset_portid =
+static 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 = {
+static cmdline_parse_inst_t cmd_tx_vlan_reset = {
.f = cmd_tx_vlan_reset_parsed,
.data = NULL,
.help_str = "tx_vlan reset <port_id>: Disable hardware insertion of a "
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);
}
}
int k;
/* Apply queue tx offloads configuration */
- for (k = 0; k < port->dev_info.max_rx_queues; k++)
- port->tx_conf[k].offloads =
+ for (k = 0; k < port->dev_info.max_tx_queues; k++)
+ port->txq[k].conf.offloads =
port->dev_conf.txmode.offloads;
}
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;
}
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);
}
}
cmd_reconfig_device_queue(res->port_id, 1, 1);
}
-cmdline_parse_token_string_t cmd_csum_csum =
+static cmdline_parse_token_string_t cmd_csum_csum =
TOKEN_STRING_INITIALIZER(struct cmd_csum_result,
csum, "csum");
-cmdline_parse_token_string_t cmd_csum_mode =
+static cmdline_parse_token_string_t cmd_csum_mode =
TOKEN_STRING_INITIALIZER(struct cmd_csum_result,
mode, "set");
-cmdline_parse_token_string_t cmd_csum_proto =
+static cmdline_parse_token_string_t cmd_csum_proto =
TOKEN_STRING_INITIALIZER(struct cmd_csum_result,
proto, "ip#tcp#udp#sctp#outer-ip#outer-udp");
-cmdline_parse_token_string_t cmd_csum_hwsw =
+static cmdline_parse_token_string_t cmd_csum_hwsw =
TOKEN_STRING_INITIALIZER(struct cmd_csum_result,
hwsw, "hw#sw");
-cmdline_parse_token_num_t cmd_csum_portid =
+static 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 = {
+static cmdline_parse_inst_t cmd_csum_set = {
.f = cmd_csum_parsed,
.data = NULL,
.help_str = "csum set ip|tcp|udp|sctp|outer-ip|outer-udp hw|sw <port_id>: "
},
};
-cmdline_parse_token_string_t cmd_csum_mode_show =
+static cmdline_parse_token_string_t cmd_csum_mode_show =
TOKEN_STRING_INITIALIZER(struct cmd_csum_result,
mode, "show");
-cmdline_parse_inst_t cmd_csum_show = {
+static cmdline_parse_inst_t cmd_csum_show = {
.f = cmd_csum_parsed,
.data = NULL,
.help_str = "csum show <port_id>: Show checksum offload configuration",
csum_show(res->port_id);
}
-cmdline_parse_token_string_t cmd_csum_tunnel_csum =
+static cmdline_parse_token_string_t cmd_csum_tunnel_csum =
TOKEN_STRING_INITIALIZER(struct cmd_csum_tunnel_result,
csum, "csum");
-cmdline_parse_token_string_t cmd_csum_tunnel_parse =
+static cmdline_parse_token_string_t cmd_csum_tunnel_parse =
TOKEN_STRING_INITIALIZER(struct cmd_csum_tunnel_result,
parse, "parse-tunnel");
-cmdline_parse_token_string_t cmd_csum_tunnel_onoff =
+static cmdline_parse_token_string_t cmd_csum_tunnel_onoff =
TOKEN_STRING_INITIALIZER(struct cmd_csum_tunnel_result,
onoff, "on#off");
-cmdline_parse_token_num_t cmd_csum_tunnel_portid =
+static 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 = {
+static cmdline_parse_inst_t cmd_csum_tunnel = {
.f = cmd_csum_tunnel_parsed,
.data = NULL,
.help_str = "csum parse-tunnel on|off <port_id>: "
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;
}
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);
}
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);
}
-cmdline_parse_token_string_t cmd_tso_set_tso =
+static cmdline_parse_token_string_t cmd_tso_set_tso =
TOKEN_STRING_INITIALIZER(struct cmd_tso_set_result,
tso, "tso");
-cmdline_parse_token_string_t cmd_tso_set_mode =
+static cmdline_parse_token_string_t cmd_tso_set_mode =
TOKEN_STRING_INITIALIZER(struct cmd_tso_set_result,
mode, "set");
-cmdline_parse_token_num_t cmd_tso_set_tso_segsz =
+static cmdline_parse_token_num_t cmd_tso_set_tso_segsz =
TOKEN_NUM_INITIALIZER(struct cmd_tso_set_result,
- tso_segsz, UINT16);
-cmdline_parse_token_num_t cmd_tso_set_portid =
+ tso_segsz, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_tso_set = {
.f = cmd_tso_set_parsed,
.data = NULL,
.help_str = "tso set <tso_segsz> <port_id>: "
},
};
-cmdline_parse_token_string_t cmd_tso_show_mode =
+static cmdline_parse_token_string_t cmd_tso_show_mode =
TOKEN_STRING_INITIALIZER(struct cmd_tso_set_result,
mode, "show");
-cmdline_parse_inst_t cmd_tso_show = {
+static cmdline_parse_inst_t cmd_tso_show = {
.f = cmd_tso_set_parsed,
.data = NULL,
.help_str = "tso show <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;
}
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;
}
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);
*/
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]);
cmd_reconfig_device_queue(res->port_id, 1, 1);
}
-cmdline_parse_token_string_t cmd_tunnel_tso_set_tso =
+static cmdline_parse_token_string_t cmd_tunnel_tso_set_tso =
TOKEN_STRING_INITIALIZER(struct cmd_tunnel_tso_set_result,
tso, "tunnel_tso");
-cmdline_parse_token_string_t cmd_tunnel_tso_set_mode =
+static cmdline_parse_token_string_t cmd_tunnel_tso_set_mode =
TOKEN_STRING_INITIALIZER(struct cmd_tunnel_tso_set_result,
mode, "set");
-cmdline_parse_token_num_t cmd_tunnel_tso_set_tso_segsz =
+static cmdline_parse_token_num_t cmd_tunnel_tso_set_tso_segsz =
TOKEN_NUM_INITIALIZER(struct cmd_tunnel_tso_set_result,
- tso_segsz, UINT16);
-cmdline_parse_token_num_t cmd_tunnel_tso_set_portid =
+ tso_segsz, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_tunnel_tso_set = {
.f = cmd_tunnel_tso_set_parsed,
.data = NULL,
.help_str = "tunnel_tso set <tso_segsz> <port_id>: "
},
};
-cmdline_parse_token_string_t cmd_tunnel_tso_show_mode =
+static cmdline_parse_token_string_t cmd_tunnel_tso_show_mode =
TOKEN_STRING_INITIALIZER(struct cmd_tunnel_tso_set_result,
mode, "show");
-cmdline_parse_inst_t cmd_tunnel_tso_show = {
+static cmdline_parse_inst_t cmd_tunnel_tso_show = {
.f = cmd_tunnel_tso_set_parsed,
.data = NULL,
.help_str = "tunnel_tso show <port_id> "
},
};
+#ifdef RTE_LIB_GRO
/* *** SET GRO FOR A PORT *** */
struct cmd_gro_enable_result {
cmdline_fixed_string_t cmd_set;
setup_gro(res->cmd_onoff, res->cmd_pid);
}
-cmdline_parse_token_string_t cmd_gro_enable_set =
+static cmdline_parse_token_string_t cmd_gro_enable_set =
TOKEN_STRING_INITIALIZER(struct cmd_gro_enable_result,
cmd_set, "set");
-cmdline_parse_token_string_t cmd_gro_enable_port =
+static cmdline_parse_token_string_t cmd_gro_enable_port =
TOKEN_STRING_INITIALIZER(struct cmd_gro_enable_result,
cmd_keyword, "port");
-cmdline_parse_token_num_t cmd_gro_enable_pid =
+static cmdline_parse_token_num_t cmd_gro_enable_pid =
TOKEN_NUM_INITIALIZER(struct cmd_gro_enable_result,
- cmd_pid, UINT16);
-cmdline_parse_token_string_t cmd_gro_enable_keyword =
+ cmd_pid, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_gro_enable_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_gro_enable_result,
cmd_keyword, "gro");
-cmdline_parse_token_string_t cmd_gro_enable_onoff =
+static cmdline_parse_token_string_t cmd_gro_enable_onoff =
TOKEN_STRING_INITIALIZER(struct cmd_gro_enable_result,
cmd_onoff, "on#off");
-cmdline_parse_inst_t cmd_gro_enable = {
+static cmdline_parse_inst_t cmd_gro_enable = {
.f = cmd_gro_enable_parsed,
.data = NULL,
.help_str = "set port <port_id> gro on|off",
show_gro(res->cmd_pid);
}
-cmdline_parse_token_string_t cmd_gro_show_show =
+static cmdline_parse_token_string_t cmd_gro_show_show =
TOKEN_STRING_INITIALIZER(struct cmd_gro_show_result,
cmd_show, "show");
-cmdline_parse_token_string_t cmd_gro_show_port =
+static cmdline_parse_token_string_t cmd_gro_show_port =
TOKEN_STRING_INITIALIZER(struct cmd_gro_show_result,
cmd_port, "port");
-cmdline_parse_token_num_t cmd_gro_show_pid =
+static cmdline_parse_token_num_t cmd_gro_show_pid =
TOKEN_NUM_INITIALIZER(struct cmd_gro_show_result,
- cmd_pid, UINT16);
-cmdline_parse_token_string_t cmd_gro_show_keyword =
+ cmd_pid, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_gro_show_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_gro_show_result,
cmd_keyword, "gro");
-cmdline_parse_inst_t cmd_gro_show = {
+static cmdline_parse_inst_t cmd_gro_show = {
.f = cmd_gro_show_parsed,
.data = NULL,
.help_str = "show port <port_id> gro",
setup_gro_flush_cycles(res->cmd_cycles);
}
-cmdline_parse_token_string_t cmd_gro_flush_set =
+static cmdline_parse_token_string_t cmd_gro_flush_set =
TOKEN_STRING_INITIALIZER(struct cmd_gro_flush_result,
cmd_set, "set");
-cmdline_parse_token_string_t cmd_gro_flush_keyword =
+static cmdline_parse_token_string_t cmd_gro_flush_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_gro_flush_result,
cmd_keyword, "gro");
-cmdline_parse_token_string_t cmd_gro_flush_flush =
+static cmdline_parse_token_string_t cmd_gro_flush_flush =
TOKEN_STRING_INITIALIZER(struct cmd_gro_flush_result,
cmd_flush, "flush");
-cmdline_parse_token_num_t cmd_gro_flush_cycles =
+static 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 = {
+static cmdline_parse_inst_t cmd_gro_flush = {
.f = cmd_gro_flush_parsed,
.data = NULL,
.help_str = "set gro flush <cycles>",
NULL,
},
};
+#endif /* RTE_LIB_GRO */
+#ifdef RTE_LIB_GSO
/* *** ENABLE/DISABLE GSO *** */
struct cmd_gso_enable_result {
cmdline_fixed_string_t cmd_set;
setup_gso(res->cmd_mode, res->cmd_pid);
}
-cmdline_parse_token_string_t cmd_gso_enable_set =
+static cmdline_parse_token_string_t cmd_gso_enable_set =
TOKEN_STRING_INITIALIZER(struct cmd_gso_enable_result,
cmd_set, "set");
-cmdline_parse_token_string_t cmd_gso_enable_port =
+static cmdline_parse_token_string_t cmd_gso_enable_port =
TOKEN_STRING_INITIALIZER(struct cmd_gso_enable_result,
cmd_port, "port");
-cmdline_parse_token_string_t cmd_gso_enable_keyword =
+static cmdline_parse_token_string_t cmd_gso_enable_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_gso_enable_result,
cmd_keyword, "gso");
-cmdline_parse_token_string_t cmd_gso_enable_mode =
+static cmdline_parse_token_string_t cmd_gso_enable_mode =
TOKEN_STRING_INITIALIZER(struct cmd_gso_enable_result,
cmd_mode, "on#off");
-cmdline_parse_token_num_t cmd_gso_enable_pid =
+static 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 = {
+static cmdline_parse_inst_t cmd_gso_enable = {
.f = cmd_gso_enable_parsed,
.data = NULL,
.help_str = "set port <port_id> gso on|off",
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;
}
}
-cmdline_parse_token_string_t cmd_gso_size_set =
+static cmdline_parse_token_string_t cmd_gso_size_set =
TOKEN_STRING_INITIALIZER(struct cmd_gso_size_result,
cmd_set, "set");
-cmdline_parse_token_string_t cmd_gso_size_keyword =
+static cmdline_parse_token_string_t cmd_gso_size_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_gso_size_result,
cmd_keyword, "gso");
-cmdline_parse_token_string_t cmd_gso_size_segsz =
+static cmdline_parse_token_string_t cmd_gso_size_segsz =
TOKEN_STRING_INITIALIZER(struct cmd_gso_size_result,
cmd_segsz, "segsz");
-cmdline_parse_token_num_t cmd_gso_size_size =
+static 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 = {
+static cmdline_parse_inst_t cmd_gso_size = {
.f = cmd_gso_size_parsed,
.data = NULL,
.help_str = "set gso segsz <length>",
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")) {
}
}
-cmdline_parse_token_string_t cmd_gso_show_show =
+static cmdline_parse_token_string_t cmd_gso_show_show =
TOKEN_STRING_INITIALIZER(struct cmd_gso_show_result,
cmd_show, "show");
-cmdline_parse_token_string_t cmd_gso_show_port =
+static cmdline_parse_token_string_t cmd_gso_show_port =
TOKEN_STRING_INITIALIZER(struct cmd_gso_show_result,
cmd_port, "port");
-cmdline_parse_token_string_t cmd_gso_show_keyword =
+static cmdline_parse_token_string_t cmd_gso_show_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_gso_show_result,
cmd_keyword, "gso");
-cmdline_parse_token_num_t cmd_gso_show_pid =
+static 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 = {
+static cmdline_parse_inst_t cmd_gso_show = {
.f = cmd_gso_show_parsed,
.data = NULL,
.help_str = "show port <port_id> gso",
NULL,
},
};
+#endif /* RTE_LIB_GSO */
/* *** ENABLE/DISABLE FLUSH ON RX STREAMS *** */
struct cmd_set_flush_rx {
__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);
}
-cmdline_parse_token_string_t cmd_setflushrx_set =
+static cmdline_parse_token_string_t cmd_setflushrx_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx,
set, "set");
-cmdline_parse_token_string_t cmd_setflushrx_flush_rx =
+static cmdline_parse_token_string_t cmd_setflushrx_flush_rx =
TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx,
flush_rx, "flush_rx");
-cmdline_parse_token_string_t cmd_setflushrx_mode =
+static cmdline_parse_token_string_t cmd_setflushrx_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx,
mode, "on#off");
-cmdline_parse_inst_t cmd_set_flush_rx = {
+static cmdline_parse_inst_t cmd_set_flush_rx = {
.f = cmd_set_flush_rx_parsed,
.help_str = "set flush_rx on|off: Enable/Disable flush on rx streams",
.data = NULL,
no_link_check = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1);
}
-cmdline_parse_token_string_t cmd_setlinkcheck_set =
+static cmdline_parse_token_string_t cmd_setlinkcheck_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_link_check,
set, "set");
-cmdline_parse_token_string_t cmd_setlinkcheck_link_check =
+static cmdline_parse_token_string_t cmd_setlinkcheck_link_check =
TOKEN_STRING_INITIALIZER(struct cmd_set_link_check,
link_check, "link_check");
-cmdline_parse_token_string_t cmd_setlinkcheck_mode =
+static cmdline_parse_token_string_t cmd_setlinkcheck_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_link_check,
mode, "on#off");
-cmdline_parse_inst_t cmd_set_link_check = {
+static cmdline_parse_inst_t cmd_set_link_check = {
.f = cmd_set_link_check_parsed,
.help_str = "set link_check on|off: Enable/Disable link status check "
"when starting/stopping a port",
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 =
+static cmdline_parse_token_string_t cmd_setbypass_mode_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result,
set, "set");
-cmdline_parse_token_string_t cmd_setbypass_mode_bypass =
+static cmdline_parse_token_string_t cmd_setbypass_mode_bypass =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result,
bypass, "bypass");
-cmdline_parse_token_string_t cmd_setbypass_mode_mode =
+static cmdline_parse_token_string_t cmd_setbypass_mode_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result,
mode, "mode");
-cmdline_parse_token_string_t cmd_setbypass_mode_value =
+static cmdline_parse_token_string_t cmd_setbypass_mode_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result,
value, "normal#bypass#isolate");
-cmdline_parse_token_num_t cmd_setbypass_mode_port =
+static 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 = {
+static cmdline_parse_inst_t cmd_set_bypass_mode = {
.f = cmd_set_bypass_mode_parsed,
.help_str = "set bypass mode normal|bypass|isolate <port_id>: "
"Set the NIC bypass mode for port_id",
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);
}
}
#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 =
+static cmdline_parse_token_string_t cmd_setbypass_event_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
set, "set");
-cmdline_parse_token_string_t cmd_setbypass_event_bypass =
+static cmdline_parse_token_string_t cmd_setbypass_event_bypass =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
bypass, "bypass");
-cmdline_parse_token_string_t cmd_setbypass_event_event =
+static cmdline_parse_token_string_t cmd_setbypass_event_event =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
event, "event");
-cmdline_parse_token_string_t cmd_setbypass_event_event_value =
+static cmdline_parse_token_string_t cmd_setbypass_event_event_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
event_value, "none#timeout#os_off#os_on#power_on#power_off");
-cmdline_parse_token_string_t cmd_setbypass_event_mode =
+static cmdline_parse_token_string_t cmd_setbypass_event_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
mode, "mode");
-cmdline_parse_token_string_t cmd_setbypass_event_mode_value =
+static cmdline_parse_token_string_t cmd_setbypass_event_mode_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result,
mode_value, "normal#bypass#isolate");
-cmdline_parse_token_num_t cmd_setbypass_event_port =
+static 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 = {
+static cmdline_parse_inst_t cmd_set_bypass_event = {
.f = cmd_set_bypass_event_parsed,
.help_str = "set bypass event none|timeout|os_on|os_off|power_on|"
"power_off mode normal|bypass|isolate <port_id>: "
#endif
}
-cmdline_parse_token_string_t cmd_setbypass_timeout_set =
+static cmdline_parse_token_string_t cmd_setbypass_timeout_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result,
set, "set");
-cmdline_parse_token_string_t cmd_setbypass_timeout_bypass =
+static cmdline_parse_token_string_t cmd_setbypass_timeout_bypass =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result,
bypass, "bypass");
-cmdline_parse_token_string_t cmd_setbypass_timeout_timeout =
+static cmdline_parse_token_string_t cmd_setbypass_timeout_timeout =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result,
timeout, "timeout");
-cmdline_parse_token_string_t cmd_setbypass_timeout_value =
+static cmdline_parse_token_string_t cmd_setbypass_timeout_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result,
value, "0#1.5#2#3#4#8#16#32");
-cmdline_parse_inst_t cmd_set_bypass_timeout = {
+static cmdline_parse_inst_t cmd_set_bypass_timeout = {
.f = cmd_set_bypass_timeout_parsed,
.help_str = "set bypass timeout 0|1.5|2|3|4|8|16|32: "
"Set the NIC bypass watchdog timeout in seconds",
/* 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 {
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))
}
#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);
}
-cmdline_parse_token_string_t cmd_showbypass_config_show =
+static cmdline_parse_token_string_t cmd_showbypass_config_show =
TOKEN_STRING_INITIALIZER(struct cmd_show_bypass_config_result,
show, "show");
-cmdline_parse_token_string_t cmd_showbypass_config_bypass =
+static cmdline_parse_token_string_t cmd_showbypass_config_bypass =
TOKEN_STRING_INITIALIZER(struct cmd_show_bypass_config_result,
bypass, "bypass");
-cmdline_parse_token_string_t cmd_showbypass_config_config =
+static cmdline_parse_token_string_t cmd_showbypass_config_config =
TOKEN_STRING_INITIALIZER(struct cmd_show_bypass_config_result,
config, "config");
-cmdline_parse_token_num_t cmd_showbypass_config_port =
+static 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 = {
+static cmdline_parse_inst_t cmd_show_bypass_config = {
.f = cmd_show_bypass_config_parsed,
.help_str = "show bypass config <port_id>: "
"Show the NIC bypass config for port_id",
{
struct cmd_set_bonding_mode_result *res = parsed_result;
portid_t port_id = res->port_id;
+ struct rte_port *port = &ports[port_id];
+
+ /*
+ * Bonding mode changed means resources of device changed, like whether
+ * started rte timer or not. Device should be restarted when resources
+ * of device changed.
+ */
+ if (port->port_status != RTE_PORT_STOPPED) {
+ fprintf(stderr,
+ "\t Error: Can't set bonding mode when port %d is not stopped\n",
+ port_id);
+ return;
+ }
/* Set the bonding mode for the relevant port. */
if (0 != rte_eth_bond_mode_set(port_id, res->value))
- 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 =
+static cmdline_parse_token_string_t cmd_setbonding_mode_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_mode_result,
set, "set");
-cmdline_parse_token_string_t cmd_setbonding_mode_bonding =
+static cmdline_parse_token_string_t cmd_setbonding_mode_bonding =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_mode_result,
bonding, "bonding");
-cmdline_parse_token_string_t cmd_setbonding_mode_mode =
+static cmdline_parse_token_string_t cmd_setbonding_mode_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_mode_result,
mode, "mode");
-cmdline_parse_token_num_t cmd_setbonding_mode_value =
+static cmdline_parse_token_num_t cmd_setbonding_mode_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_mode_result,
- value, UINT8);
-cmdline_parse_token_num_t cmd_setbonding_mode_port =
+ value, RTE_UINT8);
+static 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 = {
+static cmdline_parse_inst_t cmd_set_bonding_mode = {
.f = cmd_set_bonding_mode_parsed,
.help_str = "set bonding mode <mode_value> <port_id>: "
"Set the bonding mode for 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;
}
}
}
-cmdline_parse_token_string_t cmd_setbonding_lacp_dedicated_queues_set =
+static cmdline_parse_token_string_t cmd_setbonding_lacp_dedicated_queues_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_lacp_dedicated_queues_result,
set, "set");
-cmdline_parse_token_string_t cmd_setbonding_lacp_dedicated_queues_bonding =
+static cmdline_parse_token_string_t cmd_setbonding_lacp_dedicated_queues_bonding =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_lacp_dedicated_queues_result,
bonding, "bonding");
-cmdline_parse_token_string_t cmd_setbonding_lacp_dedicated_queues_lacp =
+static cmdline_parse_token_string_t cmd_setbonding_lacp_dedicated_queues_lacp =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_lacp_dedicated_queues_result,
lacp, "lacp");
-cmdline_parse_token_string_t cmd_setbonding_lacp_dedicated_queues_dedicated_queues =
+static cmdline_parse_token_string_t cmd_setbonding_lacp_dedicated_queues_dedicated_queues =
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 =
+static 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);
-cmdline_parse_token_string_t cmd_setbonding_lacp_dedicated_queues_mode =
+ port_id, RTE_UINT16);
+static 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");
-cmdline_parse_inst_t cmd_set_lacp_dedicated_queues = {
+static cmdline_parse_inst_t cmd_set_lacp_dedicated_queues = {
.f = cmd_set_bonding_lacp_dedicated_queues_parsed,
.help_str = "set bonding lacp dedicated_queues <port_id> "
"enable|disable: "
} 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);
}
}
-cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_set =
+static cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
set, "set");
-cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_bonding =
+static cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_bonding =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
bonding, "bonding");
-cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_balance_xmit_policy =
+static cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_balance_xmit_policy =
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 =
+static 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);
-cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_policy =
+ port_id, RTE_UINT16);
+static 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");
-cmdline_parse_inst_t cmd_set_balance_xmit_policy = {
+static cmdline_parse_inst_t cmd_set_balance_xmit_policy = {
.f = cmd_set_bonding_balance_xmit_policy_parsed,
.help_str = "set bonding balance_xmit_policy <port_id> "
"l2|l23|l34: "
}
};
+/* *** 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 lacp;
+ cmdline_fixed_string_t info;
+ portid_t port_id;
+};
+
+static void port_param_show(struct port_params *params)
+{
+ 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);
+}
+
+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;
+
+ static const char * const state[] = {
+ "ACTIVE",
+ "TIMEOUT",
+ "AGGREGATION",
+ "SYNCHRONIZATION",
+ "COLLECTING",
+ "DISTRIBUTING",
+ "DEFAULTED",
+ "EXPIRED"
+ };
+ static const char * const selection[] = {
+ "UNSELECTED",
+ "STANDBY",
+ "SELECTED"
+ };
+
+ 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);
+ }
+}
+
+static cmdline_parse_token_string_t cmd_show_bonding_lacp_info_show =
+TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result,
+ show, "show");
+static cmdline_parse_token_string_t cmd_show_bonding_lacp_info_bonding =
+TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result,
+ bonding, "bonding");
+static cmdline_parse_token_string_t cmd_show_bonding_lacp_info_lacp =
+TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result,
+ bonding, "lacp");
+static cmdline_parse_token_string_t cmd_show_bonding_lacp_info_info =
+TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_lacp_info_result,
+ info, "info");
+static 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);
+
+static cmdline_parse_inst_t cmd_show_bonding_lacp_info = {
+ .f = cmd_show_bonding_lacp_info_parsed,
+ .help_str = "show bonding lacp info <port_id> : "
+ "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;
/* 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);
+ 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) {
+ 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) {
- printf("\tFailed to get balance xmit policy for port = %d\n",
- port_id);
+ fprintf(stderr,
+ "\tFailed to get balance xmit policy for port = %d\n",
+ port_id);
return;
} else {
printf("\tBalance Xmit Policy: ");
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) {
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) {
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);
}
-cmdline_parse_token_string_t cmd_showbonding_config_show =
+static cmdline_parse_token_string_t cmd_showbonding_config_show =
TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_config_result,
show, "show");
-cmdline_parse_token_string_t cmd_showbonding_config_bonding =
+static cmdline_parse_token_string_t cmd_showbonding_config_bonding =
TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_config_result,
bonding, "bonding");
-cmdline_parse_token_string_t cmd_showbonding_config_config =
+static cmdline_parse_token_string_t cmd_showbonding_config_config =
TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_config_result,
config, "config");
-cmdline_parse_token_num_t cmd_showbonding_config_port =
+static 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 = {
+static cmdline_parse_inst_t cmd_show_bonding_config = {
.f = cmd_show_bonding_config_parsed,
.help_str = "show bonding config <port_id>: "
"Show the bonding config for port_id",
/* 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();
}
-cmdline_parse_token_string_t cmd_setbonding_primary_set =
+static cmdline_parse_token_string_t cmd_setbonding_primary_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_primary_result,
set, "set");
-cmdline_parse_token_string_t cmd_setbonding_primary_bonding =
+static cmdline_parse_token_string_t cmd_setbonding_primary_bonding =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_primary_result,
bonding, "bonding");
-cmdline_parse_token_string_t cmd_setbonding_primary_primary =
+static cmdline_parse_token_string_t cmd_setbonding_primary_primary =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_primary_result,
primary, "primary");
-cmdline_parse_token_num_t cmd_setbonding_primary_slave =
+static cmdline_parse_token_num_t cmd_setbonding_primary_slave =
TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_primary_result,
- slave_id, UINT16);
-cmdline_parse_token_num_t cmd_setbonding_primary_port =
+ slave_id, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_set_bonding_primary = {
.f = cmd_set_bonding_primary_parsed,
.help_str = "set bonding primary <slave_id> <port_id>: "
"Set the primary slave for port_id",
/* 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();
set_port_slave_flag(slave_port_id);
}
-cmdline_parse_token_string_t cmd_addbonding_slave_add =
+static cmdline_parse_token_string_t cmd_addbonding_slave_add =
TOKEN_STRING_INITIALIZER(struct cmd_add_bonding_slave_result,
add, "add");
-cmdline_parse_token_string_t cmd_addbonding_slave_bonding =
+static cmdline_parse_token_string_t cmd_addbonding_slave_bonding =
TOKEN_STRING_INITIALIZER(struct cmd_add_bonding_slave_result,
bonding, "bonding");
-cmdline_parse_token_string_t cmd_addbonding_slave_slave =
+static cmdline_parse_token_string_t cmd_addbonding_slave_slave =
TOKEN_STRING_INITIALIZER(struct cmd_add_bonding_slave_result,
slave, "slave");
-cmdline_parse_token_num_t cmd_addbonding_slave_slaveid =
+static cmdline_parse_token_num_t cmd_addbonding_slave_slaveid =
TOKEN_NUM_INITIALIZER(struct cmd_add_bonding_slave_result,
- slave_id, UINT16);
-cmdline_parse_token_num_t cmd_addbonding_slave_port =
+ slave_id, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_add_bonding_slave = {
.f = cmd_add_bonding_slave_parsed,
.help_str = "add bonding slave <slave_id> <port_id>: "
"Add a slave device to a bonded device",
/* 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();
clear_port_slave_flag(slave_port_id);
}
-cmdline_parse_token_string_t cmd_removebonding_slave_remove =
+static cmdline_parse_token_string_t cmd_removebonding_slave_remove =
TOKEN_STRING_INITIALIZER(struct cmd_remove_bonding_slave_result,
remove, "remove");
-cmdline_parse_token_string_t cmd_removebonding_slave_bonding =
+static cmdline_parse_token_string_t cmd_removebonding_slave_bonding =
TOKEN_STRING_INITIALIZER(struct cmd_remove_bonding_slave_result,
bonding, "bonding");
-cmdline_parse_token_string_t cmd_removebonding_slave_slave =
+static cmdline_parse_token_string_t cmd_removebonding_slave_slave =
TOKEN_STRING_INITIALIZER(struct cmd_remove_bonding_slave_result,
slave, "slave");
-cmdline_parse_token_num_t cmd_removebonding_slave_slaveid =
+static cmdline_parse_token_num_t cmd_removebonding_slave_slaveid =
TOKEN_NUM_INITIALIZER(struct cmd_remove_bonding_slave_result,
- slave_id, UINT16);
-cmdline_parse_token_num_t cmd_removebonding_slave_port =
+ slave_id, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_remove_bonding_slave = {
.f = cmd_remove_bonding_slave_parsed,
.help_str = "remove bonding slave <slave_id> <port_id>: "
"Remove a slave device from a bonded device",
int ret;
if (test_done == 0) {
- printf("Please stop forwarding first\n");
+ fprintf(stderr, "Please stop forwarding first\n");
return;
}
/* 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,
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].bond_flag = 1;
ports[port_id].need_setup = 0;
ports[port_id].port_status = RTE_PORT_STOPPED;
}
}
-cmdline_parse_token_string_t cmd_createbonded_device_create =
+static cmdline_parse_token_string_t cmd_createbonded_device_create =
TOKEN_STRING_INITIALIZER(struct cmd_create_bonded_device_result,
create, "create");
-cmdline_parse_token_string_t cmd_createbonded_device_bonded =
+static cmdline_parse_token_string_t cmd_createbonded_device_bonded =
TOKEN_STRING_INITIALIZER(struct cmd_create_bonded_device_result,
bonded, "bonded");
-cmdline_parse_token_string_t cmd_createbonded_device_device =
+static cmdline_parse_token_string_t cmd_createbonded_device_device =
TOKEN_STRING_INITIALIZER(struct cmd_create_bonded_device_result,
device, "device");
-cmdline_parse_token_num_t cmd_createbonded_device_mode =
+static cmdline_parse_token_num_t cmd_createbonded_device_mode =
TOKEN_NUM_INITIALIZER(struct cmd_create_bonded_device_result,
- mode, UINT8);
-cmdline_parse_token_num_t cmd_createbonded_device_socket =
+ mode, RTE_UINT8);
+static 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 = {
+static cmdline_parse_inst_t cmd_create_bonded_device = {
.f = cmd_create_bonded_device_parsed,
.help_str = "create bonded device <mode> <socket>: "
"Create a new bonded device with specific bonding mode and socket",
/* 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 =
+static cmdline_parse_token_string_t cmd_set_bond_mac_addr_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_bond_mac_addr_result, set, "set");
-cmdline_parse_token_string_t cmd_set_bond_mac_addr_bonding =
+static cmdline_parse_token_string_t cmd_set_bond_mac_addr_bonding =
TOKEN_STRING_INITIALIZER(struct cmd_set_bond_mac_addr_result, bonding,
"bonding");
-cmdline_parse_token_string_t cmd_set_bond_mac_addr_mac =
+static cmdline_parse_token_string_t cmd_set_bond_mac_addr_mac =
TOKEN_STRING_INITIALIZER(struct cmd_set_bond_mac_addr_result, mac_addr,
"mac_addr");
-cmdline_parse_token_num_t cmd_set_bond_mac_addr_portnum =
+static cmdline_parse_token_num_t cmd_set_bond_mac_addr_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_set_bond_mac_addr_result,
- port_num, UINT16);
-cmdline_parse_token_etheraddr_t cmd_set_bond_mac_addr_addr =
+ port_num, RTE_UINT16);
+static cmdline_parse_token_etheraddr_t cmd_set_bond_mac_addr_addr =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_bond_mac_addr_result, address);
-cmdline_parse_inst_t cmd_set_bond_mac_addr = {
+static cmdline_parse_inst_t cmd_set_bond_mac_addr = {
.f = cmd_set_bond_mac_addr_parsed,
.data = (void *) 0,
.help_str = "set bonding mac_addr <port_id> <mac_addr>",
/* 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 =
+static cmdline_parse_token_string_t cmd_set_bond_mon_period_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_bond_mon_period_result,
set, "set");
-cmdline_parse_token_string_t cmd_set_bond_mon_period_bonding =
+static cmdline_parse_token_string_t cmd_set_bond_mon_period_bonding =
TOKEN_STRING_INITIALIZER(struct cmd_set_bond_mon_period_result,
bonding, "bonding");
-cmdline_parse_token_string_t cmd_set_bond_mon_period_mon_period =
+static cmdline_parse_token_string_t cmd_set_bond_mon_period_mon_period =
TOKEN_STRING_INITIALIZER(struct cmd_set_bond_mon_period_result,
mon_period, "mon_period");
-cmdline_parse_token_num_t cmd_set_bond_mon_period_portnum =
+static cmdline_parse_token_num_t cmd_set_bond_mon_period_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_set_bond_mon_period_result,
- port_num, UINT16);
-cmdline_parse_token_num_t cmd_set_bond_mon_period_period_ms =
+ port_num, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_set_bond_mon_period = {
.f = cmd_set_bond_mon_period_parsed,
.data = (void *) 0,
.help_str = "set bonding mon_period <port_id> <period_ms>",
}
-cmdline_parse_token_string_t cmd_set_bonding_agg_mode_set =
+static cmdline_parse_token_string_t cmd_set_bonding_agg_mode_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_agg_mode_policy_result,
set, "set");
-cmdline_parse_token_string_t cmd_set_bonding_agg_mode_bonding =
+static cmdline_parse_token_string_t cmd_set_bonding_agg_mode_bonding =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_agg_mode_policy_result,
bonding, "bonding");
-cmdline_parse_token_string_t cmd_set_bonding_agg_mode_agg_mode =
+static cmdline_parse_token_string_t cmd_set_bonding_agg_mode_agg_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_agg_mode_policy_result,
agg_mode, "agg_mode");
-cmdline_parse_token_num_t cmd_set_bonding_agg_mode_portnum =
+static 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 =
+static cmdline_parse_token_string_t cmd_set_bonding_agg_mode_policy_string =
TOKEN_STRING_INITIALIZER(
struct cmd_set_bonding_balance_xmit_policy_result,
policy, "stable#bandwidth#count");
-cmdline_parse_inst_t cmd_set_bonding_agg_mode_policy = {
+static cmdline_parse_inst_t cmd_set_bonding_agg_mode_policy = {
.f = cmd_set_bonding_agg_mode,
.data = (void *) 0,
.help_str = "set bonding mode IEEE802.3AD aggregator policy <port_id> <agg_name>",
set_pkt_forwarding_mode(res->mode);
}
-cmdline_parse_token_string_t cmd_setfwd_set =
+static cmdline_parse_token_string_t cmd_setfwd_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, set, "set");
-cmdline_parse_token_string_t cmd_setfwd_fwd =
+static cmdline_parse_token_string_t cmd_setfwd_fwd =
TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, fwd, "fwd");
-cmdline_parse_token_string_t cmd_setfwd_mode =
+static cmdline_parse_token_string_t cmd_setfwd_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, mode,
"" /* defined at init */);
-cmdline_parse_inst_t cmd_set_fwd_mode = {
+static cmdline_parse_inst_t cmd_set_fwd_mode = {
.f = cmd_set_fwd_mode_parsed,
.data = NULL,
.help_str = NULL, /* defined at init */
set_pkt_forwarding_mode(res->mode);
}
-cmdline_parse_token_string_t cmd_setfwd_retry_set =
+static cmdline_parse_token_string_t cmd_setfwd_retry_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_retry_mode_result,
set, "set");
-cmdline_parse_token_string_t cmd_setfwd_retry_fwd =
+static cmdline_parse_token_string_t cmd_setfwd_retry_fwd =
TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_retry_mode_result,
fwd, "fwd");
-cmdline_parse_token_string_t cmd_setfwd_retry_mode =
+static cmdline_parse_token_string_t cmd_setfwd_retry_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_retry_mode_result,
mode,
"" /* defined at init */);
-cmdline_parse_token_string_t cmd_setfwd_retry_retry =
+static cmdline_parse_token_string_t cmd_setfwd_retry_retry =
TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_retry_mode_result,
retry, "retry");
-cmdline_parse_inst_t cmd_set_fwd_retry_mode = {
+static cmdline_parse_inst_t cmd_set_fwd_retry_mode = {
.f = cmd_set_fwd_retry_mode_parsed,
.data = NULL,
.help_str = NULL, /* defined at init */
}
-cmdline_parse_token_string_t cmd_set_burst_tx_retry_set =
+static cmdline_parse_token_string_t cmd_set_burst_tx_retry_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, set, "set");
-cmdline_parse_token_string_t cmd_set_burst_tx_retry_burst =
+static cmdline_parse_token_string_t cmd_set_burst_tx_retry_burst =
TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, burst,
"burst");
-cmdline_parse_token_string_t cmd_set_burst_tx_retry_tx =
+static cmdline_parse_token_string_t cmd_set_burst_tx_retry_tx =
TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, tx, "tx");
-cmdline_parse_token_string_t cmd_set_burst_tx_retry_delay =
+static 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);
-cmdline_parse_token_string_t cmd_set_burst_tx_retry_retry =
+static cmdline_parse_token_num_t cmd_set_burst_tx_retry_time =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, time,
+ RTE_UINT32);
+static 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);
+static cmdline_parse_token_num_t cmd_set_burst_tx_retry_retry_num =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry_num,
+ RTE_UINT32);
-cmdline_parse_inst_t cmd_set_burst_tx_retry = {
+static cmdline_parse_inst_t cmd_set_burst_tx_retry = {
.f = cmd_set_burst_tx_retry_parsed,
.help_str = "set burst tx delay <delay_usec> retry <num_retry>",
.tokens = {
}
}
-cmdline_parse_token_string_t cmd_setpromisc_set =
+static cmdline_parse_token_string_t cmd_setpromisc_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_promisc_mode_result, set, "set");
-cmdline_parse_token_string_t cmd_setpromisc_promisc =
+static cmdline_parse_token_string_t cmd_setpromisc_promisc =
TOKEN_STRING_INITIALIZER(struct cmd_set_promisc_mode_result, promisc,
"promisc");
-cmdline_parse_token_string_t cmd_setpromisc_portall =
+static cmdline_parse_token_string_t cmd_setpromisc_portall =
TOKEN_STRING_INITIALIZER(struct cmd_set_promisc_mode_result, port_all,
"all");
-cmdline_parse_token_num_t cmd_setpromisc_portnum =
+static cmdline_parse_token_num_t cmd_setpromisc_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_set_promisc_mode_result, port_num,
- UINT16);
-cmdline_parse_token_string_t cmd_setpromisc_mode =
+ RTE_UINT16);
+static cmdline_parse_token_string_t cmd_setpromisc_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_promisc_mode_result, mode,
"on#off");
-cmdline_parse_inst_t cmd_set_promisc_mode_all = {
+static cmdline_parse_inst_t cmd_set_promisc_mode_all = {
.f = cmd_set_promisc_mode_parsed,
.data = (void *)1,
.help_str = "set promisc all on|off: Set promisc mode for all ports",
},
};
-cmdline_parse_inst_t cmd_set_promisc_mode_one = {
+static cmdline_parse_inst_t cmd_set_promisc_mode_one = {
.f = cmd_set_promisc_mode_parsed,
.data = (void *)0,
.help_str = "set promisc <port_id> on|off: Set promisc mode on port_id",
}
}
-cmdline_parse_token_string_t cmd_setallmulti_set =
+static cmdline_parse_token_string_t cmd_setallmulti_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_allmulti_mode_result, set, "set");
-cmdline_parse_token_string_t cmd_setallmulti_allmulti =
+static cmdline_parse_token_string_t cmd_setallmulti_allmulti =
TOKEN_STRING_INITIALIZER(struct cmd_set_allmulti_mode_result, allmulti,
"allmulti");
-cmdline_parse_token_string_t cmd_setallmulti_portall =
+static cmdline_parse_token_string_t cmd_setallmulti_portall =
TOKEN_STRING_INITIALIZER(struct cmd_set_allmulti_mode_result, port_all,
"all");
-cmdline_parse_token_num_t cmd_setallmulti_portnum =
+static cmdline_parse_token_num_t cmd_setallmulti_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_set_allmulti_mode_result, port_num,
- UINT16);
-cmdline_parse_token_string_t cmd_setallmulti_mode =
+ RTE_UINT16);
+static cmdline_parse_token_string_t cmd_setallmulti_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_allmulti_mode_result, mode,
"on#off");
-cmdline_parse_inst_t cmd_set_allmulti_mode_all = {
+static cmdline_parse_inst_t cmd_set_allmulti_mode_all = {
.f = cmd_set_allmulti_mode_parsed,
.data = (void *)1,
.help_str = "set allmulti all on|off: Set allmulti mode for all ports",
},
};
-cmdline_parse_inst_t cmd_set_allmulti_mode_one = {
+static cmdline_parse_inst_t cmd_set_allmulti_mode_one = {
.f = cmd_set_allmulti_mode_parsed,
.data = (void *)0,
.help_str = "set allmulti <port_id> on|off: "
},
};
-/* *** SETUP ETHERNET LINK FLOW CONTROL *** */
-struct cmd_link_flow_ctrl_set_result {
- cmdline_fixed_string_t set;
+/* *** 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_fixed_string_t rx;
+};
+
+static cmdline_parse_token_string_t cmd_lfc_show_show =
+ TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_show,
+ show, "show");
+static cmdline_parse_token_string_t cmd_lfc_show_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_show,
+ port, "port");
+static cmdline_parse_token_num_t cmd_lfc_show_portid =
+ TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_show,
+ port_id, RTE_UINT16);
+static 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);
+}
+
+static cmdline_parse_inst_t cmd_link_flow_control_show = {
+ .f = cmd_link_flow_ctrl_show_parsed,
+ .data = NULL,
+ .help_str = "show port <port_id> 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;
+ cmdline_fixed_string_t flow_ctrl;
+ cmdline_fixed_string_t rx;
cmdline_fixed_string_t rx_lfc_mode;
cmdline_fixed_string_t tx;
cmdline_fixed_string_t tx_lfc_mode;
portid_t port_id;
};
-cmdline_parse_token_string_t cmd_lfc_set_set =
+static cmdline_parse_token_string_t cmd_lfc_set_set =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
set, "set");
-cmdline_parse_token_string_t cmd_lfc_set_flow_ctrl =
+static cmdline_parse_token_string_t cmd_lfc_set_flow_ctrl =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
flow_ctrl, "flow_ctrl");
-cmdline_parse_token_string_t cmd_lfc_set_rx =
+static cmdline_parse_token_string_t cmd_lfc_set_rx =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
rx, "rx");
-cmdline_parse_token_string_t cmd_lfc_set_rx_mode =
+static cmdline_parse_token_string_t cmd_lfc_set_rx_mode =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
rx_lfc_mode, "on#off");
-cmdline_parse_token_string_t cmd_lfc_set_tx =
+static cmdline_parse_token_string_t cmd_lfc_set_tx =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
tx, "tx");
-cmdline_parse_token_string_t cmd_lfc_set_tx_mode =
+static cmdline_parse_token_string_t cmd_lfc_set_tx_mode =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
tx_lfc_mode, "on#off");
-cmdline_parse_token_string_t cmd_lfc_set_high_water_str =
+static cmdline_parse_token_string_t cmd_lfc_set_high_water_str =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
hw_str, "high_water");
-cmdline_parse_token_num_t cmd_lfc_set_high_water =
+static cmdline_parse_token_num_t cmd_lfc_set_high_water =
TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
- high_water, UINT32);
-cmdline_parse_token_string_t cmd_lfc_set_low_water_str =
+ high_water, RTE_UINT32);
+static 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 =
+static cmdline_parse_token_num_t cmd_lfc_set_low_water =
TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
- low_water, UINT32);
-cmdline_parse_token_string_t cmd_lfc_set_pause_time_str =
+ low_water, RTE_UINT32);
+static 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 =
+static cmdline_parse_token_num_t cmd_lfc_set_pause_time =
TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
- pause_time, UINT16);
-cmdline_parse_token_string_t cmd_lfc_set_send_xon_str =
+ pause_time, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_lfc_set_send_xon =
TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
- send_xon, UINT16);
-cmdline_parse_token_string_t cmd_lfc_set_mac_ctrl_frame_fwd_mode =
+ send_xon, RTE_UINT16);
+static 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");
-cmdline_parse_token_string_t cmd_lfc_set_mac_ctrl_frame_fwd =
+static cmdline_parse_token_string_t cmd_lfc_set_mac_ctrl_frame_fwd =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
mac_ctrl_frame_fwd_mode, "on#off");
-cmdline_parse_token_string_t cmd_lfc_set_autoneg_str =
+static cmdline_parse_token_string_t cmd_lfc_set_autoneg_str =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
autoneg_str, "autoneg");
-cmdline_parse_token_string_t cmd_lfc_set_autoneg =
+static cmdline_parse_token_string_t cmd_lfc_set_autoneg =
TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
autoneg, "on#off");
-cmdline_parse_token_num_t cmd_lfc_set_portid =
+static 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
cmd_link_flow_ctrl_set_parsed(void *parsed_result, struct cmdline *cl,
void *data);
-cmdline_parse_inst_t cmd_link_flow_control_set = {
+static cmdline_parse_inst_t cmd_link_flow_control_set = {
.f = cmd_link_flow_ctrl_set_parsed,
.data = NULL,
.help_str = "set flow_ctrl rx on|off tx on|off <high_water> "
},
};
-cmdline_parse_inst_t cmd_link_flow_control_set_rx = {
+static cmdline_parse_inst_t cmd_link_flow_control_set_rx = {
.f = cmd_link_flow_ctrl_set_parsed,
.data = (void *)&cmd_link_flow_control_set_rx,
.help_str = "set flow_ctrl rx on|off <port_id>: "
},
};
-cmdline_parse_inst_t cmd_link_flow_control_set_tx = {
+static cmdline_parse_inst_t cmd_link_flow_control_set_tx = {
.f = cmd_link_flow_ctrl_set_parsed,
.data = (void *)&cmd_link_flow_control_set_tx,
.help_str = "set flow_ctrl tx on|off <port_id>: "
},
};
-cmdline_parse_inst_t cmd_link_flow_control_set_hw = {
+static cmdline_parse_inst_t cmd_link_flow_control_set_hw = {
.f = cmd_link_flow_ctrl_set_parsed,
.data = (void *)&cmd_link_flow_control_set_hw,
.help_str = "set flow_ctrl high_water <value> <port_id>: "
},
};
-cmdline_parse_inst_t cmd_link_flow_control_set_lw = {
+static cmdline_parse_inst_t cmd_link_flow_control_set_lw = {
.f = cmd_link_flow_ctrl_set_parsed,
.data = (void *)&cmd_link_flow_control_set_lw,
.help_str = "set flow_ctrl low_water <value> <port_id>: "
},
};
-cmdline_parse_inst_t cmd_link_flow_control_set_pt = {
+static cmdline_parse_inst_t cmd_link_flow_control_set_pt = {
.f = cmd_link_flow_ctrl_set_parsed,
.data = (void *)&cmd_link_flow_control_set_pt,
.help_str = "set flow_ctrl pause_time <value> <port_id>: "
},
};
-cmdline_parse_inst_t cmd_link_flow_control_set_xon = {
+static cmdline_parse_inst_t cmd_link_flow_control_set_xon = {
.f = cmd_link_flow_ctrl_set_parsed,
.data = (void *)&cmd_link_flow_control_set_xon,
.help_str = "set flow_ctrl send_xon <value> <port_id>: "
},
};
-cmdline_parse_inst_t cmd_link_flow_control_set_macfwd = {
+static cmdline_parse_inst_t cmd_link_flow_control_set_macfwd = {
.f = cmd_link_flow_ctrl_set_parsed,
.data = (void *)&cmd_link_flow_control_set_macfwd,
.help_str = "set flow_ctrl mac_ctrl_frame_fwd on|off <port_id>: "
},
};
-cmdline_parse_inst_t cmd_link_flow_control_set_autoneg = {
+static cmdline_parse_inst_t cmd_link_flow_control_set_autoneg = {
.f = cmd_link_flow_ctrl_set_parsed,
.data = (void *)&cmd_link_flow_control_set_autoneg,
.help_str = "set flow_ctrl autoneg on|off <port_id>: "
/*
* 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;
}
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 *** */
/*
* 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));
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 =
+static cmdline_parse_token_string_t cmd_pfc_set_set =
TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
set, "set");
-cmdline_parse_token_string_t cmd_pfc_set_flow_ctrl =
+static cmdline_parse_token_string_t cmd_pfc_set_flow_ctrl =
TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
pfc_ctrl, "pfc_ctrl");
-cmdline_parse_token_string_t cmd_pfc_set_rx =
+static cmdline_parse_token_string_t cmd_pfc_set_rx =
TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
rx, "rx");
-cmdline_parse_token_string_t cmd_pfc_set_rx_mode =
+static cmdline_parse_token_string_t cmd_pfc_set_rx_mode =
TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
rx_pfc_mode, "on#off");
-cmdline_parse_token_string_t cmd_pfc_set_tx =
+static cmdline_parse_token_string_t cmd_pfc_set_tx =
TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
tx, "tx");
-cmdline_parse_token_string_t cmd_pfc_set_tx_mode =
+static cmdline_parse_token_string_t cmd_pfc_set_tx_mode =
TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
tx_pfc_mode, "on#off");
-cmdline_parse_token_num_t cmd_pfc_set_high_water =
+static cmdline_parse_token_num_t cmd_pfc_set_high_water =
TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
- high_water, UINT32);
-cmdline_parse_token_num_t cmd_pfc_set_low_water =
+ high_water, RTE_UINT32);
+static cmdline_parse_token_num_t cmd_pfc_set_low_water =
TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
- low_water, UINT32);
-cmdline_parse_token_num_t cmd_pfc_set_pause_time =
+ low_water, RTE_UINT32);
+static cmdline_parse_token_num_t cmd_pfc_set_pause_time =
TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
- pause_time, UINT16);
-cmdline_parse_token_num_t cmd_pfc_set_priority =
+ pause_time, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_pfc_set_priority =
TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
- priority, UINT8);
-cmdline_parse_token_num_t cmd_pfc_set_portid =
+ priority, RTE_UINT8);
+static 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 = {
+static cmdline_parse_inst_t cmd_priority_flow_control_set = {
.f = cmd_priority_flow_ctrl_set_parsed,
.data = NULL,
.help_str = "set pfc_ctrl rx on|off tx on|off <high_water> <low_water> "
},
};
+struct cmd_queue_priority_flow_ctrl_set_result {
+ cmdline_fixed_string_t set;
+ cmdline_fixed_string_t pfc_queue_ctrl;
+ portid_t port_id;
+ cmdline_fixed_string_t rx;
+ cmdline_fixed_string_t rx_pfc_mode;
+ uint16_t tx_qid;
+ uint8_t tx_tc;
+ cmdline_fixed_string_t tx;
+ cmdline_fixed_string_t tx_pfc_mode;
+ uint16_t rx_qid;
+ uint8_t rx_tc;
+ uint16_t pause_time;
+};
+
+static void
+cmd_queue_priority_flow_ctrl_set_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_queue_priority_flow_ctrl_set_result *res = parsed_result;
+ struct rte_eth_pfc_queue_conf pfc_queue_conf;
+ int rx_fc_enable, tx_fc_enable;
+ int ret;
+
+ /*
+ * Rx on/off, flow control is enabled/disabled on RX side. This can
+ * indicate the RTE_ETH_FC_TX_PAUSE, Transmit pause frame at the Rx
+ * side. Tx on/off, flow control is enabled/disabled on TX side. This
+ * can indicate the RTE_ETH_FC_RX_PAUSE, Respond to the pause frame at
+ * the Tx side.
+ */
+ static enum rte_eth_fc_mode rx_tx_onoff_2_mode[2][2] = {
+ {RTE_ETH_FC_NONE, RTE_ETH_FC_TX_PAUSE},
+ {RTE_ETH_FC_RX_PAUSE, RTE_ETH_FC_FULL}
+ };
+
+ memset(&pfc_queue_conf, 0, sizeof(struct rte_eth_pfc_queue_conf));
+ rx_fc_enable = (!strncmp(res->rx_pfc_mode, "on", 2)) ? 1 : 0;
+ tx_fc_enable = (!strncmp(res->tx_pfc_mode, "on", 2)) ? 1 : 0;
+ pfc_queue_conf.mode = rx_tx_onoff_2_mode[rx_fc_enable][tx_fc_enable];
+ pfc_queue_conf.rx_pause.tc = res->tx_tc;
+ pfc_queue_conf.rx_pause.tx_qid = res->tx_qid;
+ pfc_queue_conf.tx_pause.tc = res->rx_tc;
+ pfc_queue_conf.tx_pause.rx_qid = res->rx_qid;
+ pfc_queue_conf.tx_pause.pause_time = res->pause_time;
+
+ ret = rte_eth_dev_priority_flow_ctrl_queue_configure(res->port_id,
+ &pfc_queue_conf);
+ if (ret != 0) {
+ fprintf(stderr,
+ "bad queue priority flow control parameter, rc = %d\n",
+ ret);
+ }
+}
+
+static cmdline_parse_token_string_t cmd_q_pfc_set_set =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ set, "set");
+static cmdline_parse_token_string_t cmd_q_pfc_set_flow_ctrl =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ pfc_queue_ctrl, "pfc_queue_ctrl");
+static cmdline_parse_token_num_t cmd_q_pfc_set_portid =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_q_pfc_set_rx =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ rx, "rx");
+static cmdline_parse_token_string_t cmd_q_pfc_set_rx_mode =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ rx_pfc_mode, "on#off");
+static cmdline_parse_token_num_t cmd_q_pfc_set_tx_qid =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ tx_qid, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_q_pfc_set_tx_tc =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ tx_tc, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_q_pfc_set_tx =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ tx, "tx");
+static cmdline_parse_token_string_t cmd_q_pfc_set_tx_mode =
+ TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ tx_pfc_mode, "on#off");
+static cmdline_parse_token_num_t cmd_q_pfc_set_rx_qid =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ rx_qid, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_q_pfc_set_rx_tc =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ rx_tc, RTE_UINT8);
+static cmdline_parse_token_num_t cmd_q_pfc_set_pause_time =
+ TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result,
+ pause_time, RTE_UINT16);
+
+static cmdline_parse_inst_t cmd_queue_priority_flow_control_set = {
+ .f = cmd_queue_priority_flow_ctrl_set_parsed,
+ .data = NULL,
+ .help_str = "set pfc_queue_ctrl <port_id> rx <on|off> <tx_qid> <tx_tc> "
+ "tx <on|off> <rx_qid> <rx_tc> <pause_time>: "
+ "Configure the Ethernet queue priority flow control",
+ .tokens = {
+ (void *)&cmd_q_pfc_set_set,
+ (void *)&cmd_q_pfc_set_flow_ctrl,
+ (void *)&cmd_q_pfc_set_portid,
+ (void *)&cmd_q_pfc_set_rx,
+ (void *)&cmd_q_pfc_set_rx_mode,
+ (void *)&cmd_q_pfc_set_tx_qid,
+ (void *)&cmd_q_pfc_set_tx_tc,
+ (void *)&cmd_q_pfc_set_tx,
+ (void *)&cmd_q_pfc_set_tx_mode,
+ (void *)&cmd_q_pfc_set_rx_qid,
+ (void *)&cmd_q_pfc_set_rx_tc,
+ (void *)&cmd_q_pfc_set_pause_time,
+ NULL,
+ },
+};
+
/* *** RESET CONFIGURATION *** */
struct cmd_reset_result {
cmdline_fixed_string_t reset;
set_def_fwd_config();
}
-cmdline_parse_token_string_t cmd_reset_set =
+static cmdline_parse_token_string_t cmd_reset_set =
TOKEN_STRING_INITIALIZER(struct cmd_reset_result, reset, "set");
-cmdline_parse_token_string_t cmd_reset_def =
+static cmdline_parse_token_string_t cmd_reset_def =
TOKEN_STRING_INITIALIZER(struct cmd_reset_result, def,
"default");
-cmdline_parse_inst_t cmd_reset = {
+static cmdline_parse_inst_t cmd_reset = {
.f = cmd_reset_parsed,
.data = NULL,
.help_str = "set default: Reset default forwarding configuration",
cmdline_fixed_string_t start;
};
-cmdline_parse_token_string_t cmd_start_start =
+static cmdline_parse_token_string_t cmd_start_start =
TOKEN_STRING_INITIALIZER(struct cmd_start_result, start, "start");
static void cmd_start_parsed(__rte_unused void *parsed_result,
start_packet_forwarding(0);
}
-cmdline_parse_inst_t cmd_start = {
+static cmdline_parse_inst_t cmd_start = {
.f = cmd_start_parsed,
.data = NULL,
.help_str = "start: Start packet forwarding",
start_packet_forwarding(1);
}
-cmdline_parse_token_string_t cmd_start_tx_first_start =
+static cmdline_parse_token_string_t cmd_start_tx_first_start =
TOKEN_STRING_INITIALIZER(struct cmd_start_tx_first_result, start,
"start");
-cmdline_parse_token_string_t cmd_start_tx_first_tx_first =
+static cmdline_parse_token_string_t cmd_start_tx_first_tx_first =
TOKEN_STRING_INITIALIZER(struct cmd_start_tx_first_result,
tx_first, "tx_first");
-cmdline_parse_inst_t cmd_start_tx_first = {
+static cmdline_parse_inst_t cmd_start_tx_first = {
.f = cmd_start_tx_first_parsed,
.data = NULL,
.help_str = "start tx_first: Start packet forwarding, "
start_packet_forwarding(res->tx_num);
}
-cmdline_parse_token_string_t cmd_start_tx_first_n_start =
+static cmdline_parse_token_string_t cmd_start_tx_first_n_start =
TOKEN_STRING_INITIALIZER(struct cmd_start_tx_first_n_result,
start, "start");
-cmdline_parse_token_string_t cmd_start_tx_first_n_tx_first =
+static cmdline_parse_token_string_t cmd_start_tx_first_n_tx_first =
TOKEN_STRING_INITIALIZER(struct cmd_start_tx_first_n_result,
tx_first, "tx_first");
-cmdline_parse_token_num_t cmd_start_tx_first_n_tx_num =
+static 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 = {
+static cmdline_parse_inst_t cmd_start_tx_first_n = {
.f = cmd_start_tx_first_n_parsed,
.data = NULL,
.help_str = "start tx_first <num>: "
portid_t port_id;
};
-cmdline_parse_token_string_t cmd_set_link_up_set =
+static cmdline_parse_token_string_t cmd_set_link_up_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_link_up_result, set, "set");
-cmdline_parse_token_string_t cmd_set_link_up_link_up =
+static cmdline_parse_token_string_t cmd_set_link_up_link_up =
TOKEN_STRING_INITIALIZER(struct cmd_set_link_up_result, link_up,
"link-up");
-cmdline_parse_token_string_t cmd_set_link_up_port =
+static 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);
+static cmdline_parse_token_num_t cmd_set_link_up_port_id =
+ 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,
dev_set_link_up(res->port_id);
}
-cmdline_parse_inst_t cmd_set_link_up = {
+static cmdline_parse_inst_t cmd_set_link_up = {
.f = cmd_set_link_up_parsed,
.data = NULL,
.help_str = "set link-up port <port id>",
portid_t port_id;
};
-cmdline_parse_token_string_t cmd_set_link_down_set =
+static cmdline_parse_token_string_t cmd_set_link_down_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_link_down_result, set, "set");
-cmdline_parse_token_string_t cmd_set_link_down_link_down =
+static cmdline_parse_token_string_t cmd_set_link_down_link_down =
TOKEN_STRING_INITIALIZER(struct cmd_set_link_down_result, link_down,
"link-down");
-cmdline_parse_token_string_t cmd_set_link_down_port =
+static 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);
+static cmdline_parse_token_num_t cmd_set_link_down_port_id =
+ 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,
dev_set_link_down(res->port_id);
}
-cmdline_parse_inst_t cmd_set_link_down = {
+static cmdline_parse_inst_t cmd_set_link_down = {
.f = cmd_set_link_down_parsed,
.data = NULL,
.help_str = "set link-down port <port id>",
show_tx_pkt_times();
}
-cmdline_parse_token_string_t cmd_showcfg_show =
+static cmdline_parse_token_string_t cmd_showcfg_show =
TOKEN_STRING_INITIALIZER(struct cmd_showcfg_result, show, "show");
-cmdline_parse_token_string_t cmd_showcfg_port =
+static 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 =
+static cmdline_parse_token_string_t cmd_showcfg_what =
TOKEN_STRING_INITIALIZER(struct cmd_showcfg_result, what,
"rxtx#cores#fwd#rxoffs#rxpkts#txpkts#txtimes");
-cmdline_parse_inst_t cmd_showcfg = {
+static cmdline_parse_inst_t cmd_showcfg = {
.f = cmd_showcfg_parsed,
.data = NULL,
.help_str = "show config rxtx|cores|fwd|rxoffs|rxpkts|txpkts|txtimes",
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 =
+static cmdline_parse_token_string_t cmd_showportall_show =
TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, show,
"show#clear");
-cmdline_parse_token_string_t cmd_showportall_port =
+static 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 =
+static 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");
-cmdline_parse_token_string_t cmd_showportall_all =
+ "info#summary#stats#xstats#fdir#dcb_tc");
+static cmdline_parse_token_string_t cmd_showportall_all =
TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, all, "all");
-cmdline_parse_inst_t cmd_showportall = {
+static cmdline_parse_inst_t cmd_showportall = {
.f = cmd_showportall_parsed,
.data = NULL,
.help_str = "show|clear port "
- "info|summary|stats|xstats|fdir|stat_qmap|dcb_tc|cap all",
+ "info|summary|stats|xstats|fdir|dcb_tc all",
.tokens = {
(void *)&cmd_showportall_show,
(void *)&cmd_showportall_port,
nic_stats_display(res->portnum);
else if (!strcmp(res->what, "xstats"))
nic_xstats_display(res->portnum);
+#if defined(RTE_NET_I40E) || defined(RTE_NET_IXGBE)
else if (!strcmp(res->what, "fdir"))
fdir_get_infos(res->portnum);
- else if (!strcmp(res->what, "stat_qmap"))
- nic_stats_mapping_display(res->portnum);
+#endif
else if (!strcmp(res->what, "dcb_tc"))
port_dcb_info_display(res->portnum);
- else if (!strcmp(res->what, "cap"))
- port_offload_cap_display(res->portnum);
}
-cmdline_parse_token_string_t cmd_showport_show =
+static cmdline_parse_token_string_t cmd_showport_show =
TOKEN_STRING_INITIALIZER(struct cmd_showport_result, show,
"show#clear");
-cmdline_parse_token_string_t cmd_showport_port =
+static 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 =
+static 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");
-cmdline_parse_token_num_t cmd_showport_portnum =
- TOKEN_NUM_INITIALIZER(struct cmd_showport_result, portnum, UINT16);
+ "info#summary#stats#xstats#fdir#dcb_tc");
+static cmdline_parse_token_num_t cmd_showport_portnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_showport_result, portnum, RTE_UINT16);
-cmdline_parse_inst_t cmd_showport = {
+static cmdline_parse_inst_t cmd_showport = {
.f = cmd_showport_parsed,
.data = NULL,
.help_str = "show|clear port "
- "info|summary|stats|xstats|fdir|stat_qmap|dcb_tc|cap "
+ "info|summary|stats|xstats|fdir|dcb_tc "
"<port_id>",
.tokens = {
(void *)&cmd_showport_show,
},
};
+/* *** 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);
+}
+
+static cmdline_parse_token_string_t cmd_representor_info_show =
+ TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result,
+ cmd_show, "show");
+static cmdline_parse_token_string_t cmd_representor_info_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result,
+ cmd_port, "port");
+static cmdline_parse_token_string_t cmd_representor_info_info =
+ TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result,
+ cmd_info, "info");
+static cmdline_parse_token_num_t cmd_representor_info_pid =
+ TOKEN_NUM_INITIALIZER(struct cmd_representor_info_result,
+ cmd_pid, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_representor_info_keyword =
+ TOKEN_STRING_INITIALIZER(struct cmd_representor_info_result,
+ cmd_keyword, "representor");
+
+static cmdline_parse_inst_t cmd_representor_info = {
+ .f = cmd_representor_info_parsed,
+ .data = NULL,
+ .help_str = "show port info <port_id> 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;
}
}
-cmdline_parse_token_string_t cmd_showdevice_show =
+static cmdline_parse_token_string_t cmd_showdevice_show =
TOKEN_STRING_INITIALIZER(struct cmd_showdevice_result, show,
"show");
-cmdline_parse_token_string_t cmd_showdevice_device =
+static cmdline_parse_token_string_t cmd_showdevice_device =
TOKEN_STRING_INITIALIZER(struct cmd_showdevice_result, device, "device");
-cmdline_parse_token_string_t cmd_showdevice_what =
+static cmdline_parse_token_string_t cmd_showdevice_what =
TOKEN_STRING_INITIALIZER(struct cmd_showdevice_result, what,
"info");
-cmdline_parse_token_string_t cmd_showdevice_identifier =
+static cmdline_parse_token_string_t cmd_showdevice_identifier =
TOKEN_STRING_INITIALIZER(struct cmd_showdevice_result,
identifier, NULL);
-cmdline_parse_inst_t cmd_showdevice = {
+static cmdline_parse_inst_t cmd_showdevice = {
.f = cmd_showdevice_parsed,
.data = NULL,
.help_str = "show device info <identifier>|all",
else if (!strcmp(res->type, "module_eeprom"))
port_module_eeprom_display(res->portnum);
else
- printf("Unknown argument\n");
+ fprintf(stderr, "Unknown argument\n");
}
-cmdline_parse_token_string_t cmd_showeeprom_show =
+static 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 =
+static cmdline_parse_token_string_t cmd_showeeprom_port =
TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, port, "port");
-cmdline_parse_token_num_t cmd_showeeprom_portnum =
- TOKEN_NUM_INITIALIZER(struct cmd_showeeprom_result, portnum, UINT16);
-cmdline_parse_token_string_t cmd_showeeprom_type =
+static cmdline_parse_token_num_t cmd_showeeprom_portnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_showeeprom_result, portnum,
+ RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_showeeprom = {
.f = cmd_showeeprom_parsed,
.data = NULL,
.help_str = "show port <port_id> module_eeprom|eeprom",
tx_queue_infos_display(res->portnum, res->queuenum);
}
-cmdline_parse_token_string_t cmd_showqueue_show =
+static cmdline_parse_token_string_t cmd_showqueue_show =
TOKEN_STRING_INITIALIZER(struct cmd_showqueue_result, show, "show");
-cmdline_parse_token_string_t cmd_showqueue_type =
+static cmdline_parse_token_string_t cmd_showqueue_type =
TOKEN_STRING_INITIALIZER(struct cmd_showqueue_result, type, "rxq#txq");
-cmdline_parse_token_string_t cmd_showqueue_what =
+static 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);
-cmdline_parse_token_num_t cmd_showqueue_queuenum =
- TOKEN_NUM_INITIALIZER(struct cmd_showqueue_result, queuenum, UINT16);
-
-cmdline_parse_inst_t cmd_showqueue = {
+static cmdline_parse_token_num_t cmd_showqueue_portnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_showqueue_result, portnum,
+ RTE_UINT16);
+static cmdline_parse_token_num_t cmd_showqueue_queuenum =
+ TOKEN_NUM_INITIALIZER(struct cmd_showqueue_result, queuenum,
+ RTE_UINT16);
+
+static cmdline_parse_inst_t cmd_showqueue = {
.f = cmd_showqueue_parsed,
.data = NULL,
.help_str = "show rxq|txq info <port_id> <queue_id>",
cmdline_fixed_string_t all;
};
-cmdline_parse_token_string_t cmd_fwd_action =
+static cmdline_parse_token_string_t cmd_fwd_action =
TOKEN_STRING_INITIALIZER(struct fwd_result, action, "show#clear");
-cmdline_parse_token_string_t cmd_fwd_fwd =
+static cmdline_parse_token_string_t cmd_fwd_fwd =
TOKEN_STRING_INITIALIZER(struct fwd_result, fwd, "fwd");
-cmdline_parse_token_string_t cmd_fwd_stats =
+static cmdline_parse_token_string_t cmd_fwd_stats =
TOKEN_STRING_INITIALIZER(struct fwd_result, stats, "stats");
-cmdline_parse_token_string_t cmd_fwd_all =
+static cmdline_parse_token_string_t cmd_fwd_all =
TOKEN_STRING_INITIALIZER(struct fwd_result, all, "all");
static void
port_reg_display(res->port_id, res->reg_off);
}
-cmdline_parse_token_string_t cmd_read_reg_read =
+static cmdline_parse_token_string_t cmd_read_reg_read =
TOKEN_STRING_INITIALIZER(struct cmd_read_reg_result, read, "read");
-cmdline_parse_token_string_t cmd_read_reg_reg =
+static 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);
-cmdline_parse_token_num_t cmd_read_reg_reg_off =
- TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, reg_off, UINT32);
+static cmdline_parse_token_num_t cmd_read_reg_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_read_reg_reg_off =
+ TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, reg_off, RTE_UINT32);
-cmdline_parse_inst_t cmd_read_reg = {
+static cmdline_parse_inst_t cmd_read_reg = {
.f = cmd_read_reg_parsed,
.data = NULL,
.help_str = "read reg <port_id> <reg_off>",
res->bit1_pos, res->bit2_pos);
}
-cmdline_parse_token_string_t cmd_read_reg_bit_field_read =
+static cmdline_parse_token_string_t cmd_read_reg_bit_field_read =
TOKEN_STRING_INITIALIZER(struct cmd_read_reg_bit_field_result, read,
"read");
-cmdline_parse_token_string_t cmd_read_reg_bit_field_regfield =
+static cmdline_parse_token_string_t cmd_read_reg_bit_field_regfield =
TOKEN_STRING_INITIALIZER(struct cmd_read_reg_bit_field_result,
regfield, "regfield");
-cmdline_parse_token_num_t cmd_read_reg_bit_field_port_id =
+static 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);
-cmdline_parse_token_num_t cmd_read_reg_bit_field_reg_off =
+ RTE_UINT16);
+static 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);
-cmdline_parse_token_num_t cmd_read_reg_bit_field_bit1_pos =
+ RTE_UINT32);
+static 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);
-cmdline_parse_token_num_t cmd_read_reg_bit_field_bit2_pos =
+ RTE_UINT8);
+static 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 = {
+static cmdline_parse_inst_t cmd_read_reg_bit_field = {
.f = cmd_read_reg_bit_field_parsed,
.data = NULL,
.help_str = "read regfield <port_id> <reg_off> <bit_x> <bit_y>: "
port_reg_bit_display(res->port_id, res->reg_off, res->bit_pos);
}
-cmdline_parse_token_string_t cmd_read_reg_bit_read =
+static cmdline_parse_token_string_t cmd_read_reg_bit_read =
TOKEN_STRING_INITIALIZER(struct cmd_read_reg_bit_result, read, "read");
-cmdline_parse_token_string_t cmd_read_reg_bit_regbit =
+static 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);
-cmdline_parse_token_num_t cmd_read_reg_bit_reg_off =
- TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, reg_off, UINT32);
-cmdline_parse_token_num_t cmd_read_reg_bit_bit_pos =
- TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, bit_pos, UINT8);
-
-cmdline_parse_inst_t cmd_read_reg_bit = {
+static cmdline_parse_token_num_t cmd_read_reg_bit_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, port_id,
+ RTE_UINT16);
+static cmdline_parse_token_num_t cmd_read_reg_bit_reg_off =
+ TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, reg_off,
+ RTE_UINT32);
+static cmdline_parse_token_num_t cmd_read_reg_bit_bit_pos =
+ TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, bit_pos,
+ RTE_UINT8);
+
+static cmdline_parse_inst_t cmd_read_reg_bit = {
.f = cmd_read_reg_bit_parsed,
.data = NULL,
.help_str = "read regbit <port_id> <reg_off> <bit_x>: 0 <= bit_x <= 31",
port_reg_set(res->port_id, res->reg_off, res->value);
}
-cmdline_parse_token_string_t cmd_write_reg_write =
+static cmdline_parse_token_string_t cmd_write_reg_write =
TOKEN_STRING_INITIALIZER(struct cmd_write_reg_result, write, "write");
-cmdline_parse_token_string_t cmd_write_reg_reg =
+static 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);
-cmdline_parse_token_num_t cmd_write_reg_reg_off =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, reg_off, UINT32);
-cmdline_parse_token_num_t cmd_write_reg_value =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, value, UINT32);
-
-cmdline_parse_inst_t cmd_write_reg = {
+static cmdline_parse_token_num_t cmd_write_reg_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_write_reg_reg_off =
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, reg_off, RTE_UINT32);
+static cmdline_parse_token_num_t cmd_write_reg_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, value, RTE_UINT32);
+
+static cmdline_parse_inst_t cmd_write_reg = {
.f = cmd_write_reg_parsed,
.data = NULL,
.help_str = "write reg <port_id> <reg_off> <reg_value>",
res->bit1_pos, res->bit2_pos, res->value);
}
-cmdline_parse_token_string_t cmd_write_reg_bit_field_write =
+static cmdline_parse_token_string_t cmd_write_reg_bit_field_write =
TOKEN_STRING_INITIALIZER(struct cmd_write_reg_bit_field_result, write,
"write");
-cmdline_parse_token_string_t cmd_write_reg_bit_field_regfield =
+static cmdline_parse_token_string_t cmd_write_reg_bit_field_regfield =
TOKEN_STRING_INITIALIZER(struct cmd_write_reg_bit_field_result,
regfield, "regfield");
-cmdline_parse_token_num_t cmd_write_reg_bit_field_port_id =
+static 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);
-cmdline_parse_token_num_t cmd_write_reg_bit_field_reg_off =
+ RTE_UINT16);
+static 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);
-cmdline_parse_token_num_t cmd_write_reg_bit_field_bit1_pos =
+ RTE_UINT32);
+static 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);
-cmdline_parse_token_num_t cmd_write_reg_bit_field_bit2_pos =
+ RTE_UINT8);
+static 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);
-cmdline_parse_token_num_t cmd_write_reg_bit_field_value =
+ RTE_UINT8);
+static 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 = {
+static cmdline_parse_inst_t cmd_write_reg_bit_field = {
.f = cmd_write_reg_bit_field_parsed,
.data = NULL,
.help_str = "write regfield <port_id> <reg_off> <bit_x> <bit_y> "
port_reg_bit_set(res->port_id, res->reg_off, res->bit_pos, res->value);
}
-cmdline_parse_token_string_t cmd_write_reg_bit_write =
+static cmdline_parse_token_string_t cmd_write_reg_bit_write =
TOKEN_STRING_INITIALIZER(struct cmd_write_reg_bit_result, write,
"write");
-cmdline_parse_token_string_t cmd_write_reg_bit_regbit =
+static 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);
-cmdline_parse_token_num_t cmd_write_reg_bit_reg_off =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, reg_off, UINT32);
-cmdline_parse_token_num_t cmd_write_reg_bit_bit_pos =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, bit_pos, UINT8);
-cmdline_parse_token_num_t cmd_write_reg_bit_value =
- TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, value, UINT8);
-
-cmdline_parse_inst_t cmd_write_reg_bit = {
+static cmdline_parse_token_num_t cmd_write_reg_bit_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, port_id,
+ RTE_UINT16);
+static cmdline_parse_token_num_t cmd_write_reg_bit_reg_off =
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, reg_off,
+ RTE_UINT32);
+static cmdline_parse_token_num_t cmd_write_reg_bit_bit_pos =
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, bit_pos,
+ RTE_UINT8);
+static cmdline_parse_token_num_t cmd_write_reg_bit_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, value,
+ RTE_UINT8);
+
+static cmdline_parse_inst_t cmd_write_reg_bit = {
.f = cmd_write_reg_bit_parsed,
.data = NULL,
.help_str = "write regbit <port_id> <reg_off> <bit_x> 0|1: "
tx_ring_desc_display(res->port_id, res->queue_id, res->desc_id);
}
-cmdline_parse_token_string_t cmd_read_rxd_txd_read =
+static cmdline_parse_token_string_t cmd_read_rxd_txd_read =
TOKEN_STRING_INITIALIZER(struct cmd_read_rxd_txd_result, read, "read");
-cmdline_parse_token_string_t cmd_read_rxd_txd_rxd_txd =
+static 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);
-cmdline_parse_token_num_t cmd_read_rxd_txd_queue_id =
- TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, queue_id, UINT16);
-cmdline_parse_token_num_t cmd_read_rxd_txd_desc_id =
- TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, desc_id, UINT16);
-
-cmdline_parse_inst_t cmd_read_rxd_txd = {
+static cmdline_parse_token_num_t cmd_read_rxd_txd_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, port_id,
+ RTE_UINT16);
+static cmdline_parse_token_num_t cmd_read_rxd_txd_queue_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, queue_id,
+ RTE_UINT16);
+static cmdline_parse_token_num_t cmd_read_rxd_txd_desc_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, desc_id,
+ RTE_UINT16);
+
+static cmdline_parse_inst_t cmd_read_rxd_txd = {
.f = cmd_read_rxd_txd_parsed,
.data = NULL,
.help_str = "read rxd|txd <port_id> <queue_id> <desc_id>",
cmdline_quit(cl);
}
-cmdline_parse_token_string_t cmd_quit_quit =
+static cmdline_parse_token_string_t cmd_quit_quit =
TOKEN_STRING_INITIALIZER(struct cmd_quit_result, quit, "quit");
-cmdline_parse_inst_t cmd_quit = {
+static cmdline_parse_inst_t cmd_quit = {
.f = cmd_quit_parsed,
.data = NULL,
.help_str = "quit: Exit application",
/* 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));
}
-cmdline_parse_token_string_t cmd_mac_addr_cmd =
+static cmdline_parse_token_string_t cmd_mac_addr_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_mac_addr_result, mac_addr_cmd,
"mac_addr");
-cmdline_parse_token_string_t cmd_mac_addr_what =
+static cmdline_parse_token_string_t cmd_mac_addr_what =
TOKEN_STRING_INITIALIZER(struct cmd_mac_addr_result, what,
"add#remove#set");
-cmdline_parse_token_num_t cmd_mac_addr_portnum =
+static cmdline_parse_token_num_t cmd_mac_addr_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_mac_addr_result, port_num,
- UINT16);
-cmdline_parse_token_etheraddr_t cmd_mac_addr_addr =
+ RTE_UINT16);
+static cmdline_parse_token_etheraddr_t cmd_mac_addr_addr =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address);
-cmdline_parse_inst_t cmd_mac_addr = {
+static cmdline_parse_inst_t cmd_mac_addr = {
.f = cmd_mac_addr_parsed,
.data = (void *)0,
.help_str = "mac_addr add|remove|set <port_id> <mac_addr>: "
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")) {
fwd_config_setup();
}
}
-cmdline_parse_token_string_t cmd_eth_peer_set =
+static cmdline_parse_token_string_t cmd_eth_peer_set =
TOKEN_STRING_INITIALIZER(struct cmd_eth_peer_result, set, "set");
-cmdline_parse_token_string_t cmd_eth_peer =
+static 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);
-cmdline_parse_token_string_t cmd_eth_peer_addr =
+static cmdline_parse_token_num_t cmd_eth_peer_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_eth_peer_result, port_id,
+ RTE_UINT16);
+static cmdline_parse_token_string_t cmd_eth_peer_addr =
TOKEN_STRING_INITIALIZER(struct cmd_eth_peer_result, peer_addr, NULL);
-cmdline_parse_inst_t cmd_set_fwd_eth_peer = {
+static cmdline_parse_inst_t cmd_set_fwd_eth_peer = {
.f = cmd_set_eth_peer_parsed,
.data = NULL,
.help_str = "set eth-peer <port_id> <peer_mac>",
set_qmap(res->port_id, (uint8_t)is_rx, res->queue_id, res->map_value);
}
-cmdline_parse_token_string_t cmd_setqmap_set =
+static cmdline_parse_token_string_t cmd_setqmap_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_qmap_result,
set, "set");
-cmdline_parse_token_string_t cmd_setqmap_qmap =
+static cmdline_parse_token_string_t cmd_setqmap_qmap =
TOKEN_STRING_INITIALIZER(struct cmd_set_qmap_result,
qmap, "stat_qmap");
-cmdline_parse_token_string_t cmd_setqmap_what =
+static cmdline_parse_token_string_t cmd_setqmap_what =
TOKEN_STRING_INITIALIZER(struct cmd_set_qmap_result,
what, "tx#rx");
-cmdline_parse_token_num_t cmd_setqmap_portid =
+static cmdline_parse_token_num_t cmd_setqmap_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_qmap_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_setqmap_queueid =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_setqmap_queueid =
TOKEN_NUM_INITIALIZER(struct cmd_set_qmap_result,
- queue_id, UINT16);
-cmdline_parse_token_num_t cmd_setqmap_mapvalue =
+ queue_id, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_set_qmap = {
.f = cmd_set_qmap_parsed,
.data = NULL,
.help_str = "set stat_qmap rx|tx <port_id> <queue_id> <map_value>: "
set_xstats_hide_zero(on_off);
}
-cmdline_parse_token_string_t cmd_set_xstats_hide_zero_keyword =
+static cmdline_parse_token_string_t cmd_set_xstats_hide_zero_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_set_xstats_hide_zero_result,
keyword, "set");
-cmdline_parse_token_string_t cmd_set_xstats_hide_zero_name =
+static cmdline_parse_token_string_t cmd_set_xstats_hide_zero_name =
TOKEN_STRING_INITIALIZER(struct cmd_set_xstats_hide_zero_result,
name, "xstats-hide-zero");
-cmdline_parse_token_string_t cmd_set_xstats_hide_zero_on_off =
+static cmdline_parse_token_string_t cmd_set_xstats_hide_zero_on_off =
TOKEN_STRING_INITIALIZER(struct cmd_set_xstats_hide_zero_result,
on_off, "on#off");
-cmdline_parse_inst_t cmd_set_xstats_hide_zero = {
+static cmdline_parse_inst_t cmd_set_xstats_hide_zero = {
.f = cmd_set_xstats_hide_zero_parsed,
.data = NULL,
.help_str = "set xstats-hide-zero on|off",
set_record_core_cycles(on_off);
}
-cmdline_parse_token_string_t cmd_set_record_core_cycles_keyword =
+static 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 =
+static 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 =
+static 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 = {
+static 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",
set_record_burst_stats(on_off);
}
-cmdline_parse_token_string_t cmd_set_record_burst_stats_keyword =
+static 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 =
+static 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 =
+static 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 = {
+static 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",
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);
}
-cmdline_parse_token_string_t cmd_set_uc_hash_set =
+static cmdline_parse_token_string_t cmd_set_uc_hash_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table,
set, "set");
-cmdline_parse_token_string_t cmd_set_uc_hash_port =
+static cmdline_parse_token_string_t cmd_set_uc_hash_port =
TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table,
port, "port");
-cmdline_parse_token_num_t cmd_set_uc_hash_portid =
+static cmdline_parse_token_num_t cmd_set_uc_hash_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_uc_hash_table,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_uc_hash_what =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_uc_hash_what =
TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table,
what, "uta");
-cmdline_parse_token_etheraddr_t cmd_set_uc_hash_mac =
+static cmdline_parse_token_etheraddr_t cmd_set_uc_hash_mac =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_uc_hash_table,
address);
-cmdline_parse_token_string_t cmd_set_uc_hash_mode =
+static cmdline_parse_token_string_t cmd_set_uc_hash_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table,
mode, "on#off");
-cmdline_parse_inst_t cmd_set_uc_hash_filter = {
+static cmdline_parse_inst_t cmd_set_uc_hash_filter = {
.f = cmd_set_uc_hash_parsed,
.data = NULL,
.help_str = "set port <port_id> uta <mac_addr> on|off)",
(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 =
+static cmdline_parse_token_string_t cmd_set_uc_all_hash_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table,
set, "set");
-cmdline_parse_token_string_t cmd_set_uc_all_hash_port =
+static cmdline_parse_token_string_t cmd_set_uc_all_hash_port =
TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table,
port, "port");
-cmdline_parse_token_num_t cmd_set_uc_all_hash_portid =
+static cmdline_parse_token_num_t cmd_set_uc_all_hash_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_uc_all_hash_table,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_uc_all_hash_what =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_uc_all_hash_what =
TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table,
what, "uta");
-cmdline_parse_token_string_t cmd_set_uc_all_hash_value =
+static cmdline_parse_token_string_t cmd_set_uc_all_hash_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table,
value,"all");
-cmdline_parse_token_string_t cmd_set_uc_all_hash_mode =
+static cmdline_parse_token_string_t cmd_set_uc_all_hash_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table,
mode, "on#off");
-cmdline_parse_inst_t cmd_set_uc_all_hash_filter = {
+static cmdline_parse_inst_t cmd_set_uc_all_hash_filter = {
.f = cmd_set_uc_all_hash_parsed,
.data = NULL,
.help_str = "set port <port_id> uta all on|off",
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 =
+static cmdline_parse_token_string_t cmd_setvf_traffic_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
set, "set");
-cmdline_parse_token_string_t cmd_setvf_traffic_port =
+static cmdline_parse_token_string_t cmd_setvf_traffic_port =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
port, "port");
-cmdline_parse_token_num_t cmd_setvf_traffic_portid =
+static cmdline_parse_token_num_t cmd_setvf_traffic_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_setvf_traffic_vf =
+ port_id, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_setvf_traffic_vfid =
TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic,
- vf_id, UINT8);
-cmdline_parse_token_string_t cmd_setvf_traffic_what =
+ vf_id, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_setvf_traffic_what =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
what, "tx#rx");
-cmdline_parse_token_string_t cmd_setvf_traffic_mode =
+static cmdline_parse_token_string_t cmd_setvf_traffic_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
mode, "on#off");
-cmdline_parse_inst_t cmd_set_vf_traffic = {
+static cmdline_parse_inst_t cmd_set_vf_traffic = {
.f = cmd_set_vf_traffic_parsed,
.data = NULL,
.help_str = "set port <port_id> vf <vf_id> rx|tx on|off",
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);
+ RTE_SET_USED(vf_rxmode);
#ifdef RTE_NET_IXGBE
if (ret == -ENOTSUP)
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 =
+static cmdline_parse_token_string_t cmd_set_vf_rxmode_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
set, "set");
-cmdline_parse_token_string_t cmd_set_vf_rxmode_port =
+static cmdline_parse_token_string_t cmd_set_vf_rxmode_port =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
port, "port");
-cmdline_parse_token_num_t cmd_set_vf_rxmode_portid =
+static cmdline_parse_token_num_t cmd_set_vf_rxmode_portid =
TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_vf_rxmode_vf =
+ port_id, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_set_vf_rxmode_vfid =
TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode,
- vf_id, UINT8);
-cmdline_parse_token_string_t cmd_set_vf_rxmode_what =
+ vf_id, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_set_vf_rxmode_what =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
what, "rxmode");
-cmdline_parse_token_string_t cmd_set_vf_rxmode_mode =
+static cmdline_parse_token_string_t cmd_set_vf_rxmode_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
mode, "AUPE#ROPE#BAM#MPE");
-cmdline_parse_token_string_t cmd_set_vf_rxmode_on =
+static cmdline_parse_token_string_t cmd_set_vf_rxmode_on =
TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
on, "on#off");
-cmdline_parse_inst_t cmd_set_vf_rxmode = {
+static cmdline_parse_inst_t cmd_set_vf_rxmode = {
.f = cmd_set_vf_rxmode_parsed,
.data = NULL,
.help_str = "set port <port_id> vf <vf_id> rxmode "
#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));
}
-cmdline_parse_token_string_t cmd_vf_mac_addr_cmd =
+static cmdline_parse_token_string_t cmd_vf_mac_addr_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result,
mac_addr_cmd,"mac_addr");
-cmdline_parse_token_string_t cmd_vf_mac_addr_what =
+static cmdline_parse_token_string_t cmd_vf_mac_addr_what =
TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result,
what,"add");
-cmdline_parse_token_string_t cmd_vf_mac_addr_port =
+static cmdline_parse_token_string_t cmd_vf_mac_addr_port =
TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result,
port,"port");
-cmdline_parse_token_num_t cmd_vf_mac_addr_portnum =
+static cmdline_parse_token_num_t cmd_vf_mac_addr_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result,
- port_num, UINT16);
-cmdline_parse_token_string_t cmd_vf_mac_addr_vf =
+ port_num, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_vf_mac_addr_vfnum =
TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result,
- vf_num, UINT8);
-cmdline_parse_token_etheraddr_t cmd_vf_mac_addr_addr =
+ vf_num, RTE_UINT8);
+static cmdline_parse_token_etheraddr_t cmd_vf_mac_addr_addr =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_vf_mac_addr_result,
address);
-cmdline_parse_inst_t cmd_vf_mac_addr_filter = {
+static cmdline_parse_inst_t cmd_vf_mac_addr_filter = {
.f = cmd_vf_mac_addr_parsed,
.data = (void *)0,
.help_str = "mac_addr add port <port_id> vf <vf_id> <mac_addr>: "
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));
}
}
-cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_rx_vlan =
+static cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_rx_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter,
rx_vlan, "rx_vlan");
-cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_what =
+static cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_what =
TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter,
what, "add#rm");
-cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vlanid =
+static cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vlanid =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter,
- vlan_id, UINT16);
-cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_port =
+ vlan_id, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_portid =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_vf =
+ port_id, RTE_UINT16);
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_vf_rxvlan_filter = {
.f = cmd_vf_rx_vlan_filter_parsed,
.data = NULL,
.help_str = "rx_vlan add|rm <vlan_id> port <port_id> vf <vf_mask>: "
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));
}
-cmdline_parse_token_string_t cmd_queue_rate_limit_set =
+static cmdline_parse_token_string_t cmd_queue_rate_limit_set =
TOKEN_STRING_INITIALIZER(struct cmd_queue_rate_limit_result,
set, "set");
-cmdline_parse_token_string_t cmd_queue_rate_limit_port =
+static cmdline_parse_token_string_t cmd_queue_rate_limit_port =
TOKEN_STRING_INITIALIZER(struct cmd_queue_rate_limit_result,
port, "port");
-cmdline_parse_token_num_t cmd_queue_rate_limit_portnum =
+static cmdline_parse_token_num_t cmd_queue_rate_limit_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_queue_rate_limit_result,
- port_num, UINT16);
-cmdline_parse_token_string_t cmd_queue_rate_limit_queue =
+ port_num, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_queue_rate_limit_queuenum =
TOKEN_NUM_INITIALIZER(struct cmd_queue_rate_limit_result,
- queue_num, UINT8);
-cmdline_parse_token_string_t cmd_queue_rate_limit_rate =
+ queue_num, RTE_UINT8);
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_queue_rate_limit = {
.f = cmd_queue_rate_limit_parsed,
.data = (void *)0,
.help_str = "set port <port_id> queue <queue_id> rate <rate_value>: "
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));
}
-cmdline_parse_token_string_t cmd_vf_rate_limit_set =
+static cmdline_parse_token_string_t cmd_vf_rate_limit_set =
TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result,
set, "set");
-cmdline_parse_token_string_t cmd_vf_rate_limit_port =
+static cmdline_parse_token_string_t cmd_vf_rate_limit_port =
TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result,
port, "port");
-cmdline_parse_token_num_t cmd_vf_rate_limit_portnum =
+static cmdline_parse_token_num_t cmd_vf_rate_limit_portnum =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result,
- port_num, UINT16);
-cmdline_parse_token_string_t cmd_vf_rate_limit_vf =
+ port_num, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_vf_rate_limit_vfnum =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result,
- vf_num, UINT8);
-cmdline_parse_token_string_t cmd_vf_rate_limit_rate =
+ vf_num, RTE_UINT8);
+static 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 =
+static cmdline_parse_token_num_t cmd_vf_rate_limit_ratenum =
TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result,
- rate_num, UINT16);
-cmdline_parse_token_string_t cmd_vf_rate_limit_q_msk =
+ rate_num, RTE_UINT16);
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_vf_rate_limit = {
.f = cmd_vf_rate_limit_parsed,
.data = (void *)0,
.help_str = "set port <port_id> vf <vf_id> rate <rate_value> "
/* *** CONFIGURE TUNNEL UDP PORT *** */
struct cmd_tunnel_udp_config {
- cmdline_fixed_string_t cmd;
+ cmdline_fixed_string_t rx_vxlan_port;
cmdline_fixed_string_t what;
uint16_t udp_port;
portid_t port_id;
int ret;
tunnel_udp.udp_port = res->udp_port;
-
- if (!strcmp(res->cmd, "rx_vxlan_port"))
- tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN;
+ tunnel_udp.prot_type = RTE_ETH_TUNNEL_TYPE_VXLAN;
if (!strcmp(res->what, "add"))
ret = rte_eth_dev_udp_tunnel_port_add(res->port_id,
&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 =
+static cmdline_parse_token_string_t cmd_tunnel_udp_config_rx_vxlan_port =
TOKEN_STRING_INITIALIZER(struct cmd_tunnel_udp_config,
- cmd, "rx_vxlan_port");
-cmdline_parse_token_string_t cmd_tunnel_udp_config_what =
+ rx_vxlan_port, "rx_vxlan_port");
+static 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 =
+static cmdline_parse_token_num_t cmd_tunnel_udp_config_udp_port =
TOKEN_NUM_INITIALIZER(struct cmd_tunnel_udp_config,
- udp_port, UINT16);
-cmdline_parse_token_num_t cmd_tunnel_udp_config_port_id =
+ udp_port, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_tunnel_udp_config = {
.f = cmd_tunnel_udp_config_parsed,
.data = (void *)0,
.help_str = "rx_vxlan_port add|rm <udp_port> <port_id>: "
"Add/Remove a tunneling UDP port filter",
.tokens = {
- (void *)&cmd_tunnel_udp_config_cmd,
+ (void *)&cmd_tunnel_udp_config_rx_vxlan_port,
(void *)&cmd_tunnel_udp_config_what,
(void *)&cmd_tunnel_udp_config_udp_port,
(void *)&cmd_tunnel_udp_config_port_id,
tunnel_udp.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;
}
&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 =
+static cmdline_parse_token_string_t cmd_config_tunnel_udp_port_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_tunnel_udp_port, port,
"port");
-cmdline_parse_token_string_t cmd_config_tunnel_udp_port_config =
+static cmdline_parse_token_string_t cmd_config_tunnel_udp_port_config =
TOKEN_STRING_INITIALIZER(struct cmd_config_tunnel_udp_port, config,
"config");
-cmdline_parse_token_num_t cmd_config_tunnel_udp_port_port_id =
+static cmdline_parse_token_num_t cmd_config_tunnel_udp_port_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_config_tunnel_udp_port, port_id,
- UINT16);
-cmdline_parse_token_string_t cmd_config_tunnel_udp_port_tunnel_port =
+ RTE_UINT16);
+static cmdline_parse_token_string_t cmd_config_tunnel_udp_port_tunnel_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_tunnel_udp_port,
udp_tunnel_port,
"udp_tunnel_port");
-cmdline_parse_token_string_t cmd_config_tunnel_udp_port_action =
+static cmdline_parse_token_string_t cmd_config_tunnel_udp_port_action =
TOKEN_STRING_INITIALIZER(struct cmd_config_tunnel_udp_port, action,
"add#rm");
-cmdline_parse_token_string_t cmd_config_tunnel_udp_port_tunnel_type =
+static 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");
-cmdline_parse_token_num_t cmd_config_tunnel_udp_port_value =
+ "vxlan#geneve#vxlan-gpe#ecpri");
+static 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 = {
+static cmdline_parse_inst_t cmd_cfg_tunnel_udp_port = {
.f = cmd_cfg_tunnel_udp_port_parsed,
.data = NULL,
- .help_str = "port config <port_id> udp_tunnel_port add|rm vxlan|geneve|vxlan-gpe <udp_port>",
+ .help_str = "port config <port_id> udp_tunnel_port add|rm vxlan|"
+ "geneve|vxlan-gpe|ecpri <udp_port>",
.tokens = {
(void *)&cmd_config_tunnel_udp_port_port,
(void *)&cmd_config_tunnel_udp_port_config,
},
};
-/* *** 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 <port_id> mirror-rule <rule_id> "
- "pool-mirror-up|pool-mirror-down|vlan-mirror "
- "<pool_mask|vlan_id[,vlan_id]*> dst-pool <pool_id> 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 <port_id> mirror-rule <rule_id> "
- "uplink-mirror|downlink-mirror dst-pool <pool_id> 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 <port_id> mirror-rule <rule_id>",
- .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 {
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)
rte_log_dump(stdout);
}
-cmdline_parse_token_string_t cmd_dump_dump =
+static cmdline_parse_token_string_t cmd_dump_dump =
TOKEN_STRING_INITIALIZER(struct cmd_dump_result, dump,
"dump_physmem#"
"dump_memzone#"
"dump_devargs#"
"dump_log_types");
-cmdline_parse_inst_t cmd_dump = {
+static cmdline_parse_inst_t cmd_dump = {
.f = cmd_dump_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = "Dump status",
}
}
-cmdline_parse_token_string_t cmd_dump_one_dump =
+static cmdline_parse_token_string_t cmd_dump_one_dump =
TOKEN_STRING_INITIALIZER(struct cmd_dump_one_result, dump,
"dump_ring#dump_mempool");
-cmdline_parse_token_string_t cmd_dump_one_name =
+static cmdline_parse_token_string_t cmd_dump_one_name =
TOKEN_STRING_INITIALIZER(struct cmd_dump_one_result, name, NULL);
-cmdline_parse_inst_t cmd_dump_one = {
+static cmdline_parse_inst_t cmd_dump_one = {
.f = cmd_dump_one_parsed, /* function to call */
.data = NULL, /* 2nd arg of func */
.help_str = "dump_ring|dump_mempool <name>: Dump one ring/mempool",
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));
}
}
-cmdline_parse_token_string_t cmd_queue_region_set =
+static cmdline_parse_token_string_t cmd_queue_region_set =
TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
set, "set");
-cmdline_parse_token_string_t cmd_queue_region_port =
+static 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 =
+static cmdline_parse_token_num_t cmd_queue_region_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_queue_region_cmd =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_queue_region_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
cmd, "queue-region");
-cmdline_parse_token_string_t cmd_queue_region_id =
+static cmdline_parse_token_string_t cmd_queue_region_id =
TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
region, "region_id");
-cmdline_parse_token_num_t cmd_queue_region_index =
+static cmdline_parse_token_num_t cmd_queue_region_index =
TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
- region_id, UINT8);
-cmdline_parse_token_string_t cmd_queue_region_queue_start_index =
+ region_id, RTE_UINT8);
+static 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 =
+static cmdline_parse_token_num_t cmd_queue_region_queue_id =
TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
- queue_id, UINT8);
-cmdline_parse_token_string_t cmd_queue_region_queue_num =
+ queue_id, RTE_UINT8);
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_queue_region = {
.f = cmd_queue_region_parsed,
.data = NULL,
.help_str = "set port <port_id> queue-region region_id <value> "
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));
}
}
-cmdline_parse_token_string_t cmd_region_flowtype_set =
+static cmdline_parse_token_string_t cmd_region_flowtype_set =
TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
set, "set");
-cmdline_parse_token_string_t cmd_region_flowtype_port =
+static cmdline_parse_token_string_t cmd_region_flowtype_port =
TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
port, "port");
-cmdline_parse_token_num_t cmd_region_flowtype_port_index =
+static cmdline_parse_token_num_t cmd_region_flowtype_port_index =
TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_region_flowtype_cmd =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_region_flowtype_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
cmd, "queue-region");
-cmdline_parse_token_string_t cmd_region_flowtype_index =
+static cmdline_parse_token_string_t cmd_region_flowtype_index =
TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
region, "region_id");
-cmdline_parse_token_num_t cmd_region_flowtype_id =
+static cmdline_parse_token_num_t cmd_region_flowtype_id =
TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
- region_id, UINT8);
-cmdline_parse_token_string_t cmd_region_flowtype_flow_index =
+ region_id, RTE_UINT8);
+static 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 =
+static cmdline_parse_token_num_t cmd_region_flowtype_flow_id =
TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
- flowtype_id, UINT8);
-cmdline_parse_inst_t cmd_region_flowtype = {
+ flowtype_id, RTE_UINT8);
+static cmdline_parse_inst_t cmd_region_flowtype = {
.f = cmd_region_flowtype_parsed,
.data = NULL,
.help_str = "set port <port_id> queue-region region_id <value> "
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));
}
}
-cmdline_parse_token_string_t cmd_user_priority_region_set =
+static cmdline_parse_token_string_t cmd_user_priority_region_set =
TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
set, "set");
-cmdline_parse_token_string_t cmd_user_priority_region_port =
+static cmdline_parse_token_string_t cmd_user_priority_region_port =
TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
port, "port");
-cmdline_parse_token_num_t cmd_user_priority_region_port_index =
+static cmdline_parse_token_num_t cmd_user_priority_region_port_index =
TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_user_priority_region_cmd =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_user_priority_region_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
cmd, "queue-region");
-cmdline_parse_token_string_t cmd_user_priority_region_UP =
+static cmdline_parse_token_string_t cmd_user_priority_region_UP =
TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
user_priority, "UP");
-cmdline_parse_token_num_t cmd_user_priority_region_UP_id =
+static cmdline_parse_token_num_t cmd_user_priority_region_UP_id =
TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
- user_priority_id, UINT8);
-cmdline_parse_token_string_t cmd_user_priority_region_region =
+ user_priority_id, RTE_UINT8);
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_user_priority_region = {
.f = cmd_user_priority_region_parsed,
.data = NULL,
.help_str = "set port <port_id> queue-region UP <value> "
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));
}
}
-cmdline_parse_token_string_t cmd_flush_queue_region_set =
+static cmdline_parse_token_string_t cmd_flush_queue_region_set =
TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
set, "set");
-cmdline_parse_token_string_t cmd_flush_queue_region_port =
+static cmdline_parse_token_string_t cmd_flush_queue_region_port =
TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
port, "port");
-cmdline_parse_token_num_t cmd_flush_queue_region_port_index =
+static cmdline_parse_token_num_t cmd_flush_queue_region_port_index =
TOKEN_NUM_INITIALIZER(struct cmd_flush_queue_region_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_flush_queue_region_cmd =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_flush_queue_region_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
cmd, "queue-region");
-cmdline_parse_token_string_t cmd_flush_queue_region_flush =
+static cmdline_parse_token_string_t cmd_flush_queue_region_flush =
TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
flush, "flush");
-cmdline_parse_token_string_t cmd_flush_queue_region_what =
+static cmdline_parse_token_string_t cmd_flush_queue_region_what =
TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
what, "on#off");
-cmdline_parse_inst_t cmd_flush_queue_region = {
+static cmdline_parse_inst_t cmd_flush_queue_region = {
.f = cmd_flush_queue_region_parsed,
.data = NULL,
.help_str = "set port <port_id> queue-region flush on|off"
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));
}
}
-cmdline_parse_token_string_t cmd_show_queue_region_info_get =
+static cmdline_parse_token_string_t cmd_show_queue_region_info_get =
TOKEN_STRING_INITIALIZER(struct cmd_show_queue_region_info,
show, "show");
-cmdline_parse_token_string_t cmd_show_queue_region_info_port =
+static cmdline_parse_token_string_t cmd_show_queue_region_info_port =
TOKEN_STRING_INITIALIZER(struct cmd_show_queue_region_info,
port, "port");
-cmdline_parse_token_num_t cmd_show_queue_region_info_port_index =
+static cmdline_parse_token_num_t cmd_show_queue_region_info_port_index =
TOKEN_NUM_INITIALIZER(struct cmd_show_queue_region_info,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_show_queue_region_info_cmd =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_show_queue_region_info_cmd =
TOKEN_STRING_INITIALIZER(struct cmd_show_queue_region_info,
cmd, "queue-region");
-cmdline_parse_inst_t cmd_show_queue_region_info_all = {
+static cmdline_parse_inst_t cmd_show_queue_region_info_all = {
.f = cmd_show_queue_region_info_parsed,
.data = NULL,
.help_str = "show port <port_id> queue-region"
/* *** Filters Control *** */
-/* *** deal with flow director filter *** */
-struct cmd_flow_director_result {
- cmdline_fixed_string_t flow_director_filter;
- portid_t port_id;
- cmdline_fixed_string_t mode;
- cmdline_fixed_string_t mode_value;
- cmdline_fixed_string_t ops;
- cmdline_fixed_string_t flow;
- cmdline_fixed_string_t flow_type;
- cmdline_fixed_string_t ether;
- uint16_t ether_type;
- cmdline_fixed_string_t src;
- cmdline_ipaddr_t ip_src;
- uint16_t port_src;
- cmdline_fixed_string_t dst;
- cmdline_ipaddr_t ip_dst;
- uint16_t port_dst;
- cmdline_fixed_string_t verify_tag;
- uint32_t verify_tag_value;
- cmdline_fixed_string_t tos;
- uint8_t tos_value;
- cmdline_fixed_string_t proto;
- uint8_t proto_value;
- cmdline_fixed_string_t ttl;
- uint8_t ttl_value;
- cmdline_fixed_string_t vlan;
- uint16_t vlan_value;
- cmdline_fixed_string_t flexbytes;
- cmdline_fixed_string_t flexbytes_value;
- cmdline_fixed_string_t pf_vf;
- cmdline_fixed_string_t drop;
- cmdline_fixed_string_t queue;
- uint16_t queue_id;
- cmdline_fixed_string_t fd_id;
- uint32_t fd_id_value;
- cmdline_fixed_string_t mac;
- struct rte_ether_addr mac_addr;
- cmdline_fixed_string_t tunnel;
- cmdline_fixed_string_t tunnel_type;
- cmdline_fixed_string_t tunnel_id;
- uint32_t tunnel_id_value;
- cmdline_fixed_string_t packet;
- char filepath[];
-};
+#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)
-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;
+#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)
- snprintf(s, sizeof(s), "%.*s", size, p);
- ret = rte_strsplit(s, sizeof(s), str_fld, max_num, ',');
- if (ret < 0 || ret > max_num)
- return -1;
- for (i = 0; i < ret; i++) {
- errno = 0;
- int_fld = strtoul(str_fld[i], &end, 0);
- if (errno != 0 || *end != '\0' || int_fld > UINT8_MAX)
- return -1;
- flexbytes[i] = (uint8_t)int_fld;
- }
- return ret;
-}
+#ifdef RTE_NET_I40E
static uint16_t
str2flowtype(char *string)
{"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},
};
for (i = 0; i < RTE_DIM(flowtype_str); i++) {
return RTE_ETH_FLOW_UNKNOWN;
}
-static enum rte_eth_fdir_tunnel_type
-str2fdir_tunneltype(char *string)
-{
- uint8_t i = 0;
-
- static const struct {
- char str[32];
- enum rte_eth_fdir_tunnel_type type;
- } tunneltype_str[] = {
- {"NVGRE", RTE_FDIR_TUNNEL_TYPE_NVGRE},
- {"VxLAN", RTE_FDIR_TUNNEL_TYPE_VXLAN},
- };
-
- for (i = 0; i < RTE_DIM(tunneltype_str); i++) {
- if (!strcmp(tunneltype_str[i].str, string))
- return tunneltype_str[i].type;
- }
- return RTE_FDIR_TUNNEL_TYPE_UNKNOWN;
-}
-
-#define IPV4_ADDR_TO_UINT(ip_addr, ip) \
-do { \
- if ((ip_addr).family == AF_INET) \
- (ip) = (ip_addr).addr.ipv4.s_addr; \
- else { \
- printf("invalid parameter.\n"); \
- return; \
- } \
-} while (0)
-
-#define IPV6_ADDR_TO_ARRAY(ip_addr, ip) \
-do { \
- if ((ip_addr).family == AF_INET6) \
- rte_memcpy(&(ip), \
- &((ip_addr).addr.ipv6), \
- sizeof(struct in6_addr)); \
- else { \
- printf("invalid parameter.\n"); \
- return; \
- } \
-} while (0)
+/* *** deal with flow director filter *** */
+struct cmd_flow_director_result {
+ cmdline_fixed_string_t flow_director_filter;
+ portid_t port_id;
+ cmdline_fixed_string_t mode;
+ cmdline_fixed_string_t mode_value;
+ cmdline_fixed_string_t ops;
+ cmdline_fixed_string_t flow;
+ cmdline_fixed_string_t flow_type;
+ cmdline_fixed_string_t drop;
+ cmdline_fixed_string_t queue;
+ uint16_t queue_id;
+ cmdline_fixed_string_t fd_id;
+ uint32_t fd_id_value;
+ cmdline_fixed_string_t packet;
+ char filepath[];
+};
static void
cmd_flow_director_filter_parsed(void *parsed_result,
__rte_unused void *data)
{
struct cmd_flow_director_result *res = parsed_result;
- struct rte_eth_fdir_filter entry;
- uint8_t flexbytes[RTE_ETH_FDIR_MAX_FLEXLEN];
- char *end;
- unsigned long vf_id;
int ret = 0;
+ struct rte_pmd_i40e_flow_type_mapping
+ mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
+ struct rte_pmd_i40e_pkt_template_conf conf;
+ uint16_t flow_type = str2flowtype(res->flow_type);
+ uint16_t i, port = res->port_id;
+ uint8_t add;
- ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_FDIR);
- if (ret < 0) {
- printf("flow director is not supported on port %u.\n",
- res->port_id);
- return;
- }
- memset(flexbytes, 0, sizeof(flexbytes));
- memset(&entry, 0, sizeof(struct rte_eth_fdir_filter));
-
- if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
- if (strcmp(res->mode_value, "MAC-VLAN")) {
- printf("Please set mode to MAC-VLAN.\n");
- return;
- }
- } else if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) {
- if (strcmp(res->mode_value, "Tunnel")) {
- printf("Please set mode to Tunnel.\n");
- return;
- }
- } else {
- if (!strcmp(res->mode_value, "raw")) {
-#ifdef RTE_NET_I40E
- struct rte_pmd_i40e_flow_type_mapping
- mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
- struct rte_pmd_i40e_pkt_template_conf conf;
- uint16_t flow_type = str2flowtype(res->flow_type);
- uint16_t i, port = res->port_id;
- uint8_t add;
-
- memset(&conf, 0, sizeof(conf));
-
- if (flow_type == RTE_ETH_FLOW_UNKNOWN) {
- printf("Invalid flow type specified.\n");
- return;
- }
- ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id,
- mapping);
- if (ret)
- return;
- if (mapping[flow_type].pctype == 0ULL) {
- printf("Invalid flow type specified.\n");
- return;
- }
- for (i = 0; i < RTE_PMD_I40E_PCTYPE_MAX; i++) {
- if (mapping[flow_type].pctype & (1ULL << i)) {
- conf.input.pctype = i;
- break;
- }
- }
-
- conf.input.packet = open_file(res->filepath,
- &conf.input.length);
- if (!conf.input.packet)
- return;
- if (!strcmp(res->drop, "drop"))
- conf.action.behavior =
- RTE_PMD_I40E_PKT_TEMPLATE_REJECT;
- else
- conf.action.behavior =
- RTE_PMD_I40E_PKT_TEMPLATE_ACCEPT;
- conf.action.report_status =
- RTE_PMD_I40E_PKT_TEMPLATE_REPORT_ID;
- conf.action.rx_queue = res->queue_id;
- conf.soft_id = res->fd_id_value;
- add = strcmp(res->ops, "del") ? 1 : 0;
- ret = rte_pmd_i40e_flow_add_del_packet_template(port,
- &conf,
- add);
- if (ret < 0)
- printf("flow director config error: (%s)\n",
- strerror(-ret));
- close_file(conf.input.packet);
-#endif
- return;
- } else if (strcmp(res->mode_value, "IP")) {
- printf("Please set mode to IP or raw.\n");
- return;
- }
- entry.input.flow_type = str2flowtype(res->flow_type);
- }
+ memset(&conf, 0, sizeof(conf));
- ret = parse_flexbytes(res->flexbytes_value,
- flexbytes,
- RTE_ETH_FDIR_MAX_FLEXLEN);
- if (ret < 0) {
- printf("error: Cannot parse flexbytes input.\n");
+ if (flow_type == RTE_ETH_FLOW_UNKNOWN) {
+ fprintf(stderr, "Invalid flow type specified.\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);
+ 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;
}
-
- 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;
+ for (i = 0; i < RTE_PMD_I40E_PCTYPE_MAX; i++) {
+ if (mapping[flow_type].pctype & (1ULL << i)) {
+ conf.input.pctype = i;
+ break;
}
}
- /* set to report FD ID by default */
- entry.action.report_status = RTE_ETH_FDIR_REPORT_ID;
- entry.action.rx_queue = res->queue_id;
- entry.soft_id = res->fd_id_value;
- if (!strcmp(res->ops, "add"))
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_ADD, &entry);
- else if (!strcmp(res->ops, "del"))
- ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_DELETE, &entry);
+ conf.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_FDIR,
- RTE_ETH_FILTER_UPDATE, &entry);
+ conf.action.behavior =
+ RTE_PMD_I40E_PKT_TEMPLATE_ACCEPT;
+ conf.action.report_status =
+ RTE_PMD_I40E_PKT_TEMPLATE_REPORT_ID;
+ conf.action.rx_queue = res->queue_id;
+ conf.soft_id = res->fd_id_value;
+ add = strcmp(res->ops, "del") ? 1 : 0;
+ ret = rte_pmd_i40e_flow_add_del_packet_template(port,
+ &conf,
+ add);
if (ret < 0)
- printf("flow director programming error: (%s)\n",
+ fprintf(stderr, "flow director config error: (%s)\n",
strerror(-ret));
+ close_file(conf.input.packet);
}
-cmdline_parse_token_string_t cmd_flow_director_filter =
+static 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 =
+static 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 =
+ port_id, RTE_UINT16);
+static 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 =
+static 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 =
+static 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 =
+static 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 =
+static 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 =
+static 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 =
+ queue_id, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_flow_director_fd_id_value =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
- fd_id_value, UINT32);
+ fd_id_value, RTE_UINT32);
-cmdline_parse_token_string_t cmd_flow_director_mode =
+static 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 =
+static 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 =
+static 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 =
+static 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 <port_id> mode IP add|del|update flow"
- " ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|"
- "ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|"
- "l2_payload src <src_ip> dst <dst_ip> tos <tos_value> "
- "proto <proto_value> ttl <ttl_value> vlan <vlan_value> "
- "flexbytes <flexbyte_values> drop|fw <pf_vf> queue <queue_id> "
- "fd_id <fd_id_value>: "
- "Add or delete an ip flow director entry on NIC",
- .tokens = {
- (void *)&cmd_flow_director_filter,
- (void *)&cmd_flow_director_port_id,
- (void *)&cmd_flow_director_mode,
- (void *)&cmd_flow_director_mode_ip,
- (void *)&cmd_flow_director_ops,
- (void *)&cmd_flow_director_flow,
- (void *)&cmd_flow_director_flow_type,
- (void *)&cmd_flow_director_src,
- (void *)&cmd_flow_director_ip_src,
- (void *)&cmd_flow_director_dst,
- (void *)&cmd_flow_director_ip_dst,
- (void *)&cmd_flow_director_tos,
- (void *)&cmd_flow_director_tos_value,
- (void *)&cmd_flow_director_proto,
- (void *)&cmd_flow_director_proto_value,
- (void *)&cmd_flow_director_ttl,
- (void *)&cmd_flow_director_ttl_value,
- (void *)&cmd_flow_director_vlan,
- (void *)&cmd_flow_director_vlan_value,
- (void *)&cmd_flow_director_flexbytes,
- (void *)&cmd_flow_director_flexbytes_value,
- (void *)&cmd_flow_director_drop,
- (void *)&cmd_flow_director_pf_vf,
- (void *)&cmd_flow_director_queue,
- (void *)&cmd_flow_director_queue_id,
- (void *)&cmd_flow_director_fd_id,
- (void *)&cmd_flow_director_fd_id_value,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_add_del_udp_flow_director = {
+static 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 an udp/tcp flow "
+ .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_ip,
+ (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_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,
+ (void *)&cmd_flow_director_packet,
+ (void *)&cmd_flow_director_filepath,
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 <port_id>: "
- "Flush all flow director entries of a device on NIC",
- .tokens = {
- (void *)&cmd_flush_flow_director_flush,
- (void *)&cmd_flush_flow_director_port_id,
- NULL,
- },
-};
-
-/* *** 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;
+#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 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
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;
}
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");
+ fprintf(stderr, "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");
+ fprintf(stderr, "Please set mode to Tunnel.\n");
return;
}
mask->tunnel_type_mask = res->tunnel_type_mask;
} else {
if (strcmp(res->mode_value, "IP")) {
- printf("Please set mode to IP.\n");
+ fprintf(stderr, "Please set mode to IP.\n");
return;
}
cmd_reconfig_device_queue(res->port_id, 1, 1);
}
-cmdline_parse_token_string_t cmd_flow_director_mask =
+static 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 =
+static 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 =
+ port_id, RTE_UINT16);
+static 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 =
+static 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 =
+ vlan_mask, RTE_UINT16);
+static 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 =
+static 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 =
+static 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 =
+static 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 =
+ port_src, RTE_UINT16);
+static 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 =
+static 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 =
+static 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 =
+static cmdline_parse_token_num_t cmd_flow_director_mask_port_dst =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
- port_dst, UINT16);
+ port_dst, RTE_UINT16);
-cmdline_parse_token_string_t cmd_flow_director_mask_mode =
+static 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 =
+static 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 =
+static 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 =
+static 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 =
+static 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 =
+static 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 =
+ mac_addr_byte_mask, RTE_UINT8);
+static 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 =
+static 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 =
+ tunnel_type_mask, RTE_UINT8);
+static 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 =
+static cmdline_parse_token_num_t cmd_flow_director_mask_tunnel_id_value =
TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
- tunnel_id_mask, UINT32);
+ tunnel_id_mask, RTE_UINT32);
-cmdline_parse_inst_t cmd_set_flow_director_ip_mask = {
+static cmdline_parse_inst_t cmd_set_flow_director_ip_mask = {
.f = cmd_flow_director_mask_parsed,
.data = NULL,
.help_str = "flow_director_mask ... : "
},
};
-cmdline_parse_inst_t cmd_set_flow_director_mac_vlan_mask = {
+static 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 "
},
};
-cmdline_parse_inst_t cmd_set_flow_director_tunnel_mask = {
+static 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 "
},
};
-/* *** 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;
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;
}
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 *** */
-
-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;
-}
-
-/* Set flow director input set */
-struct cmd_set_fdir_input_set_result {
- cmdline_fixed_string_t set_fdir_input_set;
- portid_t port_id;
- cmdline_fixed_string_t flow_type;
- cmdline_fixed_string_t inset_field;
- cmdline_fixed_string_t select;
-};
-
-static void
-cmd_set_fdir_input_set_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_set_fdir_input_set_result *res = parsed_result;
- struct rte_eth_fdir_filter_info info;
-
- memset(&info, 0, sizeof(info));
- info.info_type = RTE_ETH_FDIR_FILTER_INPUT_SET_SELECT;
- info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
- info.info.input_set_conf.field[0] = str2inset(res->inset_field);
- info.info.input_set_conf.inset_size = 1;
- if (!strcmp(res->select, "select"))
- info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
- else if (!strcmp(res->select, "add"))
- info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
- rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
- RTE_ETH_FILTER_SET, &info);
-}
-
-cmdline_parse_token_string_t cmd_set_fdir_input_set_cmd =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- set_fdir_input_set, "set_fdir_input_set");
-cmdline_parse_token_num_t cmd_set_fdir_input_set_port_id =
- TOKEN_NUM_INITIALIZER(struct cmd_set_fdir_input_set_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_fdir_input_set_flow_type =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- flow_type,
- "ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#ipv4-other#"
- "ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#ipv6-other#l2_payload");
-cmdline_parse_token_string_t cmd_set_fdir_input_set_field =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- inset_field,
- "ivlan#ethertype#src-ipv4#dst-ipv4#src-ipv6#dst-ipv6#"
- "ipv4-tos#ipv4-proto#ipv4-ttl#ipv6-tc#ipv6-next-header#"
- "ipv6-hop-limits#udp-src-port#udp-dst-port#"
- "tcp-src-port#tcp-dst-port#sctp-src-port#sctp-dst-port#"
- "sctp-veri-tag#none");
-cmdline_parse_token_string_t cmd_set_fdir_input_set_select =
- TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
- select, "select#add");
-
-cmdline_parse_inst_t cmd_set_fdir_input_set = {
- .f = cmd_set_fdir_input_set_parsed,
- .data = NULL,
- .help_str = "set_fdir_input_set <port_id> "
- "ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
- "ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
- "ivlan|ethertype|src-ipv4|dst-ipv4|src-ipv6|dst-ipv6|"
- "ipv4-tos|ipv4-proto|ipv4-ttl|ipv6-tc|ipv6-next-header|"
- "ipv6-hop-limits|udp-src-port|udp-dst-port|"
- "tcp-src-port|tcp-dst-port|sctp-src-port|sctp-dst-port|"
- "sctp-veri-tag|none select|add",
- .tokens = {
- (void *)&cmd_set_fdir_input_set_cmd,
- (void *)&cmd_set_fdir_input_set_port_id,
- (void *)&cmd_set_fdir_input_set_flow_type,
- (void *)&cmd_set_fdir_input_set_field,
- (void *)&cmd_set_fdir_input_set_select,
- NULL,
- },
-};
-
-/* *** ADD/REMOVE A MULTICAST MAC ADDRESS TO/FROM A PORT *** */
-struct cmd_mcast_addr_result {
- cmdline_fixed_string_t mcast_addr_cmd;
- cmdline_fixed_string_t what;
- uint16_t port_num;
- struct rte_ether_addr mc_addr;
-};
-
-static void cmd_mcast_addr_parsed(void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_mcast_addr_result *res = parsed_result;
-
- if (!rte_is_multicast_ether_addr(&res->mc_addr)) {
- printf("Invalid multicast addr %02X:%02X:%02X:%02X:%02X:%02X\n",
- res->mc_addr.addr_bytes[0], res->mc_addr.addr_bytes[1],
- res->mc_addr.addr_bytes[2], res->mc_addr.addr_bytes[3],
- res->mc_addr.addr_bytes[4], res->mc_addr.addr_bytes[5]);
- return;
- }
- if (strcmp(res->what, "add") == 0)
- mcast_addr_add(res->port_num, &res->mc_addr);
- else
- mcast_addr_remove(res->port_num, &res->mc_addr);
-}
-
-cmdline_parse_token_string_t cmd_mcast_addr_cmd =
- TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result,
- mcast_addr_cmd, "mcast_addr");
-cmdline_parse_token_string_t cmd_mcast_addr_what =
- TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result, what,
- "add#remove");
-cmdline_parse_token_num_t cmd_mcast_addr_portnum =
- TOKEN_NUM_INITIALIZER(struct cmd_mcast_addr_result, port_num, UINT16);
-cmdline_parse_token_etheraddr_t cmd_mcast_addr_addr =
- TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address);
-
-cmdline_parse_inst_t cmd_mcast_addr = {
- .f = cmd_mcast_addr_parsed,
- .data = (void *)0,
- .help_str = "mcast_addr add|remove <port_id> <mcast_addr>: "
- "Add/Remove multicast MAC address on port_id",
- .tokens = {
- (void *)&cmd_mcast_addr_cmd,
- (void *)&cmd_mcast_addr_what,
- (void *)&cmd_mcast_addr_portnum,
- (void *)&cmd_mcast_addr_addr,
- NULL,
- },
-};
-
-/* l2 tunnel config
- * only support E-tag now.
- */
-
-/* Ether type config */
-struct cmd_config_l2_tunnel_eth_type_result {
- cmdline_fixed_string_t port;
- cmdline_fixed_string_t config;
- cmdline_fixed_string_t all;
- portid_t id;
- cmdline_fixed_string_t l2_tunnel;
- cmdline_fixed_string_t l2_tunnel_type;
- cmdline_fixed_string_t eth_type;
- uint16_t eth_type_val;
-};
-
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_port =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- port, "port");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_config =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- config, "config");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_all_str =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- all, "all");
-cmdline_parse_token_num_t cmd_config_l2_tunnel_eth_type_id =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- id, UINT16);
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_l2_tunnel =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- l2_tunnel, "l2-tunnel");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_l2_tunnel_type =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- l2_tunnel_type, "E-tag");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_eth_type =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- eth_type, "ether-type");
-cmdline_parse_token_num_t cmd_config_l2_tunnel_eth_type_eth_type_val =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_l2_tunnel_eth_type_result,
- eth_type_val, UINT16);
-
-static enum rte_eth_tunnel_type
-str2fdir_l2_tunnel_type(char *string)
-{
- uint32_t i = 0;
-
- static const struct {
- char str[32];
- enum rte_eth_tunnel_type type;
- } l2_tunnel_type_str[] = {
- {"E-tag", RTE_L2_TUNNEL_TYPE_E_TAG},
- };
-
- for (i = 0; i < RTE_DIM(l2_tunnel_type_str); i++) {
- if (!strcmp(l2_tunnel_type_str[i].str, string))
- return l2_tunnel_type_str[i].type;
- }
- return RTE_TUNNEL_TYPE_NONE;
-}
-
-/* ether type config for all ports */
-static void
-cmd_config_l2_tunnel_eth_type_all_parsed
- (void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_config_l2_tunnel_eth_type_result *res = parsed_result;
- struct rte_eth_l2_tunnel_conf entry;
- portid_t pid;
-
- entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
- entry.ether_type = res->eth_type_val;
-
- RTE_ETH_FOREACH_DEV(pid) {
- rte_eth_dev_l2_tunnel_eth_type_conf(pid, &entry);
- }
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_eth_type_all = {
- .f = cmd_config_l2_tunnel_eth_type_all_parsed,
- .data = NULL,
- .help_str = "port config all l2-tunnel E-tag ether-type <value>",
- .tokens = {
- (void *)&cmd_config_l2_tunnel_eth_type_port,
- (void *)&cmd_config_l2_tunnel_eth_type_config,
- (void *)&cmd_config_l2_tunnel_eth_type_all_str,
- (void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel,
- (void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel_type,
- (void *)&cmd_config_l2_tunnel_eth_type_eth_type,
- (void *)&cmd_config_l2_tunnel_eth_type_eth_type_val,
- NULL,
- },
-};
-
-/* ether type config for a specific port */
-static void
-cmd_config_l2_tunnel_eth_type_specific_parsed(
- void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_config_l2_tunnel_eth_type_result *res =
- parsed_result;
- struct rte_eth_l2_tunnel_conf entry;
-
- if (port_id_is_invalid(res->id, ENABLED_WARN))
- return;
-
- entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
- entry.ether_type = res->eth_type_val;
-
- rte_eth_dev_l2_tunnel_eth_type_conf(res->id, &entry);
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_eth_type_specific = {
- .f = cmd_config_l2_tunnel_eth_type_specific_parsed,
- .data = NULL,
- .help_str = "port config <port_id> l2-tunnel E-tag ether-type <value>",
- .tokens = {
- (void *)&cmd_config_l2_tunnel_eth_type_port,
- (void *)&cmd_config_l2_tunnel_eth_type_config,
- (void *)&cmd_config_l2_tunnel_eth_type_id,
- (void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel,
- (void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel_type,
- (void *)&cmd_config_l2_tunnel_eth_type_eth_type,
- (void *)&cmd_config_l2_tunnel_eth_type_eth_type_val,
- NULL,
- },
-};
-
-/* Enable/disable l2 tunnel */
-struct cmd_config_l2_tunnel_en_dis_result {
- cmdline_fixed_string_t port;
- cmdline_fixed_string_t config;
- cmdline_fixed_string_t all;
- portid_t id;
- cmdline_fixed_string_t l2_tunnel;
- cmdline_fixed_string_t l2_tunnel_type;
- cmdline_fixed_string_t en_dis;
-};
-
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_port =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- port, "port");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_config =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- config, "config");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_all_str =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- all, "all");
-cmdline_parse_token_num_t cmd_config_l2_tunnel_en_dis_id =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- id, UINT16);
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_l2_tunnel =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- l2_tunnel, "l2-tunnel");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_l2_tunnel_type =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- l2_tunnel_type, "E-tag");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_en_dis =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_l2_tunnel_en_dis_result,
- en_dis, "enable#disable");
-
-/* enable/disable l2 tunnel for all ports */
-static void
-cmd_config_l2_tunnel_en_dis_all_parsed(
- void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_config_l2_tunnel_en_dis_result *res = parsed_result;
- struct rte_eth_l2_tunnel_conf entry;
- portid_t pid;
- uint8_t en;
-
- entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
-
- if (!strcmp("enable", res->en_dis))
- en = 1;
- else
- en = 0;
-
- RTE_ETH_FOREACH_DEV(pid) {
- rte_eth_dev_l2_tunnel_offload_set(pid,
- &entry,
- ETH_L2_TUNNEL_ENABLE_MASK,
- en);
- }
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_en_dis_all = {
- .f = cmd_config_l2_tunnel_en_dis_all_parsed,
- .data = NULL,
- .help_str = "port config all l2-tunnel E-tag enable|disable",
- .tokens = {
- (void *)&cmd_config_l2_tunnel_en_dis_port,
- (void *)&cmd_config_l2_tunnel_en_dis_config,
- (void *)&cmd_config_l2_tunnel_en_dis_all_str,
- (void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel,
- (void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel_type,
- (void *)&cmd_config_l2_tunnel_en_dis_en_dis,
- NULL,
- },
-};
-
-/* enable/disable l2 tunnel for a port */
-static void
-cmd_config_l2_tunnel_en_dis_specific_parsed(
- void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_config_l2_tunnel_en_dis_result *res =
- parsed_result;
- struct rte_eth_l2_tunnel_conf entry;
-
- if (port_id_is_invalid(res->id, ENABLED_WARN))
- return;
-
- entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
-
- if (!strcmp("enable", res->en_dis))
- rte_eth_dev_l2_tunnel_offload_set(res->id,
- &entry,
- ETH_L2_TUNNEL_ENABLE_MASK,
- 1);
- else
- rte_eth_dev_l2_tunnel_offload_set(res->id,
- &entry,
- ETH_L2_TUNNEL_ENABLE_MASK,
- 0);
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_en_dis_specific = {
- .f = cmd_config_l2_tunnel_en_dis_specific_parsed,
- .data = NULL,
- .help_str = "port config <port_id> l2-tunnel E-tag enable|disable",
- .tokens = {
- (void *)&cmd_config_l2_tunnel_en_dis_port,
- (void *)&cmd_config_l2_tunnel_en_dis_config,
- (void *)&cmd_config_l2_tunnel_en_dis_id,
- (void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel,
- (void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel_type,
- (void *)&cmd_config_l2_tunnel_en_dis_en_dis,
- NULL,
- },
-};
-
-/* E-tag configuration */
-
-/* Common result structure for all E-tag configuration */
-struct cmd_config_e_tag_result {
- cmdline_fixed_string_t e_tag;
- cmdline_fixed_string_t set;
- cmdline_fixed_string_t insertion;
- cmdline_fixed_string_t stripping;
- cmdline_fixed_string_t forwarding;
- cmdline_fixed_string_t filter;
- cmdline_fixed_string_t add;
- cmdline_fixed_string_t del;
- cmdline_fixed_string_t on;
- cmdline_fixed_string_t off;
- cmdline_fixed_string_t on_off;
- cmdline_fixed_string_t port_tag_id;
- uint32_t port_tag_id_val;
- cmdline_fixed_string_t e_tag_id;
- uint16_t e_tag_id_val;
- cmdline_fixed_string_t dst_pool;
- uint8_t dst_pool_val;
- cmdline_fixed_string_t port;
- portid_t port_id;
- cmdline_fixed_string_t vf;
- uint8_t vf_id;
-};
-
-/* Common CLI fields for all E-tag configuration */
-cmdline_parse_token_string_t cmd_config_e_tag_e_tag =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- e_tag, "E-tag");
-cmdline_parse_token_string_t cmd_config_e_tag_set =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- set, "set");
-cmdline_parse_token_string_t cmd_config_e_tag_insertion =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- insertion, "insertion");
-cmdline_parse_token_string_t cmd_config_e_tag_stripping =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- stripping, "stripping");
-cmdline_parse_token_string_t cmd_config_e_tag_forwarding =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- forwarding, "forwarding");
-cmdline_parse_token_string_t cmd_config_e_tag_filter =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- filter, "filter");
-cmdline_parse_token_string_t cmd_config_e_tag_add =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- add, "add");
-cmdline_parse_token_string_t cmd_config_e_tag_del =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- del, "del");
-cmdline_parse_token_string_t cmd_config_e_tag_on =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- on, "on");
-cmdline_parse_token_string_t cmd_config_e_tag_off =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- off, "off");
-cmdline_parse_token_string_t cmd_config_e_tag_on_off =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- on_off, "on#off");
-cmdline_parse_token_string_t cmd_config_e_tag_port_tag_id =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- port_tag_id, "port-tag-id");
-cmdline_parse_token_num_t cmd_config_e_tag_port_tag_id_val =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_e_tag_result,
- port_tag_id_val, UINT32);
-cmdline_parse_token_string_t cmd_config_e_tag_e_tag_id =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- e_tag_id, "e-tag-id");
-cmdline_parse_token_num_t cmd_config_e_tag_e_tag_id_val =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_e_tag_result,
- e_tag_id_val, UINT16);
-cmdline_parse_token_string_t cmd_config_e_tag_dst_pool =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- dst_pool, "dst-pool");
-cmdline_parse_token_num_t cmd_config_e_tag_dst_pool_val =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_e_tag_result,
- dst_pool_val, UINT8);
-cmdline_parse_token_string_t cmd_config_e_tag_port =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- port, "port");
-cmdline_parse_token_num_t cmd_config_e_tag_port_id =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_e_tag_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_config_e_tag_vf =
- TOKEN_STRING_INITIALIZER
- (struct cmd_config_e_tag_result,
- vf, "vf");
-cmdline_parse_token_num_t cmd_config_e_tag_vf_id =
- TOKEN_NUM_INITIALIZER
- (struct cmd_config_e_tag_result,
- vf_id, UINT8);
-
-/* E-tag insertion configuration */
-static void
-cmd_config_e_tag_insertion_en_parsed(
- void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_config_e_tag_result *res =
- parsed_result;
- struct rte_eth_l2_tunnel_conf entry;
-
- if (port_id_is_invalid(res->port_id, ENABLED_WARN))
- return;
-
- entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
- entry.tunnel_id = res->port_tag_id_val;
- entry.vf_id = res->vf_id;
- rte_eth_dev_l2_tunnel_offload_set(res->port_id,
- &entry,
- ETH_L2_TUNNEL_INSERTION_MASK,
- 1);
-}
-
-static void
-cmd_config_e_tag_insertion_dis_parsed(
- void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_config_e_tag_result *res =
- parsed_result;
- struct rte_eth_l2_tunnel_conf entry;
-
- if (port_id_is_invalid(res->port_id, ENABLED_WARN))
- return;
-
- entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
- entry.vf_id = res->vf_id;
-
- rte_eth_dev_l2_tunnel_offload_set(res->port_id,
- &entry,
- ETH_L2_TUNNEL_INSERTION_MASK,
- 0);
-}
-
-cmdline_parse_inst_t cmd_config_e_tag_insertion_en = {
- .f = cmd_config_e_tag_insertion_en_parsed,
- .data = NULL,
- .help_str = "E-tag ... : E-tag insertion enable",
- .tokens = {
- (void *)&cmd_config_e_tag_e_tag,
- (void *)&cmd_config_e_tag_set,
- (void *)&cmd_config_e_tag_insertion,
- (void *)&cmd_config_e_tag_on,
- (void *)&cmd_config_e_tag_port_tag_id,
- (void *)&cmd_config_e_tag_port_tag_id_val,
- (void *)&cmd_config_e_tag_port,
- (void *)&cmd_config_e_tag_port_id,
- (void *)&cmd_config_e_tag_vf,
- (void *)&cmd_config_e_tag_vf_id,
- NULL,
- },
-};
-
-cmdline_parse_inst_t cmd_config_e_tag_insertion_dis = {
- .f = cmd_config_e_tag_insertion_dis_parsed,
- .data = NULL,
- .help_str = "E-tag ... : E-tag insertion disable",
- .tokens = {
- (void *)&cmd_config_e_tag_e_tag,
- (void *)&cmd_config_e_tag_set,
- (void *)&cmd_config_e_tag_insertion,
- (void *)&cmd_config_e_tag_off,
- (void *)&cmd_config_e_tag_port,
- (void *)&cmd_config_e_tag_port_id,
- (void *)&cmd_config_e_tag_vf,
- (void *)&cmd_config_e_tag_vf_id,
- NULL,
- },
-};
-
-/* E-tag stripping configuration */
-static void
-cmd_config_e_tag_stripping_parsed(
- void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_config_e_tag_result *res =
- parsed_result;
- struct rte_eth_l2_tunnel_conf entry;
+ 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;
- if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+ ret = parse_offsets(res->payload_cfg, flex_cfg.src_offset,
+ RTE_ETH_FDIR_MAX_FLEXLEN);
+ if (ret < 0) {
+ fprintf(stderr, "error: Cannot parse flex payload input.\n");
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);
+ 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_stripping_en_dis = {
- .f = cmd_config_e_tag_stripping_parsed,
+static 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");
+static cmdline_parse_token_num_t cmd_flow_director_flexpayload_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_flow_director_flexpayload_result,
+ port_id, RTE_UINT16);
+static 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");
+static cmdline_parse_token_string_t cmd_flow_director_flexpayload_payload_cfg =
+ TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
+ payload_cfg, NULL);
+
+static cmdline_parse_inst_t cmd_set_flow_director_flex_payload = {
+ .f = cmd_flow_director_flxpld_parsed,
.data = NULL,
- .help_str = "E-tag ... : E-tag stripping enable/disable",
+ .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_stripping,
- (void *)&cmd_config_e_tag_on_off,
- (void *)&cmd_config_e_tag_port,
- (void *)&cmd_config_e_tag_port_id,
+ (void *)&cmd_flow_director_flexpayload,
+ (void *)&cmd_flow_director_flexpayload_port_id,
+ (void *)&cmd_flow_director_flexpayload_payload_layer,
+ (void *)&cmd_flow_director_flexpayload_payload_cfg,
NULL,
},
};
-/* E-tag forwarding configuration */
-static void
-cmd_config_e_tag_forwarding_parsed(
- void *parsed_result,
- __rte_unused struct cmdline *cl,
- __rte_unused void *data)
-{
- struct cmd_config_e_tag_result *res = parsed_result;
- struct rte_eth_l2_tunnel_conf entry;
+/* 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;
+};
- entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
+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 (!strcmp(res->on_off, "on"))
- rte_eth_dev_l2_tunnel_offload_set
- (res->port_id,
- &entry,
- ETH_L2_TUNNEL_FORWARDING_MASK,
- 1);
+ 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;
+ }
+ if (strcmp(res->what, "add") == 0)
+ mcast_addr_add(res->port_num, &res->mc_addr);
else
- rte_eth_dev_l2_tunnel_offload_set
- (res->port_id,
- &entry,
- ETH_L2_TUNNEL_FORWARDING_MASK,
- 0);
+ mcast_addr_remove(res->port_num, &res->mc_addr);
}
-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",
+static cmdline_parse_token_string_t cmd_mcast_addr_cmd =
+ TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result,
+ mcast_addr_cmd, "mcast_addr");
+static cmdline_parse_token_string_t cmd_mcast_addr_what =
+ TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result, what,
+ "add#remove");
+static cmdline_parse_token_num_t cmd_mcast_addr_portnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_mcast_addr_result, port_num,
+ RTE_UINT16);
+static cmdline_parse_token_etheraddr_t cmd_mcast_addr_addr =
+ TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address);
+
+static cmdline_parse_inst_t cmd_mcast_addr = {
+ .f = cmd_mcast_addr_parsed,
+ .data = (void *)0,
+ .help_str = "mcast_addr add|remove <port_id> <mcast_addr>: "
+ "Add/Remove multicast MAC address on port_id",
.tokens = {
- (void *)&cmd_config_e_tag_e_tag,
- (void *)&cmd_config_e_tag_set,
- (void *)&cmd_config_e_tag_forwarding,
- (void *)&cmd_config_e_tag_on_off,
- (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,
},
};
};
/* Common CLI fields for vf vlan anti spoof enable disable */
-cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_set =
+static cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_set =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_anti_spoof_result,
set, "set");
-cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_vf =
+static cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_anti_spoof_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_vlan =
+static cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_vlan =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_anti_spoof_result,
vlan, "vlan");
-cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_antispoof =
+static cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_antispoof =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_anti_spoof_result,
antispoof, "antispoof");
-cmdline_parse_token_num_t cmd_vf_vlan_anti_spoof_port_id =
+static 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);
-cmdline_parse_token_num_t cmd_vf_vlan_anti_spoof_vf_id =
+ port_id, RTE_UINT16);
+static 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);
-cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_on_off =
+ vf_id, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_anti_spoof_result,
on_off, "on#off");
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));
}
}
-cmdline_parse_inst_t cmd_set_vf_vlan_anti_spoof = {
+static cmdline_parse_inst_t cmd_set_vf_vlan_anti_spoof = {
.f = cmd_set_vf_vlan_anti_spoof_parsed,
.data = NULL,
.help_str = "set vf vlan antispoof <port_id> <vf_id> on|off",
};
/* Common CLI fields for vf mac anti spoof enable disable */
-cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_set =
+static cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_set =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_mac_anti_spoof_result,
set, "set");
-cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_vf =
+static cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_mac_anti_spoof_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_mac =
+static cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_mac =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_mac_anti_spoof_result,
mac, "mac");
-cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_antispoof =
+static cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_antispoof =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_mac_anti_spoof_result,
antispoof, "antispoof");
-cmdline_parse_token_num_t cmd_vf_mac_anti_spoof_port_id =
+static 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);
-cmdline_parse_token_num_t cmd_vf_mac_anti_spoof_vf_id =
+ port_id, RTE_UINT16);
+static 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);
-cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_on_off =
+ vf_id, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_mac_anti_spoof_result,
on_off, "on#off");
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));
}
}
-cmdline_parse_inst_t cmd_set_vf_mac_anti_spoof = {
+static cmdline_parse_inst_t cmd_set_vf_mac_anti_spoof = {
.f = cmd_set_vf_mac_anti_spoof_parsed,
.data = NULL,
.help_str = "set vf mac antispoof <port_id> <vf_id> on|off",
};
/* Common CLI fields for vf vlan strip enable disable */
-cmdline_parse_token_string_t cmd_vf_vlan_stripq_set =
+static cmdline_parse_token_string_t cmd_vf_vlan_stripq_set =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_stripq_result,
set, "set");
-cmdline_parse_token_string_t cmd_vf_vlan_stripq_vf =
+static cmdline_parse_token_string_t cmd_vf_vlan_stripq_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_stripq_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_vf_vlan_stripq_vlan =
+static cmdline_parse_token_string_t cmd_vf_vlan_stripq_vlan =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_stripq_result,
vlan, "vlan");
-cmdline_parse_token_string_t cmd_vf_vlan_stripq_stripq =
+static cmdline_parse_token_string_t cmd_vf_vlan_stripq_stripq =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_stripq_result,
stripq, "stripq");
-cmdline_parse_token_num_t cmd_vf_vlan_stripq_port_id =
+static cmdline_parse_token_num_t cmd_vf_vlan_stripq_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_vlan_stripq_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_vf_vlan_stripq_vf_id =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_vf_vlan_stripq_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_vlan_stripq_result,
- vf_id, UINT16);
-cmdline_parse_token_string_t cmd_vf_vlan_stripq_on_off =
+ vf_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_vf_vlan_stripq_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_stripq_result,
on_off, "on#off");
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));
}
}
-cmdline_parse_inst_t cmd_set_vf_vlan_stripq = {
+static cmdline_parse_inst_t cmd_set_vf_vlan_stripq = {
.f = cmd_set_vf_vlan_stripq_parsed,
.data = NULL,
.help_str = "set vf vlan stripq <port_id> <vf_id> on|off",
};
/* Common CLI fields for vf vlan insert enable disable */
-cmdline_parse_token_string_t cmd_vf_vlan_insert_set =
+static cmdline_parse_token_string_t cmd_vf_vlan_insert_set =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_insert_result,
set, "set");
-cmdline_parse_token_string_t cmd_vf_vlan_insert_vf =
+static cmdline_parse_token_string_t cmd_vf_vlan_insert_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_insert_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_vf_vlan_insert_vlan =
+static cmdline_parse_token_string_t cmd_vf_vlan_insert_vlan =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_insert_result,
vlan, "vlan");
-cmdline_parse_token_string_t cmd_vf_vlan_insert_insert =
+static cmdline_parse_token_string_t cmd_vf_vlan_insert_insert =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_vlan_insert_result,
insert, "insert");
-cmdline_parse_token_num_t cmd_vf_vlan_insert_port_id =
+static cmdline_parse_token_num_t cmd_vf_vlan_insert_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_vlan_insert_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_vf_vlan_insert_vf_id =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_vf_vlan_insert_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_vlan_insert_result,
- vf_id, UINT16);
-cmdline_parse_token_num_t cmd_vf_vlan_insert_vlan_id =
+ vf_id, RTE_UINT16);
+static 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(
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));
}
}
-cmdline_parse_inst_t cmd_set_vf_vlan_insert = {
+static cmdline_parse_inst_t cmd_set_vf_vlan_insert = {
.f = cmd_set_vf_vlan_insert_parsed,
.data = NULL,
.help_str = "set vf vlan insert <port_id> <vf_id> <vlan_id>",
};
/* Common CLI fields for tx loopback enable disable */
-cmdline_parse_token_string_t cmd_tx_loopback_set =
+static cmdline_parse_token_string_t cmd_tx_loopback_set =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_loopback_result,
set, "set");
-cmdline_parse_token_string_t cmd_tx_loopback_tx =
+static cmdline_parse_token_string_t cmd_tx_loopback_tx =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_loopback_result,
tx, "tx");
-cmdline_parse_token_string_t cmd_tx_loopback_loopback =
+static cmdline_parse_token_string_t cmd_tx_loopback_loopback =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_loopback_result,
loopback, "loopback");
-cmdline_parse_token_num_t cmd_tx_loopback_port_id =
+static cmdline_parse_token_num_t cmd_tx_loopback_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_tx_loopback_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_tx_loopback_on_off =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_tx_loopback_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_loopback_result,
on_off, "on#off");
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));
}
}
-cmdline_parse_inst_t cmd_set_tx_loopback = {
+static cmdline_parse_inst_t cmd_set_tx_loopback = {
.f = cmd_set_tx_loopback_parsed,
.data = NULL,
.help_str = "set tx loopback <port_id> on|off",
};
/* Common CLI fields for tx loopback enable disable */
-cmdline_parse_token_string_t cmd_all_queues_drop_en_set =
+static cmdline_parse_token_string_t cmd_all_queues_drop_en_set =
TOKEN_STRING_INITIALIZER
(struct cmd_all_queues_drop_en_result,
set, "set");
-cmdline_parse_token_string_t cmd_all_queues_drop_en_all =
+static cmdline_parse_token_string_t cmd_all_queues_drop_en_all =
TOKEN_STRING_INITIALIZER
(struct cmd_all_queues_drop_en_result,
all, "all");
-cmdline_parse_token_string_t cmd_all_queues_drop_en_queues =
+static cmdline_parse_token_string_t cmd_all_queues_drop_en_queues =
TOKEN_STRING_INITIALIZER
(struct cmd_all_queues_drop_en_result,
queues, "queues");
-cmdline_parse_token_string_t cmd_all_queues_drop_en_drop =
+static cmdline_parse_token_string_t cmd_all_queues_drop_en_drop =
TOKEN_STRING_INITIALIZER
(struct cmd_all_queues_drop_en_result,
drop, "drop");
-cmdline_parse_token_num_t cmd_all_queues_drop_en_port_id =
+static 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);
-cmdline_parse_token_string_t cmd_all_queues_drop_en_on_off =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_all_queues_drop_en_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_all_queues_drop_en_result,
on_off, "on#off");
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));
}
}
-cmdline_parse_inst_t cmd_set_all_queues_drop_en = {
+static cmdline_parse_inst_t cmd_set_all_queues_drop_en = {
.f = cmd_set_all_queues_drop_en_parsed,
.data = NULL,
.help_str = "set all queues drop <port_id> on|off",
};
/* Common CLI fields for vf split drop enable disable */
-cmdline_parse_token_string_t cmd_vf_split_drop_en_set =
+static cmdline_parse_token_string_t cmd_vf_split_drop_en_set =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_split_drop_en_result,
set, "set");
-cmdline_parse_token_string_t cmd_vf_split_drop_en_vf =
+static cmdline_parse_token_string_t cmd_vf_split_drop_en_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_split_drop_en_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_vf_split_drop_en_split =
+static cmdline_parse_token_string_t cmd_vf_split_drop_en_split =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_split_drop_en_result,
split, "split");
-cmdline_parse_token_string_t cmd_vf_split_drop_en_drop =
+static cmdline_parse_token_string_t cmd_vf_split_drop_en_drop =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_split_drop_en_result,
drop, "drop");
-cmdline_parse_token_num_t cmd_vf_split_drop_en_port_id =
+static 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);
-cmdline_parse_token_num_t cmd_vf_split_drop_en_vf_id =
+ port_id, RTE_UINT16);
+static 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);
-cmdline_parse_token_string_t cmd_vf_split_drop_en_on_off =
+ vf_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_vf_split_drop_en_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_split_drop_en_result,
on_off, "on#off");
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));
}
}
-cmdline_parse_inst_t cmd_set_vf_split_drop_en = {
+static cmdline_parse_inst_t cmd_set_vf_split_drop_en = {
.f = cmd_set_vf_split_drop_en_parsed,
.data = NULL,
.help_str = "set vf split drop <port_id> <vf_id> on|off",
};
/* Common CLI fields for vf split drop enable disable */
-cmdline_parse_token_string_t cmd_set_vf_mac_addr_set =
+static cmdline_parse_token_string_t cmd_set_vf_mac_addr_set =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_mac_addr_result,
set, "set");
-cmdline_parse_token_string_t cmd_set_vf_mac_addr_vf =
+static cmdline_parse_token_string_t cmd_set_vf_mac_addr_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_mac_addr_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_set_vf_mac_addr_mac =
+static cmdline_parse_token_string_t cmd_set_vf_mac_addr_mac =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_mac_addr_result,
mac, "mac");
-cmdline_parse_token_string_t cmd_set_vf_mac_addr_addr =
+static cmdline_parse_token_string_t cmd_set_vf_mac_addr_addr =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_mac_addr_result,
addr, "addr");
-cmdline_parse_token_num_t cmd_set_vf_mac_addr_port_id =
+static 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);
-cmdline_parse_token_num_t cmd_set_vf_mac_addr_vf_id =
+ port_id, RTE_UINT16);
+static 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);
-cmdline_parse_token_etheraddr_t cmd_set_vf_mac_addr_mac_addr =
+ vf_id, RTE_UINT16);
+static cmdline_parse_token_etheraddr_t cmd_set_vf_mac_addr_mac_addr =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vf_mac_addr_result,
mac_addr);
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));
}
}
-cmdline_parse_inst_t cmd_set_vf_mac_addr = {
+static cmdline_parse_inst_t cmd_set_vf_mac_addr = {
.f = cmd_set_vf_mac_addr_parsed,
.data = NULL,
.help_str = "set vf mac addr <port_id> <vf_id> <mac_addr>",
};
/* Common CLI fields for MACsec offload disable */
-cmdline_parse_token_string_t cmd_macsec_offload_on_set =
+static cmdline_parse_token_string_t cmd_macsec_offload_on_set =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_on_result,
set, "set");
-cmdline_parse_token_string_t cmd_macsec_offload_on_macsec =
+static cmdline_parse_token_string_t cmd_macsec_offload_on_macsec =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_on_result,
macsec, "macsec");
-cmdline_parse_token_string_t cmd_macsec_offload_on_offload =
+static cmdline_parse_token_string_t cmd_macsec_offload_on_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_on_result,
offload, "offload");
-cmdline_parse_token_num_t cmd_macsec_offload_on_port_id =
+static cmdline_parse_token_num_t cmd_macsec_offload_on_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_offload_on_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_macsec_offload_on_on =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_macsec_offload_on_on =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_on_result,
on, "on");
-cmdline_parse_token_string_t cmd_macsec_offload_on_encrypt =
+static cmdline_parse_token_string_t cmd_macsec_offload_on_encrypt =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_on_result,
encrypt, "encrypt");
-cmdline_parse_token_string_t cmd_macsec_offload_on_en_on_off =
+static cmdline_parse_token_string_t cmd_macsec_offload_on_en_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_on_result,
en_on_off, "on#off");
-cmdline_parse_token_string_t cmd_macsec_offload_on_replay_protect =
+static cmdline_parse_token_string_t cmd_macsec_offload_on_replay_protect =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_on_result,
replay_protect, "replay-protect");
-cmdline_parse_token_string_t cmd_macsec_offload_on_rp_on_off =
+static cmdline_parse_token_string_t cmd_macsec_offload_on_rp_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_on_result,
rp_on_off, "on#off");
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;
}
if (ret != 0)
return;
- if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) {
+ 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
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));
}
}
-cmdline_parse_inst_t cmd_set_macsec_offload_on = {
+static cmdline_parse_inst_t cmd_set_macsec_offload_on = {
.f = cmd_set_macsec_offload_on_parsed,
.data = NULL,
.help_str = "set macsec offload <port_id> on "
};
/* Common CLI fields for MACsec offload disable */
-cmdline_parse_token_string_t cmd_macsec_offload_off_set =
+static cmdline_parse_token_string_t cmd_macsec_offload_off_set =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_off_result,
set, "set");
-cmdline_parse_token_string_t cmd_macsec_offload_off_macsec =
+static cmdline_parse_token_string_t cmd_macsec_offload_off_macsec =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_off_result,
macsec, "macsec");
-cmdline_parse_token_string_t cmd_macsec_offload_off_offload =
+static cmdline_parse_token_string_t cmd_macsec_offload_off_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_off_result,
offload, "offload");
-cmdline_parse_token_num_t cmd_macsec_offload_off_port_id =
+static cmdline_parse_token_num_t cmd_macsec_offload_off_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_offload_off_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_macsec_offload_off_off =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_macsec_offload_off_off =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_offload_off_result,
off, "off");
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;
}
if (ret != 0)
return;
- if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) {
+ 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));
}
}
-cmdline_parse_inst_t cmd_set_macsec_offload_off = {
+static cmdline_parse_inst_t cmd_set_macsec_offload_off = {
.f = cmd_set_macsec_offload_off_parsed,
.data = NULL,
.help_str = "set macsec offload <port_id> off",
};
/* Common CLI fields for MACsec secure connection configure */
-cmdline_parse_token_string_t cmd_macsec_sc_set =
+static cmdline_parse_token_string_t cmd_macsec_sc_set =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_sc_result,
set, "set");
-cmdline_parse_token_string_t cmd_macsec_sc_macsec =
+static cmdline_parse_token_string_t cmd_macsec_sc_macsec =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_sc_result,
macsec, "macsec");
-cmdline_parse_token_string_t cmd_macsec_sc_sc =
+static cmdline_parse_token_string_t cmd_macsec_sc_sc =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_sc_result,
sc, "sc");
-cmdline_parse_token_string_t cmd_macsec_sc_tx_rx =
+static cmdline_parse_token_string_t cmd_macsec_sc_tx_rx =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_sc_result,
tx_rx, "tx#rx");
-cmdline_parse_token_num_t cmd_macsec_sc_port_id =
+static cmdline_parse_token_num_t cmd_macsec_sc_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_sc_result,
- port_id, UINT16);
-cmdline_parse_token_etheraddr_t cmd_macsec_sc_mac =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_etheraddr_t cmd_macsec_sc_mac =
TOKEN_ETHERADDR_INITIALIZER
(struct cmd_macsec_sc_result,
mac);
-cmdline_parse_token_num_t cmd_macsec_sc_pi =
+static 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(
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));
}
}
-cmdline_parse_inst_t cmd_set_macsec_sc = {
+static cmdline_parse_inst_t cmd_set_macsec_sc = {
.f = cmd_set_macsec_sc_parsed,
.data = NULL,
.help_str = "set macsec sc tx|rx <port_id> <mac> <pi>",
};
/* Common CLI fields for MACsec secure connection configure */
-cmdline_parse_token_string_t cmd_macsec_sa_set =
+static cmdline_parse_token_string_t cmd_macsec_sa_set =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_sa_result,
set, "set");
-cmdline_parse_token_string_t cmd_macsec_sa_macsec =
+static cmdline_parse_token_string_t cmd_macsec_sa_macsec =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_sa_result,
macsec, "macsec");
-cmdline_parse_token_string_t cmd_macsec_sa_sa =
+static cmdline_parse_token_string_t cmd_macsec_sa_sa =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_sa_result,
sa, "sa");
-cmdline_parse_token_string_t cmd_macsec_sa_tx_rx =
+static cmdline_parse_token_string_t cmd_macsec_sa_tx_rx =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_sa_result,
tx_rx, "tx#rx");
-cmdline_parse_token_num_t cmd_macsec_sa_port_id =
+static cmdline_parse_token_num_t cmd_macsec_sa_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_sa_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_macsec_sa_idx =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_macsec_sa_idx =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_sa_result,
- idx, UINT8);
-cmdline_parse_token_num_t cmd_macsec_sa_an =
+ idx, RTE_UINT8);
+static cmdline_parse_token_num_t cmd_macsec_sa_an =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_sa_result,
- an, UINT8);
-cmdline_parse_token_num_t cmd_macsec_sa_pn =
+ an, RTE_UINT8);
+static cmdline_parse_token_num_t cmd_macsec_sa_pn =
TOKEN_NUM_INITIALIZER
(struct cmd_macsec_sa_result,
- pn, UINT32);
-cmdline_parse_token_string_t cmd_macsec_sa_key =
+ pn, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_macsec_sa_key =
TOKEN_STRING_INITIALIZER
(struct cmd_macsec_sa_result,
key, NULL);
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));
}
}
-cmdline_parse_inst_t cmd_set_macsec_sa = {
+static cmdline_parse_inst_t cmd_set_macsec_sa = {
.f = cmd_set_macsec_sa_parsed,
.data = NULL,
.help_str = "set macsec sa tx|rx <port_id> <idx> <an> <pn> <key>",
};
/* Common CLI fields for VF unicast promiscuous mode enable disable */
-cmdline_parse_token_string_t cmd_vf_promisc_set =
+static cmdline_parse_token_string_t cmd_vf_promisc_set =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_promisc_result,
set, "set");
-cmdline_parse_token_string_t cmd_vf_promisc_vf =
+static cmdline_parse_token_string_t cmd_vf_promisc_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_promisc_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_vf_promisc_promisc =
+static cmdline_parse_token_string_t cmd_vf_promisc_promisc =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_promisc_result,
promisc, "promisc");
-cmdline_parse_token_num_t cmd_vf_promisc_port_id =
+static cmdline_parse_token_num_t cmd_vf_promisc_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_promisc_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_vf_promisc_vf_id =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_vf_promisc_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_promisc_result,
- vf_id, UINT32);
-cmdline_parse_token_string_t cmd_vf_promisc_on_off =
+ vf_id, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_vf_promisc_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_promisc_result,
on_off, "on#off");
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));
}
}
-cmdline_parse_inst_t cmd_set_vf_promisc = {
+static cmdline_parse_inst_t cmd_set_vf_promisc = {
.f = cmd_set_vf_promisc_parsed,
.data = NULL,
.help_str = "set vf promisc <port_id> <vf_id> on|off: "
};
/* Common CLI fields for VF multicast promiscuous mode enable disable */
-cmdline_parse_token_string_t cmd_vf_allmulti_set =
+static cmdline_parse_token_string_t cmd_vf_allmulti_set =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_allmulti_result,
set, "set");
-cmdline_parse_token_string_t cmd_vf_allmulti_vf =
+static cmdline_parse_token_string_t cmd_vf_allmulti_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_allmulti_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_vf_allmulti_allmulti =
+static cmdline_parse_token_string_t cmd_vf_allmulti_allmulti =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_allmulti_result,
allmulti, "allmulti");
-cmdline_parse_token_num_t cmd_vf_allmulti_port_id =
+static cmdline_parse_token_num_t cmd_vf_allmulti_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_allmulti_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_vf_allmulti_vf_id =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_vf_allmulti_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_allmulti_result,
- vf_id, UINT32);
-cmdline_parse_token_string_t cmd_vf_allmulti_on_off =
+ vf_id, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_vf_allmulti_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_allmulti_result,
on_off, "on#off");
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));
}
}
-cmdline_parse_inst_t cmd_set_vf_allmulti = {
+static cmdline_parse_inst_t cmd_set_vf_allmulti = {
.f = cmd_set_vf_allmulti_parsed,
.data = NULL,
.help_str = "set vf allmulti <port_id> <vf_id> on|off: "
};
/* Common CLI fields for vf broadcast enable disable */
-cmdline_parse_token_string_t cmd_set_vf_broadcast_set =
+static cmdline_parse_token_string_t cmd_set_vf_broadcast_set =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_broadcast_result,
set, "set");
-cmdline_parse_token_string_t cmd_set_vf_broadcast_vf =
+static cmdline_parse_token_string_t cmd_set_vf_broadcast_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_broadcast_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_set_vf_broadcast_broadcast =
+static cmdline_parse_token_string_t cmd_set_vf_broadcast_broadcast =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_broadcast_result,
broadcast, "broadcast");
-cmdline_parse_token_num_t cmd_set_vf_broadcast_port_id =
+static cmdline_parse_token_num_t cmd_set_vf_broadcast_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_vf_broadcast_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_set_vf_broadcast_vf_id =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_set_vf_broadcast_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_vf_broadcast_result,
- vf_id, UINT16);
-cmdline_parse_token_string_t cmd_set_vf_broadcast_on_off =
+ vf_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_vf_broadcast_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_broadcast_result,
on_off, "on#off");
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));
}
}
-cmdline_parse_inst_t cmd_set_vf_broadcast = {
+static cmdline_parse_inst_t cmd_set_vf_broadcast = {
.f = cmd_set_vf_broadcast_parsed,
.data = NULL,
.help_str = "set vf broadcast <port_id> <vf_id> on|off",
};
/* Common CLI fields for vf vlan tag enable disable */
-cmdline_parse_token_string_t cmd_set_vf_vlan_tag_set =
+static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_set =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_vlan_tag_result,
set, "set");
-cmdline_parse_token_string_t cmd_set_vf_vlan_tag_vf =
+static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_vlan_tag_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_set_vf_vlan_tag_vlan =
+static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_vlan =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_vlan_tag_result,
vlan, "vlan");
-cmdline_parse_token_string_t cmd_set_vf_vlan_tag_tag =
+static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_tag =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_vlan_tag_result,
tag, "tag");
-cmdline_parse_token_num_t cmd_set_vf_vlan_tag_port_id =
+static 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);
-cmdline_parse_token_num_t cmd_set_vf_vlan_tag_vf_id =
+ port_id, RTE_UINT16);
+static 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);
-cmdline_parse_token_string_t cmd_set_vf_vlan_tag_on_off =
+ vf_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_set_vf_vlan_tag_result,
on_off, "on#off");
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));
}
}
-cmdline_parse_inst_t cmd_set_vf_vlan_tag = {
+static cmdline_parse_inst_t cmd_set_vf_vlan_tag = {
.f = cmd_set_vf_vlan_tag_parsed,
.data = NULL,
.help_str = "set vf vlan tag <port_id> <vf_id> on|off",
uint8_t tc_map;
};
-cmdline_parse_token_string_t cmd_vf_tc_bw_set =
+static cmdline_parse_token_string_t cmd_vf_tc_bw_set =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_tc_bw_result,
set, "set");
-cmdline_parse_token_string_t cmd_vf_tc_bw_vf =
+static cmdline_parse_token_string_t cmd_vf_tc_bw_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_tc_bw_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_vf_tc_bw_tc =
+static cmdline_parse_token_string_t cmd_vf_tc_bw_tc =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_tc_bw_result,
tc, "tc");
-cmdline_parse_token_string_t cmd_vf_tc_bw_tx =
+static cmdline_parse_token_string_t cmd_vf_tc_bw_tx =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_tc_bw_result,
tx, "tx");
-cmdline_parse_token_string_t cmd_vf_tc_bw_strict_link_prio =
+static cmdline_parse_token_string_t cmd_vf_tc_bw_strict_link_prio =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_tc_bw_result,
strict_link_prio, "strict-link-priority");
-cmdline_parse_token_string_t cmd_vf_tc_bw_min_bw =
+static cmdline_parse_token_string_t cmd_vf_tc_bw_min_bw =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_tc_bw_result,
min_bw, "min-bandwidth");
-cmdline_parse_token_string_t cmd_vf_tc_bw_max_bw =
+static cmdline_parse_token_string_t cmd_vf_tc_bw_max_bw =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_tc_bw_result,
max_bw, "max-bandwidth");
-cmdline_parse_token_num_t cmd_vf_tc_bw_port_id =
+static cmdline_parse_token_num_t cmd_vf_tc_bw_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_tc_bw_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_vf_tc_bw_vf_id =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_vf_tc_bw_vf_id =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_tc_bw_result,
- vf_id, UINT16);
-cmdline_parse_token_num_t cmd_vf_tc_bw_tc_no =
+ vf_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_vf_tc_bw_tc_no =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_tc_bw_result,
- tc_no, UINT8);
-cmdline_parse_token_num_t cmd_vf_tc_bw_bw =
+ tc_no, RTE_UINT8);
+static cmdline_parse_token_num_t cmd_vf_tc_bw_bw =
TOKEN_NUM_INITIALIZER
(struct cmd_vf_tc_bw_result,
- bw, UINT32);
-cmdline_parse_token_string_t cmd_vf_tc_bw_bw_list =
+ bw, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_vf_tc_bw_bw_list =
TOKEN_STRING_INITIALIZER
(struct cmd_vf_tc_bw_result,
bw_list, NULL);
-cmdline_parse_token_num_t cmd_vf_tc_bw_tc_map =
+static 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
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));
}
}
-cmdline_parse_inst_t cmd_vf_max_bw = {
+static cmdline_parse_inst_t cmd_vf_max_bw = {
.f = cmd_vf_max_bw_parsed,
.data = NULL,
.help_str = "set vf tx max-bandwidth <port_id> <vf_id> <bandwidth>",
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;
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));
}
}
-cmdline_parse_inst_t cmd_vf_tc_min_bw = {
+static cmdline_parse_inst_t cmd_vf_tc_min_bw = {
.f = cmd_vf_tc_min_bw_parsed,
.data = NULL,
.help_str = "set vf tc tx min-bandwidth <port_id> <vf_id>"
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;
}
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));
}
}
-cmdline_parse_inst_t cmd_tc_min_bw = {
+static cmdline_parse_inst_t cmd_tc_min_bw = {
.f = cmd_tc_min_bw_parsed,
.data = NULL,
.help_str = "set tc tx min-bandwidth <port_id> <bw1, bw2, ...>",
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);
+ fprintf(stderr,
+ "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);
+ 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));
}
}
-cmdline_parse_inst_t cmd_vf_tc_max_bw = {
+static 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 <port_id> <vf_id> <tc_no>"
struct rte_ether_addr eth_dst;
};
-cmdline_parse_token_string_t cmd_set_vxlan_set =
+static cmdline_parse_token_string_t cmd_set_vxlan_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, set, "set");
-cmdline_parse_token_string_t cmd_set_vxlan_vxlan =
+static cmdline_parse_token_string_t cmd_set_vxlan_vxlan =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, vxlan, "vxlan");
-cmdline_parse_token_string_t cmd_set_vxlan_vxlan_tos_ttl =
+static cmdline_parse_token_string_t cmd_set_vxlan_vxlan_tos_ttl =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, vxlan,
"vxlan-tos-ttl");
-cmdline_parse_token_string_t cmd_set_vxlan_vxlan_with_vlan =
+static cmdline_parse_token_string_t cmd_set_vxlan_vxlan_with_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, vxlan,
"vxlan-with-vlan");
-cmdline_parse_token_string_t cmd_set_vxlan_ip_version =
+static cmdline_parse_token_string_t cmd_set_vxlan_ip_version =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"ip-version");
-cmdline_parse_token_string_t cmd_set_vxlan_ip_version_value =
+static cmdline_parse_token_string_t cmd_set_vxlan_ip_version_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, ip_version,
"ipv4#ipv6");
-cmdline_parse_token_string_t cmd_set_vxlan_vni =
+static 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);
-cmdline_parse_token_string_t cmd_set_vxlan_udp_src =
+static cmdline_parse_token_num_t cmd_set_vxlan_vni_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, vni, RTE_UINT32);
+static 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);
-cmdline_parse_token_string_t cmd_set_vxlan_udp_dst =
+static cmdline_parse_token_num_t cmd_set_vxlan_udp_src_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_src, RTE_UINT16);
+static 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);
-cmdline_parse_token_string_t cmd_set_vxlan_ip_tos =
+static cmdline_parse_token_num_t cmd_set_vxlan_udp_dst_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_dst, RTE_UINT16);
+static 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);
-cmdline_parse_token_string_t cmd_set_vxlan_ip_ttl =
+static cmdline_parse_token_num_t cmd_set_vxlan_ip_tos_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tos, RTE_UINT8);
+static 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);
-cmdline_parse_token_string_t cmd_set_vxlan_ip_src =
+static cmdline_parse_token_num_t cmd_set_vxlan_ip_ttl_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, ttl, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_set_vxlan_ip_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"ip-src");
-cmdline_parse_token_ipaddr_t cmd_set_vxlan_ip_src_value =
+static cmdline_parse_token_ipaddr_t cmd_set_vxlan_ip_src_value =
TOKEN_IPADDR_INITIALIZER(struct cmd_set_vxlan_result, ip_src);
-cmdline_parse_token_string_t cmd_set_vxlan_ip_dst =
+static cmdline_parse_token_string_t cmd_set_vxlan_ip_dst =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"ip-dst");
-cmdline_parse_token_ipaddr_t cmd_set_vxlan_ip_dst_value =
+static cmdline_parse_token_ipaddr_t cmd_set_vxlan_ip_dst_value =
TOKEN_IPADDR_INITIALIZER(struct cmd_set_vxlan_result, ip_dst);
-cmdline_parse_token_string_t cmd_set_vxlan_vlan =
+static 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);
-cmdline_parse_token_string_t cmd_set_vxlan_eth_src =
+static cmdline_parse_token_num_t cmd_set_vxlan_vlan_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tci, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_vxlan_eth_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"eth-src");
-cmdline_parse_token_etheraddr_t cmd_set_vxlan_eth_src_value =
+static cmdline_parse_token_etheraddr_t cmd_set_vxlan_eth_src_value =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vxlan_result, eth_src);
-cmdline_parse_token_string_t cmd_set_vxlan_eth_dst =
+static cmdline_parse_token_string_t cmd_set_vxlan_eth_dst =
TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
"eth-dst");
-cmdline_parse_token_etheraddr_t cmd_set_vxlan_eth_dst_value =
+static cmdline_parse_token_etheraddr_t cmd_set_vxlan_eth_dst_value =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vxlan_result, eth_dst);
static void cmd_set_vxlan_parsed(void *parsed_result,
RTE_ETHER_ADDR_LEN);
}
-cmdline_parse_inst_t cmd_set_vxlan = {
+static cmdline_parse_inst_t cmd_set_vxlan = {
.f = cmd_set_vxlan_parsed,
.data = NULL,
.help_str = "set vxlan ip-version ipv4|ipv6 vni <vni> udp-src"
},
};
-cmdline_parse_inst_t cmd_set_vxlan_tos_ttl = {
+static cmdline_parse_inst_t cmd_set_vxlan_tos_ttl = {
.f = cmd_set_vxlan_parsed,
.data = NULL,
.help_str = "set vxlan-tos-ttl ip-version ipv4|ipv6 vni <vni> udp-src"
},
};
-cmdline_parse_inst_t cmd_set_vxlan_with_vlan = {
+static cmdline_parse_inst_t cmd_set_vxlan_with_vlan = {
.f = cmd_set_vxlan_parsed,
.data = NULL,
.help_str = "set vxlan-with-vlan ip-version ipv4|ipv6 vni <vni>"
struct rte_ether_addr eth_dst;
};
-cmdline_parse_token_string_t cmd_set_nvgre_set =
+static cmdline_parse_token_string_t cmd_set_nvgre_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, set, "set");
-cmdline_parse_token_string_t cmd_set_nvgre_nvgre =
+static cmdline_parse_token_string_t cmd_set_nvgre_nvgre =
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, nvgre, "nvgre");
-cmdline_parse_token_string_t cmd_set_nvgre_nvgre_with_vlan =
+static cmdline_parse_token_string_t cmd_set_nvgre_nvgre_with_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, nvgre,
"nvgre-with-vlan");
-cmdline_parse_token_string_t cmd_set_nvgre_ip_version =
+static cmdline_parse_token_string_t cmd_set_nvgre_ip_version =
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
"ip-version");
-cmdline_parse_token_string_t cmd_set_nvgre_ip_version_value =
+static cmdline_parse_token_string_t cmd_set_nvgre_ip_version_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, ip_version,
"ipv4#ipv6");
-cmdline_parse_token_string_t cmd_set_nvgre_tni =
+static 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);
-cmdline_parse_token_string_t cmd_set_nvgre_ip_src =
+static cmdline_parse_token_num_t cmd_set_nvgre_tni_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tni, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_nvgre_ip_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
"ip-src");
-cmdline_parse_token_num_t cmd_set_nvgre_ip_src_value =
+static cmdline_parse_token_num_t cmd_set_nvgre_ip_src_value =
TOKEN_IPADDR_INITIALIZER(struct cmd_set_nvgre_result, ip_src);
-cmdline_parse_token_string_t cmd_set_nvgre_ip_dst =
+static cmdline_parse_token_string_t cmd_set_nvgre_ip_dst =
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
"ip-dst");
-cmdline_parse_token_ipaddr_t cmd_set_nvgre_ip_dst_value =
+static cmdline_parse_token_ipaddr_t cmd_set_nvgre_ip_dst_value =
TOKEN_IPADDR_INITIALIZER(struct cmd_set_nvgre_result, ip_dst);
-cmdline_parse_token_string_t cmd_set_nvgre_vlan =
+static 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);
-cmdline_parse_token_string_t cmd_set_nvgre_eth_src =
+static cmdline_parse_token_num_t cmd_set_nvgre_vlan_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tci, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_nvgre_eth_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
"eth-src");
-cmdline_parse_token_etheraddr_t cmd_set_nvgre_eth_src_value =
+static cmdline_parse_token_etheraddr_t cmd_set_nvgre_eth_src_value =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_nvgre_result, eth_src);
-cmdline_parse_token_string_t cmd_set_nvgre_eth_dst =
+static cmdline_parse_token_string_t cmd_set_nvgre_eth_dst =
TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
"eth-dst");
-cmdline_parse_token_etheraddr_t cmd_set_nvgre_eth_dst_value =
+static cmdline_parse_token_etheraddr_t cmd_set_nvgre_eth_dst_value =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_nvgre_result, eth_dst);
static void cmd_set_nvgre_parsed(void *parsed_result,
RTE_ETHER_ADDR_LEN);
}
-cmdline_parse_inst_t cmd_set_nvgre = {
+static cmdline_parse_inst_t cmd_set_nvgre = {
.f = cmd_set_nvgre_parsed,
.data = NULL,
.help_str = "set nvgre ip-version <ipv4|ipv6> tni <tni> ip-src"
},
};
-cmdline_parse_inst_t cmd_set_nvgre_with_vlan = {
+static cmdline_parse_inst_t cmd_set_nvgre_with_vlan = {
.f = cmd_set_nvgre_parsed,
.data = NULL,
.help_str = "set nvgre-with-vlan ip-version <ipv4|ipv6> tni <tni>"
struct rte_ether_addr eth_dst;
};
-cmdline_parse_token_string_t cmd_set_l2_encap_set =
+static cmdline_parse_token_string_t cmd_set_l2_encap_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, set, "set");
-cmdline_parse_token_string_t cmd_set_l2_encap_l2_encap =
+static cmdline_parse_token_string_t cmd_set_l2_encap_l2_encap =
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, l2_encap, "l2_encap");
-cmdline_parse_token_string_t cmd_set_l2_encap_l2_encap_with_vlan =
+static cmdline_parse_token_string_t cmd_set_l2_encap_l2_encap_with_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, l2_encap,
"l2_encap-with-vlan");
-cmdline_parse_token_string_t cmd_set_l2_encap_ip_version =
+static cmdline_parse_token_string_t cmd_set_l2_encap_ip_version =
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
"ip-version");
-cmdline_parse_token_string_t cmd_set_l2_encap_ip_version_value =
+static cmdline_parse_token_string_t cmd_set_l2_encap_ip_version_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, ip_version,
"ipv4#ipv6");
-cmdline_parse_token_string_t cmd_set_l2_encap_vlan =
+static 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);
-cmdline_parse_token_string_t cmd_set_l2_encap_eth_src =
+static cmdline_parse_token_num_t cmd_set_l2_encap_vlan_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_l2_encap_result, tci, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_l2_encap_eth_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
"eth-src");
-cmdline_parse_token_etheraddr_t cmd_set_l2_encap_eth_src_value =
+static cmdline_parse_token_etheraddr_t cmd_set_l2_encap_eth_src_value =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_l2_encap_result, eth_src);
-cmdline_parse_token_string_t cmd_set_l2_encap_eth_dst =
+static cmdline_parse_token_string_t cmd_set_l2_encap_eth_dst =
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
"eth-dst");
-cmdline_parse_token_etheraddr_t cmd_set_l2_encap_eth_dst_value =
+static cmdline_parse_token_etheraddr_t cmd_set_l2_encap_eth_dst_value =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_l2_encap_result, eth_dst);
static void cmd_set_l2_encap_parsed(void *parsed_result,
RTE_ETHER_ADDR_LEN);
}
-cmdline_parse_inst_t cmd_set_l2_encap = {
+static cmdline_parse_inst_t cmd_set_l2_encap = {
.f = cmd_set_l2_encap_parsed,
.data = NULL,
.help_str = "set l2_encap ip-version ipv4|ipv6"
},
};
-cmdline_parse_inst_t cmd_set_l2_encap_with_vlan = {
+static cmdline_parse_inst_t cmd_set_l2_encap_with_vlan = {
.f = cmd_set_l2_encap_parsed,
.data = NULL,
.help_str = "set l2_encap-with-vlan ip-version ipv4|ipv6"
uint32_t vlan_present:1;
};
-cmdline_parse_token_string_t cmd_set_l2_decap_set =
+static cmdline_parse_token_string_t cmd_set_l2_decap_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_decap_result, set, "set");
-cmdline_parse_token_string_t cmd_set_l2_decap_l2_decap =
+static cmdline_parse_token_string_t cmd_set_l2_decap_l2_decap =
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_decap_result, l2_decap,
"l2_decap");
-cmdline_parse_token_string_t cmd_set_l2_decap_l2_decap_with_vlan =
+static cmdline_parse_token_string_t cmd_set_l2_decap_l2_decap_with_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_set_l2_decap_result, l2_decap,
"l2_decap-with-vlan");
l2_decap_conf.select_vlan = 1;
}
-cmdline_parse_inst_t cmd_set_l2_decap = {
+static cmdline_parse_inst_t cmd_set_l2_decap = {
.f = cmd_set_l2_decap_parsed,
.data = NULL,
.help_str = "set l2_decap",
},
};
-cmdline_parse_inst_t cmd_set_l2_decap_with_vlan = {
+static cmdline_parse_inst_t cmd_set_l2_decap_with_vlan = {
.f = cmd_set_l2_decap_parsed,
.data = NULL,
.help_str = "set l2_decap-with-vlan",
struct rte_ether_addr eth_dst;
};
-cmdline_parse_token_string_t cmd_set_mplsogre_encap_set =
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result, set,
"set");
-cmdline_parse_token_string_t cmd_set_mplsogre_encap_mplsogre_encap =
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_mplsogre_encap =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result, mplsogre,
"mplsogre_encap");
-cmdline_parse_token_string_t cmd_set_mplsogre_encap_mplsogre_encap_with_vlan =
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_mplsogre_encap_with_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
mplsogre, "mplsogre_encap-with-vlan");
-cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_version =
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_version =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
pos_token, "ip-version");
-cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_version_value =
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_version_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
ip_version, "ipv4#ipv6");
-cmdline_parse_token_string_t cmd_set_mplsogre_encap_label =
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_label =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
pos_token, "label");
-cmdline_parse_token_num_t cmd_set_mplsogre_encap_label_value =
+static cmdline_parse_token_num_t cmd_set_mplsogre_encap_label_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsogre_encap_result, label,
- UINT32);
-cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_src =
+ RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
pos_token, "ip-src");
-cmdline_parse_token_ipaddr_t cmd_set_mplsogre_encap_ip_src_value =
+static cmdline_parse_token_ipaddr_t cmd_set_mplsogre_encap_ip_src_value =
TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result, ip_src);
-cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_dst =
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_dst =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
pos_token, "ip-dst");
-cmdline_parse_token_ipaddr_t cmd_set_mplsogre_encap_ip_dst_value =
+static cmdline_parse_token_ipaddr_t cmd_set_mplsogre_encap_ip_dst_value =
TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result, ip_dst);
-cmdline_parse_token_string_t cmd_set_mplsogre_encap_vlan =
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
pos_token, "vlan-tci");
-cmdline_parse_token_num_t cmd_set_mplsogre_encap_vlan_value =
+static cmdline_parse_token_num_t cmd_set_mplsogre_encap_vlan_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsogre_encap_result, tci,
- UINT16);
-cmdline_parse_token_string_t cmd_set_mplsogre_encap_eth_src =
+ RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_eth_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
pos_token, "eth-src");
-cmdline_parse_token_etheraddr_t cmd_set_mplsogre_encap_eth_src_value =
+static cmdline_parse_token_etheraddr_t cmd_set_mplsogre_encap_eth_src_value =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result,
eth_src);
-cmdline_parse_token_string_t cmd_set_mplsogre_encap_eth_dst =
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_eth_dst =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
pos_token, "eth-dst");
-cmdline_parse_token_etheraddr_t cmd_set_mplsogre_encap_eth_dst_value =
+static cmdline_parse_token_etheraddr_t cmd_set_mplsogre_encap_eth_dst_value =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result,
eth_dst);
RTE_ETHER_ADDR_LEN);
}
-cmdline_parse_inst_t cmd_set_mplsogre_encap = {
+static cmdline_parse_inst_t cmd_set_mplsogre_encap = {
.f = cmd_set_mplsogre_encap_parsed,
.data = NULL,
.help_str = "set mplsogre_encap ip-version ipv4|ipv6 label <label>"
},
};
-cmdline_parse_inst_t cmd_set_mplsogre_encap_with_vlan = {
+static cmdline_parse_inst_t cmd_set_mplsogre_encap_with_vlan = {
.f = cmd_set_mplsogre_encap_parsed,
.data = NULL,
.help_str = "set mplsogre_encap-with-vlan ip-version ipv4|ipv6"
uint32_t vlan_present:1;
};
-cmdline_parse_token_string_t cmd_set_mplsogre_decap_set =
+static cmdline_parse_token_string_t cmd_set_mplsogre_decap_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result, set,
"set");
-cmdline_parse_token_string_t cmd_set_mplsogre_decap_mplsogre_decap =
+static cmdline_parse_token_string_t cmd_set_mplsogre_decap_mplsogre_decap =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result, mplsogre,
"mplsogre_decap");
-cmdline_parse_token_string_t cmd_set_mplsogre_decap_mplsogre_decap_with_vlan =
+static cmdline_parse_token_string_t cmd_set_mplsogre_decap_mplsogre_decap_with_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result,
mplsogre, "mplsogre_decap-with-vlan");
-cmdline_parse_token_string_t cmd_set_mplsogre_decap_ip_version =
+static cmdline_parse_token_string_t cmd_set_mplsogre_decap_ip_version =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result,
pos_token, "ip-version");
-cmdline_parse_token_string_t cmd_set_mplsogre_decap_ip_version_value =
+static cmdline_parse_token_string_t cmd_set_mplsogre_decap_ip_version_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result,
ip_version, "ipv4#ipv6");
mplsogre_decap_conf.select_ipv4 = 0;
}
-cmdline_parse_inst_t cmd_set_mplsogre_decap = {
+static cmdline_parse_inst_t cmd_set_mplsogre_decap = {
.f = cmd_set_mplsogre_decap_parsed,
.data = NULL,
.help_str = "set mplsogre_decap ip-version ipv4|ipv6",
},
};
-cmdline_parse_inst_t cmd_set_mplsogre_decap_with_vlan = {
+static cmdline_parse_inst_t cmd_set_mplsogre_decap_with_vlan = {
.f = cmd_set_mplsogre_decap_parsed,
.data = NULL,
.help_str = "set mplsogre_decap-with-vlan ip-version ipv4|ipv6",
struct rte_ether_addr eth_dst;
};
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_set =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result, set,
"set");
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_mplsoudp_encap =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_mplsoudp_encap =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result, mplsoudp,
"mplsoudp_encap");
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_mplsoudp_encap_with_vlan =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_mplsoudp_encap_with_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
mplsoudp, "mplsoudp_encap-with-vlan");
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_version =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_version =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
pos_token, "ip-version");
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_version_value =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_version_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
ip_version, "ipv4#ipv6");
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_label =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_label =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
pos_token, "label");
-cmdline_parse_token_num_t cmd_set_mplsoudp_encap_label_value =
+static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_label_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, label,
- UINT32);
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_udp_src =
+ RTE_UINT32);
+static 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 =
+static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_udp_src_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, udp_src,
- UINT16);
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_udp_dst =
+ RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_udp_dst_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, udp_dst,
- UINT16);
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_src =
+ RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
pos_token, "ip-src");
-cmdline_parse_token_ipaddr_t cmd_set_mplsoudp_encap_ip_src_value =
+static cmdline_parse_token_ipaddr_t cmd_set_mplsoudp_encap_ip_src_value =
TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result, ip_src);
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_dst =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_dst =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
pos_token, "ip-dst");
-cmdline_parse_token_ipaddr_t cmd_set_mplsoudp_encap_ip_dst_value =
+static cmdline_parse_token_ipaddr_t cmd_set_mplsoudp_encap_ip_dst_value =
TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result, ip_dst);
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_vlan =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
pos_token, "vlan-tci");
-cmdline_parse_token_num_t cmd_set_mplsoudp_encap_vlan_value =
+static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_vlan_value =
TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, tci,
- UINT16);
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_eth_src =
+ RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_eth_src =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
pos_token, "eth-src");
-cmdline_parse_token_etheraddr_t cmd_set_mplsoudp_encap_eth_src_value =
+static cmdline_parse_token_etheraddr_t cmd_set_mplsoudp_encap_eth_src_value =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
eth_src);
-cmdline_parse_token_string_t cmd_set_mplsoudp_encap_eth_dst =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_eth_dst =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
pos_token, "eth-dst");
-cmdline_parse_token_etheraddr_t cmd_set_mplsoudp_encap_eth_dst_value =
+static cmdline_parse_token_etheraddr_t cmd_set_mplsoudp_encap_eth_dst_value =
TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
eth_dst);
RTE_ETHER_ADDR_LEN);
}
-cmdline_parse_inst_t cmd_set_mplsoudp_encap = {
+static cmdline_parse_inst_t cmd_set_mplsoudp_encap = {
.f = cmd_set_mplsoudp_encap_parsed,
.data = NULL,
.help_str = "set mplsoudp_encap ip-version ipv4|ipv6 label <label>"
},
};
-cmdline_parse_inst_t cmd_set_mplsoudp_encap_with_vlan = {
+static cmdline_parse_inst_t cmd_set_mplsoudp_encap_with_vlan = {
.f = cmd_set_mplsoudp_encap_parsed,
.data = NULL,
.help_str = "set mplsoudp_encap-with-vlan ip-version ipv4|ipv6"
uint32_t vlan_present:1;
};
-cmdline_parse_token_string_t cmd_set_mplsoudp_decap_set =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_set =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result, set,
"set");
-cmdline_parse_token_string_t cmd_set_mplsoudp_decap_mplsoudp_decap =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_mplsoudp_decap =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result, mplsoudp,
"mplsoudp_decap");
-cmdline_parse_token_string_t cmd_set_mplsoudp_decap_mplsoudp_decap_with_vlan =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_mplsoudp_decap_with_vlan =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result,
mplsoudp, "mplsoudp_decap-with-vlan");
-cmdline_parse_token_string_t cmd_set_mplsoudp_decap_ip_version =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_ip_version =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result,
pos_token, "ip-version");
-cmdline_parse_token_string_t cmd_set_mplsoudp_decap_ip_version_value =
+static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_ip_version_value =
TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result,
ip_version, "ipv4#ipv6");
mplsoudp_decap_conf.select_ipv4 = 0;
}
-cmdline_parse_inst_t cmd_set_mplsoudp_decap = {
+static cmdline_parse_inst_t cmd_set_mplsoudp_decap = {
.f = cmd_set_mplsoudp_decap_parsed,
.data = NULL,
.help_str = "set mplsoudp_decap ip-version ipv4|ipv6",
},
};
-cmdline_parse_inst_t cmd_set_mplsoudp_decap_with_vlan = {
+static cmdline_parse_inst_t cmd_set_mplsoudp_decap_with_vlan = {
.f = cmd_set_mplsoudp_decap_parsed,
.data = NULL,
.help_str = "set mplsoudp_decap-with-vlan ip-version ipv4|ipv6",
},
};
+/** 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;
+};
+
+static cmdline_parse_token_string_t cmd_set_conntrack_set =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ set, "set");
+static cmdline_parse_token_string_t cmd_set_conntrack_conntrack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ conntrack, "conntrack");
+static cmdline_parse_token_string_t cmd_set_conntrack_common_com =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ common, "com");
+static cmdline_parse_token_string_t cmd_set_conntrack_common_peer =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ peer, "peer");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_peer_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ peer_port, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_is_orig =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ is_orig, "is_orig");
+static 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);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_enable =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ enable, "enable");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_enable_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ en, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_live =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ live, "live");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_live_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ is_live, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_sack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ sack, "sack");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_sack_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ s_ack, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_cack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ cack, "cack");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_cack_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ c_ack, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_dir =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_dir, "last_dir");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_last_dir_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ ld, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_liberal =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ liberal, "liberal");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_liberal_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ lb, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_state =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ state, "state");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_state_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ stat, RTE_UINT8);
+static 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");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_max_ackwin_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ factor, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_retrans =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ retrans, "r_lim");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_retrans_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ re_num, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_win =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_win, "last_win");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_last_win_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ lw, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_seq =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_seq, "last_seq");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_last_seq_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ ls, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_ack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_ack, "last_ack");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_last_ack_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ la, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_end =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_end, "last_end");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_last_end_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+ le, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_index =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+ last_index, "last_index");
+static 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;
+}
+
+static cmdline_parse_inst_t cmd_set_conntrack_common = {
+ .f = cmd_set_conntrack_common_parsed,
+ .data = NULL,
+ .help_str = "set conntrack com peer <port_id> is_orig <dir> enable <en>"
+ " live <ack_seen> sack <en> cack <passed> last_dir <dir>"
+ " liberal <en> state <s> max_ack_win <factor> r_lim <num>"
+ " last_win <win> last_seq <seq> last_ack <ack> last_end <end>"
+ " last_index <flag>",
+ .tokens = {
+ (void *)&cmd_set_conntrack_set,
+ (void *)&cmd_set_conntrack_conntrack,
+ (void *)&cmd_set_conntrack_common_com,
+ (void *)&cmd_set_conntrack_common_peer,
+ (void *)&cmd_set_conntrack_common_peer_value,
+ (void *)&cmd_set_conntrack_common_is_orig,
+ (void *)&cmd_set_conntrack_common_is_orig_value,
+ (void *)&cmd_set_conntrack_common_enable,
+ (void *)&cmd_set_conntrack_common_enable_value,
+ (void *)&cmd_set_conntrack_common_live,
+ (void *)&cmd_set_conntrack_common_live_value,
+ (void *)&cmd_set_conntrack_common_sack,
+ (void *)&cmd_set_conntrack_common_sack_value,
+ (void *)&cmd_set_conntrack_common_cack,
+ (void *)&cmd_set_conntrack_common_cack_value,
+ (void *)&cmd_set_conntrack_common_last_dir,
+ (void *)&cmd_set_conntrack_common_last_dir_value,
+ (void *)&cmd_set_conntrack_common_liberal,
+ (void *)&cmd_set_conntrack_common_liberal_value,
+ (void *)&cmd_set_conntrack_common_state,
+ (void *)&cmd_set_conntrack_common_state_value,
+ (void *)&cmd_set_conntrack_common_max_ackwin,
+ (void *)&cmd_set_conntrack_common_max_ackwin_value,
+ (void *)&cmd_set_conntrack_common_retrans,
+ (void *)&cmd_set_conntrack_common_retrans_value,
+ (void *)&cmd_set_conntrack_common_last_win,
+ (void *)&cmd_set_conntrack_common_last_win_value,
+ (void *)&cmd_set_conntrack_common_last_seq,
+ (void *)&cmd_set_conntrack_common_last_seq_value,
+ (void *)&cmd_set_conntrack_common_last_ack,
+ (void *)&cmd_set_conntrack_common_last_ack_value,
+ (void *)&cmd_set_conntrack_common_last_end,
+ (void *)&cmd_set_conntrack_common_last_end_value,
+ (void *)&cmd_set_conntrack_common_last_index,
+ (void *)&cmd_set_conntrack_common_last_index_value,
+ NULL,
+ },
+};
+
+/** Set connection tracking object both directions' details */
+struct cmd_set_conntrack_dir_result {
+ cmdline_fixed_string_t set;
+ cmdline_fixed_string_t conntrack;
+ cmdline_fixed_string_t dir;
+ cmdline_fixed_string_t scale;
+ cmdline_fixed_string_t fin;
+ cmdline_fixed_string_t ack_seen;
+ cmdline_fixed_string_t unack;
+ cmdline_fixed_string_t sent_end;
+ cmdline_fixed_string_t reply_end;
+ cmdline_fixed_string_t max_win;
+ cmdline_fixed_string_t max_ack;
+ uint32_t factor;
+ uint32_t f;
+ uint32_t as;
+ uint32_t un;
+ uint32_t se;
+ uint32_t re;
+ uint32_t mw;
+ uint32_t ma;
+};
+
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_dir =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ dir, "orig#rply");
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_scale =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ scale, "scale");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_scale_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ factor, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_fin =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ fin, "fin");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_fin_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ f, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_ack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ ack_seen, "acked");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_ack_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ as, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_unack_data =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ unack, "unack_data");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_unack_data_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ un, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_sent_end =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ sent_end, "sent_end");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_sent_end_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ se, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_reply_end =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ reply_end, "reply_end");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_reply_end_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ re, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_max_win =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ max_win, "max_win");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_max_win_value =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ mw, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_max_ack =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+ max_ack, "max_ack");
+static 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;
+}
+
+static cmdline_parse_inst_t cmd_set_conntrack_dir = {
+ .f = cmd_set_conntrack_dir_parsed,
+ .data = NULL,
+ .help_str = "set conntrack orig|rply scale <factor> fin <sent>"
+ " acked <seen> unack_data <unack> sent_end <sent>"
+ " reply_end <reply> max_win <win> max_ack <ack>",
+ .tokens = {
+ (void *)&cmd_set_conntrack_set,
+ (void *)&cmd_set_conntrack_conntrack,
+ (void *)&cmd_set_conntrack_dir_dir,
+ (void *)&cmd_set_conntrack_dir_scale,
+ (void *)&cmd_set_conntrack_dir_scale_value,
+ (void *)&cmd_set_conntrack_dir_fin,
+ (void *)&cmd_set_conntrack_dir_fin_value,
+ (void *)&cmd_set_conntrack_dir_ack,
+ (void *)&cmd_set_conntrack_dir_ack_value,
+ (void *)&cmd_set_conntrack_dir_unack_data,
+ (void *)&cmd_set_conntrack_dir_unack_data_value,
+ (void *)&cmd_set_conntrack_dir_sent_end,
+ (void *)&cmd_set_conntrack_dir_sent_end_value,
+ (void *)&cmd_set_conntrack_dir_reply_end,
+ (void *)&cmd_set_conntrack_dir_reply_end_value,
+ (void *)&cmd_set_conntrack_dir_max_win,
+ (void *)&cmd_set_conntrack_dir_max_win_value,
+ (void *)&cmd_set_conntrack_dir_max_ack,
+ (void *)&cmd_set_conntrack_dir_max_ack_value,
+ NULL,
+ },
+};
+
/* Strict link priority scheduling mode setting */
static void
cmd_strict_link_prio_parsed(
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));
}
}
-cmdline_parse_inst_t cmd_strict_link_prio = {
+static cmdline_parse_inst_t cmd_strict_link_prio = {
.f = cmd_strict_link_prio_parsed,
.data = NULL,
.help_str = "set tx strict-link-priority <port_id> <tc_bitmap>",
char filepath[];
};
-cmdline_parse_token_string_t cmd_ddp_add_ddp =
+static cmdline_parse_token_string_t cmd_ddp_add_ddp =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, ddp, "ddp");
-cmdline_parse_token_string_t cmd_ddp_add_add =
+static 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);
-cmdline_parse_token_string_t cmd_ddp_add_filepath =
+static cmdline_parse_token_num_t cmd_ddp_add_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_ddp_add_result, port_id,
+ RTE_UINT16);
+static cmdline_parse_token_string_t cmd_ddp_add_filepath =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, filepath, NULL);
static void
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, ',');
#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);
free((void *)filepath);
}
-cmdline_parse_inst_t cmd_ddp_add = {
+static cmdline_parse_inst_t cmd_ddp_add = {
.f = cmd_ddp_add_parsed,
.data = NULL,
.help_str = "ddp add <port_id> <profile_path[,backup_profile_path]>",
char filepath[];
};
-cmdline_parse_token_string_t cmd_ddp_del_ddp =
+static cmdline_parse_token_string_t cmd_ddp_del_ddp =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, ddp, "ddp");
-cmdline_parse_token_string_t cmd_ddp_del_del =
+static 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);
-cmdline_parse_token_string_t cmd_ddp_del_filepath =
+static cmdline_parse_token_num_t cmd_ddp_del_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_ddp_del_result, port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_ddp_del_filepath =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, filepath, NULL);
static void
int ret = -ENOTSUP;
if (!all_ports_stopped()) {
- printf("Please stop all ports first\n");
+ fprintf(stderr, "Please stop all ports first\n");
return;
}
#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);
}
-cmdline_parse_inst_t cmd_ddp_del = {
+static cmdline_parse_inst_t cmd_ddp_del = {
.f = cmd_ddp_del_parsed,
.data = NULL,
.help_str = "ddp del <port_id> <backup_profile_path>",
char filepath[];
};
-cmdline_parse_token_string_t cmd_ddp_info_ddp =
+static cmdline_parse_token_string_t cmd_ddp_info_ddp =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, ddp, "ddp");
-cmdline_parse_token_string_t cmd_ddp_info_get =
+static cmdline_parse_token_string_t cmd_ddp_info_get =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, get, "get");
-cmdline_parse_token_string_t cmd_ddp_info_info =
+static cmdline_parse_token_string_t cmd_ddp_info_info =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, info, "info");
-cmdline_parse_token_string_t cmd_ddp_info_filepath =
+static cmdline_parse_token_string_t cmd_ddp_info_filepath =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, filepath, NULL);
static void
ret = 0;
no_print_return:
- if (proto)
- free(proto);
+ free(proto);
#endif
if (ret == -ENOTSUP)
- printf("Function not supported in PMD driver\n");
+ fprintf(stderr, "Function not supported in PMD\n");
close_file(pkg);
}
-cmdline_parse_inst_t cmd_ddp_get_info = {
+static cmdline_parse_inst_t cmd_ddp_get_info = {
.f = cmd_ddp_info_parsed,
.data = NULL,
.help_str = "ddp get info <profile_path>",
portid_t port_id;
};
-cmdline_parse_token_string_t cmd_ddp_get_list_ddp =
+static cmdline_parse_token_string_t cmd_ddp_get_list_ddp =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_get_list_result, ddp, "ddp");
-cmdline_parse_token_string_t cmd_ddp_get_list_get =
+static cmdline_parse_token_string_t cmd_ddp_get_list_get =
TOKEN_STRING_INITIALIZER(struct cmd_ddp_get_list_result, get, "get");
-cmdline_parse_token_string_t cmd_ddp_get_list_list =
+static 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);
+static cmdline_parse_token_num_t cmd_ddp_get_list_port_id =
+ TOKEN_NUM_INITIALIZER(struct cmd_ddp_get_list_result, port_id,
+ RTE_UINT16);
static void
cmd_ddp_get_list_parsed(
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__);
+ fprintf(stderr, "%s: Failed to malloc buffer\n", __func__);
return;
}
#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 = {
+static cmdline_parse_inst_t cmd_ddp_get_list = {
.f = cmd_ddp_get_list_parsed,
.data = NULL,
.help_str = "ddp get list <port_id>",
int ret = -ENOTSUP;
if (!all_ports_stopped()) {
- printf("Please stop all ports first\n");
+ fprintf(stderr, "Please stop all ports first\n");
return;
}
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;
}
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 =
+static cmdline_parse_token_string_t cmd_cfg_input_set_port =
TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
port, "port");
-cmdline_parse_token_string_t cmd_cfg_input_set_cfg =
+static cmdline_parse_token_string_t cmd_cfg_input_set_cfg =
TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
cfg, "config");
-cmdline_parse_token_num_t cmd_cfg_input_set_port_id =
+static cmdline_parse_token_num_t cmd_cfg_input_set_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_cfg_input_set_pctype =
+ port_id, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_cfg_input_set_pctype_id =
TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
- pctype_id, UINT8);
-cmdline_parse_token_string_t cmd_cfg_input_set_inset_type =
+ pctype_id, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_cfg_input_set_inset_type =
TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
inset_type,
"hash_inset#fdir_inset#fdir_flx_inset");
-cmdline_parse_token_string_t cmd_cfg_input_set_opt =
+static cmdline_parse_token_string_t cmd_cfg_input_set_opt =
TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
opt, "get#set#clear");
-cmdline_parse_token_string_t cmd_cfg_input_set_field =
+static cmdline_parse_token_string_t cmd_cfg_input_set_field =
TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
field, "field");
-cmdline_parse_token_num_t cmd_cfg_input_set_field_idx =
+static 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 = {
+static cmdline_parse_inst_t cmd_cfg_input_set = {
.f = cmd_cfg_input_set_parsed,
.data = NULL,
.help_str = "port config <port_id> pctype <pctype_id> hash_inset|"
int ret = -ENOTSUP;
if (!all_ports_stopped()) {
- printf("Please stop all ports first\n");
+ fprintf(stderr, "Please stop all ports first\n");
return;
}
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 =
+static cmdline_parse_token_string_t cmd_clear_input_set_port =
TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
port, "port");
-cmdline_parse_token_string_t cmd_clear_input_set_cfg =
+static cmdline_parse_token_string_t cmd_clear_input_set_cfg =
TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
cfg, "config");
-cmdline_parse_token_num_t cmd_clear_input_set_port_id =
+static cmdline_parse_token_num_t cmd_clear_input_set_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_clear_input_set_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_clear_input_set_pctype =
+ port_id, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_clear_input_set_pctype_id =
TOKEN_NUM_INITIALIZER(struct cmd_clear_input_set_result,
- pctype_id, UINT8);
-cmdline_parse_token_string_t cmd_clear_input_set_inset_type =
+ pctype_id, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_clear_input_set_inset_type =
TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
inset_type,
"hash_inset#fdir_inset#fdir_flx_inset");
-cmdline_parse_token_string_t cmd_clear_input_set_clear =
+static cmdline_parse_token_string_t cmd_clear_input_set_clear =
TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
clear, "clear");
-cmdline_parse_token_string_t cmd_clear_input_set_all =
+static cmdline_parse_token_string_t cmd_clear_input_set_all =
TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
all, "all");
-cmdline_parse_inst_t cmd_clear_input_set = {
+static cmdline_parse_inst_t cmd_clear_input_set = {
.f = cmd_clear_input_set_parsed,
.data = NULL,
.help_str = "port config <port_id> pctype <pctype_id> hash_inset|"
};
/* Common CLI fields show vf stats*/
-cmdline_parse_token_string_t cmd_show_vf_stats_show =
+static cmdline_parse_token_string_t cmd_show_vf_stats_show =
TOKEN_STRING_INITIALIZER
(struct cmd_show_vf_stats_result,
show, "show");
-cmdline_parse_token_string_t cmd_show_vf_stats_vf =
+static cmdline_parse_token_string_t cmd_show_vf_stats_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_show_vf_stats_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_show_vf_stats_stats =
+static cmdline_parse_token_string_t cmd_show_vf_stats_stats =
TOKEN_STRING_INITIALIZER
(struct cmd_show_vf_stats_result,
stats, "stats");
-cmdline_parse_token_num_t cmd_show_vf_stats_port_id =
+static cmdline_parse_token_num_t cmd_show_vf_stats_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_show_vf_stats_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_show_vf_stats_vf_id =
+ port_id, RTE_UINT16);
+static 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(
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",
nic_stats_border, nic_stats_border);
}
-cmdline_parse_inst_t cmd_show_vf_stats = {
+static cmdline_parse_inst_t cmd_show_vf_stats = {
.f = cmd_show_vf_stats_parsed,
.data = NULL,
.help_str = "show vf stats <port_id> <vf_id>",
};
/* Common CLI fields clear vf stats*/
-cmdline_parse_token_string_t cmd_clear_vf_stats_clear =
+static cmdline_parse_token_string_t cmd_clear_vf_stats_clear =
TOKEN_STRING_INITIALIZER
(struct cmd_clear_vf_stats_result,
clear, "clear");
-cmdline_parse_token_string_t cmd_clear_vf_stats_vf =
+static cmdline_parse_token_string_t cmd_clear_vf_stats_vf =
TOKEN_STRING_INITIALIZER
(struct cmd_clear_vf_stats_result,
vf, "vf");
-cmdline_parse_token_string_t cmd_clear_vf_stats_stats =
+static cmdline_parse_token_string_t cmd_clear_vf_stats_stats =
TOKEN_STRING_INITIALIZER
(struct cmd_clear_vf_stats_result,
stats, "stats");
-cmdline_parse_token_num_t cmd_clear_vf_stats_port_id =
+static cmdline_parse_token_num_t cmd_clear_vf_stats_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_clear_vf_stats_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_clear_vf_stats_vf_id =
+ port_id, RTE_UINT16);
+static 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(
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));
}
}
-cmdline_parse_inst_t cmd_clear_vf_stats = {
+static cmdline_parse_inst_t cmd_clear_vf_stats = {
.f = cmd_clear_vf_stats_parsed,
.data = NULL,
.help_str = "clear vf stats <port_id> <vf_id>",
};
/* Common CLI fields for port config pctype mapping reset*/
-cmdline_parse_token_string_t cmd_pctype_mapping_reset_port =
+static cmdline_parse_token_string_t cmd_pctype_mapping_reset_port =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_reset_result,
port, "port");
-cmdline_parse_token_string_t cmd_pctype_mapping_reset_config =
+static cmdline_parse_token_string_t cmd_pctype_mapping_reset_config =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_reset_result,
config, "config");
-cmdline_parse_token_num_t cmd_pctype_mapping_reset_port_id =
+static cmdline_parse_token_num_t cmd_pctype_mapping_reset_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_pctype_mapping_reset_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_pctype_mapping_reset_pctype =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_pctype_mapping_reset_pctype =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_reset_result,
pctype, "pctype");
-cmdline_parse_token_string_t cmd_pctype_mapping_reset_mapping =
+static cmdline_parse_token_string_t cmd_pctype_mapping_reset_mapping =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_reset_result,
mapping, "mapping");
-cmdline_parse_token_string_t cmd_pctype_mapping_reset_reset =
+static cmdline_parse_token_string_t cmd_pctype_mapping_reset_reset =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_reset_result,
reset, "reset");
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));
}
}
-cmdline_parse_inst_t cmd_pctype_mapping_reset = {
+static cmdline_parse_inst_t cmd_pctype_mapping_reset = {
.f = cmd_pctype_mapping_reset_parsed,
.data = NULL,
.help_str = "port config <port_id> pctype mapping reset",
};
/* Common CLI fields for pctype mapping get */
-cmdline_parse_token_string_t cmd_pctype_mapping_get_show =
+static cmdline_parse_token_string_t cmd_pctype_mapping_get_show =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_get_result,
show, "show");
-cmdline_parse_token_string_t cmd_pctype_mapping_get_port =
+static cmdline_parse_token_string_t cmd_pctype_mapping_get_port =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_get_result,
port, "port");
-cmdline_parse_token_num_t cmd_pctype_mapping_get_port_id =
+static cmdline_parse_token_num_t cmd_pctype_mapping_get_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_pctype_mapping_get_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_pctype_mapping_get_pctype =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_pctype_mapping_get_pctype =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_get_result,
pctype, "pctype");
-cmdline_parse_token_string_t cmd_pctype_mapping_get_mapping =
+static cmdline_parse_token_string_t cmd_pctype_mapping_get_mapping =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_get_result,
mapping, "mapping");
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;
}
#endif
}
-cmdline_parse_inst_t cmd_pctype_mapping_get = {
+static cmdline_parse_inst_t cmd_pctype_mapping_get = {
.f = cmd_pctype_mapping_get_parsed,
.data = NULL,
.help_str = "show port <port_id> pctype mapping",
};
/* Common CLI fields for pctype mapping update*/
-cmdline_parse_token_string_t cmd_pctype_mapping_update_port =
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_port =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_update_result,
port, "port");
-cmdline_parse_token_string_t cmd_pctype_mapping_update_config =
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_config =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_update_result,
config, "config");
-cmdline_parse_token_num_t cmd_pctype_mapping_update_port_id =
+static cmdline_parse_token_num_t cmd_pctype_mapping_update_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_pctype_mapping_update_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_pctype_mapping_update_pctype =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_pctype =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_update_result,
pctype, "pctype");
-cmdline_parse_token_string_t cmd_pctype_mapping_update_mapping =
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_mapping =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_update_result,
mapping, "mapping");
-cmdline_parse_token_string_t cmd_pctype_mapping_update_update =
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_update =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_update_result,
update, "update");
-cmdline_parse_token_string_t cmd_pctype_mapping_update_pc_type =
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_pc_type =
TOKEN_STRING_INITIALIZER
(struct cmd_pctype_mapping_update_result,
pctype_list, NULL);
-cmdline_parse_token_num_t cmd_pctype_mapping_update_flow_type =
+static 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(
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));
}
}
-cmdline_parse_inst_t cmd_pctype_mapping_update = {
+static cmdline_parse_inst_t cmd_pctype_mapping_update = {
.f = cmd_pctype_mapping_update_parsed,
.data = NULL,
.help_str = "port config <port_id> pctype mapping update"
};
/* Common CLI fields for ptype mapping get */
-cmdline_parse_token_string_t cmd_ptype_mapping_get_ptype =
+static cmdline_parse_token_string_t cmd_ptype_mapping_get_ptype =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_get_result,
ptype, "ptype");
-cmdline_parse_token_string_t cmd_ptype_mapping_get_mapping =
+static cmdline_parse_token_string_t cmd_ptype_mapping_get_mapping =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_get_result,
mapping, "mapping");
-cmdline_parse_token_string_t cmd_ptype_mapping_get_get =
+static cmdline_parse_token_string_t cmd_ptype_mapping_get_get =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_get_result,
get, "get");
-cmdline_parse_token_num_t cmd_ptype_mapping_get_port_id =
+static cmdline_parse_token_num_t cmd_ptype_mapping_get_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_get_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_ptype_mapping_get_valid_only =
+ port_id, RTE_UINT16);
+static 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(
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_NET_I40E
#endif
}
-cmdline_parse_inst_t cmd_ptype_mapping_get = {
+static cmdline_parse_inst_t cmd_ptype_mapping_get = {
.f = cmd_ptype_mapping_get_parsed,
.data = NULL,
.help_str = "ptype mapping get <port_id> <valid_only>",
};
/* Common CLI fields for ptype mapping replace */
-cmdline_parse_token_string_t cmd_ptype_mapping_replace_ptype =
+static cmdline_parse_token_string_t cmd_ptype_mapping_replace_ptype =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_replace_result,
ptype, "ptype");
-cmdline_parse_token_string_t cmd_ptype_mapping_replace_mapping =
+static cmdline_parse_token_string_t cmd_ptype_mapping_replace_mapping =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_replace_result,
mapping, "mapping");
-cmdline_parse_token_string_t cmd_ptype_mapping_replace_replace =
+static cmdline_parse_token_string_t cmd_ptype_mapping_replace_replace =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_replace_result,
replace, "replace");
-cmdline_parse_token_num_t cmd_ptype_mapping_replace_port_id =
+static cmdline_parse_token_num_t cmd_ptype_mapping_replace_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_replace_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_ptype_mapping_replace_target =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_ptype_mapping_replace_target =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_replace_result,
- target, UINT32);
-cmdline_parse_token_num_t cmd_ptype_mapping_replace_mask =
+ target, RTE_UINT32);
+static cmdline_parse_token_num_t cmd_ptype_mapping_replace_mask =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_replace_result,
- mask, UINT8);
-cmdline_parse_token_num_t cmd_ptype_mapping_replace_pkt_type =
+ mask, RTE_UINT8);
+static 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(
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));
}
}
-cmdline_parse_inst_t cmd_ptype_mapping_replace = {
+static cmdline_parse_inst_t cmd_ptype_mapping_replace = {
.f = cmd_ptype_mapping_replace_parsed,
.data = NULL,
.help_str =
};
/* Common CLI fields for ptype mapping reset*/
-cmdline_parse_token_string_t cmd_ptype_mapping_reset_ptype =
+static cmdline_parse_token_string_t cmd_ptype_mapping_reset_ptype =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_reset_result,
ptype, "ptype");
-cmdline_parse_token_string_t cmd_ptype_mapping_reset_mapping =
+static cmdline_parse_token_string_t cmd_ptype_mapping_reset_mapping =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_reset_result,
mapping, "mapping");
-cmdline_parse_token_string_t cmd_ptype_mapping_reset_reset =
+static cmdline_parse_token_string_t cmd_ptype_mapping_reset_reset =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_reset_result,
reset, "reset");
-cmdline_parse_token_num_t cmd_ptype_mapping_reset_port_id =
+static 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(
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));
}
}
-cmdline_parse_inst_t cmd_ptype_mapping_reset = {
+static cmdline_parse_inst_t cmd_ptype_mapping_reset = {
.f = cmd_ptype_mapping_reset_parsed,
.data = NULL,
.help_str = "ptype mapping reset <port_id>",
};
/* Common CLI fields for ptype mapping update*/
-cmdline_parse_token_string_t cmd_ptype_mapping_update_ptype =
+static cmdline_parse_token_string_t cmd_ptype_mapping_update_ptype =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_update_result,
ptype, "ptype");
-cmdline_parse_token_string_t cmd_ptype_mapping_update_mapping =
+static cmdline_parse_token_string_t cmd_ptype_mapping_update_mapping =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_update_result,
mapping, "mapping");
-cmdline_parse_token_string_t cmd_ptype_mapping_update_update =
+static cmdline_parse_token_string_t cmd_ptype_mapping_update_update =
TOKEN_STRING_INITIALIZER
(struct cmd_ptype_mapping_update_result,
reset, "update");
-cmdline_parse_token_num_t cmd_ptype_mapping_update_port_id =
+static cmdline_parse_token_num_t cmd_ptype_mapping_update_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_update_result,
- port_id, UINT16);
-cmdline_parse_token_num_t cmd_ptype_mapping_update_hw_ptype =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_ptype_mapping_update_hw_ptype =
TOKEN_NUM_INITIALIZER
(struct cmd_ptype_mapping_update_result,
- hw_ptype, UINT8);
-cmdline_parse_token_num_t cmd_ptype_mapping_update_sw_ptype =
+ hw_ptype, RTE_UINT8);
+static 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(
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));
}
}
-cmdline_parse_inst_t cmd_ptype_mapping_update = {
+static cmdline_parse_inst_t cmd_ptype_mapping_update = {
.f = cmd_ptype_mapping_update_parsed,
.data = NULL,
.help_str = "ptype mapping update <port_id> <hw_ptype> <sw_ptype>",
};
/* Common CLI fields for file commands */
-cmdline_parse_token_string_t cmd_load_cmdfile =
+static cmdline_parse_token_string_t cmd_load_cmdfile =
TOKEN_STRING_INITIALIZER(struct cmd_cmdfile_result, load, "load");
-cmdline_parse_token_string_t cmd_load_cmdfile_filename =
+static cmdline_parse_token_string_t cmd_load_cmdfile_filename =
TOKEN_STRING_INITIALIZER(struct cmd_cmdfile_result, filename, NULL);
static void
cmdline_read_from_file(res->filename);
}
-cmdline_parse_inst_t cmd_load_from_file = {
+static cmdline_parse_inst_t cmd_load_from_file = {
.f = cmd_load_from_file_parsed,
.data = NULL,
.help_str = "load <filename>",
cmdline_fixed_string_t capabilities;
};
-cmdline_parse_token_string_t cmd_rx_offload_get_capa_show =
+static cmdline_parse_token_string_t cmd_rx_offload_get_capa_show =
TOKEN_STRING_INITIALIZER
(struct cmd_rx_offload_get_capa_result,
show, "show");
-cmdline_parse_token_string_t cmd_rx_offload_get_capa_port =
+static cmdline_parse_token_string_t cmd_rx_offload_get_capa_port =
TOKEN_STRING_INITIALIZER
(struct cmd_rx_offload_get_capa_result,
port, "port");
-cmdline_parse_token_num_t cmd_rx_offload_get_capa_port_id =
+static 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);
-cmdline_parse_token_string_t cmd_rx_offload_get_capa_rx_offload =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_rx_offload_get_capa_rx_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_rx_offload_get_capa_result,
rx_offload, "rx_offload");
-cmdline_parse_token_string_t cmd_rx_offload_get_capa_capabilities =
+static cmdline_parse_token_string_t cmd_rx_offload_get_capa_capabilities =
TOKEN_STRING_INITIALIZER
(struct cmd_rx_offload_get_capa_result,
capabilities, "capabilities");
printf("\n\n");
}
-cmdline_parse_inst_t cmd_rx_offload_get_capa = {
+static cmdline_parse_inst_t cmd_rx_offload_get_capa = {
.f = cmd_rx_offload_get_capa_parsed,
.data = NULL,
.help_str = "show port <port_id> rx_offload capabilities",
cmdline_fixed_string_t configuration;
};
-cmdline_parse_token_string_t cmd_rx_offload_get_configuration_show =
+static cmdline_parse_token_string_t cmd_rx_offload_get_configuration_show =
TOKEN_STRING_INITIALIZER
(struct cmd_rx_offload_get_configuration_result,
show, "show");
-cmdline_parse_token_string_t cmd_rx_offload_get_configuration_port =
+static cmdline_parse_token_string_t cmd_rx_offload_get_configuration_port =
TOKEN_STRING_INITIALIZER
(struct cmd_rx_offload_get_configuration_result,
port, "port");
-cmdline_parse_token_num_t cmd_rx_offload_get_configuration_port_id =
+static 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);
-cmdline_parse_token_string_t cmd_rx_offload_get_configuration_rx_offload =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_rx_offload_get_configuration_rx_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_rx_offload_get_configuration_result,
rx_offload, "rx_offload");
-cmdline_parse_token_string_t cmd_rx_offload_get_configuration_configuration =
+static cmdline_parse_token_string_t cmd_rx_offload_get_configuration_configuration =
TOKEN_STRING_INITIALIZER
(struct cmd_rx_offload_get_configuration_result,
configuration, "configuration");
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;
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");
nb_rx_queues = dev_info.nb_rx_queues;
for (q = 0; q < nb_rx_queues; q++) {
- queue_offloads = port->rx_conf[q].offloads;
+ queue_offloads = port->rxq[q].conf.offloads;
printf(" Queue[%2d] :", q);
print_rx_offloads(queue_offloads);
printf("\n");
printf("\n");
}
-cmdline_parse_inst_t cmd_rx_offload_get_configuration = {
+static cmdline_parse_inst_t cmd_rx_offload_get_configuration = {
.f = cmd_rx_offload_get_configuration_parsed,
.data = NULL,
.help_str = "show port <port_id> rx_offload configuration",
cmdline_fixed_string_t on_off;
};
-cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_port =
+static cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_port =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_port_rx_offload_result,
port, "port");
-cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_config =
+static cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_config =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_port_rx_offload_result,
config, "config");
-cmdline_parse_token_num_t cmd_config_per_port_rx_offload_result_port_id =
+static 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);
-cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_rx_offload =
+ port_id, RTE_UINT16);
+static 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,
rx_offload, "rx_offload");
-cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_offload =
+static cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_port_rx_offload_result,
offload, "vlan_strip#ipv4_cksum#udp_cksum#tcp_cksum#tcp_lro#"
"header_split#vlan_filter#vlan_extend#jumbo_frame#"
"scatter#buffer_split#timestamp#security#"
"keep_crc#rss_hash");
-cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_on_off =
+static 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,
on_off, "on#off");
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;
}
if (!strcmp(res->on_off, "on")) {
port->dev_conf.rxmode.offloads |= single_offload;
for (q = 0; q < nb_rx_queues; q++)
- port->rx_conf[q].offloads |= single_offload;
+ port->rxq[q].conf.offloads |= single_offload;
} else {
port->dev_conf.rxmode.offloads &= ~single_offload;
for (q = 0; q < nb_rx_queues; q++)
- port->rx_conf[q].offloads &= ~single_offload;
+ port->rxq[q].conf.offloads &= ~single_offload;
}
cmd_reconfig_device_queue(port_id, 1, 1);
}
-cmdline_parse_inst_t cmd_config_per_port_rx_offload = {
+static cmdline_parse_inst_t cmd_config_per_port_rx_offload = {
.f = cmd_config_per_port_rx_offload_parsed,
.data = NULL,
.help_str = "port config <port_id> rx_offload vlan_strip|ipv4_cksum|"
cmdline_fixed_string_t on_off;
};
-cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_port =
+static cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_port =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_rx_offload_result,
port, "port");
-cmdline_parse_token_num_t cmd_config_per_queue_rx_offload_result_port_id =
+static 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);
-cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_rxq =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_rxq =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_rx_offload_result,
rxq, "rxq");
-cmdline_parse_token_num_t cmd_config_per_queue_rx_offload_result_queue_id =
+static 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);
-cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_rxoffload =
+ queue_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_rxoffload =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_rx_offload_result,
rx_offload, "rx_offload");
-cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_offload =
+static cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_rx_offload_result,
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#buffer_split#timestamp#security#keep_crc");
-cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_on_off =
+static 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,
on_off, "on#off");
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;
}
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;
}
if (!strcmp(res->on_off, "on"))
- port->rx_conf[queue_id].offloads |= single_offload;
+ port->rxq[queue_id].conf.offloads |= single_offload;
else
- port->rx_conf[queue_id].offloads &= ~single_offload;
+ port->rxq[queue_id].conf.offloads &= ~single_offload;
cmd_reconfig_device_queue(port_id, 1, 1);
}
-cmdline_parse_inst_t cmd_config_per_queue_rx_offload = {
+static cmdline_parse_inst_t cmd_config_per_queue_rx_offload = {
.f = cmd_config_per_queue_rx_offload_parsed,
.data = NULL,
.help_str = "port <port_id> rxq <queue_id> rx_offload "
cmdline_fixed_string_t capabilities;
};
-cmdline_parse_token_string_t cmd_tx_offload_get_capa_show =
+static cmdline_parse_token_string_t cmd_tx_offload_get_capa_show =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_offload_get_capa_result,
show, "show");
-cmdline_parse_token_string_t cmd_tx_offload_get_capa_port =
+static cmdline_parse_token_string_t cmd_tx_offload_get_capa_port =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_offload_get_capa_result,
port, "port");
-cmdline_parse_token_num_t cmd_tx_offload_get_capa_port_id =
+static 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);
-cmdline_parse_token_string_t cmd_tx_offload_get_capa_tx_offload =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_tx_offload_get_capa_tx_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_offload_get_capa_result,
tx_offload, "tx_offload");
-cmdline_parse_token_string_t cmd_tx_offload_get_capa_capabilities =
+static cmdline_parse_token_string_t cmd_tx_offload_get_capa_capabilities =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_offload_get_capa_result,
capabilities, "capabilities");
printf("\n\n");
}
-cmdline_parse_inst_t cmd_tx_offload_get_capa = {
+static cmdline_parse_inst_t cmd_tx_offload_get_capa = {
.f = cmd_tx_offload_get_capa_parsed,
.data = NULL,
.help_str = "show port <port_id> tx_offload capabilities",
cmdline_fixed_string_t configuration;
};
-cmdline_parse_token_string_t cmd_tx_offload_get_configuration_show =
+static cmdline_parse_token_string_t cmd_tx_offload_get_configuration_show =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_offload_get_configuration_result,
show, "show");
-cmdline_parse_token_string_t cmd_tx_offload_get_configuration_port =
+static cmdline_parse_token_string_t cmd_tx_offload_get_configuration_port =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_offload_get_configuration_result,
port, "port");
-cmdline_parse_token_num_t cmd_tx_offload_get_configuration_port_id =
+static 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);
-cmdline_parse_token_string_t cmd_tx_offload_get_configuration_tx_offload =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_tx_offload_get_configuration_tx_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_offload_get_configuration_result,
tx_offload, "tx_offload");
-cmdline_parse_token_string_t cmd_tx_offload_get_configuration_configuration =
+static cmdline_parse_token_string_t cmd_tx_offload_get_configuration_configuration =
TOKEN_STRING_INITIALIZER
(struct cmd_tx_offload_get_configuration_result,
configuration, "configuration");
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;
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");
nb_tx_queues = dev_info.nb_tx_queues;
for (q = 0; q < nb_tx_queues; q++) {
- queue_offloads = port->tx_conf[q].offloads;
+ queue_offloads = port->txq[q].conf.offloads;
printf(" Queue[%2d] :", q);
print_tx_offloads(queue_offloads);
printf("\n");
printf("\n");
}
-cmdline_parse_inst_t cmd_tx_offload_get_configuration = {
+static cmdline_parse_inst_t cmd_tx_offload_get_configuration = {
.f = cmd_tx_offload_get_configuration_parsed,
.data = NULL,
.help_str = "show port <port_id> tx_offload configuration",
cmdline_fixed_string_t on_off;
};
-cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_port =
+static cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_port =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_port_tx_offload_result,
port, "port");
-cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_config =
+static cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_config =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_port_tx_offload_result,
config, "config");
-cmdline_parse_token_num_t cmd_config_per_port_tx_offload_result_port_id =
+static 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);
-cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_tx_offload =
+ port_id, RTE_UINT16);
+static 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,
tx_offload, "tx_offload");
-cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_offload =
+static cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_port_tx_offload_result,
offload, "vlan_insert#ipv4_cksum#udp_cksum#tcp_cksum#"
"ipip_tnl_tso#geneve_tnl_tso#macsec_insert#"
"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 =
+static 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,
on_off, "on#off");
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;
}
if (!strcmp(res->on_off, "on")) {
port->dev_conf.txmode.offloads |= single_offload;
for (q = 0; q < nb_tx_queues; q++)
- port->tx_conf[q].offloads |= single_offload;
+ port->txq[q].conf.offloads |= single_offload;
} else {
port->dev_conf.txmode.offloads &= ~single_offload;
for (q = 0; q < nb_tx_queues; q++)
- port->tx_conf[q].offloads &= ~single_offload;
+ port->txq[q].conf.offloads &= ~single_offload;
}
cmd_reconfig_device_queue(port_id, 1, 1);
}
-cmdline_parse_inst_t cmd_config_per_port_tx_offload = {
+static cmdline_parse_inst_t cmd_config_per_port_tx_offload = {
.f = cmd_config_per_port_tx_offload_parsed,
.data = NULL,
.help_str = "port config <port_id> tx_offload "
cmdline_fixed_string_t on_off;
};
-cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_port =
+static cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_port =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_tx_offload_result,
port, "port");
-cmdline_parse_token_num_t cmd_config_per_queue_tx_offload_result_port_id =
+static 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);
-cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_txq =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_txq =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_tx_offload_result,
txq, "txq");
-cmdline_parse_token_num_t cmd_config_per_queue_tx_offload_result_queue_id =
+static 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);
-cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_txoffload =
+ queue_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_txoffload =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_tx_offload_result,
tx_offload, "tx_offload");
-cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_offload =
+static cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_offload =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_tx_offload_result,
offload, "vlan_insert#ipv4_cksum#udp_cksum#tcp_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");
-cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_on_off =
+static cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_on_off =
TOKEN_STRING_INITIALIZER
(struct cmd_config_per_queue_tx_offload_result,
on_off, "on#off");
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;
}
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;
}
if (!strcmp(res->on_off, "on"))
- port->tx_conf[queue_id].offloads |= single_offload;
+ port->txq[queue_id].conf.offloads |= single_offload;
else
- port->tx_conf[queue_id].offloads &= ~single_offload;
+ port->txq[queue_id].conf.offloads &= ~single_offload;
cmd_reconfig_device_queue(port_id, 1, 1);
}
-cmdline_parse_inst_t cmd_config_per_queue_tx_offload = {
+static cmdline_parse_inst_t cmd_config_per_queue_tx_offload = {
.f = cmd_config_per_queue_tx_offload_parsed,
.data = NULL,
.help_str = "port <port_id> txq <queue_id> tx_offload "
rte_flow_dynf_metadata_register();
}
-cmdline_parse_token_string_t cmd_config_tx_metadata_specific_port =
+static cmdline_parse_token_string_t cmd_config_tx_metadata_specific_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_tx_metadata_specific_result,
port, "port");
-cmdline_parse_token_string_t cmd_config_tx_metadata_specific_keyword =
+static cmdline_parse_token_string_t cmd_config_tx_metadata_specific_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_tx_metadata_specific_result,
keyword, "config");
-cmdline_parse_token_num_t cmd_config_tx_metadata_specific_id =
+static cmdline_parse_token_num_t cmd_config_tx_metadata_specific_id =
TOKEN_NUM_INITIALIZER(struct cmd_config_tx_metadata_specific_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_config_tx_metadata_specific_item =
+ port_id, RTE_UINT16);
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_config_tx_metadata_specific = {
.f = cmd_config_tx_metadata_specific_parsed,
.data = NULL,
.help_str = "port config <port_id> tx_metadata <value>",
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);
}
}
-cmdline_parse_token_string_t cmd_config_tx_dynf_specific_port =
+static cmdline_parse_token_string_t cmd_config_tx_dynf_specific_port =
TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
keyword, "port");
-cmdline_parse_token_string_t cmd_config_tx_dynf_specific_keyword =
+static cmdline_parse_token_string_t cmd_config_tx_dynf_specific_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
keyword, "config");
-cmdline_parse_token_num_t cmd_config_tx_dynf_specific_port_id =
+static cmdline_parse_token_num_t cmd_config_tx_dynf_specific_port_id =
TOKEN_NUM_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_config_tx_dynf_specific_item =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_config_tx_dynf_specific_item =
TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
item, "dynf");
-cmdline_parse_token_string_t cmd_config_tx_dynf_specific_name =
+static cmdline_parse_token_string_t cmd_config_tx_dynf_specific_name =
TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
name, NULL);
-cmdline_parse_token_string_t cmd_config_tx_dynf_specific_value =
+static cmdline_parse_token_string_t cmd_config_tx_dynf_specific_value =
TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
value, "set#clear");
-cmdline_parse_inst_t cmd_config_tx_dynf_specific = {
+static cmdline_parse_inst_t cmd_config_tx_dynf_specific = {
.f = cmd_config_dynf_specific_parsed,
.data = NULL,
.help_str = "port config <port id> dynf <name> set|clear",
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")) {
}
}
-cmdline_parse_token_string_t cmd_show_tx_metadata_show =
+static cmdline_parse_token_string_t cmd_show_tx_metadata_show =
TOKEN_STRING_INITIALIZER(struct cmd_show_tx_metadata_result,
cmd_show, "show");
-cmdline_parse_token_string_t cmd_show_tx_metadata_port =
+static cmdline_parse_token_string_t cmd_show_tx_metadata_port =
TOKEN_STRING_INITIALIZER(struct cmd_show_tx_metadata_result,
cmd_port, "port");
-cmdline_parse_token_num_t cmd_show_tx_metadata_pid =
+static cmdline_parse_token_num_t cmd_show_tx_metadata_pid =
TOKEN_NUM_INITIALIZER(struct cmd_show_tx_metadata_result,
- cmd_pid, UINT16);
-cmdline_parse_token_string_t cmd_show_tx_metadata_keyword =
+ cmd_pid, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_show_tx_metadata_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_show_tx_metadata_result,
cmd_keyword, "tx_metadata");
-cmdline_parse_inst_t cmd_show_tx_metadata = {
+static cmdline_parse_inst_t cmd_show_tx_metadata = {
.f = cmd_show_tx_metadata_parsed,
.data = NULL,
.help_str = "show port <port_id> tx_metadata",
__rte_unused struct cmdline *cl,
__rte_unused void *data)
{
-#define FEC_CAP_NUM 2
struct cmd_show_fec_capability_result *res = parsed_result;
- struct rte_eth_fec_capa speed_fec_capa[FEC_CAP_NUM];
- unsigned int num = FEC_CAP_NUM;
- unsigned int ret_num;
+ struct rte_eth_fec_capa *speed_fec_capa;
+ unsigned int num;
int ret;
if (!rte_eth_dev_is_valid_port(res->cmd_pid)) {
- printf("Invalid port id %u\n", res->cmd_pid);
+ fprintf(stderr, "Invalid port id %u\n", res->cmd_pid);
return;
}
- ret = rte_eth_fec_get_capability(res->cmd_pid, speed_fec_capa, num);
+ ret = rte_eth_fec_get_capability(res->cmd_pid, NULL, 0);
if (ret == -ENOTSUP) {
- printf("Function not implemented\n");
+ fprintf(stderr, "Function not implemented\n");
return;
} else if (ret < 0) {
- printf("Get FEC capability failed\n");
+ 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_num = (unsigned int)ret;
- show_fec_capability(ret_num, speed_fec_capa);
+ ret = rte_eth_fec_get_capability(res->cmd_pid, speed_fec_capa, num);
+ if (ret < 0) {
+ 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 =
+static 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 =
+static 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 =
+static cmdline_parse_token_num_t cmd_show_fec_capability_pid =
TOKEN_NUM_INITIALIZER(struct cmd_show_fec_capability_result,
- cmd_pid, UINT16);
-cmdline_parse_token_string_t cmd_show_fec_capability_fec =
+ cmd_pid, RTE_UINT16);
+static 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 =
+static 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 = {
+static cmdline_parse_inst_t cmd_show_capability = {
.f = cmd_show_fec_capability_parsed,
.data = NULL,
.help_str = "show port <port_id> fec capabilities",
int ret;
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;
}
ret = rte_eth_fec_get(res->cmd_pid, &mode);
if (ret == -ENOTSUP) {
- printf("Function not implemented\n");
+ fprintf(stderr, "Function not implemented\n");
return;
} else if (ret < 0) {
- printf("Get FEC mode failed\n");
+ fprintf(stderr, "Get FEC mode failed\n");
return;
}
printf("%s\n", buf);
}
-cmdline_parse_token_string_t cmd_show_fec_mode_show =
+static 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 =
+static 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 =
+static cmdline_parse_token_num_t cmd_show_fec_mode_pid =
TOKEN_NUM_INITIALIZER(struct cmd_show_fec_metadata_result,
- cmd_pid, UINT16);
-cmdline_parse_token_string_t cmd_show_fec_mode_keyword =
+ cmd_pid, RTE_UINT16);
+static 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 = {
+static cmdline_parse_inst_t cmd_show_fec_mode = {
.f = cmd_show_fec_mode_parsed,
.data = NULL,
.help_str = "show port <port_id> fec_mode",
};
/* Common CLI fields for set fec mode */
-cmdline_parse_token_string_t cmd_set_port_fec_mode_set =
+static 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 =
+static 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 =
+static cmdline_parse_token_num_t cmd_set_port_fec_mode_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_port_fec_mode,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_port_fec_mode_str =
+ port_id, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_string_t cmd_set_port_fec_mode_value =
TOKEN_STRING_INITIALIZER
(struct cmd_set_port_fec_mode,
fec_value, NULL);
{
struct cmd_set_port_fec_mode *res = parsed_result;
uint16_t port_id = res->port_id;
- uint32_t mode;
+ uint32_t fec_capa;
int ret;
- ret = parse_fec_mode(res->fec_value, &mode);
+ ret = parse_fec_mode(res->fec_value, &fec_capa);
if (ret < 0) {
- printf("Unknown fec mode: %s for Port %d\n", res->fec_value,
- port_id);
+ fprintf(stderr, "Unknown fec mode: %s for port %d\n",
+ res->fec_value, port_id);
return;
}
- ret = rte_eth_fec_set(port_id, mode);
+ ret = rte_eth_fec_set(port_id, fec_capa);
if (ret == -ENOTSUP) {
- printf("Function not implemented\n");
+ fprintf(stderr, "Function not implemented\n");
return;
} else if (ret < 0) {
- printf("Set FEC mode failed\n");
+ fprintf(stderr, "Set FEC mode failed\n");
return;
}
}
-cmdline_parse_inst_t cmd_set_fec_mode = {
+static cmdline_parse_inst_t cmd_set_fec_mode = {
.f = cmd_set_port_fec_mode_parsed,
.data = NULL,
.help_str = "set port <port_id> fec_mode auto|off|rs|baser",
},
};
+/* *** set available descriptors threshold for an RxQ of a port *** */
+struct cmd_set_rxq_avail_thresh_result {
+ cmdline_fixed_string_t set;
+ cmdline_fixed_string_t port;
+ uint16_t port_num;
+ cmdline_fixed_string_t rxq;
+ uint16_t rxq_num;
+ cmdline_fixed_string_t avail_thresh;
+ uint8_t avail_thresh_num;
+};
+
+static void cmd_set_rxq_avail_thresh_parsed(void *parsed_result,
+ __rte_unused struct cmdline *cl,
+ __rte_unused void *data)
+{
+ struct cmd_set_rxq_avail_thresh_result *res = parsed_result;
+ int ret = 0;
+
+ if ((strcmp(res->set, "set") == 0) && (strcmp(res->port, "port") == 0)
+ && (strcmp(res->rxq, "rxq") == 0)
+ && (strcmp(res->avail_thresh, "avail_thresh") == 0))
+ ret = set_rxq_avail_thresh(res->port_num, res->rxq_num,
+ res->avail_thresh_num);
+ if (ret < 0)
+ printf("rxq_avail_thresh_cmd error: (%s)\n", strerror(-ret));
+
+}
+
+static cmdline_parse_token_string_t cmd_set_rxq_avail_thresh_set =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ set, "set");
+static cmdline_parse_token_string_t cmd_set_rxq_avail_thresh_port =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ port, "port");
+static cmdline_parse_token_num_t cmd_set_rxq_avail_thresh_portnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ port_num, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_rxq_avail_thresh_rxq =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ rxq, "rxq");
+static cmdline_parse_token_num_t cmd_set_rxq_avail_thresh_rxqnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ rxq_num, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_rxq_avail_thresh_avail_thresh =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ avail_thresh, "avail_thresh");
+static cmdline_parse_token_num_t cmd_set_rxq_avail_thresh_avail_threshnum =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_rxq_avail_thresh_result,
+ avail_thresh_num, RTE_UINT8);
+
+static cmdline_parse_inst_t cmd_set_rxq_avail_thresh = {
+ .f = cmd_set_rxq_avail_thresh_parsed,
+ .data = (void *)0,
+ .help_str =
+ "set port <port_id> rxq <queue_id> avail_thresh <0..99>: "
+ "Set available descriptors threshold for Rx queue",
+ .tokens = {
+ (void *)&cmd_set_rxq_avail_thresh_set,
+ (void *)&cmd_set_rxq_avail_thresh_port,
+ (void *)&cmd_set_rxq_avail_thresh_portnum,
+ (void *)&cmd_set_rxq_avail_thresh_rxq,
+ (void *)&cmd_set_rxq_avail_thresh_rxqnum,
+ (void *)&cmd_set_rxq_avail_thresh_avail_thresh,
+ (void *)&cmd_set_rxq_avail_thresh_avail_threshnum,
+ NULL,
+ },
+};
+
/* show port supported ptypes */
/* Common result structure for show port ptypes */
};
/* Common CLI fields for show port ptypes */
-cmdline_parse_token_string_t cmd_show_port_supported_ptypes_show =
+static cmdline_parse_token_string_t cmd_show_port_supported_ptypes_show =
TOKEN_STRING_INITIALIZER
(struct cmd_show_port_supported_ptypes_result,
show, "show");
-cmdline_parse_token_string_t cmd_show_port_supported_ptypes_port =
+static cmdline_parse_token_string_t cmd_show_port_supported_ptypes_port =
TOKEN_STRING_INITIALIZER
(struct cmd_show_port_supported_ptypes_result,
port, "port");
-cmdline_parse_token_num_t cmd_show_port_supported_ptypes_port_id =
+static cmdline_parse_token_num_t cmd_show_port_supported_ptypes_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_show_port_supported_ptypes_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_show_port_supported_ptypes_ptypes =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_show_port_supported_ptypes_ptypes =
TOKEN_STRING_INITIALIZER
(struct cmd_show_port_supported_ptypes_result,
ptypes, "ptypes");
}
}
-cmdline_parse_inst_t cmd_show_port_supported_ptypes = {
+static cmdline_parse_inst_t cmd_show_port_supported_ptypes = {
.f = cmd_show_port_supported_ptypes_parsed,
.data = NULL,
.help_str = "show port <port_id> ptypes",
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;
}
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)
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)
}
}
-cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_show =
+static cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_show =
TOKEN_STRING_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
cmd_show, "show");
-cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_port =
+static cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_port =
TOKEN_STRING_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
cmd_port, "port");
-cmdline_parse_token_num_t cmd_show_rx_tx_desc_status_pid =
+static cmdline_parse_token_num_t cmd_show_rx_tx_desc_status_pid =
TOKEN_NUM_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
- cmd_pid, UINT16);
-cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_keyword =
+ cmd_pid, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_show_rx_tx_desc_status_qid =
TOKEN_NUM_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
- cmd_qid, UINT16);
-cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_desc =
+ cmd_qid, RTE_UINT16);
+static 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 =
+static cmdline_parse_token_num_t cmd_show_rx_tx_desc_status_did =
TOKEN_NUM_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
- cmd_did, UINT16);
-cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_status =
+ cmd_did, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_status =
TOKEN_STRING_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
cmd_status, "status");
-cmdline_parse_inst_t cmd_show_rx_tx_desc_status = {
+static cmdline_parse_inst_t cmd_show_rx_tx_desc_status = {
.f = cmd_show_rx_tx_desc_status_parsed,
.data = NULL,
.help_str = "show port <port_id> rxq|txq <queue_id> desc <desc_id> "
},
};
+/* *** 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);
+}
+
+static 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");
+static 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");
+static 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);
+static 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");
+static 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);
+static 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");
+static 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");
+static 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");
+static cmdline_parse_inst_t cmd_show_rx_queue_desc_used_count = {
+ .f = cmd_show_rx_queue_desc_used_count_parsed,
+ .data = NULL,
+ .help_str = "show port <port_id> rxq <queue_id> desc used count",
+ .tokens = {
+ (void *)&cmd_show_rx_queue_desc_used_count_show,
+ (void *)&cmd_show_rx_queue_desc_used_count_port,
+ (void *)&cmd_show_rx_queue_desc_used_count_pid,
+ (void *)&cmd_show_rx_queue_desc_used_count_rxq,
+ (void *)&cmd_show_rx_queue_desc_used_count_qid,
+ (void *)&cmd_show_rx_queue_desc_used_count_desc,
+ (void *)&cmd_show_rx_queue_desc_used_count_used,
+ (void *)&cmd_show_rx_queue_desc_used_count_count,
+ NULL,
+ },
+};
+
/* Common result structure for set port ptypes */
struct cmd_set_port_ptypes_result {
cmdline_fixed_string_t set;
};
/* Common CLI fields for set port ptypes */
-cmdline_parse_token_string_t cmd_set_port_ptypes_set =
+static cmdline_parse_token_string_t cmd_set_port_ptypes_set =
TOKEN_STRING_INITIALIZER
(struct cmd_set_port_ptypes_result,
set, "set");
-cmdline_parse_token_string_t cmd_set_port_ptypes_port =
+static cmdline_parse_token_string_t cmd_set_port_ptypes_port =
TOKEN_STRING_INITIALIZER
(struct cmd_set_port_ptypes_result,
port, "port");
-cmdline_parse_token_num_t cmd_set_port_ptypes_port_id =
+static cmdline_parse_token_num_t cmd_set_port_ptypes_port_id =
TOKEN_NUM_INITIALIZER
(struct cmd_set_port_ptypes_result,
- port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_port_ptypes_mask_str =
+ port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_port_ptypes_mask_str =
TOKEN_STRING_INITIALIZER
(struct cmd_set_port_ptypes_result,
ptype_mask, "ptype_mask");
-cmdline_parse_token_num_t cmd_set_port_ptypes_mask_u32 =
+static 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(
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;
}
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;
}
clear_ptypes = false;
}
-cmdline_parse_inst_t cmd_set_port_ptypes = {
+static cmdline_parse_inst_t cmd_set_port_ptypes = {
.f = cmd_set_port_ptypes_parsed,
.data = NULL,
.help_str = "set port <port_id> ptype_mask <mask>",
show_mcast_macs(res->cmd_pid);
}
-cmdline_parse_token_string_t cmd_showport_macs_show =
+static cmdline_parse_token_string_t cmd_showport_macs_show =
TOKEN_STRING_INITIALIZER(struct cmd_showport_macs_result,
cmd_show, "show");
-cmdline_parse_token_string_t cmd_showport_macs_port =
+static cmdline_parse_token_string_t cmd_showport_macs_port =
TOKEN_STRING_INITIALIZER(struct cmd_showport_macs_result,
cmd_port, "port");
-cmdline_parse_token_num_t cmd_showport_macs_pid =
+static cmdline_parse_token_num_t cmd_showport_macs_pid =
TOKEN_NUM_INITIALIZER(struct cmd_showport_macs_result,
- cmd_pid, UINT16);
-cmdline_parse_token_string_t cmd_showport_macs_keyword =
+ cmd_pid, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_showport_macs_keyword =
TOKEN_STRING_INITIALIZER(struct cmd_showport_macs_result,
cmd_keyword, "macs#mcast_macs");
-cmdline_parse_inst_t cmd_showport_macs = {
+static cmdline_parse_inst_t cmd_showport_macs = {
.f = cmd_showport_macs_parsed,
.data = NULL,
.help_str = "show port <port_id> macs|mcast_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;
+};
+
+static 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");
+static 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");
+static 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);
+static 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");
+static 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");
+static 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);
+}
+
+static cmdline_parse_inst_t cmd_show_port_flow_transfer_proxy = {
+ .f = cmd_show_port_flow_transfer_proxy_parsed,
+ .data = NULL,
+ .help_str = "show port <port_id> flow transfer proxy",
+ .tokens = {
+ (void *)&cmd_show_port_flow_transfer_proxy_show,
+ (void *)&cmd_show_port_flow_transfer_proxy_port,
+ (void *)&cmd_show_port_flow_transfer_proxy_port_id,
+ (void *)&cmd_show_port_flow_transfer_proxy_flow,
+ (void *)&cmd_show_port_flow_transfer_proxy_transfer,
+ (void *)&cmd_show_port_flow_transfer_proxy_proxy,
+ NULL,
+ }
+};
+
/* ******************************************************************************** */
/* list of instructions */
-cmdline_parse_ctx_t main_ctx[] = {
+static cmdline_parse_ctx_t builtin_ctx[] = {
(cmdline_parse_inst_t *)&cmd_help_brief,
(cmdline_parse_inst_t *)&cmd_help_long,
(cmdline_parse_inst_t *)&cmd_quit,
(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,
#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,
(cmdline_parse_inst_t *)&cmd_tso_show,
(cmdline_parse_inst_t *)&cmd_tunnel_tso_set,
(cmdline_parse_inst_t *)&cmd_tunnel_tso_show,
+#ifdef RTE_LIB_GRO
(cmdline_parse_inst_t *)&cmd_gro_enable,
(cmdline_parse_inst_t *)&cmd_gro_flush,
(cmdline_parse_inst_t *)&cmd_gro_show,
+#endif
+#ifdef RTE_LIB_GSO
(cmdline_parse_inst_t *)&cmd_gso_enable,
(cmdline_parse_inst_t *)&cmd_gso_size,
(cmdline_parse_inst_t *)&cmd_gso_show,
+#endif
(cmdline_parse_inst_t *)&cmd_link_flow_control_set,
(cmdline_parse_inst_t *)&cmd_link_flow_control_set_rx,
(cmdline_parse_inst_t *)&cmd_link_flow_control_set_tx,
(cmdline_parse_inst_t *)&cmd_link_flow_control_set_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_queue_priority_flow_control_set,
(cmdline_parse_inst_t *)&cmd_config_dcb,
(cmdline_parse_inst_t *)&cmd_read_reg,
(cmdline_parse_inst_t *)&cmd_read_reg_bit_field,
(cmdline_parse_inst_t *)&cmd_config_rss_reta,
(cmdline_parse_inst_t *)&cmd_showport_reta,
(cmdline_parse_inst_t *)&cmd_showport_macs,
+ (cmdline_parse_inst_t *)&cmd_show_port_flow_transfer_proxy,
(cmdline_parse_inst_t *)&cmd_config_burst,
(cmdline_parse_inst_t *)&cmd_config_thresh,
(cmdline_parse_inst_t *)&cmd_config_threshold,
(cmdline_parse_inst_t *)&cmd_vf_mac_addr_filter,
(cmdline_parse_inst_t *)&cmd_queue_rate_limit,
(cmdline_parse_inst_t *)&cmd_tunnel_udp_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_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_set_fdir_input_set,
(cmdline_parse_inst_t *)&cmd_flow,
(cmdline_parse_inst_t *)&cmd_show_port_meter_cap,
(cmdline_parse_inst_t *)&cmd_add_port_meter_profile_srtcm,
(cmdline_parse_inst_t *)&cmd_add_port_meter_profile_trtcm,
+ (cmdline_parse_inst_t *)&cmd_add_port_meter_profile_trtcm_rfc4115,
(cmdline_parse_inst_t *)&cmd_del_port_meter_profile,
(cmdline_parse_inst_t *)&cmd_create_port_meter,
(cmdline_parse_inst_t *)&cmd_enable_port_meter,
(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_set_vf_vlan_anti_spoof,
(cmdline_parse_inst_t *)&cmd_set_vf_mac_anti_spoof,
(cmdline_parse_inst_t *)&cmd_set_vf_vlan_stripq,
(cmdline_parse_inst_t *)&cmd_set_mplsoudp_encap_with_vlan,
(cmdline_parse_inst_t *)&cmd_set_mplsoudp_decap,
(cmdline_parse_inst_t *)&cmd_set_mplsoudp_decap_with_vlan,
+ (cmdline_parse_inst_t *)&cmd_set_conntrack_common,
+ (cmdline_parse_inst_t *)&cmd_set_conntrack_dir,
(cmdline_parse_inst_t *)&cmd_ddp_add,
(cmdline_parse_inst_t *)&cmd_ddp_del,
(cmdline_parse_inst_t *)&cmd_ddp_get_list,
(cmdline_parse_inst_t *)&cmd_config_tx_metadata_specific,
(cmdline_parse_inst_t *)&cmd_show_tx_metadata,
(cmdline_parse_inst_t *)&cmd_show_rx_tx_desc_status,
+ (cmdline_parse_inst_t *)&cmd_show_rx_queue_desc_used_count,
(cmdline_parse_inst_t *)&cmd_set_raw,
(cmdline_parse_inst_t *)&cmd_show_set_raw,
(cmdline_parse_inst_t *)&cmd_show_set_raw_all,
(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_set_rxq_avail_thresh,
(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,
};
+void
+testpmd_add_driver_commands(struct testpmd_driver_commands *c)
+{
+ TAILQ_INSERT_TAIL(&driver_commands_head, c, next);
+}
+
+int
+init_cmdline(void)
+{
+ struct testpmd_driver_commands *c;
+ unsigned int count;
+ unsigned int i;
+
+ /* initialize non-constant commands */
+ cmd_set_fwd_mode_init();
+ cmd_set_fwd_retry_mode_init();
+
+ count = 0;
+ for (i = 0; builtin_ctx[i] != NULL; i++)
+ count++;
+ TAILQ_FOREACH(c, &driver_commands_head, next) {
+ for (i = 0; c->commands[i].ctx != NULL; i++)
+ count++;
+ }
+
+ /* cmdline expects a NULL terminated array */
+ main_ctx = calloc(count + 1, sizeof(main_ctx[0]));
+ if (main_ctx == NULL)
+ return -1;
+
+ count = 0;
+ for (i = 0; builtin_ctx[i] != NULL; i++, count++)
+ main_ctx[count] = builtin_ctx[i];
+ TAILQ_FOREACH(c, &driver_commands_head, next) {
+ for (i = 0; c->commands[i].ctx != NULL; i++, count++)
+ main_ctx[count] = c->commands[i].ctx;
+ }
+
+ return 0;
+}
+
/* read cmdline commands from file */
void
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;
}
void
prompt(void)
{
- /* initialize non-constant commands */
- cmd_set_fwd_mode_init();
- cmd_set_fwd_retry_mode_init();
+ int ret;
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
git.droids-corp.org / dpdk.git / blobdiff