" help registers : Reading and setting port registers.\n"
" help filters : Filters configuration help.\n"
" help traffic_management : Traffic Management commmands.\n"
+ " help devices : Device related cmds.\n"
" help all : All of the above sections.\n\n"
);
"show port (port_id) tx_metadata\n"
" Show Tx metadata value set"
" for a specific port\n\n"
+
+ "show device info (<identifier>|all)"
+ " Show general information about devices probed.\n\n"
);
}
"show port (port_id) queue-region\n"
" show all queue region related configuration info\n\n"
- "vxlan ip-version (ipv4|ipv6) vni (vni) udp-src"
- " (udp-src) udp-dst (udp-dst) ip-src (ip-src) ip-dst"
- " (ip-dst) eth-src (eth-src) eth-dst (eth-dst)\n"
- " Configure the VXLAN encapsulation for flows.\n\n"
-
- "vxlan-with-vlan ip-version (ipv4|ipv6) vni (vni)"
- " udp-src (udp-src) udp-dst (udp-dst) ip-src (ip-src)"
- " ip-dst (ip-dst) vlan-tci (vlan-tci) eth-src (eth-src)"
- " eth-dst (eth-dst)\n"
- " Configure the VXLAN encapsulation for flows.\n\n"
-
- "vxlan-tos-ttl ip-version (ipv4|ipv6) vni (vni) udp-src"
- " (udp-src) udp-dst (udp-dst) ip-tos (ip-tos) ip-ttl (ip-ttl)"
- " ip-src (ip-src) ip-dst (ip-dst) eth-src (eth-src)"
- " eth-dst (eth-dst)\n"
- " Configure the VXLAN encapsulation for flows.\n\n"
-
- "nvgre ip-version (ipv4|ipv6) tni (tni) ip-src"
- " (ip-src) ip-dst (ip-dst) eth-src (eth-src) eth-dst"
- " (eth-dst)\n"
- " Configure the NVGRE encapsulation for flows.\n\n"
-
- "nvgre-with-vlan ip-version (ipv4|ipv6) tni (tni)"
- " ip-src (ip-src) ip-dst (ip-dst) vlan-tci (vlan-tci)"
- " eth-src (eth-src) eth-dst (eth-dst)\n"
- " Configure the NVGRE encapsulation for flows.\n\n"
-
, list_pkt_forwarding_modes()
);
}
"port close (port_id|all)\n"
" Close all ports or port_id.\n\n"
+ "port reset (port_id|all)\n"
+ " Reset all ports or port_id.\n\n"
+
"port attach (ident)\n"
" Attach physical or virtual dev by pci address or virtual device name\n\n"
"port config all max-pkt-len (value)\n"
" Set the max packet length.\n\n"
- "port config all (crc-strip|scatter|rx-cksum|rx-timestamp|hw-vlan|hw-vlan-filter|"
- "hw-vlan-strip|hw-vlan-extend|drop-en)"
- " (on|off)\n"
- " Set crc-strip/scatter/rx-checksum/hardware-vlan/drop_en"
- " for ports.\n\n"
+ "port config all drop-en (on|off)\n"
+ " Enable or disable packet drop on all RX queues of all ports when no "
+ "receive buffers available.\n\n"
"port config all rss (all|default|ip|tcp|udp|sctp|"
"ether|port|vxlan|geneve|nvgre|vxlan-gpe|none|<flowtype_id>)\n"
"flow isolate {port_id} {boolean}\n"
" Restrict ingress traffic to the defined"
" flow rules\n\n"
+
+ "set vxlan ip-version (ipv4|ipv6) vni (vni) udp-src"
+ " (udp-src) udp-dst (udp-dst) ip-src (ip-src) ip-dst"
+ " (ip-dst) eth-src (eth-src) eth-dst (eth-dst)\n"
+ " Configure the VXLAN encapsulation for flows.\n\n"
+
+ "set vxlan-with-vlan ip-version (ipv4|ipv6) vni (vni)"
+ " udp-src (udp-src) udp-dst (udp-dst) ip-src (ip-src)"
+ " ip-dst (ip-dst) vlan-tci (vlan-tci) eth-src (eth-src)"
+ " eth-dst (eth-dst)\n"
+ " Configure the VXLAN encapsulation for flows.\n\n"
+
+ "set vxlan-tos-ttl ip-version (ipv4|ipv6) vni (vni) udp-src"
+ " (udp-src) udp-dst (udp-dst) ip-tos (ip-tos) ip-ttl (ip-ttl)"
+ " ip-src (ip-src) ip-dst (ip-dst) eth-src (eth-src)"
+ " eth-dst (eth-dst)\n"
+ " Configure the VXLAN encapsulation for flows.\n\n"
+
+ "set nvgre ip-version (ipv4|ipv6) tni (tni) ip-src"
+ " (ip-src) ip-dst (ip-dst) eth-src (eth-src) eth-dst"
+ " (eth-dst)\n"
+ " Configure the NVGRE encapsulation for flows.\n\n"
+
+ "set nvgre-with-vlan ip-version (ipv4|ipv6) tni (tni)"
+ " ip-src (ip-src) ip-dst (ip-dst) vlan-tci (vlan-tci)"
+ " eth-src (eth-src) eth-dst (eth-dst)\n"
+ " Configure the NVGRE encapsulation for flows.\n\n"
+
+ "set raw_encap {flow items}\n"
+ " Configure the encapsulation with raw data.\n\n"
+
+ "set raw_decap {flow items}\n"
+ " Configure the decapsulation with raw data.\n\n"
+
);
}
);
}
+ if (show_all || !strcmp(res->section, "devices")) {
+ cmdline_printf(
+ cl,
+ "\n"
+ "Device Operations:\n"
+ "--------------\n"
+ "device detach (identifier)\n"
+ " Detach device by identifier.\n\n"
+ );
+ }
+
}
cmdline_parse_token_string_t cmd_help_long_help =
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");
+ "ports#registers#filters#traffic_management#devices");
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: "
+ "filters|traffic_management|devices: "
"Show help",
.tokens = {
(void *)&cmd_help_long_help,
},
};
+/* *** detach device by identifier *** */
+struct cmd_operate_detach_device_result {
+ cmdline_fixed_string_t device;
+ cmdline_fixed_string_t keyword;
+ cmdline_fixed_string_t identifier;
+};
+
+static void cmd_operate_detach_device_parsed(void *parsed_result,
+ __attribute__((unused)) struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ struct cmd_operate_detach_device_result *res = parsed_result;
+
+ if (!strcmp(res->keyword, "detach"))
+ detach_device(res->identifier);
+ else
+ printf("Unknown parameter\n");
+}
+
+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 =
+ TOKEN_STRING_INITIALIZER(struct cmd_operate_detach_device_result,
+ keyword, "detach");
+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 = {
+ .f = cmd_operate_detach_device_parsed,
+ .data = NULL,
+ .help_str = "device detach <identifier>:"
+ "(identifier: pci address or virtual dev name)",
+ .tokens = {
+ (void *)&cmd_operate_detach_device_device,
+ (void *)&cmd_operate_detach_device_keyword,
+ (void *)&cmd_operate_detach_device_identifier,
+ NULL,
+ },
+};
/* *** configure speed for all ports *** */
struct cmd_config_speed_all {
cmdline_fixed_string_t port;
uint64_t rx_offloads = port->dev_conf.rxmode.offloads;
if (!strcmp(res->name, "max-pkt-len")) {
- if (res->value < ETHER_MIN_LEN) {
+ if (res->value < RTE_ETHER_MIN_LEN) {
printf("max-pkt-len can not be less than %d\n",
- ETHER_MIN_LEN);
+ RTE_ETHER_MIN_LEN);
return;
}
if (res->value == port->dev_conf.rxmode.max_rx_pkt_len)
return;
port->dev_conf.rxmode.max_rx_pkt_len = res->value;
- if (res->value > ETHER_MAX_LEN)
+ if (res->value > RTE_ETHER_MAX_LEN)
rx_offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME;
else
rx_offloads &= ~DEV_RX_OFFLOAD_JUMBO_FRAME;
{
struct cmd_config_mtu_result *res = parsed_result;
- if (res->value < ETHER_MIN_LEN) {
- printf("mtu cannot be less than %d\n", ETHER_MIN_LEN);
+ 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);
__attribute__((unused)) void *data)
{
struct cmd_config_rx_mode_flag *res = parsed_result;
- portid_t pid;
if (!all_ports_stopped()) {
printf("Please stop all ports first\n");
return;
}
- RTE_ETH_FOREACH_DEV(pid) {
- struct rte_port *port;
- uint64_t rx_offloads;
-
- port = &ports[pid];
- rx_offloads = port->dev_conf.rxmode.offloads;
- if (!strcmp(res->name, "crc-strip")) {
- if (!strcmp(res->value, "on")) {
- rx_offloads &= ~DEV_RX_OFFLOAD_KEEP_CRC;
- } else if (!strcmp(res->value, "off")) {
- rx_offloads |= DEV_RX_OFFLOAD_KEEP_CRC;
- } else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "scatter")) {
- if (!strcmp(res->value, "on")) {
- rx_offloads |= DEV_RX_OFFLOAD_SCATTER;
- } else if (!strcmp(res->value, "off")) {
- rx_offloads &= ~DEV_RX_OFFLOAD_SCATTER;
- } else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "rx-cksum")) {
- if (!strcmp(res->value, "on"))
- rx_offloads |= DEV_RX_OFFLOAD_CHECKSUM;
- else if (!strcmp(res->value, "off"))
- rx_offloads &= ~DEV_RX_OFFLOAD_CHECKSUM;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "rx-timestamp")) {
- if (!strcmp(res->value, "on"))
- rx_offloads |= DEV_RX_OFFLOAD_TIMESTAMP;
- else if (!strcmp(res->value, "off"))
- rx_offloads &= ~DEV_RX_OFFLOAD_TIMESTAMP;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "hw-vlan")) {
- if (!strcmp(res->value, "on")) {
- rx_offloads |= (DEV_RX_OFFLOAD_VLAN_FILTER |
- DEV_RX_OFFLOAD_VLAN_STRIP);
- } else if (!strcmp(res->value, "off")) {
- rx_offloads &= ~(DEV_RX_OFFLOAD_VLAN_FILTER |
- DEV_RX_OFFLOAD_VLAN_STRIP);
- } else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "hw-vlan-filter")) {
- if (!strcmp(res->value, "on"))
- rx_offloads |= DEV_RX_OFFLOAD_VLAN_FILTER;
- else if (!strcmp(res->value, "off"))
- rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_FILTER;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "hw-vlan-strip")) {
- if (!strcmp(res->value, "on"))
- rx_offloads |= DEV_RX_OFFLOAD_VLAN_STRIP;
- else if (!strcmp(res->value, "off"))
- rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_STRIP;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "hw-vlan-extend")) {
- if (!strcmp(res->value, "on"))
- rx_offloads |= DEV_RX_OFFLOAD_VLAN_EXTEND;
- else if (!strcmp(res->value, "off"))
- rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_EXTEND;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else if (!strcmp(res->name, "drop-en")) {
- if (!strcmp(res->value, "on"))
- rx_drop_en = 1;
- else if (!strcmp(res->value, "off"))
- rx_drop_en = 0;
- else {
- printf("Unknown parameter\n");
- return;
- }
- } else {
+ if (!strcmp(res->name, "drop-en")) {
+ if (!strcmp(res->value, "on"))
+ rx_drop_en = 1;
+ else if (!strcmp(res->value, "off"))
+ rx_drop_en = 0;
+ else {
printf("Unknown parameter\n");
return;
}
- port->dev_conf.rxmode.offloads = rx_offloads;
+ } else {
+ printf("Unknown parameter\n");
+ return;
}
init_port_config();
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, all, "all");
cmdline_parse_token_string_t cmd_config_rx_mode_flag_name =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, name,
- "crc-strip#scatter#rx-cksum#rx-timestamp#hw-vlan#"
- "hw-vlan-filter#hw-vlan-strip#hw-vlan-extend");
+ "drop-en");
cmdline_parse_token_string_t cmd_config_rx_mode_flag_value =
TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, value,
"on#off");
cmdline_parse_inst_t cmd_config_rx_mode_flag = {
.f = cmd_config_rx_mode_flag_parsed,
.data = NULL,
- .help_str = "port config all crc-strip|scatter|rx-cksum|rx-timestamp|hw-vlan|"
- "hw-vlan-filter|hw-vlan-strip|hw-vlan-extend on|off",
+ .help_str = "port config all drop-en on|off",
.tokens = {
(void *)&cmd_config_rx_mode_flag_port,
(void *)&cmd_config_rx_mode_flag_keyword,
int all_updated = 1;
int diag;
uint16_t i;
+ int ret;
if (!strcmp(res->value, "all"))
rss_conf.rss_hf = ETH_RSS_IP | ETH_RSS_TCP |
RTE_ETH_FOREACH_DEV(i) {
struct rte_eth_rss_conf local_rss_conf;
- rte_eth_dev_info_get(i, &dev_info);
+ ret = eth_dev_info_get_print_err(i, &dev_info);
+ if (ret != 0)
+ return;
+
if (use_default)
rss_conf.rss_hf = dev_info.flow_type_rss_offloads;
struct rte_eth_dev_info dev_info;
uint8_t hash_key_size;
uint32_t key_len;
+ int ret;
+
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
- memset(&dev_info, 0, sizeof(dev_info));
- rte_eth_dev_info_get(res->port_id, &dev_info);
if (dev_info.hash_key_size > 0 &&
dev_info.hash_key_size <= sizeof(hash_key))
hash_key_size = dev_info.hash_key_size;
struct rte_eth_rss_reta_entry64 reta_conf[8];
struct cmd_config_rss_reta *res = parsed_result;
- memset(&dev_info, 0, sizeof(dev_info));
- rte_eth_dev_info_get(res->port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (dev_info.reta_size == 0) {
printf("Redirection table size is 0 which is "
"invalid for RSS\n");
struct rte_eth_rss_reta_entry64 reta_conf[8];
struct rte_eth_dev_info dev_info;
uint16_t max_reta_size;
+ int ret;
+
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
- memset(&dev_info, 0, sizeof(dev_info));
- rte_eth_dev_info_get(res->port_id, &dev_info);
max_reta_size = RTE_MIN(dev_info.reta_size, ETH_RSS_RETA_SIZE_512);
if (res->size == 0 || res->size > max_reta_size) {
printf("Invalid redirection table size: %u (1-%u)\n",
struct cmd_config_burst *res = parsed_result;
struct rte_eth_dev_info dev_info;
uint16_t rec_nb_pkts;
+ int ret;
if (!all_ports_stopped()) {
printf("Please stop all ports first\n");
* size for all ports, so assume all ports are the same
* NIC model and use the values from Port 0.
*/
- rte_eth_dev_info_get(0, &dev_info);
+ ret = eth_dev_info_get_print_err(0, &dev_info);
+ if (ret != 0)
+ return;
+
rec_nb_pkts = dev_info.default_rxportconf.burst_size;
if (rec_nb_pkts == 0) {
{
struct rte_eth_dev_info dev_info;
uint64_t tx_offloads;
+ int ret;
tx_offloads = ports[port_id].dev_conf.txmode.offloads;
printf("Parse tunnel is %s\n",
(tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) ? "hw" : "sw");
/* display warnings if configuration is not supported by the NIC */
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if ((tx_offloads & DEV_TX_OFFLOAD_IPV4_CKSUM) &&
(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IPV4_CKSUM) == 0) {
printf("Warning: hardware IP checksum enabled but not "
}
}
+static void
+cmd_config_queue_tx_offloads(struct rte_port *port)
+{
+ int k;
+
+ /* Apply queue tx offloads configuration */
+ for (k = 0; k < port->dev_info.max_rx_queues; k++)
+ port->tx_conf[k].offloads =
+ port->dev_conf.txmode.offloads;
+}
+
static void
cmd_csum_parsed(void *parsed_result,
__attribute__((unused)) struct cmdline *cl,
int hw = 0;
uint64_t csum_offloads = 0;
struct rte_eth_dev_info dev_info;
+ int ret;
if (port_id_is_invalid(res->port_id, ENABLED_WARN)) {
printf("invalid port %d\n", res->port_id);
return;
}
- rte_eth_dev_info_get(res->port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (!strcmp(res->mode, "set")) {
if (!strcmp(res->hwsw, "hw"))
ports[res->port_id].dev_conf.txmode.offloads &=
(~csum_offloads);
}
+ cmd_config_queue_tx_offloads(&ports[res->port_id]);
}
csum_show(res->port_id);
{
struct cmd_tso_set_result *res = parsed_result;
struct rte_eth_dev_info dev_info;
+ int ret;
if (port_id_is_invalid(res->port_id, ENABLED_WARN))
return;
if (!strcmp(res->mode, "set"))
ports[res->port_id].tso_segsz = res->tso_segsz;
- rte_eth_dev_info_get(res->port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if ((ports[res->port_id].tso_segsz != 0) &&
(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_TSO) == 0) {
printf("Error: TSO is not supported by port %d\n",
printf("TSO segment size for non-tunneled packets is %d\n",
ports[res->port_id].tso_segsz);
}
+ cmd_config_queue_tx_offloads(&ports[res->port_id]);
/* display warnings if configuration is not supported by the NIC */
- rte_eth_dev_info_get(res->port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(res->port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if ((ports[res->port_id].tso_segsz != 0) &&
(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_TSO) == 0) {
printf("Warning: TSO enabled but not "
{
struct rte_eth_dev_info dev_info;
- rte_eth_dev_info_get(port_id, &dev_info);
+ if (eth_dev_info_get_print_err(port_id, &dev_info) != 0)
+ return dev_info;
+
if (!(dev_info.tx_offload_capa & DEV_TX_OFFLOAD_VXLAN_TNL_TSO))
printf("Warning: VXLAN TUNNEL TSO not supported therefore "
"not enabled for port %d\n", port_id);
"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);
}
struct cmd_create_bonded_device_result *res = parsed_result;
char ethdev_name[RTE_ETH_NAME_MAX_LEN];
int port_id;
+ int ret;
if (test_done == 0) {
printf("Please stop forwarding first\n");
/* Update number of ports */
nb_ports = rte_eth_dev_count_avail();
reconfig(port_id, res->socket);
- rte_eth_promiscuous_enable(port_id);
+ ret = rte_eth_promiscuous_enable(port_id);
+ if (ret != 0)
+ printf("Failed to enable promiscuous mode for port %u: %s - ignore\n",
+ port_id, rte_strerror(-ret));
+
ports[port_id].need_setup = 0;
ports[port_id].port_status = RTE_PORT_STOPPED;
}
/* all ports */
if (allports) {
- RTE_ETH_FOREACH_DEV(i) {
- if (enable)
- rte_eth_promiscuous_enable(i);
- else
- rte_eth_promiscuous_disable(i);
- }
- }
- else {
- if (enable)
- rte_eth_promiscuous_enable(res->port_num);
- else
- rte_eth_promiscuous_disable(res->port_num);
+ RTE_ETH_FOREACH_DEV(i)
+ eth_set_promisc_mode(i, enable);
+ } else {
+ eth_set_promisc_mode(res->port_num, enable);
}
}
/* all ports */
if (allports) {
RTE_ETH_FOREACH_DEV(i) {
- if (enable)
- rte_eth_allmulticast_enable(i);
- else
- rte_eth_allmulticast_disable(i);
+ eth_set_allmulticast_mode(i, enable);
}
}
else {
- if (enable)
- rte_eth_allmulticast_enable(res->port_num);
- else
- rte_eth_allmulticast_disable(res->port_num);
+ eth_set_allmulticast_mode(res->port_num, enable);
}
}
},
};
+/* *** SHOW DEVICE INFO *** */
+struct cmd_showdevice_result {
+ cmdline_fixed_string_t show;
+ cmdline_fixed_string_t device;
+ cmdline_fixed_string_t what;
+ cmdline_fixed_string_t identifier;
+};
+
+static void cmd_showdevice_parsed(void *parsed_result,
+ __attribute__((unused)) struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ struct cmd_showdevice_result *res = parsed_result;
+ if (!strcmp(res->what, "info")) {
+ if (!strcmp(res->identifier, "all"))
+ device_infos_display(NULL);
+ else
+ device_infos_display(res->identifier);
+ }
+}
+
+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 =
+ TOKEN_STRING_INITIALIZER(struct cmd_showdevice_result, device, "device");
+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 =
+ TOKEN_STRING_INITIALIZER(struct cmd_showdevice_result,
+ identifier, NULL);
+
+cmdline_parse_inst_t cmd_showdevice = {
+ .f = cmd_showdevice_parsed,
+ .data = NULL,
+ .help_str = "show device info <identifier>|all",
+ .tokens = {
+ (void *)&cmd_showdevice_show,
+ (void *)&cmd_showdevice_device,
+ (void *)&cmd_showdevice_what,
+ (void *)&cmd_showdevice_identifier,
+ NULL,
+ },
+};
/* *** SHOW QUEUE INFO *** */
struct cmd_showqueue_result {
cmdline_fixed_string_t show;
memset(&filter, 0, sizeof(struct rte_eth_mac_filter));
- rte_memcpy(&filter.mac_addr, &res->address, ETHER_ADDR_LEN);
+ rte_memcpy(&filter.mac_addr, &res->address, RTE_ETHER_ADDR_LEN);
/* set VF MAC filter */
filter.is_vf = 1;
__attribute__((unused)) void *data)
{
int ret = -ENOTSUP;
- uint16_t rx_mode = 0;
+ uint16_t vf_rxmode = 0;
struct cmd_set_vf_rxmode *res = parsed_result;
int is_on = (strcmp(res->on, "on") == 0) ? 1 : 0;
if (!strcmp(res->what,"rxmode")) {
if (!strcmp(res->mode, "AUPE"))
- rx_mode |= ETH_VMDQ_ACCEPT_UNTAG;
+ vf_rxmode |= ETH_VMDQ_ACCEPT_UNTAG;
else if (!strcmp(res->mode, "ROPE"))
- rx_mode |= ETH_VMDQ_ACCEPT_HASH_UC;
+ vf_rxmode |= ETH_VMDQ_ACCEPT_HASH_UC;
else if (!strcmp(res->mode, "BAM"))
- rx_mode |= ETH_VMDQ_ACCEPT_BROADCAST;
+ vf_rxmode |= ETH_VMDQ_ACCEPT_BROADCAST;
else if (!strncmp(res->mode, "MPE",3))
- rx_mode |= ETH_VMDQ_ACCEPT_MULTICAST;
+ vf_rxmode |= ETH_VMDQ_ACCEPT_MULTICAST;
}
RTE_SET_USED(is_on);
#ifdef RTE_LIBRTE_IXGBE_PMD
if (ret == -ENOTSUP)
ret = rte_pmd_ixgbe_set_vf_rxmode(res->port_id, res->vf_id,
- rx_mode, (uint8_t)is_on);
+ vf_rxmode, (uint8_t)is_on);
#endif
#ifdef RTE_LIBRTE_BNXT_PMD
if (ret == -ENOTSUP)
ret = rte_pmd_bnxt_set_vf_rxmode(res->port_id, res->vf_id,
- rx_mode, (uint8_t)is_on);
+ vf_rxmode, (uint8_t)is_on);
#endif
if (ret < 0)
printf("bad VF receive mode parameter, return code = %d \n",
return;
for (i = 0; i < nb_item; i++) {
- if (vlan_list[i] > ETHER_MAX_VLAN_ID) {
+ if (vlan_list[i] > RTE_ETHER_MAX_VLAN_ID) {
printf("Invalid vlan_id: must be < 4096\n");
return;
}
" when protocol is TCP.\n");
return;
}
- if (res->tcp_flags_value > TCP_FLAG_ALL) {
+ if (res->tcp_flags_value > RTE_NTUPLE_TCP_FLAGS_MASK) {
printf("invalid TCP flags.\n");
return;
}
" when protocol is TCP.\n");
return;
}
- if (res->tcp_flags_value > TCP_FLAG_ALL) {
+ if (res->tcp_flags_value > RTE_NTUPLE_TCP_FLAGS_MASK) {
printf("invalid TCP flags.\n");
return;
}
else if (!strncmp(res->pf_vf, "vf", 2)) {
struct rte_eth_dev_info dev_info;
- memset(&dev_info, 0, sizeof(dev_info));
- rte_eth_dev_info_get(res->port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(res->port_id,
+ &dev_info);
+ if (ret != 0)
+ return;
+
errno = 0;
vf_id = strtoul(res->pf_vf + 2, &end, 10);
if (errno != 0 || *end != '\0' ||
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) {
#ifdef RTE_LIBRTE_IXGBE_PMD
ret = rte_pmd_ixgbe_macsec_enable(port_id, en, rp);
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) {
#ifdef RTE_LIBRTE_IXGBE_PMD
ret = rte_pmd_ixgbe_macsec_disable(port_id);
if (vxlan_encap_conf.select_vlan)
vxlan_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
rte_memcpy(vxlan_encap_conf.eth_src, res->eth_src.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
rte_memcpy(vxlan_encap_conf.eth_dst, res->eth_dst.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
}
cmdline_parse_inst_t cmd_set_vxlan = {
if (nvgre_encap_conf.select_vlan)
nvgre_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
rte_memcpy(nvgre_encap_conf.eth_src, res->eth_src.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
rte_memcpy(nvgre_encap_conf.eth_dst, res->eth_dst.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
}
cmdline_parse_inst_t cmd_set_nvgre = {
if (l2_encap_conf.select_vlan)
l2_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
rte_memcpy(l2_encap_conf.eth_src, res->eth_src.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
rte_memcpy(l2_encap_conf.eth_dst, res->eth_dst.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
}
cmdline_parse_inst_t cmd_set_l2_encap = {
if (mplsogre_encap_conf.select_vlan)
mplsogre_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
rte_memcpy(mplsogre_encap_conf.eth_src, res->eth_src.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
rte_memcpy(mplsogre_encap_conf.eth_dst, res->eth_dst.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
}
cmdline_parse_inst_t cmd_set_mplsogre_encap = {
if (mplsoudp_encap_conf.select_vlan)
mplsoudp_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
rte_memcpy(mplsoudp_encap_conf.eth_src, res->eth_src.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
rte_memcpy(mplsoudp_encap_conf.eth_dst, res->eth_dst.addr_bytes,
- ETHER_ADDR_LEN);
+ RTE_ETHER_ADDR_LEN);
}
cmdline_parse_inst_t cmd_set_mplsoudp_encap = {
portid_t port_id = res->port_id;
uint64_t queue_offloads;
uint64_t port_offloads;
+ int ret;
+
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
- rte_eth_dev_info_get(port_id, &dev_info);
queue_offloads = dev_info.rx_queue_offload_capa;
port_offloads = dev_info.rx_offload_capa ^ queue_offloads;
uint64_t queue_offloads;
uint16_t nb_rx_queues;
int q;
+ int ret;
printf("Rx Offloading Configuration of port %d :\n", port_id);
print_rx_offloads(port_offloads);
printf("\n");
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
nb_rx_queues = dev_info.nb_rx_queues;
for (q = 0; q < nb_rx_queues; q++) {
queue_offloads = port->rx_conf[q].offloads;
uint64_t single_offload;
uint16_t nb_rx_queues;
int q;
+ int ret;
if (port->port_status != RTE_PORT_STOPPED) {
printf("Error: Can't config offload when Port %d "
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
nb_rx_queues = dev_info.nb_rx_queues;
if (!strcmp(res->on_off, "on")) {
port->dev_conf.rxmode.offloads |= single_offload;
uint16_t queue_id = res->queue_id;
struct rte_port *port = &ports[port_id];
uint64_t single_offload;
+ int ret;
if (port->port_status != RTE_PORT_STOPPED) {
printf("Error: Can't config offload when Port %d "
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (queue_id >= dev_info.nb_rx_queues) {
printf("Error: input queue_id should be 0 ... "
"%d\n", dev_info.nb_rx_queues - 1);
portid_t port_id = res->port_id;
uint64_t queue_offloads;
uint64_t port_offloads;
+ int ret;
+
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
- rte_eth_dev_info_get(port_id, &dev_info);
queue_offloads = dev_info.tx_queue_offload_capa;
port_offloads = dev_info.tx_offload_capa ^ queue_offloads;
uint64_t queue_offloads;
uint16_t nb_tx_queues;
int q;
+ int ret;
printf("Tx Offloading Configuration of port %d :\n", port_id);
print_tx_offloads(port_offloads);
printf("\n");
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
nb_tx_queues = dev_info.nb_tx_queues;
for (q = 0; q < nb_tx_queues; q++) {
queue_offloads = port->tx_conf[q].offloads;
uint64_t single_offload;
uint16_t nb_tx_queues;
int q;
+ int ret;
if (port->port_status != RTE_PORT_STOPPED) {
printf("Error: Can't config offload when Port %d "
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
nb_tx_queues = dev_info.nb_tx_queues;
if (!strcmp(res->on_off, "on")) {
port->dev_conf.txmode.offloads |= single_offload;
uint16_t queue_id = res->queue_id;
struct rte_port *port = &ports[port_id];
uint64_t single_offload;
+ int ret;
if (port->port_status != RTE_PORT_STOPPED) {
printf("Error: Can't config offload when Port %d "
return;
}
- rte_eth_dev_info_get(port_id, &dev_info);
+ ret = eth_dev_info_get_print_err(port_id, &dev_info);
+ if (ret != 0)
+ return;
+
if (queue_id >= dev_info.nb_tx_queues) {
printf("Error: input queue_id should be 0 ... "
"%d\n", dev_info.nb_tx_queues - 1);
(cmdline_parse_inst_t *)&cmd_showport,
(cmdline_parse_inst_t *)&cmd_showqueue,
(cmdline_parse_inst_t *)&cmd_showportall,
+ (cmdline_parse_inst_t *)&cmd_showdevice,
(cmdline_parse_inst_t *)&cmd_showcfg,
(cmdline_parse_inst_t *)&cmd_showfwdall,
(cmdline_parse_inst_t *)&cmd_start,
(cmdline_parse_inst_t *)&cmd_operate_specific_port,
(cmdline_parse_inst_t *)&cmd_operate_attach_port,
(cmdline_parse_inst_t *)&cmd_operate_detach_port,
+ (cmdline_parse_inst_t *)&cmd_operate_detach_device,
(cmdline_parse_inst_t *)&cmd_set_port_setup_on,
(cmdline_parse_inst_t *)&cmd_config_speed_all,
(cmdline_parse_inst_t *)&cmd_config_speed_specific,
#endif
(cmdline_parse_inst_t *)&cmd_config_tx_metadata_specific,
(cmdline_parse_inst_t *)&cmd_show_tx_metadata,
+ (cmdline_parse_inst_t *)&cmd_set_raw,
NULL,
};
git.droids-corp.org / dpdk.git / blobdiff