1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2016 Intel Corporation. 3 * Copyright 2013-2014 6WIND S.A. 4 */ 5 6 #include <stdarg.h> 7 #include <errno.h> 8 #include <stdio.h> 9 #include <string.h> 10 #include <stdint.h> 11 #include <inttypes.h> 12 13 #include <sys/queue.h> 14 #include <sys/types.h> 15 #include <sys/stat.h> 16 #include <fcntl.h> 17 #include <unistd.h> 18 19 #include <rte_common.h> 20 #include <rte_byteorder.h> 21 #include <rte_debug.h> 22 #include <rte_log.h> 23 #include <rte_memory.h> 24 #include <rte_memcpy.h> 25 #include <rte_memzone.h> 26 #include <rte_launch.h> 27 #include <rte_eal.h> 28 #include <rte_per_lcore.h> 29 #include <rte_lcore.h> 30 #include <rte_atomic.h> 31 #include <rte_branch_prediction.h> 32 #include <rte_mempool.h> 33 #include <rte_mbuf.h> 34 #include <rte_interrupts.h> 35 #include <rte_pci.h> 36 #include <rte_ether.h> 37 #include <rte_ethdev.h> 38 #include <rte_string_fns.h> 39 #include <rte_cycles.h> 40 #include <rte_flow.h> 41 #include <rte_errno.h> 42 #ifdef RTE_LIBRTE_IXGBE_PMD 43 #include <rte_pmd_ixgbe.h> 44 #endif 45 #ifdef RTE_LIBRTE_I40E_PMD 46 #include <rte_pmd_i40e.h> 47 #endif 48 #ifdef RTE_LIBRTE_BNXT_PMD 49 #include <rte_pmd_bnxt.h> 50 #endif 51 #include <rte_gro.h> 52 #include <cmdline_parse_etheraddr.h> 53 54 #include "testpmd.h" 55 56 static char *flowtype_to_str(uint16_t flow_type); 57 58 static const struct { 59 enum tx_pkt_split split; 60 const char *name; 61 } tx_split_name[] = { 62 { 63 .split = TX_PKT_SPLIT_OFF, 64 .name = "off", 65 }, 66 { 67 .split = TX_PKT_SPLIT_ON, 68 .name = "on", 69 }, 70 { 71 .split = TX_PKT_SPLIT_RND, 72 .name = "rand", 73 }, 74 }; 75 76 const struct rss_type_info rss_type_table[] = { 77 { "ipv4", ETH_RSS_IPV4 }, 78 { "ipv4-frag", ETH_RSS_FRAG_IPV4 }, 79 { "ipv4-tcp", ETH_RSS_NONFRAG_IPV4_TCP }, 80 { "ipv4-udp", ETH_RSS_NONFRAG_IPV4_UDP }, 81 { "ipv4-sctp", ETH_RSS_NONFRAG_IPV4_SCTP }, 82 { "ipv4-other", ETH_RSS_NONFRAG_IPV4_OTHER }, 83 { "ipv6", ETH_RSS_IPV6 }, 84 { "ipv6-frag", ETH_RSS_FRAG_IPV6 }, 85 { "ipv6-tcp", ETH_RSS_NONFRAG_IPV6_TCP }, 86 { "ipv6-udp", ETH_RSS_NONFRAG_IPV6_UDP }, 87 { "ipv6-sctp", ETH_RSS_NONFRAG_IPV6_SCTP }, 88 { "ipv6-other", ETH_RSS_NONFRAG_IPV6_OTHER }, 89 { "l2-payload", ETH_RSS_L2_PAYLOAD }, 90 { "ipv6-ex", ETH_RSS_IPV6_EX }, 91 { "ipv6-tcp-ex", ETH_RSS_IPV6_TCP_EX }, 92 { "ipv6-udp-ex", ETH_RSS_IPV6_UDP_EX }, 93 { "port", ETH_RSS_PORT }, 94 { "vxlan", ETH_RSS_VXLAN }, 95 { "geneve", ETH_RSS_GENEVE }, 96 { "nvgre", ETH_RSS_NVGRE }, 97 { "ip", ETH_RSS_IP }, 98 { "udp", ETH_RSS_UDP }, 99 { "tcp", ETH_RSS_TCP }, 100 { "sctp", ETH_RSS_SCTP }, 101 { "tunnel", ETH_RSS_TUNNEL }, 102 { NULL, 0 }, 103 }; 104 105 static void 106 print_ethaddr(const char *name, struct ether_addr *eth_addr) 107 { 108 char buf[ETHER_ADDR_FMT_SIZE]; 109 ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr); 110 printf("%s%s", name, buf); 111 } 112 113 void 114 nic_stats_display(portid_t port_id) 115 { 116 static uint64_t prev_pkts_rx[RTE_MAX_ETHPORTS]; 117 static uint64_t prev_pkts_tx[RTE_MAX_ETHPORTS]; 118 static uint64_t prev_cycles[RTE_MAX_ETHPORTS]; 119 uint64_t diff_pkts_rx, diff_pkts_tx, diff_cycles; 120 uint64_t mpps_rx, mpps_tx; 121 struct rte_eth_stats stats; 122 struct rte_port *port = &ports[port_id]; 123 uint8_t i; 124 125 static const char *nic_stats_border = "########################"; 126 127 if (port_id_is_invalid(port_id, ENABLED_WARN)) { 128 print_valid_ports(); 129 return; 130 } 131 rte_eth_stats_get(port_id, &stats); 132 printf("\n %s NIC statistics for port %-2d %s\n", 133 nic_stats_border, port_id, nic_stats_border); 134 135 if ((!port->rx_queue_stats_mapping_enabled) && (!port->tx_queue_stats_mapping_enabled)) { 136 printf(" RX-packets: %-10"PRIu64" RX-missed: %-10"PRIu64" RX-bytes: " 137 "%-"PRIu64"\n", 138 stats.ipackets, stats.imissed, stats.ibytes); 139 printf(" RX-errors: %-"PRIu64"\n", stats.ierrors); 140 printf(" RX-nombuf: %-10"PRIu64"\n", 141 stats.rx_nombuf); 142 printf(" TX-packets: %-10"PRIu64" TX-errors: %-10"PRIu64" TX-bytes: " 143 "%-"PRIu64"\n", 144 stats.opackets, stats.oerrors, stats.obytes); 145 } 146 else { 147 printf(" RX-packets: %10"PRIu64" RX-errors: %10"PRIu64 148 " RX-bytes: %10"PRIu64"\n", 149 stats.ipackets, stats.ierrors, stats.ibytes); 150 printf(" RX-errors: %10"PRIu64"\n", stats.ierrors); 151 printf(" RX-nombuf: %10"PRIu64"\n", 152 stats.rx_nombuf); 153 printf(" TX-packets: %10"PRIu64" TX-errors: %10"PRIu64 154 " TX-bytes: %10"PRIu64"\n", 155 stats.opackets, stats.oerrors, stats.obytes); 156 } 157 158 if (port->rx_queue_stats_mapping_enabled) { 159 printf("\n"); 160 for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS; i++) { 161 printf(" Stats reg %2d RX-packets: %10"PRIu64 162 " RX-errors: %10"PRIu64 163 " RX-bytes: %10"PRIu64"\n", 164 i, stats.q_ipackets[i], stats.q_errors[i], stats.q_ibytes[i]); 165 } 166 } 167 if (port->tx_queue_stats_mapping_enabled) { 168 printf("\n"); 169 for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS; i++) { 170 printf(" Stats reg %2d TX-packets: %10"PRIu64 171 " TX-bytes: %10"PRIu64"\n", 172 i, stats.q_opackets[i], stats.q_obytes[i]); 173 } 174 } 175 176 diff_cycles = prev_cycles[port_id]; 177 prev_cycles[port_id] = rte_rdtsc(); 178 if (diff_cycles > 0) 179 diff_cycles = prev_cycles[port_id] - diff_cycles; 180 181 diff_pkts_rx = (stats.ipackets > prev_pkts_rx[port_id]) ? 182 (stats.ipackets - prev_pkts_rx[port_id]) : 0; 183 diff_pkts_tx = (stats.opackets > prev_pkts_tx[port_id]) ? 184 (stats.opackets - prev_pkts_tx[port_id]) : 0; 185 prev_pkts_rx[port_id] = stats.ipackets; 186 prev_pkts_tx[port_id] = stats.opackets; 187 mpps_rx = diff_cycles > 0 ? 188 diff_pkts_rx * rte_get_tsc_hz() / diff_cycles : 0; 189 mpps_tx = diff_cycles > 0 ? 190 diff_pkts_tx * rte_get_tsc_hz() / diff_cycles : 0; 191 printf("\n Throughput (since last show)\n"); 192 printf(" Rx-pps: %12"PRIu64"\n Tx-pps: %12"PRIu64"\n", 193 mpps_rx, mpps_tx); 194 195 printf(" %s############################%s\n", 196 nic_stats_border, nic_stats_border); 197 } 198 199 void 200 nic_stats_clear(portid_t port_id) 201 { 202 if (port_id_is_invalid(port_id, ENABLED_WARN)) { 203 print_valid_ports(); 204 return; 205 } 206 rte_eth_stats_reset(port_id); 207 printf("\n NIC statistics for port %d cleared\n", port_id); 208 } 209 210 void 211 nic_xstats_display(portid_t port_id) 212 { 213 struct rte_eth_xstat *xstats; 214 int cnt_xstats, idx_xstat; 215 struct rte_eth_xstat_name *xstats_names; 216 217 printf("###### NIC extended statistics for port %-2d\n", port_id); 218 if (!rte_eth_dev_is_valid_port(port_id)) { 219 printf("Error: Invalid port number %i\n", port_id); 220 return; 221 } 222 223 /* Get count */ 224 cnt_xstats = rte_eth_xstats_get_names(port_id, NULL, 0); 225 if (cnt_xstats < 0) { 226 printf("Error: Cannot get count of xstats\n"); 227 return; 228 } 229 230 /* Get id-name lookup table */ 231 xstats_names = malloc(sizeof(struct rte_eth_xstat_name) * cnt_xstats); 232 if (xstats_names == NULL) { 233 printf("Cannot allocate memory for xstats lookup\n"); 234 return; 235 } 236 if (cnt_xstats != rte_eth_xstats_get_names( 237 port_id, xstats_names, cnt_xstats)) { 238 printf("Error: Cannot get xstats lookup\n"); 239 free(xstats_names); 240 return; 241 } 242 243 /* Get stats themselves */ 244 xstats = malloc(sizeof(struct rte_eth_xstat) * cnt_xstats); 245 if (xstats == NULL) { 246 printf("Cannot allocate memory for xstats\n"); 247 free(xstats_names); 248 return; 249 } 250 if (cnt_xstats != rte_eth_xstats_get(port_id, xstats, cnt_xstats)) { 251 printf("Error: Unable to get xstats\n"); 252 free(xstats_names); 253 free(xstats); 254 return; 255 } 256 257 /* Display xstats */ 258 for (idx_xstat = 0; idx_xstat < cnt_xstats; idx_xstat++) { 259 if (xstats_hide_zero && !xstats[idx_xstat].value) 260 continue; 261 printf("%s: %"PRIu64"\n", 262 xstats_names[idx_xstat].name, 263 xstats[idx_xstat].value); 264 } 265 free(xstats_names); 266 free(xstats); 267 } 268 269 void 270 nic_xstats_clear(portid_t port_id) 271 { 272 rte_eth_xstats_reset(port_id); 273 } 274 275 void 276 nic_stats_mapping_display(portid_t port_id) 277 { 278 struct rte_port *port = &ports[port_id]; 279 uint16_t i; 280 281 static const char *nic_stats_mapping_border = "########################"; 282 283 if (port_id_is_invalid(port_id, ENABLED_WARN)) { 284 print_valid_ports(); 285 return; 286 } 287 288 if ((!port->rx_queue_stats_mapping_enabled) && (!port->tx_queue_stats_mapping_enabled)) { 289 printf("Port id %d - either does not support queue statistic mapping or" 290 " no queue statistic mapping set\n", port_id); 291 return; 292 } 293 294 printf("\n %s NIC statistics mapping for port %-2d %s\n", 295 nic_stats_mapping_border, port_id, nic_stats_mapping_border); 296 297 if (port->rx_queue_stats_mapping_enabled) { 298 for (i = 0; i < nb_rx_queue_stats_mappings; i++) { 299 if (rx_queue_stats_mappings[i].port_id == port_id) { 300 printf(" RX-queue %2d mapped to Stats Reg %2d\n", 301 rx_queue_stats_mappings[i].queue_id, 302 rx_queue_stats_mappings[i].stats_counter_id); 303 } 304 } 305 printf("\n"); 306 } 307 308 309 if (port->tx_queue_stats_mapping_enabled) { 310 for (i = 0; i < nb_tx_queue_stats_mappings; i++) { 311 if (tx_queue_stats_mappings[i].port_id == port_id) { 312 printf(" TX-queue %2d mapped to Stats Reg %2d\n", 313 tx_queue_stats_mappings[i].queue_id, 314 tx_queue_stats_mappings[i].stats_counter_id); 315 } 316 } 317 } 318 319 printf(" %s####################################%s\n", 320 nic_stats_mapping_border, nic_stats_mapping_border); 321 } 322 323 void 324 rx_queue_infos_display(portid_t port_id, uint16_t queue_id) 325 { 326 struct rte_eth_rxq_info qinfo; 327 int32_t rc; 328 static const char *info_border = "*********************"; 329 330 rc = rte_eth_rx_queue_info_get(port_id, queue_id, &qinfo); 331 if (rc != 0) { 332 printf("Failed to retrieve information for port: %u, " 333 "RX queue: %hu\nerror desc: %s(%d)\n", 334 port_id, queue_id, strerror(-rc), rc); 335 return; 336 } 337 338 printf("\n%s Infos for port %-2u, RX queue %-2u %s", 339 info_border, port_id, queue_id, info_border); 340 341 printf("\nMempool: %s", (qinfo.mp == NULL) ? "NULL" : qinfo.mp->name); 342 printf("\nRX prefetch threshold: %hhu", qinfo.conf.rx_thresh.pthresh); 343 printf("\nRX host threshold: %hhu", qinfo.conf.rx_thresh.hthresh); 344 printf("\nRX writeback threshold: %hhu", qinfo.conf.rx_thresh.wthresh); 345 printf("\nRX free threshold: %hu", qinfo.conf.rx_free_thresh); 346 printf("\nRX drop packets: %s", 347 (qinfo.conf.rx_drop_en != 0) ? "on" : "off"); 348 printf("\nRX deferred start: %s", 349 (qinfo.conf.rx_deferred_start != 0) ? "on" : "off"); 350 printf("\nRX scattered packets: %s", 351 (qinfo.scattered_rx != 0) ? "on" : "off"); 352 printf("\nNumber of RXDs: %hu", qinfo.nb_desc); 353 printf("\n"); 354 } 355 356 void 357 tx_queue_infos_display(portid_t port_id, uint16_t queue_id) 358 { 359 struct rte_eth_txq_info qinfo; 360 int32_t rc; 361 static const char *info_border = "*********************"; 362 363 rc = rte_eth_tx_queue_info_get(port_id, queue_id, &qinfo); 364 if (rc != 0) { 365 printf("Failed to retrieve information for port: %u, " 366 "TX queue: %hu\nerror desc: %s(%d)\n", 367 port_id, queue_id, strerror(-rc), rc); 368 return; 369 } 370 371 printf("\n%s Infos for port %-2u, TX queue %-2u %s", 372 info_border, port_id, queue_id, info_border); 373 374 printf("\nTX prefetch threshold: %hhu", qinfo.conf.tx_thresh.pthresh); 375 printf("\nTX host threshold: %hhu", qinfo.conf.tx_thresh.hthresh); 376 printf("\nTX writeback threshold: %hhu", qinfo.conf.tx_thresh.wthresh); 377 printf("\nTX RS threshold: %hu", qinfo.conf.tx_rs_thresh); 378 printf("\nTX free threshold: %hu", qinfo.conf.tx_free_thresh); 379 printf("\nTX deferred start: %s", 380 (qinfo.conf.tx_deferred_start != 0) ? "on" : "off"); 381 printf("\nNumber of TXDs: %hu", qinfo.nb_desc); 382 printf("\n"); 383 } 384 385 void 386 port_infos_display(portid_t port_id) 387 { 388 struct rte_port *port; 389 struct ether_addr mac_addr; 390 struct rte_eth_link link; 391 struct rte_eth_dev_info dev_info; 392 int vlan_offload; 393 struct rte_mempool * mp; 394 static const char *info_border = "*********************"; 395 uint16_t mtu; 396 char name[RTE_ETH_NAME_MAX_LEN]; 397 398 if (port_id_is_invalid(port_id, ENABLED_WARN)) { 399 print_valid_ports(); 400 return; 401 } 402 port = &ports[port_id]; 403 rte_eth_link_get_nowait(port_id, &link); 404 memset(&dev_info, 0, sizeof(dev_info)); 405 rte_eth_dev_info_get(port_id, &dev_info); 406 printf("\n%s Infos for port %-2d %s\n", 407 info_border, port_id, info_border); 408 rte_eth_macaddr_get(port_id, &mac_addr); 409 print_ethaddr("MAC address: ", &mac_addr); 410 rte_eth_dev_get_name_by_port(port_id, name); 411 printf("\nDevice name: %s", name); 412 printf("\nDriver name: %s", dev_info.driver_name); 413 printf("\nConnect to socket: %u", port->socket_id); 414 415 if (port_numa[port_id] != NUMA_NO_CONFIG) { 416 mp = mbuf_pool_find(port_numa[port_id]); 417 if (mp) 418 printf("\nmemory allocation on the socket: %d", 419 port_numa[port_id]); 420 } else 421 printf("\nmemory allocation on the socket: %u",port->socket_id); 422 423 printf("\nLink status: %s\n", (link.link_status) ? ("up") : ("down")); 424 printf("Link speed: %u Mbps\n", (unsigned) link.link_speed); 425 printf("Link duplex: %s\n", (link.link_duplex == ETH_LINK_FULL_DUPLEX) ? 426 ("full-duplex") : ("half-duplex")); 427 428 if (!rte_eth_dev_get_mtu(port_id, &mtu)) 429 printf("MTU: %u\n", mtu); 430 431 printf("Promiscuous mode: %s\n", 432 rte_eth_promiscuous_get(port_id) ? "enabled" : "disabled"); 433 printf("Allmulticast mode: %s\n", 434 rte_eth_allmulticast_get(port_id) ? "enabled" : "disabled"); 435 printf("Maximum number of MAC addresses: %u\n", 436 (unsigned int)(port->dev_info.max_mac_addrs)); 437 printf("Maximum number of MAC addresses of hash filtering: %u\n", 438 (unsigned int)(port->dev_info.max_hash_mac_addrs)); 439 440 vlan_offload = rte_eth_dev_get_vlan_offload(port_id); 441 if (vlan_offload >= 0){ 442 printf("VLAN offload: \n"); 443 if (vlan_offload & ETH_VLAN_STRIP_OFFLOAD) 444 printf(" strip on \n"); 445 else 446 printf(" strip off \n"); 447 448 if (vlan_offload & ETH_VLAN_FILTER_OFFLOAD) 449 printf(" filter on \n"); 450 else 451 printf(" filter off \n"); 452 453 if (vlan_offload & ETH_VLAN_EXTEND_OFFLOAD) 454 printf(" qinq(extend) on \n"); 455 else 456 printf(" qinq(extend) off \n"); 457 } 458 459 if (dev_info.hash_key_size > 0) 460 printf("Hash key size in bytes: %u\n", dev_info.hash_key_size); 461 if (dev_info.reta_size > 0) 462 printf("Redirection table size: %u\n", dev_info.reta_size); 463 if (!dev_info.flow_type_rss_offloads) 464 printf("No flow type is supported.\n"); 465 else { 466 uint16_t i; 467 char *p; 468 469 printf("Supported flow types:\n"); 470 for (i = RTE_ETH_FLOW_UNKNOWN + 1; 471 i < sizeof(dev_info.flow_type_rss_offloads) * CHAR_BIT; i++) { 472 if (!(dev_info.flow_type_rss_offloads & (1ULL << i))) 473 continue; 474 p = flowtype_to_str(i); 475 if (p) 476 printf(" %s\n", p); 477 else 478 printf(" user defined %d\n", i); 479 } 480 } 481 482 printf("Minimum size of RX buffer: %u\n", dev_info.min_rx_bufsize); 483 printf("Maximum configurable length of RX packet: %u\n", 484 dev_info.max_rx_pktlen); 485 if (dev_info.max_vfs) 486 printf("Maximum number of VFs: %u\n", dev_info.max_vfs); 487 if (dev_info.max_vmdq_pools) 488 printf("Maximum number of VMDq pools: %u\n", 489 dev_info.max_vmdq_pools); 490 491 printf("Current number of RX queues: %u\n", dev_info.nb_rx_queues); 492 printf("Max possible RX queues: %u\n", dev_info.max_rx_queues); 493 printf("Max possible number of RXDs per queue: %hu\n", 494 dev_info.rx_desc_lim.nb_max); 495 printf("Min possible number of RXDs per queue: %hu\n", 496 dev_info.rx_desc_lim.nb_min); 497 printf("RXDs number alignment: %hu\n", dev_info.rx_desc_lim.nb_align); 498 499 printf("Current number of TX queues: %u\n", dev_info.nb_tx_queues); 500 printf("Max possible TX queues: %u\n", dev_info.max_tx_queues); 501 printf("Max possible number of TXDs per queue: %hu\n", 502 dev_info.tx_desc_lim.nb_max); 503 printf("Min possible number of TXDs per queue: %hu\n", 504 dev_info.tx_desc_lim.nb_min); 505 printf("TXDs number alignment: %hu\n", dev_info.tx_desc_lim.nb_align); 506 507 /* Show switch info only if valid switch domain and port id is set */ 508 if (dev_info.switch_info.domain_id != 509 RTE_ETH_DEV_SWITCH_DOMAIN_ID_INVALID) { 510 if (dev_info.switch_info.name) 511 printf("Switch name: %s\n", dev_info.switch_info.name); 512 513 printf("Switch domain Id: %u\n", 514 dev_info.switch_info.domain_id); 515 printf("Switch Port Id: %u\n", 516 dev_info.switch_info.port_id); 517 } 518 } 519 520 void 521 port_offload_cap_display(portid_t port_id) 522 { 523 struct rte_eth_dev_info dev_info; 524 static const char *info_border = "************"; 525 526 if (port_id_is_invalid(port_id, ENABLED_WARN)) 527 return; 528 529 rte_eth_dev_info_get(port_id, &dev_info); 530 531 printf("\n%s Port %d supported offload features: %s\n", 532 info_border, port_id, info_border); 533 534 if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_VLAN_STRIP) { 535 printf("VLAN stripped: "); 536 if (ports[port_id].dev_conf.rxmode.offloads & 537 DEV_RX_OFFLOAD_VLAN_STRIP) 538 printf("on\n"); 539 else 540 printf("off\n"); 541 } 542 543 if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_QINQ_STRIP) { 544 printf("Double VLANs stripped: "); 545 if (ports[port_id].dev_conf.rxmode.offloads & 546 DEV_RX_OFFLOAD_VLAN_EXTEND) 547 printf("on\n"); 548 else 549 printf("off\n"); 550 } 551 552 if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_IPV4_CKSUM) { 553 printf("RX IPv4 checksum: "); 554 if (ports[port_id].dev_conf.rxmode.offloads & 555 DEV_RX_OFFLOAD_IPV4_CKSUM) 556 printf("on\n"); 557 else 558 printf("off\n"); 559 } 560 561 if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_UDP_CKSUM) { 562 printf("RX UDP checksum: "); 563 if (ports[port_id].dev_conf.rxmode.offloads & 564 DEV_RX_OFFLOAD_UDP_CKSUM) 565 printf("on\n"); 566 else 567 printf("off\n"); 568 } 569 570 if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_TCP_CKSUM) { 571 printf("RX TCP checksum: "); 572 if (ports[port_id].dev_conf.rxmode.offloads & 573 DEV_RX_OFFLOAD_TCP_CKSUM) 574 printf("on\n"); 575 else 576 printf("off\n"); 577 } 578 579 if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM) { 580 printf("RX Outer IPv4 checksum: "); 581 if (ports[port_id].dev_conf.rxmode.offloads & 582 DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM) 583 printf("on\n"); 584 else 585 printf("off\n"); 586 } 587 588 if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_TCP_LRO) { 589 printf("Large receive offload: "); 590 if (ports[port_id].dev_conf.rxmode.offloads & 591 DEV_RX_OFFLOAD_TCP_LRO) 592 printf("on\n"); 593 else 594 printf("off\n"); 595 } 596 597 if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_TIMESTAMP) { 598 printf("HW timestamp: "); 599 if (ports[port_id].dev_conf.rxmode.offloads & 600 DEV_RX_OFFLOAD_TIMESTAMP) 601 printf("on\n"); 602 else 603 printf("off\n"); 604 } 605 606 if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_KEEP_CRC) { 607 printf("Rx Keep CRC: "); 608 if (ports[port_id].dev_conf.rxmode.offloads & 609 DEV_RX_OFFLOAD_KEEP_CRC) 610 printf("on\n"); 611 else 612 printf("off\n"); 613 } 614 615 if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_SECURITY) { 616 printf("RX offload security: "); 617 if (ports[port_id].dev_conf.rxmode.offloads & 618 DEV_RX_OFFLOAD_SECURITY) 619 printf("on\n"); 620 else 621 printf("off\n"); 622 } 623 624 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_VLAN_INSERT) { 625 printf("VLAN insert: "); 626 if (ports[port_id].dev_conf.txmode.offloads & 627 DEV_TX_OFFLOAD_VLAN_INSERT) 628 printf("on\n"); 629 else 630 printf("off\n"); 631 } 632 633 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_QINQ_INSERT) { 634 printf("Double VLANs insert: "); 635 if (ports[port_id].dev_conf.txmode.offloads & 636 DEV_TX_OFFLOAD_QINQ_INSERT) 637 printf("on\n"); 638 else 639 printf("off\n"); 640 } 641 642 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IPV4_CKSUM) { 643 printf("TX IPv4 checksum: "); 644 if (ports[port_id].dev_conf.txmode.offloads & 645 DEV_TX_OFFLOAD_IPV4_CKSUM) 646 printf("on\n"); 647 else 648 printf("off\n"); 649 } 650 651 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_UDP_CKSUM) { 652 printf("TX UDP checksum: "); 653 if (ports[port_id].dev_conf.txmode.offloads & 654 DEV_TX_OFFLOAD_UDP_CKSUM) 655 printf("on\n"); 656 else 657 printf("off\n"); 658 } 659 660 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_CKSUM) { 661 printf("TX TCP checksum: "); 662 if (ports[port_id].dev_conf.txmode.offloads & 663 DEV_TX_OFFLOAD_TCP_CKSUM) 664 printf("on\n"); 665 else 666 printf("off\n"); 667 } 668 669 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_SCTP_CKSUM) { 670 printf("TX SCTP checksum: "); 671 if (ports[port_id].dev_conf.txmode.offloads & 672 DEV_TX_OFFLOAD_SCTP_CKSUM) 673 printf("on\n"); 674 else 675 printf("off\n"); 676 } 677 678 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM) { 679 printf("TX Outer IPv4 checksum: "); 680 if (ports[port_id].dev_conf.txmode.offloads & 681 DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM) 682 printf("on\n"); 683 else 684 printf("off\n"); 685 } 686 687 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_TCP_TSO) { 688 printf("TX TCP segmentation: "); 689 if (ports[port_id].dev_conf.txmode.offloads & 690 DEV_TX_OFFLOAD_TCP_TSO) 691 printf("on\n"); 692 else 693 printf("off\n"); 694 } 695 696 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_UDP_TSO) { 697 printf("TX UDP segmentation: "); 698 if (ports[port_id].dev_conf.txmode.offloads & 699 DEV_TX_OFFLOAD_UDP_TSO) 700 printf("on\n"); 701 else 702 printf("off\n"); 703 } 704 705 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_VXLAN_TNL_TSO) { 706 printf("TSO for VXLAN tunnel packet: "); 707 if (ports[port_id].dev_conf.txmode.offloads & 708 DEV_TX_OFFLOAD_VXLAN_TNL_TSO) 709 printf("on\n"); 710 else 711 printf("off\n"); 712 } 713 714 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_GRE_TNL_TSO) { 715 printf("TSO for GRE tunnel packet: "); 716 if (ports[port_id].dev_conf.txmode.offloads & 717 DEV_TX_OFFLOAD_GRE_TNL_TSO) 718 printf("on\n"); 719 else 720 printf("off\n"); 721 } 722 723 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IPIP_TNL_TSO) { 724 printf("TSO for IPIP tunnel packet: "); 725 if (ports[port_id].dev_conf.txmode.offloads & 726 DEV_TX_OFFLOAD_IPIP_TNL_TSO) 727 printf("on\n"); 728 else 729 printf("off\n"); 730 } 731 732 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_GENEVE_TNL_TSO) { 733 printf("TSO for GENEVE tunnel packet: "); 734 if (ports[port_id].dev_conf.txmode.offloads & 735 DEV_TX_OFFLOAD_GENEVE_TNL_TSO) 736 printf("on\n"); 737 else 738 printf("off\n"); 739 } 740 741 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_IP_TNL_TSO) { 742 printf("IP tunnel TSO: "); 743 if (ports[port_id].dev_conf.txmode.offloads & 744 DEV_TX_OFFLOAD_IP_TNL_TSO) 745 printf("on\n"); 746 else 747 printf("off\n"); 748 } 749 750 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_UDP_TNL_TSO) { 751 printf("UDP tunnel TSO: "); 752 if (ports[port_id].dev_conf.txmode.offloads & 753 DEV_TX_OFFLOAD_UDP_TNL_TSO) 754 printf("on\n"); 755 else 756 printf("off\n"); 757 } 758 } 759 760 int 761 port_id_is_invalid(portid_t port_id, enum print_warning warning) 762 { 763 uint16_t pid; 764 765 if (port_id == (portid_t)RTE_PORT_ALL) 766 return 0; 767 768 RTE_ETH_FOREACH_DEV(pid) 769 if (port_id == pid) 770 return 0; 771 772 if (warning == ENABLED_WARN) 773 printf("Invalid port %d\n", port_id); 774 775 return 1; 776 } 777 778 void print_valid_ports(void) 779 { 780 portid_t pid; 781 782 printf("The valid ports array is ["); 783 RTE_ETH_FOREACH_DEV(pid) { 784 printf(" %d", pid); 785 } 786 printf(" ]\n"); 787 } 788 789 static int 790 vlan_id_is_invalid(uint16_t vlan_id) 791 { 792 if (vlan_id < 4096) 793 return 0; 794 printf("Invalid vlan_id %d (must be < 4096)\n", vlan_id); 795 return 1; 796 } 797 798 static int 799 port_reg_off_is_invalid(portid_t port_id, uint32_t reg_off) 800 { 801 const struct rte_pci_device *pci_dev; 802 const struct rte_bus *bus; 803 uint64_t pci_len; 804 805 if (reg_off & 0x3) { 806 printf("Port register offset 0x%X not aligned on a 4-byte " 807 "boundary\n", 808 (unsigned)reg_off); 809 return 1; 810 } 811 812 if (!ports[port_id].dev_info.device) { 813 printf("Invalid device\n"); 814 return 0; 815 } 816 817 bus = rte_bus_find_by_device(ports[port_id].dev_info.device); 818 if (bus && !strcmp(bus->name, "pci")) { 819 pci_dev = RTE_DEV_TO_PCI(ports[port_id].dev_info.device); 820 } else { 821 printf("Not a PCI device\n"); 822 return 1; 823 } 824 825 pci_len = pci_dev->mem_resource[0].len; 826 if (reg_off >= pci_len) { 827 printf("Port %d: register offset %u (0x%X) out of port PCI " 828 "resource (length=%"PRIu64")\n", 829 port_id, (unsigned)reg_off, (unsigned)reg_off, pci_len); 830 return 1; 831 } 832 return 0; 833 } 834 835 static int 836 reg_bit_pos_is_invalid(uint8_t bit_pos) 837 { 838 if (bit_pos <= 31) 839 return 0; 840 printf("Invalid bit position %d (must be <= 31)\n", bit_pos); 841 return 1; 842 } 843 844 #define display_port_and_reg_off(port_id, reg_off) \ 845 printf("port %d PCI register at offset 0x%X: ", (port_id), (reg_off)) 846 847 static inline void 848 display_port_reg_value(portid_t port_id, uint32_t reg_off, uint32_t reg_v) 849 { 850 display_port_and_reg_off(port_id, (unsigned)reg_off); 851 printf("0x%08X (%u)\n", (unsigned)reg_v, (unsigned)reg_v); 852 } 853 854 void 855 port_reg_bit_display(portid_t port_id, uint32_t reg_off, uint8_t bit_x) 856 { 857 uint32_t reg_v; 858 859 860 if (port_id_is_invalid(port_id, ENABLED_WARN)) 861 return; 862 if (port_reg_off_is_invalid(port_id, reg_off)) 863 return; 864 if (reg_bit_pos_is_invalid(bit_x)) 865 return; 866 reg_v = port_id_pci_reg_read(port_id, reg_off); 867 display_port_and_reg_off(port_id, (unsigned)reg_off); 868 printf("bit %d=%d\n", bit_x, (int) ((reg_v & (1 << bit_x)) >> bit_x)); 869 } 870 871 void 872 port_reg_bit_field_display(portid_t port_id, uint32_t reg_off, 873 uint8_t bit1_pos, uint8_t bit2_pos) 874 { 875 uint32_t reg_v; 876 uint8_t l_bit; 877 uint8_t h_bit; 878 879 if (port_id_is_invalid(port_id, ENABLED_WARN)) 880 return; 881 if (port_reg_off_is_invalid(port_id, reg_off)) 882 return; 883 if (reg_bit_pos_is_invalid(bit1_pos)) 884 return; 885 if (reg_bit_pos_is_invalid(bit2_pos)) 886 return; 887 if (bit1_pos > bit2_pos) 888 l_bit = bit2_pos, h_bit = bit1_pos; 889 else 890 l_bit = bit1_pos, h_bit = bit2_pos; 891 892 reg_v = port_id_pci_reg_read(port_id, reg_off); 893 reg_v >>= l_bit; 894 if (h_bit < 31) 895 reg_v &= ((1 << (h_bit - l_bit + 1)) - 1); 896 display_port_and_reg_off(port_id, (unsigned)reg_off); 897 printf("bits[%d, %d]=0x%0*X (%u)\n", l_bit, h_bit, 898 ((h_bit - l_bit) / 4) + 1, (unsigned)reg_v, (unsigned)reg_v); 899 } 900 901 void 902 port_reg_display(portid_t port_id, uint32_t reg_off) 903 { 904 uint32_t reg_v; 905 906 if (port_id_is_invalid(port_id, ENABLED_WARN)) 907 return; 908 if (port_reg_off_is_invalid(port_id, reg_off)) 909 return; 910 reg_v = port_id_pci_reg_read(port_id, reg_off); 911 display_port_reg_value(port_id, reg_off, reg_v); 912 } 913 914 void 915 port_reg_bit_set(portid_t port_id, uint32_t reg_off, uint8_t bit_pos, 916 uint8_t bit_v) 917 { 918 uint32_t reg_v; 919 920 if (port_id_is_invalid(port_id, ENABLED_WARN)) 921 return; 922 if (port_reg_off_is_invalid(port_id, reg_off)) 923 return; 924 if (reg_bit_pos_is_invalid(bit_pos)) 925 return; 926 if (bit_v > 1) { 927 printf("Invalid bit value %d (must be 0 or 1)\n", (int) bit_v); 928 return; 929 } 930 reg_v = port_id_pci_reg_read(port_id, reg_off); 931 if (bit_v == 0) 932 reg_v &= ~(1 << bit_pos); 933 else 934 reg_v |= (1 << bit_pos); 935 port_id_pci_reg_write(port_id, reg_off, reg_v); 936 display_port_reg_value(port_id, reg_off, reg_v); 937 } 938 939 void 940 port_reg_bit_field_set(portid_t port_id, uint32_t reg_off, 941 uint8_t bit1_pos, uint8_t bit2_pos, uint32_t value) 942 { 943 uint32_t max_v; 944 uint32_t reg_v; 945 uint8_t l_bit; 946 uint8_t h_bit; 947 948 if (port_id_is_invalid(port_id, ENABLED_WARN)) 949 return; 950 if (port_reg_off_is_invalid(port_id, reg_off)) 951 return; 952 if (reg_bit_pos_is_invalid(bit1_pos)) 953 return; 954 if (reg_bit_pos_is_invalid(bit2_pos)) 955 return; 956 if (bit1_pos > bit2_pos) 957 l_bit = bit2_pos, h_bit = bit1_pos; 958 else 959 l_bit = bit1_pos, h_bit = bit2_pos; 960 961 if ((h_bit - l_bit) < 31) 962 max_v = (1 << (h_bit - l_bit + 1)) - 1; 963 else 964 max_v = 0xFFFFFFFF; 965 966 if (value > max_v) { 967 printf("Invalid value %u (0x%x) must be < %u (0x%x)\n", 968 (unsigned)value, (unsigned)value, 969 (unsigned)max_v, (unsigned)max_v); 970 return; 971 } 972 reg_v = port_id_pci_reg_read(port_id, reg_off); 973 reg_v &= ~(max_v << l_bit); /* Keep unchanged bits */ 974 reg_v |= (value << l_bit); /* Set changed bits */ 975 port_id_pci_reg_write(port_id, reg_off, reg_v); 976 display_port_reg_value(port_id, reg_off, reg_v); 977 } 978 979 void 980 port_reg_set(portid_t port_id, uint32_t reg_off, uint32_t reg_v) 981 { 982 if (port_id_is_invalid(port_id, ENABLED_WARN)) 983 return; 984 if (port_reg_off_is_invalid(port_id, reg_off)) 985 return; 986 port_id_pci_reg_write(port_id, reg_off, reg_v); 987 display_port_reg_value(port_id, reg_off, reg_v); 988 } 989 990 void 991 port_mtu_set(portid_t port_id, uint16_t mtu) 992 { 993 int diag; 994 995 if (port_id_is_invalid(port_id, ENABLED_WARN)) 996 return; 997 diag = rte_eth_dev_set_mtu(port_id, mtu); 998 if (diag == 0) 999 return; 1000 printf("Set MTU failed. diag=%d\n", diag); 1001 } 1002 1003 /* Generic flow management functions. */ 1004 1005 /** Generate flow_item[] entry. */ 1006 #define MK_FLOW_ITEM(t, s) \ 1007 [RTE_FLOW_ITEM_TYPE_ ## t] = { \ 1008 .name = # t, \ 1009 .size = s, \ 1010 } 1011 1012 /** Information about known flow pattern items. */ 1013 static const struct { 1014 const char *name; 1015 size_t size; 1016 } flow_item[] = { 1017 MK_FLOW_ITEM(END, 0), 1018 MK_FLOW_ITEM(VOID, 0), 1019 MK_FLOW_ITEM(INVERT, 0), 1020 MK_FLOW_ITEM(ANY, sizeof(struct rte_flow_item_any)), 1021 MK_FLOW_ITEM(PF, 0), 1022 MK_FLOW_ITEM(VF, sizeof(struct rte_flow_item_vf)), 1023 MK_FLOW_ITEM(PHY_PORT, sizeof(struct rte_flow_item_phy_port)), 1024 MK_FLOW_ITEM(PORT_ID, sizeof(struct rte_flow_item_port_id)), 1025 MK_FLOW_ITEM(RAW, sizeof(struct rte_flow_item_raw)), 1026 MK_FLOW_ITEM(ETH, sizeof(struct rte_flow_item_eth)), 1027 MK_FLOW_ITEM(VLAN, sizeof(struct rte_flow_item_vlan)), 1028 MK_FLOW_ITEM(IPV4, sizeof(struct rte_flow_item_ipv4)), 1029 MK_FLOW_ITEM(IPV6, sizeof(struct rte_flow_item_ipv6)), 1030 MK_FLOW_ITEM(ICMP, sizeof(struct rte_flow_item_icmp)), 1031 MK_FLOW_ITEM(UDP, sizeof(struct rte_flow_item_udp)), 1032 MK_FLOW_ITEM(TCP, sizeof(struct rte_flow_item_tcp)), 1033 MK_FLOW_ITEM(SCTP, sizeof(struct rte_flow_item_sctp)), 1034 MK_FLOW_ITEM(VXLAN, sizeof(struct rte_flow_item_vxlan)), 1035 MK_FLOW_ITEM(E_TAG, sizeof(struct rte_flow_item_e_tag)), 1036 MK_FLOW_ITEM(NVGRE, sizeof(struct rte_flow_item_nvgre)), 1037 MK_FLOW_ITEM(MPLS, sizeof(struct rte_flow_item_mpls)), 1038 MK_FLOW_ITEM(GRE, sizeof(struct rte_flow_item_gre)), 1039 MK_FLOW_ITEM(FUZZY, sizeof(struct rte_flow_item_fuzzy)), 1040 MK_FLOW_ITEM(GTP, sizeof(struct rte_flow_item_gtp)), 1041 MK_FLOW_ITEM(GTPC, sizeof(struct rte_flow_item_gtp)), 1042 MK_FLOW_ITEM(GTPU, sizeof(struct rte_flow_item_gtp)), 1043 MK_FLOW_ITEM(GENEVE, sizeof(struct rte_flow_item_geneve)), 1044 MK_FLOW_ITEM(VXLAN_GPE, sizeof(struct rte_flow_item_vxlan_gpe)), 1045 MK_FLOW_ITEM(ARP_ETH_IPV4, sizeof(struct rte_flow_item_arp_eth_ipv4)), 1046 MK_FLOW_ITEM(IPV6_EXT, sizeof(struct rte_flow_item_ipv6_ext)), 1047 MK_FLOW_ITEM(ICMP6, sizeof(struct rte_flow_item_icmp6)), 1048 MK_FLOW_ITEM(ICMP6_ND_NS, sizeof(struct rte_flow_item_icmp6_nd_ns)), 1049 MK_FLOW_ITEM(ICMP6_ND_NA, sizeof(struct rte_flow_item_icmp6_nd_na)), 1050 MK_FLOW_ITEM(ICMP6_ND_OPT, sizeof(struct rte_flow_item_icmp6_nd_opt)), 1051 MK_FLOW_ITEM(ICMP6_ND_OPT_SLA_ETH, 1052 sizeof(struct rte_flow_item_icmp6_nd_opt_sla_eth)), 1053 MK_FLOW_ITEM(ICMP6_ND_OPT_TLA_ETH, 1054 sizeof(struct rte_flow_item_icmp6_nd_opt_tla_eth)), 1055 }; 1056 1057 /** Pattern item specification types. */ 1058 enum item_spec_type { 1059 ITEM_SPEC, 1060 ITEM_LAST, 1061 ITEM_MASK, 1062 }; 1063 1064 /** Compute storage space needed by item specification and copy it. */ 1065 static size_t 1066 flow_item_spec_copy(void *buf, const struct rte_flow_item *item, 1067 enum item_spec_type type) 1068 { 1069 size_t size = 0; 1070 const void *data = 1071 type == ITEM_SPEC ? item->spec : 1072 type == ITEM_LAST ? item->last : 1073 type == ITEM_MASK ? item->mask : 1074 NULL; 1075 1076 if (!item->spec || !data) 1077 goto empty; 1078 switch (item->type) { 1079 union { 1080 const struct rte_flow_item_raw *raw; 1081 } spec; 1082 union { 1083 const struct rte_flow_item_raw *raw; 1084 } last; 1085 union { 1086 const struct rte_flow_item_raw *raw; 1087 } mask; 1088 union { 1089 const struct rte_flow_item_raw *raw; 1090 } src; 1091 union { 1092 struct rte_flow_item_raw *raw; 1093 } dst; 1094 size_t off; 1095 1096 case RTE_FLOW_ITEM_TYPE_RAW: 1097 spec.raw = item->spec; 1098 last.raw = item->last ? item->last : item->spec; 1099 mask.raw = item->mask ? item->mask : &rte_flow_item_raw_mask; 1100 src.raw = data; 1101 dst.raw = buf; 1102 off = RTE_ALIGN_CEIL(sizeof(struct rte_flow_item_raw), 1103 sizeof(*src.raw->pattern)); 1104 if (type == ITEM_SPEC || 1105 (type == ITEM_MASK && 1106 ((spec.raw->length & mask.raw->length) >= 1107 (last.raw->length & mask.raw->length)))) 1108 size = spec.raw->length & mask.raw->length; 1109 else 1110 size = last.raw->length & mask.raw->length; 1111 size = off + size * sizeof(*src.raw->pattern); 1112 if (dst.raw) { 1113 memcpy(dst.raw, src.raw, sizeof(*src.raw)); 1114 dst.raw->pattern = memcpy((uint8_t *)dst.raw + off, 1115 src.raw->pattern, 1116 size - off); 1117 } 1118 break; 1119 default: 1120 size = flow_item[item->type].size; 1121 if (buf) 1122 memcpy(buf, data, size); 1123 break; 1124 } 1125 empty: 1126 return RTE_ALIGN_CEIL(size, sizeof(double)); 1127 } 1128 1129 /** Generate flow_action[] entry. */ 1130 #define MK_FLOW_ACTION(t, s) \ 1131 [RTE_FLOW_ACTION_TYPE_ ## t] = { \ 1132 .name = # t, \ 1133 .size = s, \ 1134 } 1135 1136 /** Information about known flow actions. */ 1137 static const struct { 1138 const char *name; 1139 size_t size; 1140 } flow_action[] = { 1141 MK_FLOW_ACTION(END, 0), 1142 MK_FLOW_ACTION(VOID, 0), 1143 MK_FLOW_ACTION(PASSTHRU, 0), 1144 MK_FLOW_ACTION(JUMP, 0), 1145 MK_FLOW_ACTION(MARK, sizeof(struct rte_flow_action_mark)), 1146 MK_FLOW_ACTION(FLAG, 0), 1147 MK_FLOW_ACTION(QUEUE, sizeof(struct rte_flow_action_queue)), 1148 MK_FLOW_ACTION(DROP, 0), 1149 MK_FLOW_ACTION(COUNT, sizeof(struct rte_flow_action_count)), 1150 MK_FLOW_ACTION(RSS, sizeof(struct rte_flow_action_rss)), 1151 MK_FLOW_ACTION(PF, 0), 1152 MK_FLOW_ACTION(VF, sizeof(struct rte_flow_action_vf)), 1153 MK_FLOW_ACTION(PHY_PORT, sizeof(struct rte_flow_action_phy_port)), 1154 MK_FLOW_ACTION(PORT_ID, sizeof(struct rte_flow_action_port_id)), 1155 MK_FLOW_ACTION(METER, sizeof(struct rte_flow_action_meter)), 1156 MK_FLOW_ACTION(OF_SET_MPLS_TTL, 1157 sizeof(struct rte_flow_action_of_set_mpls_ttl)), 1158 MK_FLOW_ACTION(OF_DEC_MPLS_TTL, 0), 1159 MK_FLOW_ACTION(OF_SET_NW_TTL, 1160 sizeof(struct rte_flow_action_of_set_nw_ttl)), 1161 MK_FLOW_ACTION(OF_DEC_NW_TTL, 0), 1162 MK_FLOW_ACTION(OF_COPY_TTL_OUT, 0), 1163 MK_FLOW_ACTION(OF_COPY_TTL_IN, 0), 1164 MK_FLOW_ACTION(OF_POP_VLAN, 0), 1165 MK_FLOW_ACTION(OF_PUSH_VLAN, 1166 sizeof(struct rte_flow_action_of_push_vlan)), 1167 MK_FLOW_ACTION(OF_SET_VLAN_VID, 1168 sizeof(struct rte_flow_action_of_set_vlan_vid)), 1169 MK_FLOW_ACTION(OF_SET_VLAN_PCP, 1170 sizeof(struct rte_flow_action_of_set_vlan_pcp)), 1171 MK_FLOW_ACTION(OF_POP_MPLS, 1172 sizeof(struct rte_flow_action_of_pop_mpls)), 1173 MK_FLOW_ACTION(OF_PUSH_MPLS, 1174 sizeof(struct rte_flow_action_of_push_mpls)), 1175 }; 1176 1177 /** Compute storage space needed by action configuration and copy it. */ 1178 static size_t 1179 flow_action_conf_copy(void *buf, const struct rte_flow_action *action) 1180 { 1181 size_t size = 0; 1182 1183 if (!action->conf) 1184 goto empty; 1185 switch (action->type) { 1186 union { 1187 const struct rte_flow_action_rss *rss; 1188 } src; 1189 union { 1190 struct rte_flow_action_rss *rss; 1191 } dst; 1192 size_t off; 1193 1194 case RTE_FLOW_ACTION_TYPE_RSS: 1195 src.rss = action->conf; 1196 dst.rss = buf; 1197 off = 0; 1198 if (dst.rss) 1199 *dst.rss = (struct rte_flow_action_rss){ 1200 .func = src.rss->func, 1201 .level = src.rss->level, 1202 .types = src.rss->types, 1203 .key_len = src.rss->key_len, 1204 .queue_num = src.rss->queue_num, 1205 }; 1206 off += sizeof(*src.rss); 1207 if (src.rss->key_len) { 1208 off = RTE_ALIGN_CEIL(off, sizeof(double)); 1209 size = sizeof(*src.rss->key) * src.rss->key_len; 1210 if (dst.rss) 1211 dst.rss->key = memcpy 1212 ((void *)((uintptr_t)dst.rss + off), 1213 src.rss->key, size); 1214 off += size; 1215 } 1216 if (src.rss->queue_num) { 1217 off = RTE_ALIGN_CEIL(off, sizeof(double)); 1218 size = sizeof(*src.rss->queue) * src.rss->queue_num; 1219 if (dst.rss) 1220 dst.rss->queue = memcpy 1221 ((void *)((uintptr_t)dst.rss + off), 1222 src.rss->queue, size); 1223 off += size; 1224 } 1225 size = off; 1226 break; 1227 default: 1228 size = flow_action[action->type].size; 1229 if (buf) 1230 memcpy(buf, action->conf, size); 1231 break; 1232 } 1233 empty: 1234 return RTE_ALIGN_CEIL(size, sizeof(double)); 1235 } 1236 1237 /** Generate a port_flow entry from attributes/pattern/actions. */ 1238 static struct port_flow * 1239 port_flow_new(const struct rte_flow_attr *attr, 1240 const struct rte_flow_item *pattern, 1241 const struct rte_flow_action *actions) 1242 { 1243 const struct rte_flow_item *item; 1244 const struct rte_flow_action *action; 1245 struct port_flow *pf = NULL; 1246 size_t tmp; 1247 size_t off1 = 0; 1248 size_t off2 = 0; 1249 int err = ENOTSUP; 1250 1251 store: 1252 item = pattern; 1253 if (pf) 1254 pf->pattern = (void *)&pf->data[off1]; 1255 do { 1256 struct rte_flow_item *dst = NULL; 1257 1258 if ((unsigned int)item->type >= RTE_DIM(flow_item) || 1259 !flow_item[item->type].name) 1260 goto notsup; 1261 if (pf) 1262 dst = memcpy(pf->data + off1, item, sizeof(*item)); 1263 off1 += sizeof(*item); 1264 if (item->spec) { 1265 if (pf) 1266 dst->spec = pf->data + off2; 1267 off2 += flow_item_spec_copy 1268 (pf ? pf->data + off2 : NULL, item, ITEM_SPEC); 1269 } 1270 if (item->last) { 1271 if (pf) 1272 dst->last = pf->data + off2; 1273 off2 += flow_item_spec_copy 1274 (pf ? pf->data + off2 : NULL, item, ITEM_LAST); 1275 } 1276 if (item->mask) { 1277 if (pf) 1278 dst->mask = pf->data + off2; 1279 off2 += flow_item_spec_copy 1280 (pf ? pf->data + off2 : NULL, item, ITEM_MASK); 1281 } 1282 off2 = RTE_ALIGN_CEIL(off2, sizeof(double)); 1283 } while ((item++)->type != RTE_FLOW_ITEM_TYPE_END); 1284 off1 = RTE_ALIGN_CEIL(off1, sizeof(double)); 1285 action = actions; 1286 if (pf) 1287 pf->actions = (void *)&pf->data[off1]; 1288 do { 1289 struct rte_flow_action *dst = NULL; 1290 1291 if ((unsigned int)action->type >= RTE_DIM(flow_action) || 1292 !flow_action[action->type].name) 1293 goto notsup; 1294 if (pf) 1295 dst = memcpy(pf->data + off1, action, sizeof(*action)); 1296 off1 += sizeof(*action); 1297 if (action->conf) { 1298 if (pf) 1299 dst->conf = pf->data + off2; 1300 off2 += flow_action_conf_copy 1301 (pf ? pf->data + off2 : NULL, action); 1302 } 1303 off2 = RTE_ALIGN_CEIL(off2, sizeof(double)); 1304 } while ((action++)->type != RTE_FLOW_ACTION_TYPE_END); 1305 if (pf != NULL) 1306 return pf; 1307 off1 = RTE_ALIGN_CEIL(off1, sizeof(double)); 1308 tmp = RTE_ALIGN_CEIL(offsetof(struct port_flow, data), sizeof(double)); 1309 pf = calloc(1, tmp + off1 + off2); 1310 if (pf == NULL) 1311 err = errno; 1312 else { 1313 *pf = (const struct port_flow){ 1314 .size = tmp + off1 + off2, 1315 .attr = *attr, 1316 }; 1317 tmp -= offsetof(struct port_flow, data); 1318 off2 = tmp + off1; 1319 off1 = tmp; 1320 goto store; 1321 } 1322 notsup: 1323 rte_errno = err; 1324 return NULL; 1325 } 1326 1327 /** Print a message out of a flow error. */ 1328 static int 1329 port_flow_complain(struct rte_flow_error *error) 1330 { 1331 static const char *const errstrlist[] = { 1332 [RTE_FLOW_ERROR_TYPE_NONE] = "no error", 1333 [RTE_FLOW_ERROR_TYPE_UNSPECIFIED] = "cause unspecified", 1334 [RTE_FLOW_ERROR_TYPE_HANDLE] = "flow rule (handle)", 1335 [RTE_FLOW_ERROR_TYPE_ATTR_GROUP] = "group field", 1336 [RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY] = "priority field", 1337 [RTE_FLOW_ERROR_TYPE_ATTR_INGRESS] = "ingress field", 1338 [RTE_FLOW_ERROR_TYPE_ATTR_EGRESS] = "egress field", 1339 [RTE_FLOW_ERROR_TYPE_ATTR_TRANSFER] = "transfer field", 1340 [RTE_FLOW_ERROR_TYPE_ATTR] = "attributes structure", 1341 [RTE_FLOW_ERROR_TYPE_ITEM_NUM] = "pattern length", 1342 [RTE_FLOW_ERROR_TYPE_ITEM_SPEC] = "item specification", 1343 [RTE_FLOW_ERROR_TYPE_ITEM_LAST] = "item specification range", 1344 [RTE_FLOW_ERROR_TYPE_ITEM_MASK] = "item specification mask", 1345 [RTE_FLOW_ERROR_TYPE_ITEM] = "specific pattern item", 1346 [RTE_FLOW_ERROR_TYPE_ACTION_NUM] = "number of actions", 1347 [RTE_FLOW_ERROR_TYPE_ACTION_CONF] = "action configuration", 1348 [RTE_FLOW_ERROR_TYPE_ACTION] = "specific action", 1349 }; 1350 const char *errstr; 1351 char buf[32]; 1352 int err = rte_errno; 1353 1354 if ((unsigned int)error->type >= RTE_DIM(errstrlist) || 1355 !errstrlist[error->type]) 1356 errstr = "unknown type"; 1357 else 1358 errstr = errstrlist[error->type]; 1359 printf("Caught error type %d (%s): %s%s: %s\n", 1360 error->type, errstr, 1361 error->cause ? (snprintf(buf, sizeof(buf), "cause: %p, ", 1362 error->cause), buf) : "", 1363 error->message ? error->message : "(no stated reason)", 1364 rte_strerror(err)); 1365 return -err; 1366 } 1367 1368 /** Validate flow rule. */ 1369 int 1370 port_flow_validate(portid_t port_id, 1371 const struct rte_flow_attr *attr, 1372 const struct rte_flow_item *pattern, 1373 const struct rte_flow_action *actions) 1374 { 1375 struct rte_flow_error error; 1376 1377 /* Poisoning to make sure PMDs update it in case of error. */ 1378 memset(&error, 0x11, sizeof(error)); 1379 if (rte_flow_validate(port_id, attr, pattern, actions, &error)) 1380 return port_flow_complain(&error); 1381 printf("Flow rule validated\n"); 1382 return 0; 1383 } 1384 1385 /** Create flow rule. */ 1386 int 1387 port_flow_create(portid_t port_id, 1388 const struct rte_flow_attr *attr, 1389 const struct rte_flow_item *pattern, 1390 const struct rte_flow_action *actions) 1391 { 1392 struct rte_flow *flow; 1393 struct rte_port *port; 1394 struct port_flow *pf; 1395 uint32_t id; 1396 struct rte_flow_error error; 1397 1398 /* Poisoning to make sure PMDs update it in case of error. */ 1399 memset(&error, 0x22, sizeof(error)); 1400 flow = rte_flow_create(port_id, attr, pattern, actions, &error); 1401 if (!flow) 1402 return port_flow_complain(&error); 1403 port = &ports[port_id]; 1404 if (port->flow_list) { 1405 if (port->flow_list->id == UINT32_MAX) { 1406 printf("Highest rule ID is already assigned, delete" 1407 " it first"); 1408 rte_flow_destroy(port_id, flow, NULL); 1409 return -ENOMEM; 1410 } 1411 id = port->flow_list->id + 1; 1412 } else 1413 id = 0; 1414 pf = port_flow_new(attr, pattern, actions); 1415 if (!pf) { 1416 int err = rte_errno; 1417 1418 printf("Cannot allocate flow: %s\n", rte_strerror(err)); 1419 rte_flow_destroy(port_id, flow, NULL); 1420 return -err; 1421 } 1422 pf->next = port->flow_list; 1423 pf->id = id; 1424 pf->flow = flow; 1425 port->flow_list = pf; 1426 printf("Flow rule #%u created\n", pf->id); 1427 return 0; 1428 } 1429 1430 /** Destroy a number of flow rules. */ 1431 int 1432 port_flow_destroy(portid_t port_id, uint32_t n, const uint32_t *rule) 1433 { 1434 struct rte_port *port; 1435 struct port_flow **tmp; 1436 uint32_t c = 0; 1437 int ret = 0; 1438 1439 if (port_id_is_invalid(port_id, ENABLED_WARN) || 1440 port_id == (portid_t)RTE_PORT_ALL) 1441 return -EINVAL; 1442 port = &ports[port_id]; 1443 tmp = &port->flow_list; 1444 while (*tmp) { 1445 uint32_t i; 1446 1447 for (i = 0; i != n; ++i) { 1448 struct rte_flow_error error; 1449 struct port_flow *pf = *tmp; 1450 1451 if (rule[i] != pf->id) 1452 continue; 1453 /* 1454 * Poisoning to make sure PMDs update it in case 1455 * of error. 1456 */ 1457 memset(&error, 0x33, sizeof(error)); 1458 if (rte_flow_destroy(port_id, pf->flow, &error)) { 1459 ret = port_flow_complain(&error); 1460 continue; 1461 } 1462 printf("Flow rule #%u destroyed\n", pf->id); 1463 *tmp = pf->next; 1464 free(pf); 1465 break; 1466 } 1467 if (i == n) 1468 tmp = &(*tmp)->next; 1469 ++c; 1470 } 1471 return ret; 1472 } 1473 1474 /** Remove all flow rules. */ 1475 int 1476 port_flow_flush(portid_t port_id) 1477 { 1478 struct rte_flow_error error; 1479 struct rte_port *port; 1480 int ret = 0; 1481 1482 /* Poisoning to make sure PMDs update it in case of error. */ 1483 memset(&error, 0x44, sizeof(error)); 1484 if (rte_flow_flush(port_id, &error)) { 1485 ret = port_flow_complain(&error); 1486 if (port_id_is_invalid(port_id, DISABLED_WARN) || 1487 port_id == (portid_t)RTE_PORT_ALL) 1488 return ret; 1489 } 1490 port = &ports[port_id]; 1491 while (port->flow_list) { 1492 struct port_flow *pf = port->flow_list->next; 1493 1494 free(port->flow_list); 1495 port->flow_list = pf; 1496 } 1497 return ret; 1498 } 1499 1500 /** Query a flow rule. */ 1501 int 1502 port_flow_query(portid_t port_id, uint32_t rule, 1503 const struct rte_flow_action *action) 1504 { 1505 struct rte_flow_error error; 1506 struct rte_port *port; 1507 struct port_flow *pf; 1508 const char *name; 1509 union { 1510 struct rte_flow_query_count count; 1511 } query; 1512 1513 if (port_id_is_invalid(port_id, ENABLED_WARN) || 1514 port_id == (portid_t)RTE_PORT_ALL) 1515 return -EINVAL; 1516 port = &ports[port_id]; 1517 for (pf = port->flow_list; pf; pf = pf->next) 1518 if (pf->id == rule) 1519 break; 1520 if (!pf) { 1521 printf("Flow rule #%u not found\n", rule); 1522 return -ENOENT; 1523 } 1524 if ((unsigned int)action->type >= RTE_DIM(flow_action) || 1525 !flow_action[action->type].name) 1526 name = "unknown"; 1527 else 1528 name = flow_action[action->type].name; 1529 switch (action->type) { 1530 case RTE_FLOW_ACTION_TYPE_COUNT: 1531 break; 1532 default: 1533 printf("Cannot query action type %d (%s)\n", 1534 action->type, name); 1535 return -ENOTSUP; 1536 } 1537 /* Poisoning to make sure PMDs update it in case of error. */ 1538 memset(&error, 0x55, sizeof(error)); 1539 memset(&query, 0, sizeof(query)); 1540 if (rte_flow_query(port_id, pf->flow, action, &query, &error)) 1541 return port_flow_complain(&error); 1542 switch (action->type) { 1543 case RTE_FLOW_ACTION_TYPE_COUNT: 1544 printf("%s:\n" 1545 " hits_set: %u\n" 1546 " bytes_set: %u\n" 1547 " hits: %" PRIu64 "\n" 1548 " bytes: %" PRIu64 "\n", 1549 name, 1550 query.count.hits_set, 1551 query.count.bytes_set, 1552 query.count.hits, 1553 query.count.bytes); 1554 break; 1555 default: 1556 printf("Cannot display result for action type %d (%s)\n", 1557 action->type, name); 1558 break; 1559 } 1560 return 0; 1561 } 1562 1563 /** List flow rules. */ 1564 void 1565 port_flow_list(portid_t port_id, uint32_t n, const uint32_t group[n]) 1566 { 1567 struct rte_port *port; 1568 struct port_flow *pf; 1569 struct port_flow *list = NULL; 1570 uint32_t i; 1571 1572 if (port_id_is_invalid(port_id, ENABLED_WARN) || 1573 port_id == (portid_t)RTE_PORT_ALL) 1574 return; 1575 port = &ports[port_id]; 1576 if (!port->flow_list) 1577 return; 1578 /* Sort flows by group, priority and ID. */ 1579 for (pf = port->flow_list; pf != NULL; pf = pf->next) { 1580 struct port_flow **tmp; 1581 1582 if (n) { 1583 /* Filter out unwanted groups. */ 1584 for (i = 0; i != n; ++i) 1585 if (pf->attr.group == group[i]) 1586 break; 1587 if (i == n) 1588 continue; 1589 } 1590 tmp = &list; 1591 while (*tmp && 1592 (pf->attr.group > (*tmp)->attr.group || 1593 (pf->attr.group == (*tmp)->attr.group && 1594 pf->attr.priority > (*tmp)->attr.priority) || 1595 (pf->attr.group == (*tmp)->attr.group && 1596 pf->attr.priority == (*tmp)->attr.priority && 1597 pf->id > (*tmp)->id))) 1598 tmp = &(*tmp)->tmp; 1599 pf->tmp = *tmp; 1600 *tmp = pf; 1601 } 1602 printf("ID\tGroup\tPrio\tAttr\tRule\n"); 1603 for (pf = list; pf != NULL; pf = pf->tmp) { 1604 const struct rte_flow_item *item = pf->pattern; 1605 const struct rte_flow_action *action = pf->actions; 1606 1607 printf("%" PRIu32 "\t%" PRIu32 "\t%" PRIu32 "\t%c%c%c\t", 1608 pf->id, 1609 pf->attr.group, 1610 pf->attr.priority, 1611 pf->attr.ingress ? 'i' : '-', 1612 pf->attr.egress ? 'e' : '-', 1613 pf->attr.transfer ? 't' : '-'); 1614 while (item->type != RTE_FLOW_ITEM_TYPE_END) { 1615 if (item->type != RTE_FLOW_ITEM_TYPE_VOID) 1616 printf("%s ", flow_item[item->type].name); 1617 ++item; 1618 } 1619 printf("=>"); 1620 while (action->type != RTE_FLOW_ACTION_TYPE_END) { 1621 if (action->type != RTE_FLOW_ACTION_TYPE_VOID) 1622 printf(" %s", flow_action[action->type].name); 1623 ++action; 1624 } 1625 printf("\n"); 1626 } 1627 } 1628 1629 /** Restrict ingress traffic to the defined flow rules. */ 1630 int 1631 port_flow_isolate(portid_t port_id, int set) 1632 { 1633 struct rte_flow_error error; 1634 1635 /* Poisoning to make sure PMDs update it in case of error. */ 1636 memset(&error, 0x66, sizeof(error)); 1637 if (rte_flow_isolate(port_id, set, &error)) 1638 return port_flow_complain(&error); 1639 printf("Ingress traffic on port %u is %s to the defined flow rules\n", 1640 port_id, 1641 set ? "now restricted" : "not restricted anymore"); 1642 return 0; 1643 } 1644 1645 /* 1646 * RX/TX ring descriptors display functions. 1647 */ 1648 int 1649 rx_queue_id_is_invalid(queueid_t rxq_id) 1650 { 1651 if (rxq_id < nb_rxq) 1652 return 0; 1653 printf("Invalid RX queue %d (must be < nb_rxq=%d)\n", rxq_id, nb_rxq); 1654 return 1; 1655 } 1656 1657 int 1658 tx_queue_id_is_invalid(queueid_t txq_id) 1659 { 1660 if (txq_id < nb_txq) 1661 return 0; 1662 printf("Invalid TX queue %d (must be < nb_rxq=%d)\n", txq_id, nb_txq); 1663 return 1; 1664 } 1665 1666 static int 1667 rx_desc_id_is_invalid(uint16_t rxdesc_id) 1668 { 1669 if (rxdesc_id < nb_rxd) 1670 return 0; 1671 printf("Invalid RX descriptor %d (must be < nb_rxd=%d)\n", 1672 rxdesc_id, nb_rxd); 1673 return 1; 1674 } 1675 1676 static int 1677 tx_desc_id_is_invalid(uint16_t txdesc_id) 1678 { 1679 if (txdesc_id < nb_txd) 1680 return 0; 1681 printf("Invalid TX descriptor %d (must be < nb_txd=%d)\n", 1682 txdesc_id, nb_txd); 1683 return 1; 1684 } 1685 1686 static const struct rte_memzone * 1687 ring_dma_zone_lookup(const char *ring_name, portid_t port_id, uint16_t q_id) 1688 { 1689 char mz_name[RTE_MEMZONE_NAMESIZE]; 1690 const struct rte_memzone *mz; 1691 1692 snprintf(mz_name, sizeof(mz_name), "%s_%s_%d_%d", 1693 ports[port_id].dev_info.driver_name, ring_name, port_id, q_id); 1694 mz = rte_memzone_lookup(mz_name); 1695 if (mz == NULL) 1696 printf("%s ring memory zoneof (port %d, queue %d) not" 1697 "found (zone name = %s\n", 1698 ring_name, port_id, q_id, mz_name); 1699 return mz; 1700 } 1701 1702 union igb_ring_dword { 1703 uint64_t dword; 1704 struct { 1705 #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN 1706 uint32_t lo; 1707 uint32_t hi; 1708 #else 1709 uint32_t hi; 1710 uint32_t lo; 1711 #endif 1712 } words; 1713 }; 1714 1715 struct igb_ring_desc_32_bytes { 1716 union igb_ring_dword lo_dword; 1717 union igb_ring_dword hi_dword; 1718 union igb_ring_dword resv1; 1719 union igb_ring_dword resv2; 1720 }; 1721 1722 struct igb_ring_desc_16_bytes { 1723 union igb_ring_dword lo_dword; 1724 union igb_ring_dword hi_dword; 1725 }; 1726 1727 static void 1728 ring_rxd_display_dword(union igb_ring_dword dword) 1729 { 1730 printf(" 0x%08X - 0x%08X\n", (unsigned)dword.words.lo, 1731 (unsigned)dword.words.hi); 1732 } 1733 1734 static void 1735 ring_rx_descriptor_display(const struct rte_memzone *ring_mz, 1736 #ifndef RTE_LIBRTE_I40E_16BYTE_RX_DESC 1737 portid_t port_id, 1738 #else 1739 __rte_unused portid_t port_id, 1740 #endif 1741 uint16_t desc_id) 1742 { 1743 struct igb_ring_desc_16_bytes *ring = 1744 (struct igb_ring_desc_16_bytes *)ring_mz->addr; 1745 #ifndef RTE_LIBRTE_I40E_16BYTE_RX_DESC 1746 struct rte_eth_dev_info dev_info; 1747 1748 memset(&dev_info, 0, sizeof(dev_info)); 1749 rte_eth_dev_info_get(port_id, &dev_info); 1750 if (strstr(dev_info.driver_name, "i40e") != NULL) { 1751 /* 32 bytes RX descriptor, i40e only */ 1752 struct igb_ring_desc_32_bytes *ring = 1753 (struct igb_ring_desc_32_bytes *)ring_mz->addr; 1754 ring[desc_id].lo_dword.dword = 1755 rte_le_to_cpu_64(ring[desc_id].lo_dword.dword); 1756 ring_rxd_display_dword(ring[desc_id].lo_dword); 1757 ring[desc_id].hi_dword.dword = 1758 rte_le_to_cpu_64(ring[desc_id].hi_dword.dword); 1759 ring_rxd_display_dword(ring[desc_id].hi_dword); 1760 ring[desc_id].resv1.dword = 1761 rte_le_to_cpu_64(ring[desc_id].resv1.dword); 1762 ring_rxd_display_dword(ring[desc_id].resv1); 1763 ring[desc_id].resv2.dword = 1764 rte_le_to_cpu_64(ring[desc_id].resv2.dword); 1765 ring_rxd_display_dword(ring[desc_id].resv2); 1766 1767 return; 1768 } 1769 #endif 1770 /* 16 bytes RX descriptor */ 1771 ring[desc_id].lo_dword.dword = 1772 rte_le_to_cpu_64(ring[desc_id].lo_dword.dword); 1773 ring_rxd_display_dword(ring[desc_id].lo_dword); 1774 ring[desc_id].hi_dword.dword = 1775 rte_le_to_cpu_64(ring[desc_id].hi_dword.dword); 1776 ring_rxd_display_dword(ring[desc_id].hi_dword); 1777 } 1778 1779 static void 1780 ring_tx_descriptor_display(const struct rte_memzone *ring_mz, uint16_t desc_id) 1781 { 1782 struct igb_ring_desc_16_bytes *ring; 1783 struct igb_ring_desc_16_bytes txd; 1784 1785 ring = (struct igb_ring_desc_16_bytes *)ring_mz->addr; 1786 txd.lo_dword.dword = rte_le_to_cpu_64(ring[desc_id].lo_dword.dword); 1787 txd.hi_dword.dword = rte_le_to_cpu_64(ring[desc_id].hi_dword.dword); 1788 printf(" 0x%08X - 0x%08X / 0x%08X - 0x%08X\n", 1789 (unsigned)txd.lo_dword.words.lo, 1790 (unsigned)txd.lo_dword.words.hi, 1791 (unsigned)txd.hi_dword.words.lo, 1792 (unsigned)txd.hi_dword.words.hi); 1793 } 1794 1795 void 1796 rx_ring_desc_display(portid_t port_id, queueid_t rxq_id, uint16_t rxd_id) 1797 { 1798 const struct rte_memzone *rx_mz; 1799 1800 if (port_id_is_invalid(port_id, ENABLED_WARN)) 1801 return; 1802 if (rx_queue_id_is_invalid(rxq_id)) 1803 return; 1804 if (rx_desc_id_is_invalid(rxd_id)) 1805 return; 1806 rx_mz = ring_dma_zone_lookup("rx_ring", port_id, rxq_id); 1807 if (rx_mz == NULL) 1808 return; 1809 ring_rx_descriptor_display(rx_mz, port_id, rxd_id); 1810 } 1811 1812 void 1813 tx_ring_desc_display(portid_t port_id, queueid_t txq_id, uint16_t txd_id) 1814 { 1815 const struct rte_memzone *tx_mz; 1816 1817 if (port_id_is_invalid(port_id, ENABLED_WARN)) 1818 return; 1819 if (tx_queue_id_is_invalid(txq_id)) 1820 return; 1821 if (tx_desc_id_is_invalid(txd_id)) 1822 return; 1823 tx_mz = ring_dma_zone_lookup("tx_ring", port_id, txq_id); 1824 if (tx_mz == NULL) 1825 return; 1826 ring_tx_descriptor_display(tx_mz, txd_id); 1827 } 1828 1829 void 1830 fwd_lcores_config_display(void) 1831 { 1832 lcoreid_t lc_id; 1833 1834 printf("List of forwarding lcores:"); 1835 for (lc_id = 0; lc_id < nb_cfg_lcores; lc_id++) 1836 printf(" %2u", fwd_lcores_cpuids[lc_id]); 1837 printf("\n"); 1838 } 1839 void 1840 rxtx_config_display(void) 1841 { 1842 portid_t pid; 1843 queueid_t qid; 1844 1845 printf(" %s packet forwarding%s packets/burst=%d\n", 1846 cur_fwd_eng->fwd_mode_name, 1847 retry_enabled == 0 ? "" : " with retry", 1848 nb_pkt_per_burst); 1849 1850 if (cur_fwd_eng == &tx_only_engine || cur_fwd_eng == &flow_gen_engine) 1851 printf(" packet len=%u - nb packet segments=%d\n", 1852 (unsigned)tx_pkt_length, (int) tx_pkt_nb_segs); 1853 1854 printf(" nb forwarding cores=%d - nb forwarding ports=%d\n", 1855 nb_fwd_lcores, nb_fwd_ports); 1856 1857 RTE_ETH_FOREACH_DEV(pid) { 1858 struct rte_eth_rxconf *rx_conf = &ports[pid].rx_conf[0]; 1859 struct rte_eth_txconf *tx_conf = &ports[pid].tx_conf[0]; 1860 uint16_t *nb_rx_desc = &ports[pid].nb_rx_desc[0]; 1861 uint16_t *nb_tx_desc = &ports[pid].nb_tx_desc[0]; 1862 uint16_t nb_rx_desc_tmp; 1863 uint16_t nb_tx_desc_tmp; 1864 struct rte_eth_rxq_info rx_qinfo; 1865 struct rte_eth_txq_info tx_qinfo; 1866 int32_t rc; 1867 1868 /* per port config */ 1869 printf(" port %d: RX queue number: %d Tx queue number: %d\n", 1870 (unsigned int)pid, nb_rxq, nb_txq); 1871 1872 printf(" Rx offloads=0x%"PRIx64" Tx offloads=0x%"PRIx64"\n", 1873 ports[pid].dev_conf.rxmode.offloads, 1874 ports[pid].dev_conf.txmode.offloads); 1875 1876 /* per rx queue config only for first queue to be less verbose */ 1877 for (qid = 0; qid < 1; qid++) { 1878 rc = rte_eth_rx_queue_info_get(pid, qid, &rx_qinfo); 1879 if (rc) 1880 nb_rx_desc_tmp = nb_rx_desc[qid]; 1881 else 1882 nb_rx_desc_tmp = rx_qinfo.nb_desc; 1883 1884 printf(" RX queue: %d\n", qid); 1885 printf(" RX desc=%d - RX free threshold=%d\n", 1886 nb_rx_desc_tmp, rx_conf[qid].rx_free_thresh); 1887 printf(" RX threshold registers: pthresh=%d hthresh=%d " 1888 " wthresh=%d\n", 1889 rx_conf[qid].rx_thresh.pthresh, 1890 rx_conf[qid].rx_thresh.hthresh, 1891 rx_conf[qid].rx_thresh.wthresh); 1892 printf(" RX Offloads=0x%"PRIx64"\n", 1893 rx_conf[qid].offloads); 1894 } 1895 1896 /* per tx queue config only for first queue to be less verbose */ 1897 for (qid = 0; qid < 1; qid++) { 1898 rc = rte_eth_tx_queue_info_get(pid, qid, &tx_qinfo); 1899 if (rc) 1900 nb_tx_desc_tmp = nb_tx_desc[qid]; 1901 else 1902 nb_tx_desc_tmp = tx_qinfo.nb_desc; 1903 1904 printf(" TX queue: %d\n", qid); 1905 printf(" TX desc=%d - TX free threshold=%d\n", 1906 nb_tx_desc_tmp, tx_conf[qid].tx_free_thresh); 1907 printf(" TX threshold registers: pthresh=%d hthresh=%d " 1908 " wthresh=%d\n", 1909 tx_conf[qid].tx_thresh.pthresh, 1910 tx_conf[qid].tx_thresh.hthresh, 1911 tx_conf[qid].tx_thresh.wthresh); 1912 printf(" TX offloads=0x%"PRIx64" - TX RS bit threshold=%d\n", 1913 tx_conf[qid].offloads, tx_conf->tx_rs_thresh); 1914 } 1915 } 1916 } 1917 1918 void 1919 port_rss_reta_info(portid_t port_id, 1920 struct rte_eth_rss_reta_entry64 *reta_conf, 1921 uint16_t nb_entries) 1922 { 1923 uint16_t i, idx, shift; 1924 int ret; 1925 1926 if (port_id_is_invalid(port_id, ENABLED_WARN)) 1927 return; 1928 1929 ret = rte_eth_dev_rss_reta_query(port_id, reta_conf, nb_entries); 1930 if (ret != 0) { 1931 printf("Failed to get RSS RETA info, return code = %d\n", ret); 1932 return; 1933 } 1934 1935 for (i = 0; i < nb_entries; i++) { 1936 idx = i / RTE_RETA_GROUP_SIZE; 1937 shift = i % RTE_RETA_GROUP_SIZE; 1938 if (!(reta_conf[idx].mask & (1ULL << shift))) 1939 continue; 1940 printf("RSS RETA configuration: hash index=%u, queue=%u\n", 1941 i, reta_conf[idx].reta[shift]); 1942 } 1943 } 1944 1945 /* 1946 * Displays the RSS hash functions of a port, and, optionaly, the RSS hash 1947 * key of the port. 1948 */ 1949 void 1950 port_rss_hash_conf_show(portid_t port_id, char rss_info[], int show_rss_key) 1951 { 1952 struct rte_eth_rss_conf rss_conf; 1953 uint8_t rss_key[RSS_HASH_KEY_LENGTH]; 1954 uint64_t rss_hf; 1955 uint8_t i; 1956 int diag; 1957 struct rte_eth_dev_info dev_info; 1958 uint8_t hash_key_size; 1959 1960 if (port_id_is_invalid(port_id, ENABLED_WARN)) 1961 return; 1962 1963 memset(&dev_info, 0, sizeof(dev_info)); 1964 rte_eth_dev_info_get(port_id, &dev_info); 1965 if (dev_info.hash_key_size > 0 && 1966 dev_info.hash_key_size <= sizeof(rss_key)) 1967 hash_key_size = dev_info.hash_key_size; 1968 else { 1969 printf("dev_info did not provide a valid hash key size\n"); 1970 return; 1971 } 1972 1973 rss_conf.rss_hf = 0; 1974 for (i = 0; rss_type_table[i].str; i++) { 1975 if (!strcmp(rss_info, rss_type_table[i].str)) 1976 rss_conf.rss_hf = rss_type_table[i].rss_type; 1977 } 1978 1979 /* Get RSS hash key if asked to display it */ 1980 rss_conf.rss_key = (show_rss_key) ? rss_key : NULL; 1981 rss_conf.rss_key_len = hash_key_size; 1982 diag = rte_eth_dev_rss_hash_conf_get(port_id, &rss_conf); 1983 if (diag != 0) { 1984 switch (diag) { 1985 case -ENODEV: 1986 printf("port index %d invalid\n", port_id); 1987 break; 1988 case -ENOTSUP: 1989 printf("operation not supported by device\n"); 1990 break; 1991 default: 1992 printf("operation failed - diag=%d\n", diag); 1993 break; 1994 } 1995 return; 1996 } 1997 rss_hf = rss_conf.rss_hf; 1998 if (rss_hf == 0) { 1999 printf("RSS disabled\n"); 2000 return; 2001 } 2002 printf("RSS functions:\n "); 2003 for (i = 0; rss_type_table[i].str; i++) { 2004 if (rss_hf & rss_type_table[i].rss_type) 2005 printf("%s ", rss_type_table[i].str); 2006 } 2007 printf("\n"); 2008 if (!show_rss_key) 2009 return; 2010 printf("RSS key:\n"); 2011 for (i = 0; i < hash_key_size; i++) 2012 printf("%02X", rss_key[i]); 2013 printf("\n"); 2014 } 2015 2016 void 2017 port_rss_hash_key_update(portid_t port_id, char rss_type[], uint8_t *hash_key, 2018 uint hash_key_len) 2019 { 2020 struct rte_eth_rss_conf rss_conf; 2021 int diag; 2022 unsigned int i; 2023 2024 rss_conf.rss_key = NULL; 2025 rss_conf.rss_key_len = hash_key_len; 2026 rss_conf.rss_hf = 0; 2027 for (i = 0; rss_type_table[i].str; i++) { 2028 if (!strcmp(rss_type_table[i].str, rss_type)) 2029 rss_conf.rss_hf = rss_type_table[i].rss_type; 2030 } 2031 diag = rte_eth_dev_rss_hash_conf_get(port_id, &rss_conf); 2032 if (diag == 0) { 2033 rss_conf.rss_key = hash_key; 2034 diag = rte_eth_dev_rss_hash_update(port_id, &rss_conf); 2035 } 2036 if (diag == 0) 2037 return; 2038 2039 switch (diag) { 2040 case -ENODEV: 2041 printf("port index %d invalid\n", port_id); 2042 break; 2043 case -ENOTSUP: 2044 printf("operation not supported by device\n"); 2045 break; 2046 default: 2047 printf("operation failed - diag=%d\n", diag); 2048 break; 2049 } 2050 } 2051 2052 /* 2053 * Setup forwarding configuration for each logical core. 2054 */ 2055 static void 2056 setup_fwd_config_of_each_lcore(struct fwd_config *cfg) 2057 { 2058 streamid_t nb_fs_per_lcore; 2059 streamid_t nb_fs; 2060 streamid_t sm_id; 2061 lcoreid_t nb_extra; 2062 lcoreid_t nb_fc; 2063 lcoreid_t nb_lc; 2064 lcoreid_t lc_id; 2065 2066 nb_fs = cfg->nb_fwd_streams; 2067 nb_fc = cfg->nb_fwd_lcores; 2068 if (nb_fs <= nb_fc) { 2069 nb_fs_per_lcore = 1; 2070 nb_extra = 0; 2071 } else { 2072 nb_fs_per_lcore = (streamid_t) (nb_fs / nb_fc); 2073 nb_extra = (lcoreid_t) (nb_fs % nb_fc); 2074 } 2075 2076 nb_lc = (lcoreid_t) (nb_fc - nb_extra); 2077 sm_id = 0; 2078 for (lc_id = 0; lc_id < nb_lc; lc_id++) { 2079 fwd_lcores[lc_id]->stream_idx = sm_id; 2080 fwd_lcores[lc_id]->stream_nb = nb_fs_per_lcore; 2081 sm_id = (streamid_t) (sm_id + nb_fs_per_lcore); 2082 } 2083 2084 /* 2085 * Assign extra remaining streams, if any. 2086 */ 2087 nb_fs_per_lcore = (streamid_t) (nb_fs_per_lcore + 1); 2088 for (lc_id = 0; lc_id < nb_extra; lc_id++) { 2089 fwd_lcores[nb_lc + lc_id]->stream_idx = sm_id; 2090 fwd_lcores[nb_lc + lc_id]->stream_nb = nb_fs_per_lcore; 2091 sm_id = (streamid_t) (sm_id + nb_fs_per_lcore); 2092 } 2093 } 2094 2095 static portid_t 2096 fwd_topology_tx_port_get(portid_t rxp) 2097 { 2098 static int warning_once = 1; 2099 2100 RTE_ASSERT(rxp < cur_fwd_config.nb_fwd_ports); 2101 2102 switch (port_topology) { 2103 default: 2104 case PORT_TOPOLOGY_PAIRED: 2105 if ((rxp & 0x1) == 0) { 2106 if (rxp + 1 < cur_fwd_config.nb_fwd_ports) 2107 return rxp + 1; 2108 if (warning_once) { 2109 printf("\nWarning! port-topology=paired" 2110 " and odd forward ports number," 2111 " the last port will pair with" 2112 " itself.\n\n"); 2113 warning_once = 0; 2114 } 2115 return rxp; 2116 } 2117 return rxp - 1; 2118 case PORT_TOPOLOGY_CHAINED: 2119 return (rxp + 1) % cur_fwd_config.nb_fwd_ports; 2120 case PORT_TOPOLOGY_LOOP: 2121 return rxp; 2122 } 2123 } 2124 2125 static void 2126 simple_fwd_config_setup(void) 2127 { 2128 portid_t i; 2129 2130 cur_fwd_config.nb_fwd_ports = (portid_t) nb_fwd_ports; 2131 cur_fwd_config.nb_fwd_streams = 2132 (streamid_t) cur_fwd_config.nb_fwd_ports; 2133 2134 /* reinitialize forwarding streams */ 2135 init_fwd_streams(); 2136 2137 /* 2138 * In the simple forwarding test, the number of forwarding cores 2139 * must be lower or equal to the number of forwarding ports. 2140 */ 2141 cur_fwd_config.nb_fwd_lcores = (lcoreid_t) nb_fwd_lcores; 2142 if (cur_fwd_config.nb_fwd_lcores > cur_fwd_config.nb_fwd_ports) 2143 cur_fwd_config.nb_fwd_lcores = 2144 (lcoreid_t) cur_fwd_config.nb_fwd_ports; 2145 setup_fwd_config_of_each_lcore(&cur_fwd_config); 2146 2147 for (i = 0; i < cur_fwd_config.nb_fwd_ports; i++) { 2148 fwd_streams[i]->rx_port = fwd_ports_ids[i]; 2149 fwd_streams[i]->rx_queue = 0; 2150 fwd_streams[i]->tx_port = 2151 fwd_ports_ids[fwd_topology_tx_port_get(i)]; 2152 fwd_streams[i]->tx_queue = 0; 2153 fwd_streams[i]->peer_addr = fwd_streams[i]->tx_port; 2154 fwd_streams[i]->retry_enabled = retry_enabled; 2155 } 2156 } 2157 2158 /** 2159 * For the RSS forwarding test all streams distributed over lcores. Each stream 2160 * being composed of a RX queue to poll on a RX port for input messages, 2161 * associated with a TX queue of a TX port where to send forwarded packets. 2162 */ 2163 static void 2164 rss_fwd_config_setup(void) 2165 { 2166 portid_t rxp; 2167 portid_t txp; 2168 queueid_t rxq; 2169 queueid_t nb_q; 2170 streamid_t sm_id; 2171 2172 nb_q = nb_rxq; 2173 if (nb_q > nb_txq) 2174 nb_q = nb_txq; 2175 cur_fwd_config.nb_fwd_lcores = (lcoreid_t) nb_fwd_lcores; 2176 cur_fwd_config.nb_fwd_ports = nb_fwd_ports; 2177 cur_fwd_config.nb_fwd_streams = 2178 (streamid_t) (nb_q * cur_fwd_config.nb_fwd_ports); 2179 2180 if (cur_fwd_config.nb_fwd_streams < cur_fwd_config.nb_fwd_lcores) 2181 cur_fwd_config.nb_fwd_lcores = 2182 (lcoreid_t)cur_fwd_config.nb_fwd_streams; 2183 2184 /* reinitialize forwarding streams */ 2185 init_fwd_streams(); 2186 2187 setup_fwd_config_of_each_lcore(&cur_fwd_config); 2188 rxp = 0; rxq = 0; 2189 for (sm_id = 0; sm_id < cur_fwd_config.nb_fwd_streams; sm_id++) { 2190 struct fwd_stream *fs; 2191 2192 fs = fwd_streams[sm_id]; 2193 txp = fwd_topology_tx_port_get(rxp); 2194 fs->rx_port = fwd_ports_ids[rxp]; 2195 fs->rx_queue = rxq; 2196 fs->tx_port = fwd_ports_ids[txp]; 2197 fs->tx_queue = rxq; 2198 fs->peer_addr = fs->tx_port; 2199 fs->retry_enabled = retry_enabled; 2200 rxp++; 2201 if (rxp < nb_fwd_ports) 2202 continue; 2203 rxp = 0; 2204 rxq++; 2205 } 2206 } 2207 2208 /** 2209 * For the DCB forwarding test, each core is assigned on each traffic class. 2210 * 2211 * Each core is assigned a multi-stream, each stream being composed of 2212 * a RX queue to poll on a RX port for input messages, associated with 2213 * a TX queue of a TX port where to send forwarded packets. All RX and 2214 * TX queues are mapping to the same traffic class. 2215 * If VMDQ and DCB co-exist, each traffic class on different POOLs share 2216 * the same core 2217 */ 2218 static void 2219 dcb_fwd_config_setup(void) 2220 { 2221 struct rte_eth_dcb_info rxp_dcb_info, txp_dcb_info; 2222 portid_t txp, rxp = 0; 2223 queueid_t txq, rxq = 0; 2224 lcoreid_t lc_id; 2225 uint16_t nb_rx_queue, nb_tx_queue; 2226 uint16_t i, j, k, sm_id = 0; 2227 uint8_t tc = 0; 2228 2229 cur_fwd_config.nb_fwd_lcores = (lcoreid_t) nb_fwd_lcores; 2230 cur_fwd_config.nb_fwd_ports = nb_fwd_ports; 2231 cur_fwd_config.nb_fwd_streams = 2232 (streamid_t) (nb_rxq * cur_fwd_config.nb_fwd_ports); 2233 2234 /* reinitialize forwarding streams */ 2235 init_fwd_streams(); 2236 sm_id = 0; 2237 txp = 1; 2238 /* get the dcb info on the first RX and TX ports */ 2239 (void)rte_eth_dev_get_dcb_info(fwd_ports_ids[rxp], &rxp_dcb_info); 2240 (void)rte_eth_dev_get_dcb_info(fwd_ports_ids[txp], &txp_dcb_info); 2241 2242 for (lc_id = 0; lc_id < cur_fwd_config.nb_fwd_lcores; lc_id++) { 2243 fwd_lcores[lc_id]->stream_nb = 0; 2244 fwd_lcores[lc_id]->stream_idx = sm_id; 2245 for (i = 0; i < ETH_MAX_VMDQ_POOL; i++) { 2246 /* if the nb_queue is zero, means this tc is 2247 * not enabled on the POOL 2248 */ 2249 if (rxp_dcb_info.tc_queue.tc_rxq[i][tc].nb_queue == 0) 2250 break; 2251 k = fwd_lcores[lc_id]->stream_nb + 2252 fwd_lcores[lc_id]->stream_idx; 2253 rxq = rxp_dcb_info.tc_queue.tc_rxq[i][tc].base; 2254 txq = txp_dcb_info.tc_queue.tc_txq[i][tc].base; 2255 nb_rx_queue = txp_dcb_info.tc_queue.tc_rxq[i][tc].nb_queue; 2256 nb_tx_queue = txp_dcb_info.tc_queue.tc_txq[i][tc].nb_queue; 2257 for (j = 0; j < nb_rx_queue; j++) { 2258 struct fwd_stream *fs; 2259 2260 fs = fwd_streams[k + j]; 2261 fs->rx_port = fwd_ports_ids[rxp]; 2262 fs->rx_queue = rxq + j; 2263 fs->tx_port = fwd_ports_ids[txp]; 2264 fs->tx_queue = txq + j % nb_tx_queue; 2265 fs->peer_addr = fs->tx_port; 2266 fs->retry_enabled = retry_enabled; 2267 } 2268 fwd_lcores[lc_id]->stream_nb += 2269 rxp_dcb_info.tc_queue.tc_rxq[i][tc].nb_queue; 2270 } 2271 sm_id = (streamid_t) (sm_id + fwd_lcores[lc_id]->stream_nb); 2272 2273 tc++; 2274 if (tc < rxp_dcb_info.nb_tcs) 2275 continue; 2276 /* Restart from TC 0 on next RX port */ 2277 tc = 0; 2278 if (numa_support && (nb_fwd_ports <= (nb_ports >> 1))) 2279 rxp = (portid_t) 2280 (rxp + ((nb_ports >> 1) / nb_fwd_ports)); 2281 else 2282 rxp++; 2283 if (rxp >= nb_fwd_ports) 2284 return; 2285 /* get the dcb information on next RX and TX ports */ 2286 if ((rxp & 0x1) == 0) 2287 txp = (portid_t) (rxp + 1); 2288 else 2289 txp = (portid_t) (rxp - 1); 2290 rte_eth_dev_get_dcb_info(fwd_ports_ids[rxp], &rxp_dcb_info); 2291 rte_eth_dev_get_dcb_info(fwd_ports_ids[txp], &txp_dcb_info); 2292 } 2293 } 2294 2295 static void 2296 icmp_echo_config_setup(void) 2297 { 2298 portid_t rxp; 2299 queueid_t rxq; 2300 lcoreid_t lc_id; 2301 uint16_t sm_id; 2302 2303 if ((nb_txq * nb_fwd_ports) < nb_fwd_lcores) 2304 cur_fwd_config.nb_fwd_lcores = (lcoreid_t) 2305 (nb_txq * nb_fwd_ports); 2306 else 2307 cur_fwd_config.nb_fwd_lcores = (lcoreid_t) nb_fwd_lcores; 2308 cur_fwd_config.nb_fwd_ports = nb_fwd_ports; 2309 cur_fwd_config.nb_fwd_streams = 2310 (streamid_t) (nb_rxq * cur_fwd_config.nb_fwd_ports); 2311 if (cur_fwd_config.nb_fwd_streams < cur_fwd_config.nb_fwd_lcores) 2312 cur_fwd_config.nb_fwd_lcores = 2313 (lcoreid_t)cur_fwd_config.nb_fwd_streams; 2314 if (verbose_level > 0) { 2315 printf("%s fwd_cores=%d fwd_ports=%d fwd_streams=%d\n", 2316 __FUNCTION__, 2317 cur_fwd_config.nb_fwd_lcores, 2318 cur_fwd_config.nb_fwd_ports, 2319 cur_fwd_config.nb_fwd_streams); 2320 } 2321 2322 /* reinitialize forwarding streams */ 2323 init_fwd_streams(); 2324 setup_fwd_config_of_each_lcore(&cur_fwd_config); 2325 rxp = 0; rxq = 0; 2326 for (lc_id = 0; lc_id < cur_fwd_config.nb_fwd_lcores; lc_id++) { 2327 if (verbose_level > 0) 2328 printf(" core=%d: \n", lc_id); 2329 for (sm_id = 0; sm_id < fwd_lcores[lc_id]->stream_nb; sm_id++) { 2330 struct fwd_stream *fs; 2331 fs = fwd_streams[fwd_lcores[lc_id]->stream_idx + sm_id]; 2332 fs->rx_port = fwd_ports_ids[rxp]; 2333 fs->rx_queue = rxq; 2334 fs->tx_port = fs->rx_port; 2335 fs->tx_queue = rxq; 2336 fs->peer_addr = fs->tx_port; 2337 fs->retry_enabled = retry_enabled; 2338 if (verbose_level > 0) 2339 printf(" stream=%d port=%d rxq=%d txq=%d\n", 2340 sm_id, fs->rx_port, fs->rx_queue, 2341 fs->tx_queue); 2342 rxq = (queueid_t) (rxq + 1); 2343 if (rxq == nb_rxq) { 2344 rxq = 0; 2345 rxp = (portid_t) (rxp + 1); 2346 } 2347 } 2348 } 2349 } 2350 2351 #if defined RTE_LIBRTE_PMD_SOFTNIC 2352 static void 2353 softnic_fwd_config_setup(void) 2354 { 2355 struct rte_port *port; 2356 portid_t pid, softnic_portid; 2357 queueid_t i; 2358 uint8_t softnic_enable = 0; 2359 2360 RTE_ETH_FOREACH_DEV(pid) { 2361 port = &ports[pid]; 2362 const char *driver = port->dev_info.driver_name; 2363 2364 if (strcmp(driver, "net_softnic") == 0) { 2365 softnic_portid = pid; 2366 softnic_enable = 1; 2367 break; 2368 } 2369 } 2370 2371 if (softnic_enable == 0) { 2372 printf("Softnic mode not configured(%s)!\n", __func__); 2373 return; 2374 } 2375 2376 cur_fwd_config.nb_fwd_ports = 1; 2377 cur_fwd_config.nb_fwd_streams = (streamid_t) nb_rxq; 2378 2379 /* Re-initialize forwarding streams */ 2380 init_fwd_streams(); 2381 2382 /* 2383 * In the softnic forwarding test, the number of forwarding cores 2384 * is set to one and remaining are used for softnic packet processing. 2385 */ 2386 cur_fwd_config.nb_fwd_lcores = 1; 2387 setup_fwd_config_of_each_lcore(&cur_fwd_config); 2388 2389 for (i = 0; i < cur_fwd_config.nb_fwd_streams; i++) { 2390 fwd_streams[i]->rx_port = softnic_portid; 2391 fwd_streams[i]->rx_queue = i; 2392 fwd_streams[i]->tx_port = softnic_portid; 2393 fwd_streams[i]->tx_queue = i; 2394 fwd_streams[i]->peer_addr = fwd_streams[i]->tx_port; 2395 fwd_streams[i]->retry_enabled = retry_enabled; 2396 } 2397 } 2398 #endif 2399 2400 void 2401 fwd_config_setup(void) 2402 { 2403 cur_fwd_config.fwd_eng = cur_fwd_eng; 2404 if (strcmp(cur_fwd_eng->fwd_mode_name, "icmpecho") == 0) { 2405 icmp_echo_config_setup(); 2406 return; 2407 } 2408 2409 #if defined RTE_LIBRTE_PMD_SOFTNIC 2410 if (strcmp(cur_fwd_eng->fwd_mode_name, "softnic") == 0) { 2411 softnic_fwd_config_setup(); 2412 return; 2413 } 2414 #endif 2415 2416 if ((nb_rxq > 1) && (nb_txq > 1)){ 2417 if (dcb_config) 2418 dcb_fwd_config_setup(); 2419 else 2420 rss_fwd_config_setup(); 2421 } 2422 else 2423 simple_fwd_config_setup(); 2424 } 2425 2426 static const char * 2427 mp_alloc_to_str(uint8_t mode) 2428 { 2429 switch (mode) { 2430 case MP_ALLOC_NATIVE: 2431 return "native"; 2432 case MP_ALLOC_ANON: 2433 return "anon"; 2434 case MP_ALLOC_XMEM: 2435 return "xmem"; 2436 case MP_ALLOC_XMEM_HUGE: 2437 return "xmemhuge"; 2438 default: 2439 return "invalid"; 2440 } 2441 } 2442 2443 void 2444 pkt_fwd_config_display(struct fwd_config *cfg) 2445 { 2446 struct fwd_stream *fs; 2447 lcoreid_t lc_id; 2448 streamid_t sm_id; 2449 2450 printf("%s packet forwarding%s - ports=%d - cores=%d - streams=%d - " 2451 "NUMA support %s, MP allocation mode: %s\n", 2452 cfg->fwd_eng->fwd_mode_name, 2453 retry_enabled == 0 ? "" : " with retry", 2454 cfg->nb_fwd_ports, cfg->nb_fwd_lcores, cfg->nb_fwd_streams, 2455 numa_support == 1 ? "enabled" : "disabled", 2456 mp_alloc_to_str(mp_alloc_type)); 2457 2458 if (retry_enabled) 2459 printf("TX retry num: %u, delay between TX retries: %uus\n", 2460 burst_tx_retry_num, burst_tx_delay_time); 2461 for (lc_id = 0; lc_id < cfg->nb_fwd_lcores; lc_id++) { 2462 printf("Logical Core %u (socket %u) forwards packets on " 2463 "%d streams:", 2464 fwd_lcores_cpuids[lc_id], 2465 rte_lcore_to_socket_id(fwd_lcores_cpuids[lc_id]), 2466 fwd_lcores[lc_id]->stream_nb); 2467 for (sm_id = 0; sm_id < fwd_lcores[lc_id]->stream_nb; sm_id++) { 2468 fs = fwd_streams[fwd_lcores[lc_id]->stream_idx + sm_id]; 2469 printf("\n RX P=%d/Q=%d (socket %u) -> TX " 2470 "P=%d/Q=%d (socket %u) ", 2471 fs->rx_port, fs->rx_queue, 2472 ports[fs->rx_port].socket_id, 2473 fs->tx_port, fs->tx_queue, 2474 ports[fs->tx_port].socket_id); 2475 print_ethaddr("peer=", 2476 &peer_eth_addrs[fs->peer_addr]); 2477 } 2478 printf("\n"); 2479 } 2480 printf("\n"); 2481 } 2482 2483 void 2484 set_fwd_eth_peer(portid_t port_id, char *peer_addr) 2485 { 2486 uint8_t c, new_peer_addr[6]; 2487 if (!rte_eth_dev_is_valid_port(port_id)) { 2488 printf("Error: Invalid port number %i\n", port_id); 2489 return; 2490 } 2491 if (cmdline_parse_etheraddr(NULL, peer_addr, &new_peer_addr, 2492 sizeof(new_peer_addr)) < 0) { 2493 printf("Error: Invalid ethernet address: %s\n", peer_addr); 2494 return; 2495 } 2496 for (c = 0; c < 6; c++) 2497 peer_eth_addrs[port_id].addr_bytes[c] = 2498 new_peer_addr[c]; 2499 } 2500 2501 int 2502 set_fwd_lcores_list(unsigned int *lcorelist, unsigned int nb_lc) 2503 { 2504 unsigned int i; 2505 unsigned int lcore_cpuid; 2506 int record_now; 2507 2508 record_now = 0; 2509 again: 2510 for (i = 0; i < nb_lc; i++) { 2511 lcore_cpuid = lcorelist[i]; 2512 if (! rte_lcore_is_enabled(lcore_cpuid)) { 2513 printf("lcore %u not enabled\n", lcore_cpuid); 2514 return -1; 2515 } 2516 if (lcore_cpuid == rte_get_master_lcore()) { 2517 printf("lcore %u cannot be masked on for running " 2518 "packet forwarding, which is the master lcore " 2519 "and reserved for command line parsing only\n", 2520 lcore_cpuid); 2521 return -1; 2522 } 2523 if (record_now) 2524 fwd_lcores_cpuids[i] = lcore_cpuid; 2525 } 2526 if (record_now == 0) { 2527 record_now = 1; 2528 goto again; 2529 } 2530 nb_cfg_lcores = (lcoreid_t) nb_lc; 2531 if (nb_fwd_lcores != (lcoreid_t) nb_lc) { 2532 printf("previous number of forwarding cores %u - changed to " 2533 "number of configured cores %u\n", 2534 (unsigned int) nb_fwd_lcores, nb_lc); 2535 nb_fwd_lcores = (lcoreid_t) nb_lc; 2536 } 2537 2538 return 0; 2539 } 2540 2541 int 2542 set_fwd_lcores_mask(uint64_t lcoremask) 2543 { 2544 unsigned int lcorelist[64]; 2545 unsigned int nb_lc; 2546 unsigned int i; 2547 2548 if (lcoremask == 0) { 2549 printf("Invalid NULL mask of cores\n"); 2550 return -1; 2551 } 2552 nb_lc = 0; 2553 for (i = 0; i < 64; i++) { 2554 if (! ((uint64_t)(1ULL << i) & lcoremask)) 2555 continue; 2556 lcorelist[nb_lc++] = i; 2557 } 2558 return set_fwd_lcores_list(lcorelist, nb_lc); 2559 } 2560 2561 void 2562 set_fwd_lcores_number(uint16_t nb_lc) 2563 { 2564 if (nb_lc > nb_cfg_lcores) { 2565 printf("nb fwd cores %u > %u (max. number of configured " 2566 "lcores) - ignored\n", 2567 (unsigned int) nb_lc, (unsigned int) nb_cfg_lcores); 2568 return; 2569 } 2570 nb_fwd_lcores = (lcoreid_t) nb_lc; 2571 printf("Number of forwarding cores set to %u\n", 2572 (unsigned int) nb_fwd_lcores); 2573 } 2574 2575 void 2576 set_fwd_ports_list(unsigned int *portlist, unsigned int nb_pt) 2577 { 2578 unsigned int i; 2579 portid_t port_id; 2580 int record_now; 2581 2582 record_now = 0; 2583 again: 2584 for (i = 0; i < nb_pt; i++) { 2585 port_id = (portid_t) portlist[i]; 2586 if (port_id_is_invalid(port_id, ENABLED_WARN)) 2587 return; 2588 if (record_now) 2589 fwd_ports_ids[i] = port_id; 2590 } 2591 if (record_now == 0) { 2592 record_now = 1; 2593 goto again; 2594 } 2595 nb_cfg_ports = (portid_t) nb_pt; 2596 if (nb_fwd_ports != (portid_t) nb_pt) { 2597 printf("previous number of forwarding ports %u - changed to " 2598 "number of configured ports %u\n", 2599 (unsigned int) nb_fwd_ports, nb_pt); 2600 nb_fwd_ports = (portid_t) nb_pt; 2601 } 2602 } 2603 2604 void 2605 set_fwd_ports_mask(uint64_t portmask) 2606 { 2607 unsigned int portlist[64]; 2608 unsigned int nb_pt; 2609 unsigned int i; 2610 2611 if (portmask == 0) { 2612 printf("Invalid NULL mask of ports\n"); 2613 return; 2614 } 2615 nb_pt = 0; 2616 RTE_ETH_FOREACH_DEV(i) { 2617 if (! ((uint64_t)(1ULL << i) & portmask)) 2618 continue; 2619 portlist[nb_pt++] = i; 2620 } 2621 set_fwd_ports_list(portlist, nb_pt); 2622 } 2623 2624 void 2625 set_fwd_ports_number(uint16_t nb_pt) 2626 { 2627 if (nb_pt > nb_cfg_ports) { 2628 printf("nb fwd ports %u > %u (number of configured " 2629 "ports) - ignored\n", 2630 (unsigned int) nb_pt, (unsigned int) nb_cfg_ports); 2631 return; 2632 } 2633 nb_fwd_ports = (portid_t) nb_pt; 2634 printf("Number of forwarding ports set to %u\n", 2635 (unsigned int) nb_fwd_ports); 2636 } 2637 2638 int 2639 port_is_forwarding(portid_t port_id) 2640 { 2641 unsigned int i; 2642 2643 if (port_id_is_invalid(port_id, ENABLED_WARN)) 2644 return -1; 2645 2646 for (i = 0; i < nb_fwd_ports; i++) { 2647 if (fwd_ports_ids[i] == port_id) 2648 return 1; 2649 } 2650 2651 return 0; 2652 } 2653 2654 void 2655 set_nb_pkt_per_burst(uint16_t nb) 2656 { 2657 if (nb > MAX_PKT_BURST) { 2658 printf("nb pkt per burst: %u > %u (maximum packet per burst) " 2659 " ignored\n", 2660 (unsigned int) nb, (unsigned int) MAX_PKT_BURST); 2661 return; 2662 } 2663 nb_pkt_per_burst = nb; 2664 printf("Number of packets per burst set to %u\n", 2665 (unsigned int) nb_pkt_per_burst); 2666 } 2667 2668 static const char * 2669 tx_split_get_name(enum tx_pkt_split split) 2670 { 2671 uint32_t i; 2672 2673 for (i = 0; i != RTE_DIM(tx_split_name); i++) { 2674 if (tx_split_name[i].split == split) 2675 return tx_split_name[i].name; 2676 } 2677 return NULL; 2678 } 2679 2680 void 2681 set_tx_pkt_split(const char *name) 2682 { 2683 uint32_t i; 2684 2685 for (i = 0; i != RTE_DIM(tx_split_name); i++) { 2686 if (strcmp(tx_split_name[i].name, name) == 0) { 2687 tx_pkt_split = tx_split_name[i].split; 2688 return; 2689 } 2690 } 2691 printf("unknown value: \"%s\"\n", name); 2692 } 2693 2694 void 2695 show_tx_pkt_segments(void) 2696 { 2697 uint32_t i, n; 2698 const char *split; 2699 2700 n = tx_pkt_nb_segs; 2701 split = tx_split_get_name(tx_pkt_split); 2702 2703 printf("Number of segments: %u\n", n); 2704 printf("Segment sizes: "); 2705 for (i = 0; i != n - 1; i++) 2706 printf("%hu,", tx_pkt_seg_lengths[i]); 2707 printf("%hu\n", tx_pkt_seg_lengths[i]); 2708 printf("Split packet: %s\n", split); 2709 } 2710 2711 void 2712 set_tx_pkt_segments(unsigned *seg_lengths, unsigned nb_segs) 2713 { 2714 uint16_t tx_pkt_len; 2715 unsigned i; 2716 2717 if (nb_segs >= (unsigned) nb_txd) { 2718 printf("nb segments per TX packets=%u >= nb_txd=%u - ignored\n", 2719 nb_segs, (unsigned int) nb_txd); 2720 return; 2721 } 2722 2723 /* 2724 * Check that each segment length is greater or equal than 2725 * the mbuf data sise. 2726 * Check also that the total packet length is greater or equal than the 2727 * size of an empty UDP/IP packet (sizeof(struct ether_hdr) + 20 + 8). 2728 */ 2729 tx_pkt_len = 0; 2730 for (i = 0; i < nb_segs; i++) { 2731 if (seg_lengths[i] > (unsigned) mbuf_data_size) { 2732 printf("length[%u]=%u > mbuf_data_size=%u - give up\n", 2733 i, seg_lengths[i], (unsigned) mbuf_data_size); 2734 return; 2735 } 2736 tx_pkt_len = (uint16_t)(tx_pkt_len + seg_lengths[i]); 2737 } 2738 if (tx_pkt_len < (sizeof(struct ether_hdr) + 20 + 8)) { 2739 printf("total packet length=%u < %d - give up\n", 2740 (unsigned) tx_pkt_len, 2741 (int)(sizeof(struct ether_hdr) + 20 + 8)); 2742 return; 2743 } 2744 2745 for (i = 0; i < nb_segs; i++) 2746 tx_pkt_seg_lengths[i] = (uint16_t) seg_lengths[i]; 2747 2748 tx_pkt_length = tx_pkt_len; 2749 tx_pkt_nb_segs = (uint8_t) nb_segs; 2750 } 2751 2752 void 2753 setup_gro(const char *onoff, portid_t port_id) 2754 { 2755 if (!rte_eth_dev_is_valid_port(port_id)) { 2756 printf("invalid port id %u\n", port_id); 2757 return; 2758 } 2759 if (test_done == 0) { 2760 printf("Before enable/disable GRO," 2761 " please stop forwarding first\n"); 2762 return; 2763 } 2764 if (strcmp(onoff, "on") == 0) { 2765 if (gro_ports[port_id].enable != 0) { 2766 printf("Port %u has enabled GRO. Please" 2767 " disable GRO first\n", port_id); 2768 return; 2769 } 2770 if (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) { 2771 gro_ports[port_id].param.gro_types = RTE_GRO_TCP_IPV4; 2772 gro_ports[port_id].param.max_flow_num = 2773 GRO_DEFAULT_FLOW_NUM; 2774 gro_ports[port_id].param.max_item_per_flow = 2775 GRO_DEFAULT_ITEM_NUM_PER_FLOW; 2776 } 2777 gro_ports[port_id].enable = 1; 2778 } else { 2779 if (gro_ports[port_id].enable == 0) { 2780 printf("Port %u has disabled GRO\n", port_id); 2781 return; 2782 } 2783 gro_ports[port_id].enable = 0; 2784 } 2785 } 2786 2787 void 2788 setup_gro_flush_cycles(uint8_t cycles) 2789 { 2790 if (test_done == 0) { 2791 printf("Before change flush interval for GRO," 2792 " please stop forwarding first.\n"); 2793 return; 2794 } 2795 2796 if (cycles > GRO_MAX_FLUSH_CYCLES || cycles < 2797 GRO_DEFAULT_FLUSH_CYCLES) { 2798 printf("The flushing cycle be in the range" 2799 " of 1 to %u. Revert to the default" 2800 " value %u.\n", 2801 GRO_MAX_FLUSH_CYCLES, 2802 GRO_DEFAULT_FLUSH_CYCLES); 2803 cycles = GRO_DEFAULT_FLUSH_CYCLES; 2804 } 2805 2806 gro_flush_cycles = cycles; 2807 } 2808 2809 void 2810 show_gro(portid_t port_id) 2811 { 2812 struct rte_gro_param *param; 2813 uint32_t max_pkts_num; 2814 2815 param = &gro_ports[port_id].param; 2816 2817 if (!rte_eth_dev_is_valid_port(port_id)) { 2818 printf("Invalid port id %u.\n", port_id); 2819 return; 2820 } 2821 if (gro_ports[port_id].enable) { 2822 printf("GRO type: TCP/IPv4\n"); 2823 if (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) { 2824 max_pkts_num = param->max_flow_num * 2825 param->max_item_per_flow; 2826 } else 2827 max_pkts_num = MAX_PKT_BURST * GRO_MAX_FLUSH_CYCLES; 2828 printf("Max number of packets to perform GRO: %u\n", 2829 max_pkts_num); 2830 printf("Flushing cycles: %u\n", gro_flush_cycles); 2831 } else 2832 printf("Port %u doesn't enable GRO.\n", port_id); 2833 } 2834 2835 void 2836 setup_gso(const char *mode, portid_t port_id) 2837 { 2838 if (!rte_eth_dev_is_valid_port(port_id)) { 2839 printf("invalid port id %u\n", port_id); 2840 return; 2841 } 2842 if (strcmp(mode, "on") == 0) { 2843 if (test_done == 0) { 2844 printf("before enabling GSO," 2845 " please stop forwarding first\n"); 2846 return; 2847 } 2848 gso_ports[port_id].enable = 1; 2849 } else if (strcmp(mode, "off") == 0) { 2850 if (test_done == 0) { 2851 printf("before disabling GSO," 2852 " please stop forwarding first\n"); 2853 return; 2854 } 2855 gso_ports[port_id].enable = 0; 2856 } 2857 } 2858 2859 char* 2860 list_pkt_forwarding_modes(void) 2861 { 2862 static char fwd_modes[128] = ""; 2863 const char *separator = "|"; 2864 struct fwd_engine *fwd_eng; 2865 unsigned i = 0; 2866 2867 if (strlen (fwd_modes) == 0) { 2868 while ((fwd_eng = fwd_engines[i++]) != NULL) { 2869 strncat(fwd_modes, fwd_eng->fwd_mode_name, 2870 sizeof(fwd_modes) - strlen(fwd_modes) - 1); 2871 strncat(fwd_modes, separator, 2872 sizeof(fwd_modes) - strlen(fwd_modes) - 1); 2873 } 2874 fwd_modes[strlen(fwd_modes) - strlen(separator)] = '\0'; 2875 } 2876 2877 return fwd_modes; 2878 } 2879 2880 char* 2881 list_pkt_forwarding_retry_modes(void) 2882 { 2883 static char fwd_modes[128] = ""; 2884 const char *separator = "|"; 2885 struct fwd_engine *fwd_eng; 2886 unsigned i = 0; 2887 2888 if (strlen(fwd_modes) == 0) { 2889 while ((fwd_eng = fwd_engines[i++]) != NULL) { 2890 if (fwd_eng == &rx_only_engine) 2891 continue; 2892 strncat(fwd_modes, fwd_eng->fwd_mode_name, 2893 sizeof(fwd_modes) - 2894 strlen(fwd_modes) - 1); 2895 strncat(fwd_modes, separator, 2896 sizeof(fwd_modes) - 2897 strlen(fwd_modes) - 1); 2898 } 2899 fwd_modes[strlen(fwd_modes) - strlen(separator)] = '\0'; 2900 } 2901 2902 return fwd_modes; 2903 } 2904 2905 void 2906 set_pkt_forwarding_mode(const char *fwd_mode_name) 2907 { 2908 struct fwd_engine *fwd_eng; 2909 unsigned i; 2910 2911 i = 0; 2912 while ((fwd_eng = fwd_engines[i]) != NULL) { 2913 if (! strcmp(fwd_eng->fwd_mode_name, fwd_mode_name)) { 2914 printf("Set %s packet forwarding mode%s\n", 2915 fwd_mode_name, 2916 retry_enabled == 0 ? "" : " with retry"); 2917 cur_fwd_eng = fwd_eng; 2918 return; 2919 } 2920 i++; 2921 } 2922 printf("Invalid %s packet forwarding mode\n", fwd_mode_name); 2923 } 2924 2925 void 2926 set_verbose_level(uint16_t vb_level) 2927 { 2928 printf("Change verbose level from %u to %u\n", 2929 (unsigned int) verbose_level, (unsigned int) vb_level); 2930 verbose_level = vb_level; 2931 } 2932 2933 void 2934 vlan_extend_set(portid_t port_id, int on) 2935 { 2936 int diag; 2937 int vlan_offload; 2938 uint64_t port_rx_offloads = ports[port_id].dev_conf.rxmode.offloads; 2939 2940 if (port_id_is_invalid(port_id, ENABLED_WARN)) 2941 return; 2942 2943 vlan_offload = rte_eth_dev_get_vlan_offload(port_id); 2944 2945 if (on) { 2946 vlan_offload |= ETH_VLAN_EXTEND_OFFLOAD; 2947 port_rx_offloads |= DEV_RX_OFFLOAD_VLAN_EXTEND; 2948 } else { 2949 vlan_offload &= ~ETH_VLAN_EXTEND_OFFLOAD; 2950 port_rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_EXTEND; 2951 } 2952 2953 diag = rte_eth_dev_set_vlan_offload(port_id, vlan_offload); 2954 if (diag < 0) 2955 printf("rx_vlan_extend_set(port_pi=%d, on=%d) failed " 2956 "diag=%d\n", port_id, on, diag); 2957 ports[port_id].dev_conf.rxmode.offloads = port_rx_offloads; 2958 } 2959 2960 void 2961 rx_vlan_strip_set(portid_t port_id, int on) 2962 { 2963 int diag; 2964 int vlan_offload; 2965 uint64_t port_rx_offloads = ports[port_id].dev_conf.rxmode.offloads; 2966 2967 if (port_id_is_invalid(port_id, ENABLED_WARN)) 2968 return; 2969 2970 vlan_offload = rte_eth_dev_get_vlan_offload(port_id); 2971 2972 if (on) { 2973 vlan_offload |= ETH_VLAN_STRIP_OFFLOAD; 2974 port_rx_offloads |= DEV_RX_OFFLOAD_VLAN_STRIP; 2975 } else { 2976 vlan_offload &= ~ETH_VLAN_STRIP_OFFLOAD; 2977 port_rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_STRIP; 2978 } 2979 2980 diag = rte_eth_dev_set_vlan_offload(port_id, vlan_offload); 2981 if (diag < 0) 2982 printf("rx_vlan_strip_set(port_pi=%d, on=%d) failed " 2983 "diag=%d\n", port_id, on, diag); 2984 ports[port_id].dev_conf.rxmode.offloads = port_rx_offloads; 2985 } 2986 2987 void 2988 rx_vlan_strip_set_on_queue(portid_t port_id, uint16_t queue_id, int on) 2989 { 2990 int diag; 2991 2992 if (port_id_is_invalid(port_id, ENABLED_WARN)) 2993 return; 2994 2995 diag = rte_eth_dev_set_vlan_strip_on_queue(port_id, queue_id, on); 2996 if (diag < 0) 2997 printf("rx_vlan_strip_set_on_queue(port_pi=%d, queue_id=%d, on=%d) failed " 2998 "diag=%d\n", port_id, queue_id, on, diag); 2999 } 3000 3001 void 3002 rx_vlan_filter_set(portid_t port_id, int on) 3003 { 3004 int diag; 3005 int vlan_offload; 3006 uint64_t port_rx_offloads = ports[port_id].dev_conf.rxmode.offloads; 3007 3008 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3009 return; 3010 3011 vlan_offload = rte_eth_dev_get_vlan_offload(port_id); 3012 3013 if (on) { 3014 vlan_offload |= ETH_VLAN_FILTER_OFFLOAD; 3015 port_rx_offloads |= DEV_RX_OFFLOAD_VLAN_FILTER; 3016 } else { 3017 vlan_offload &= ~ETH_VLAN_FILTER_OFFLOAD; 3018 port_rx_offloads &= ~DEV_RX_OFFLOAD_VLAN_FILTER; 3019 } 3020 3021 diag = rte_eth_dev_set_vlan_offload(port_id, vlan_offload); 3022 if (diag < 0) 3023 printf("rx_vlan_filter_set(port_pi=%d, on=%d) failed " 3024 "diag=%d\n", port_id, on, diag); 3025 ports[port_id].dev_conf.rxmode.offloads = port_rx_offloads; 3026 } 3027 3028 int 3029 rx_vft_set(portid_t port_id, uint16_t vlan_id, int on) 3030 { 3031 int diag; 3032 3033 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3034 return 1; 3035 if (vlan_id_is_invalid(vlan_id)) 3036 return 1; 3037 diag = rte_eth_dev_vlan_filter(port_id, vlan_id, on); 3038 if (diag == 0) 3039 return 0; 3040 printf("rte_eth_dev_vlan_filter(port_pi=%d, vlan_id=%d, on=%d) failed " 3041 "diag=%d\n", 3042 port_id, vlan_id, on, diag); 3043 return -1; 3044 } 3045 3046 void 3047 rx_vlan_all_filter_set(portid_t port_id, int on) 3048 { 3049 uint16_t vlan_id; 3050 3051 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3052 return; 3053 for (vlan_id = 0; vlan_id < 4096; vlan_id++) { 3054 if (rx_vft_set(port_id, vlan_id, on)) 3055 break; 3056 } 3057 } 3058 3059 void 3060 vlan_tpid_set(portid_t port_id, enum rte_vlan_type vlan_type, uint16_t tp_id) 3061 { 3062 int diag; 3063 3064 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3065 return; 3066 3067 diag = rte_eth_dev_set_vlan_ether_type(port_id, vlan_type, tp_id); 3068 if (diag == 0) 3069 return; 3070 3071 printf("tx_vlan_tpid_set(port_pi=%d, vlan_type=%d, tpid=%d) failed " 3072 "diag=%d\n", 3073 port_id, vlan_type, tp_id, diag); 3074 } 3075 3076 void 3077 tx_vlan_set(portid_t port_id, uint16_t vlan_id) 3078 { 3079 int vlan_offload; 3080 struct rte_eth_dev_info dev_info; 3081 3082 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3083 return; 3084 if (vlan_id_is_invalid(vlan_id)) 3085 return; 3086 3087 vlan_offload = rte_eth_dev_get_vlan_offload(port_id); 3088 if (vlan_offload & ETH_VLAN_EXTEND_OFFLOAD) { 3089 printf("Error, as QinQ has been enabled.\n"); 3090 return; 3091 } 3092 rte_eth_dev_info_get(port_id, &dev_info); 3093 if ((dev_info.tx_offload_capa & DEV_TX_OFFLOAD_VLAN_INSERT) == 0) { 3094 printf("Error: vlan insert is not supported by port %d\n", 3095 port_id); 3096 return; 3097 } 3098 3099 tx_vlan_reset(port_id); 3100 ports[port_id].dev_conf.txmode.offloads |= DEV_TX_OFFLOAD_VLAN_INSERT; 3101 ports[port_id].tx_vlan_id = vlan_id; 3102 } 3103 3104 void 3105 tx_qinq_set(portid_t port_id, uint16_t vlan_id, uint16_t vlan_id_outer) 3106 { 3107 int vlan_offload; 3108 struct rte_eth_dev_info dev_info; 3109 3110 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3111 return; 3112 if (vlan_id_is_invalid(vlan_id)) 3113 return; 3114 if (vlan_id_is_invalid(vlan_id_outer)) 3115 return; 3116 3117 vlan_offload = rte_eth_dev_get_vlan_offload(port_id); 3118 if (!(vlan_offload & ETH_VLAN_EXTEND_OFFLOAD)) { 3119 printf("Error, as QinQ hasn't been enabled.\n"); 3120 return; 3121 } 3122 rte_eth_dev_info_get(port_id, &dev_info); 3123 if ((dev_info.tx_offload_capa & DEV_TX_OFFLOAD_QINQ_INSERT) == 0) { 3124 printf("Error: qinq insert not supported by port %d\n", 3125 port_id); 3126 return; 3127 } 3128 3129 tx_vlan_reset(port_id); 3130 ports[port_id].dev_conf.txmode.offloads |= DEV_TX_OFFLOAD_QINQ_INSERT; 3131 ports[port_id].tx_vlan_id = vlan_id; 3132 ports[port_id].tx_vlan_id_outer = vlan_id_outer; 3133 } 3134 3135 void 3136 tx_vlan_reset(portid_t port_id) 3137 { 3138 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3139 return; 3140 ports[port_id].dev_conf.txmode.offloads &= 3141 ~(DEV_TX_OFFLOAD_VLAN_INSERT | 3142 DEV_TX_OFFLOAD_QINQ_INSERT); 3143 ports[port_id].tx_vlan_id = 0; 3144 ports[port_id].tx_vlan_id_outer = 0; 3145 } 3146 3147 void 3148 tx_vlan_pvid_set(portid_t port_id, uint16_t vlan_id, int on) 3149 { 3150 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3151 return; 3152 3153 rte_eth_dev_set_vlan_pvid(port_id, vlan_id, on); 3154 } 3155 3156 void 3157 set_qmap(portid_t port_id, uint8_t is_rx, uint16_t queue_id, uint8_t map_value) 3158 { 3159 uint16_t i; 3160 uint8_t existing_mapping_found = 0; 3161 3162 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3163 return; 3164 3165 if (is_rx ? (rx_queue_id_is_invalid(queue_id)) : (tx_queue_id_is_invalid(queue_id))) 3166 return; 3167 3168 if (map_value >= RTE_ETHDEV_QUEUE_STAT_CNTRS) { 3169 printf("map_value not in required range 0..%d\n", 3170 RTE_ETHDEV_QUEUE_STAT_CNTRS - 1); 3171 return; 3172 } 3173 3174 if (!is_rx) { /*then tx*/ 3175 for (i = 0; i < nb_tx_queue_stats_mappings; i++) { 3176 if ((tx_queue_stats_mappings[i].port_id == port_id) && 3177 (tx_queue_stats_mappings[i].queue_id == queue_id)) { 3178 tx_queue_stats_mappings[i].stats_counter_id = map_value; 3179 existing_mapping_found = 1; 3180 break; 3181 } 3182 } 3183 if (!existing_mapping_found) { /* A new additional mapping... */ 3184 tx_queue_stats_mappings[nb_tx_queue_stats_mappings].port_id = port_id; 3185 tx_queue_stats_mappings[nb_tx_queue_stats_mappings].queue_id = queue_id; 3186 tx_queue_stats_mappings[nb_tx_queue_stats_mappings].stats_counter_id = map_value; 3187 nb_tx_queue_stats_mappings++; 3188 } 3189 } 3190 else { /*rx*/ 3191 for (i = 0; i < nb_rx_queue_stats_mappings; i++) { 3192 if ((rx_queue_stats_mappings[i].port_id == port_id) && 3193 (rx_queue_stats_mappings[i].queue_id == queue_id)) { 3194 rx_queue_stats_mappings[i].stats_counter_id = map_value; 3195 existing_mapping_found = 1; 3196 break; 3197 } 3198 } 3199 if (!existing_mapping_found) { /* A new additional mapping... */ 3200 rx_queue_stats_mappings[nb_rx_queue_stats_mappings].port_id = port_id; 3201 rx_queue_stats_mappings[nb_rx_queue_stats_mappings].queue_id = queue_id; 3202 rx_queue_stats_mappings[nb_rx_queue_stats_mappings].stats_counter_id = map_value; 3203 nb_rx_queue_stats_mappings++; 3204 } 3205 } 3206 } 3207 3208 void 3209 set_xstats_hide_zero(uint8_t on_off) 3210 { 3211 xstats_hide_zero = on_off; 3212 } 3213 3214 static inline void 3215 print_fdir_mask(struct rte_eth_fdir_masks *mask) 3216 { 3217 printf("\n vlan_tci: 0x%04x", rte_be_to_cpu_16(mask->vlan_tci_mask)); 3218 3219 if (fdir_conf.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) 3220 printf(", mac_addr: 0x%02x, tunnel_type: 0x%01x," 3221 " tunnel_id: 0x%08x", 3222 mask->mac_addr_byte_mask, mask->tunnel_type_mask, 3223 rte_be_to_cpu_32(mask->tunnel_id_mask)); 3224 else if (fdir_conf.mode != RTE_FDIR_MODE_PERFECT_MAC_VLAN) { 3225 printf(", src_ipv4: 0x%08x, dst_ipv4: 0x%08x", 3226 rte_be_to_cpu_32(mask->ipv4_mask.src_ip), 3227 rte_be_to_cpu_32(mask->ipv4_mask.dst_ip)); 3228 3229 printf("\n src_port: 0x%04x, dst_port: 0x%04x", 3230 rte_be_to_cpu_16(mask->src_port_mask), 3231 rte_be_to_cpu_16(mask->dst_port_mask)); 3232 3233 printf("\n src_ipv6: 0x%08x,0x%08x,0x%08x,0x%08x", 3234 rte_be_to_cpu_32(mask->ipv6_mask.src_ip[0]), 3235 rte_be_to_cpu_32(mask->ipv6_mask.src_ip[1]), 3236 rte_be_to_cpu_32(mask->ipv6_mask.src_ip[2]), 3237 rte_be_to_cpu_32(mask->ipv6_mask.src_ip[3])); 3238 3239 printf("\n dst_ipv6: 0x%08x,0x%08x,0x%08x,0x%08x", 3240 rte_be_to_cpu_32(mask->ipv6_mask.dst_ip[0]), 3241 rte_be_to_cpu_32(mask->ipv6_mask.dst_ip[1]), 3242 rte_be_to_cpu_32(mask->ipv6_mask.dst_ip[2]), 3243 rte_be_to_cpu_32(mask->ipv6_mask.dst_ip[3])); 3244 } 3245 3246 printf("\n"); 3247 } 3248 3249 static inline void 3250 print_fdir_flex_payload(struct rte_eth_fdir_flex_conf *flex_conf, uint32_t num) 3251 { 3252 struct rte_eth_flex_payload_cfg *cfg; 3253 uint32_t i, j; 3254 3255 for (i = 0; i < flex_conf->nb_payloads; i++) { 3256 cfg = &flex_conf->flex_set[i]; 3257 if (cfg->type == RTE_ETH_RAW_PAYLOAD) 3258 printf("\n RAW: "); 3259 else if (cfg->type == RTE_ETH_L2_PAYLOAD) 3260 printf("\n L2_PAYLOAD: "); 3261 else if (cfg->type == RTE_ETH_L3_PAYLOAD) 3262 printf("\n L3_PAYLOAD: "); 3263 else if (cfg->type == RTE_ETH_L4_PAYLOAD) 3264 printf("\n L4_PAYLOAD: "); 3265 else 3266 printf("\n UNKNOWN PAYLOAD(%u): ", cfg->type); 3267 for (j = 0; j < num; j++) 3268 printf(" %-5u", cfg->src_offset[j]); 3269 } 3270 printf("\n"); 3271 } 3272 3273 static char * 3274 flowtype_to_str(uint16_t flow_type) 3275 { 3276 struct flow_type_info { 3277 char str[32]; 3278 uint16_t ftype; 3279 }; 3280 3281 uint8_t i; 3282 static struct flow_type_info flowtype_str_table[] = { 3283 {"raw", RTE_ETH_FLOW_RAW}, 3284 {"ipv4", RTE_ETH_FLOW_IPV4}, 3285 {"ipv4-frag", RTE_ETH_FLOW_FRAG_IPV4}, 3286 {"ipv4-tcp", RTE_ETH_FLOW_NONFRAG_IPV4_TCP}, 3287 {"ipv4-udp", RTE_ETH_FLOW_NONFRAG_IPV4_UDP}, 3288 {"ipv4-sctp", RTE_ETH_FLOW_NONFRAG_IPV4_SCTP}, 3289 {"ipv4-other", RTE_ETH_FLOW_NONFRAG_IPV4_OTHER}, 3290 {"ipv6", RTE_ETH_FLOW_IPV6}, 3291 {"ipv6-frag", RTE_ETH_FLOW_FRAG_IPV6}, 3292 {"ipv6-tcp", RTE_ETH_FLOW_NONFRAG_IPV6_TCP}, 3293 {"ipv6-udp", RTE_ETH_FLOW_NONFRAG_IPV6_UDP}, 3294 {"ipv6-sctp", RTE_ETH_FLOW_NONFRAG_IPV6_SCTP}, 3295 {"ipv6-other", RTE_ETH_FLOW_NONFRAG_IPV6_OTHER}, 3296 {"l2_payload", RTE_ETH_FLOW_L2_PAYLOAD}, 3297 {"port", RTE_ETH_FLOW_PORT}, 3298 {"vxlan", RTE_ETH_FLOW_VXLAN}, 3299 {"geneve", RTE_ETH_FLOW_GENEVE}, 3300 {"nvgre", RTE_ETH_FLOW_NVGRE}, 3301 {"vxlan-gpe", RTE_ETH_FLOW_VXLAN_GPE}, 3302 }; 3303 3304 for (i = 0; i < RTE_DIM(flowtype_str_table); i++) { 3305 if (flowtype_str_table[i].ftype == flow_type) 3306 return flowtype_str_table[i].str; 3307 } 3308 3309 return NULL; 3310 } 3311 3312 static inline void 3313 print_fdir_flex_mask(struct rte_eth_fdir_flex_conf *flex_conf, uint32_t num) 3314 { 3315 struct rte_eth_fdir_flex_mask *mask; 3316 uint32_t i, j; 3317 char *p; 3318 3319 for (i = 0; i < flex_conf->nb_flexmasks; i++) { 3320 mask = &flex_conf->flex_mask[i]; 3321 p = flowtype_to_str(mask->flow_type); 3322 printf("\n %s:\t", p ? p : "unknown"); 3323 for (j = 0; j < num; j++) 3324 printf(" %02x", mask->mask[j]); 3325 } 3326 printf("\n"); 3327 } 3328 3329 static inline void 3330 print_fdir_flow_type(uint32_t flow_types_mask) 3331 { 3332 int i; 3333 char *p; 3334 3335 for (i = RTE_ETH_FLOW_UNKNOWN; i < RTE_ETH_FLOW_MAX; i++) { 3336 if (!(flow_types_mask & (1 << i))) 3337 continue; 3338 p = flowtype_to_str(i); 3339 if (p) 3340 printf(" %s", p); 3341 else 3342 printf(" unknown"); 3343 } 3344 printf("\n"); 3345 } 3346 3347 void 3348 fdir_get_infos(portid_t port_id) 3349 { 3350 struct rte_eth_fdir_stats fdir_stat; 3351 struct rte_eth_fdir_info fdir_info; 3352 int ret; 3353 3354 static const char *fdir_stats_border = "########################"; 3355 3356 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3357 return; 3358 ret = rte_eth_dev_filter_supported(port_id, RTE_ETH_FILTER_FDIR); 3359 if (ret < 0) { 3360 printf("\n FDIR is not supported on port %-2d\n", 3361 port_id); 3362 return; 3363 } 3364 3365 memset(&fdir_info, 0, sizeof(fdir_info)); 3366 rte_eth_dev_filter_ctrl(port_id, RTE_ETH_FILTER_FDIR, 3367 RTE_ETH_FILTER_INFO, &fdir_info); 3368 memset(&fdir_stat, 0, sizeof(fdir_stat)); 3369 rte_eth_dev_filter_ctrl(port_id, RTE_ETH_FILTER_FDIR, 3370 RTE_ETH_FILTER_STATS, &fdir_stat); 3371 printf("\n %s FDIR infos for port %-2d %s\n", 3372 fdir_stats_border, port_id, fdir_stats_border); 3373 printf(" MODE: "); 3374 if (fdir_info.mode == RTE_FDIR_MODE_PERFECT) 3375 printf(" PERFECT\n"); 3376 else if (fdir_info.mode == RTE_FDIR_MODE_PERFECT_MAC_VLAN) 3377 printf(" PERFECT-MAC-VLAN\n"); 3378 else if (fdir_info.mode == RTE_FDIR_MODE_PERFECT_TUNNEL) 3379 printf(" PERFECT-TUNNEL\n"); 3380 else if (fdir_info.mode == RTE_FDIR_MODE_SIGNATURE) 3381 printf(" SIGNATURE\n"); 3382 else 3383 printf(" DISABLE\n"); 3384 if (fdir_info.mode != RTE_FDIR_MODE_PERFECT_MAC_VLAN 3385 && fdir_info.mode != RTE_FDIR_MODE_PERFECT_TUNNEL) { 3386 printf(" SUPPORTED FLOW TYPE: "); 3387 print_fdir_flow_type(fdir_info.flow_types_mask[0]); 3388 } 3389 printf(" FLEX PAYLOAD INFO:\n"); 3390 printf(" max_len: %-10"PRIu32" payload_limit: %-10"PRIu32"\n" 3391 " payload_unit: %-10"PRIu32" payload_seg: %-10"PRIu32"\n" 3392 " bitmask_unit: %-10"PRIu32" bitmask_num: %-10"PRIu32"\n", 3393 fdir_info.max_flexpayload, fdir_info.flex_payload_limit, 3394 fdir_info.flex_payload_unit, 3395 fdir_info.max_flex_payload_segment_num, 3396 fdir_info.flex_bitmask_unit, fdir_info.max_flex_bitmask_num); 3397 printf(" MASK: "); 3398 print_fdir_mask(&fdir_info.mask); 3399 if (fdir_info.flex_conf.nb_payloads > 0) { 3400 printf(" FLEX PAYLOAD SRC OFFSET:"); 3401 print_fdir_flex_payload(&fdir_info.flex_conf, fdir_info.max_flexpayload); 3402 } 3403 if (fdir_info.flex_conf.nb_flexmasks > 0) { 3404 printf(" FLEX MASK CFG:"); 3405 print_fdir_flex_mask(&fdir_info.flex_conf, fdir_info.max_flexpayload); 3406 } 3407 printf(" guarant_count: %-10"PRIu32" best_count: %"PRIu32"\n", 3408 fdir_stat.guarant_cnt, fdir_stat.best_cnt); 3409 printf(" guarant_space: %-10"PRIu32" best_space: %"PRIu32"\n", 3410 fdir_info.guarant_spc, fdir_info.best_spc); 3411 printf(" collision: %-10"PRIu32" free: %"PRIu32"\n" 3412 " maxhash: %-10"PRIu32" maxlen: %"PRIu32"\n" 3413 " add: %-10"PRIu64" remove: %"PRIu64"\n" 3414 " f_add: %-10"PRIu64" f_remove: %"PRIu64"\n", 3415 fdir_stat.collision, fdir_stat.free, 3416 fdir_stat.maxhash, fdir_stat.maxlen, 3417 fdir_stat.add, fdir_stat.remove, 3418 fdir_stat.f_add, fdir_stat.f_remove); 3419 printf(" %s############################%s\n", 3420 fdir_stats_border, fdir_stats_border); 3421 } 3422 3423 void 3424 fdir_set_flex_mask(portid_t port_id, struct rte_eth_fdir_flex_mask *cfg) 3425 { 3426 struct rte_port *port; 3427 struct rte_eth_fdir_flex_conf *flex_conf; 3428 int i, idx = 0; 3429 3430 port = &ports[port_id]; 3431 flex_conf = &port->dev_conf.fdir_conf.flex_conf; 3432 for (i = 0; i < RTE_ETH_FLOW_MAX; i++) { 3433 if (cfg->flow_type == flex_conf->flex_mask[i].flow_type) { 3434 idx = i; 3435 break; 3436 } 3437 } 3438 if (i >= RTE_ETH_FLOW_MAX) { 3439 if (flex_conf->nb_flexmasks < RTE_DIM(flex_conf->flex_mask)) { 3440 idx = flex_conf->nb_flexmasks; 3441 flex_conf->nb_flexmasks++; 3442 } else { 3443 printf("The flex mask table is full. Can not set flex" 3444 " mask for flow_type(%u).", cfg->flow_type); 3445 return; 3446 } 3447 } 3448 rte_memcpy(&flex_conf->flex_mask[idx], 3449 cfg, 3450 sizeof(struct rte_eth_fdir_flex_mask)); 3451 } 3452 3453 void 3454 fdir_set_flex_payload(portid_t port_id, struct rte_eth_flex_payload_cfg *cfg) 3455 { 3456 struct rte_port *port; 3457 struct rte_eth_fdir_flex_conf *flex_conf; 3458 int i, idx = 0; 3459 3460 port = &ports[port_id]; 3461 flex_conf = &port->dev_conf.fdir_conf.flex_conf; 3462 for (i = 0; i < RTE_ETH_PAYLOAD_MAX; i++) { 3463 if (cfg->type == flex_conf->flex_set[i].type) { 3464 idx = i; 3465 break; 3466 } 3467 } 3468 if (i >= RTE_ETH_PAYLOAD_MAX) { 3469 if (flex_conf->nb_payloads < RTE_DIM(flex_conf->flex_set)) { 3470 idx = flex_conf->nb_payloads; 3471 flex_conf->nb_payloads++; 3472 } else { 3473 printf("The flex payload table is full. Can not set" 3474 " flex payload for type(%u).", cfg->type); 3475 return; 3476 } 3477 } 3478 rte_memcpy(&flex_conf->flex_set[idx], 3479 cfg, 3480 sizeof(struct rte_eth_flex_payload_cfg)); 3481 3482 } 3483 3484 void 3485 set_vf_traffic(portid_t port_id, uint8_t is_rx, uint16_t vf, uint8_t on) 3486 { 3487 #ifdef RTE_LIBRTE_IXGBE_PMD 3488 int diag; 3489 3490 if (is_rx) 3491 diag = rte_pmd_ixgbe_set_vf_rx(port_id, vf, on); 3492 else 3493 diag = rte_pmd_ixgbe_set_vf_tx(port_id, vf, on); 3494 3495 if (diag == 0) 3496 return; 3497 printf("rte_pmd_ixgbe_set_vf_%s for port_id=%d failed diag=%d\n", 3498 is_rx ? "rx" : "tx", port_id, diag); 3499 return; 3500 #endif 3501 printf("VF %s setting not supported for port %d\n", 3502 is_rx ? "Rx" : "Tx", port_id); 3503 RTE_SET_USED(vf); 3504 RTE_SET_USED(on); 3505 } 3506 3507 int 3508 set_queue_rate_limit(portid_t port_id, uint16_t queue_idx, uint16_t rate) 3509 { 3510 int diag; 3511 struct rte_eth_link link; 3512 3513 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3514 return 1; 3515 rte_eth_link_get_nowait(port_id, &link); 3516 if (rate > link.link_speed) { 3517 printf("Invalid rate value:%u bigger than link speed: %u\n", 3518 rate, link.link_speed); 3519 return 1; 3520 } 3521 diag = rte_eth_set_queue_rate_limit(port_id, queue_idx, rate); 3522 if (diag == 0) 3523 return diag; 3524 printf("rte_eth_set_queue_rate_limit for port_id=%d failed diag=%d\n", 3525 port_id, diag); 3526 return diag; 3527 } 3528 3529 int 3530 set_vf_rate_limit(portid_t port_id, uint16_t vf, uint16_t rate, uint64_t q_msk) 3531 { 3532 int diag = -ENOTSUP; 3533 3534 RTE_SET_USED(vf); 3535 RTE_SET_USED(rate); 3536 RTE_SET_USED(q_msk); 3537 3538 #ifdef RTE_LIBRTE_IXGBE_PMD 3539 if (diag == -ENOTSUP) 3540 diag = rte_pmd_ixgbe_set_vf_rate_limit(port_id, vf, rate, 3541 q_msk); 3542 #endif 3543 #ifdef RTE_LIBRTE_BNXT_PMD 3544 if (diag == -ENOTSUP) 3545 diag = rte_pmd_bnxt_set_vf_rate_limit(port_id, vf, rate, q_msk); 3546 #endif 3547 if (diag == 0) 3548 return diag; 3549 3550 printf("set_vf_rate_limit for port_id=%d failed diag=%d\n", 3551 port_id, diag); 3552 return diag; 3553 } 3554 3555 /* 3556 * Functions to manage the set of filtered Multicast MAC addresses. 3557 * 3558 * A pool of filtered multicast MAC addresses is associated with each port. 3559 * The pool is allocated in chunks of MCAST_POOL_INC multicast addresses. 3560 * The address of the pool and the number of valid multicast MAC addresses 3561 * recorded in the pool are stored in the fields "mc_addr_pool" and 3562 * "mc_addr_nb" of the "rte_port" data structure. 3563 * 3564 * The function "rte_eth_dev_set_mc_addr_list" of the PMDs API imposes 3565 * to be supplied a contiguous array of multicast MAC addresses. 3566 * To comply with this constraint, the set of multicast addresses recorded 3567 * into the pool are systematically compacted at the beginning of the pool. 3568 * Hence, when a multicast address is removed from the pool, all following 3569 * addresses, if any, are copied back to keep the set contiguous. 3570 */ 3571 #define MCAST_POOL_INC 32 3572 3573 static int 3574 mcast_addr_pool_extend(struct rte_port *port) 3575 { 3576 struct ether_addr *mc_pool; 3577 size_t mc_pool_size; 3578 3579 /* 3580 * If a free entry is available at the end of the pool, just 3581 * increment the number of recorded multicast addresses. 3582 */ 3583 if ((port->mc_addr_nb % MCAST_POOL_INC) != 0) { 3584 port->mc_addr_nb++; 3585 return 0; 3586 } 3587 3588 /* 3589 * [re]allocate a pool with MCAST_POOL_INC more entries. 3590 * The previous test guarantees that port->mc_addr_nb is a multiple 3591 * of MCAST_POOL_INC. 3592 */ 3593 mc_pool_size = sizeof(struct ether_addr) * (port->mc_addr_nb + 3594 MCAST_POOL_INC); 3595 mc_pool = (struct ether_addr *) realloc(port->mc_addr_pool, 3596 mc_pool_size); 3597 if (mc_pool == NULL) { 3598 printf("allocation of pool of %u multicast addresses failed\n", 3599 port->mc_addr_nb + MCAST_POOL_INC); 3600 return -ENOMEM; 3601 } 3602 3603 port->mc_addr_pool = mc_pool; 3604 port->mc_addr_nb++; 3605 return 0; 3606 3607 } 3608 3609 static void 3610 mcast_addr_pool_remove(struct rte_port *port, uint32_t addr_idx) 3611 { 3612 port->mc_addr_nb--; 3613 if (addr_idx == port->mc_addr_nb) { 3614 /* No need to recompact the set of multicast addressses. */ 3615 if (port->mc_addr_nb == 0) { 3616 /* free the pool of multicast addresses. */ 3617 free(port->mc_addr_pool); 3618 port->mc_addr_pool = NULL; 3619 } 3620 return; 3621 } 3622 memmove(&port->mc_addr_pool[addr_idx], 3623 &port->mc_addr_pool[addr_idx + 1], 3624 sizeof(struct ether_addr) * (port->mc_addr_nb - addr_idx)); 3625 } 3626 3627 static void 3628 eth_port_multicast_addr_list_set(portid_t port_id) 3629 { 3630 struct rte_port *port; 3631 int diag; 3632 3633 port = &ports[port_id]; 3634 diag = rte_eth_dev_set_mc_addr_list(port_id, port->mc_addr_pool, 3635 port->mc_addr_nb); 3636 if (diag == 0) 3637 return; 3638 printf("rte_eth_dev_set_mc_addr_list(port=%d, nb=%u) failed. diag=%d\n", 3639 port->mc_addr_nb, port_id, -diag); 3640 } 3641 3642 void 3643 mcast_addr_add(portid_t port_id, struct ether_addr *mc_addr) 3644 { 3645 struct rte_port *port; 3646 uint32_t i; 3647 3648 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3649 return; 3650 3651 port = &ports[port_id]; 3652 3653 /* 3654 * Check that the added multicast MAC address is not already recorded 3655 * in the pool of multicast addresses. 3656 */ 3657 for (i = 0; i < port->mc_addr_nb; i++) { 3658 if (is_same_ether_addr(mc_addr, &port->mc_addr_pool[i])) { 3659 printf("multicast address already filtered by port\n"); 3660 return; 3661 } 3662 } 3663 3664 if (mcast_addr_pool_extend(port) != 0) 3665 return; 3666 ether_addr_copy(mc_addr, &port->mc_addr_pool[i]); 3667 eth_port_multicast_addr_list_set(port_id); 3668 } 3669 3670 void 3671 mcast_addr_remove(portid_t port_id, struct ether_addr *mc_addr) 3672 { 3673 struct rte_port *port; 3674 uint32_t i; 3675 3676 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3677 return; 3678 3679 port = &ports[port_id]; 3680 3681 /* 3682 * Search the pool of multicast MAC addresses for the removed address. 3683 */ 3684 for (i = 0; i < port->mc_addr_nb; i++) { 3685 if (is_same_ether_addr(mc_addr, &port->mc_addr_pool[i])) 3686 break; 3687 } 3688 if (i == port->mc_addr_nb) { 3689 printf("multicast address not filtered by port %d\n", port_id); 3690 return; 3691 } 3692 3693 mcast_addr_pool_remove(port, i); 3694 eth_port_multicast_addr_list_set(port_id); 3695 } 3696 3697 void 3698 port_dcb_info_display(portid_t port_id) 3699 { 3700 struct rte_eth_dcb_info dcb_info; 3701 uint16_t i; 3702 int ret; 3703 static const char *border = "================"; 3704 3705 if (port_id_is_invalid(port_id, ENABLED_WARN)) 3706 return; 3707 3708 ret = rte_eth_dev_get_dcb_info(port_id, &dcb_info); 3709 if (ret) { 3710 printf("\n Failed to get dcb infos on port %-2d\n", 3711 port_id); 3712 return; 3713 } 3714 printf("\n %s DCB infos for port %-2d %s\n", border, port_id, border); 3715 printf(" TC NUMBER: %d\n", dcb_info.nb_tcs); 3716 printf("\n TC : "); 3717 for (i = 0; i < dcb_info.nb_tcs; i++) 3718 printf("\t%4d", i); 3719 printf("\n Priority : "); 3720 for (i = 0; i < dcb_info.nb_tcs; i++) 3721 printf("\t%4d", dcb_info.prio_tc[i]); 3722 printf("\n BW percent :"); 3723 for (i = 0; i < dcb_info.nb_tcs; i++) 3724 printf("\t%4d%%", dcb_info.tc_bws[i]); 3725 printf("\n RXQ base : "); 3726 for (i = 0; i < dcb_info.nb_tcs; i++) 3727 printf("\t%4d", dcb_info.tc_queue.tc_rxq[0][i].base); 3728 printf("\n RXQ number :"); 3729 for (i = 0; i < dcb_info.nb_tcs; i++) 3730 printf("\t%4d", dcb_info.tc_queue.tc_rxq[0][i].nb_queue); 3731 printf("\n TXQ base : "); 3732 for (i = 0; i < dcb_info.nb_tcs; i++) 3733 printf("\t%4d", dcb_info.tc_queue.tc_txq[0][i].base); 3734 printf("\n TXQ number :"); 3735 for (i = 0; i < dcb_info.nb_tcs; i++) 3736 printf("\t%4d", dcb_info.tc_queue.tc_txq[0][i].nb_queue); 3737 printf("\n"); 3738 } 3739 3740 uint8_t * 3741 open_file(const char *file_path, uint32_t *size) 3742 { 3743 int fd = open(file_path, O_RDONLY); 3744 off_t pkg_size; 3745 uint8_t *buf = NULL; 3746 int ret = 0; 3747 struct stat st_buf; 3748 3749 if (size) 3750 *size = 0; 3751 3752 if (fd == -1) { 3753 printf("%s: Failed to open %s\n", __func__, file_path); 3754 return buf; 3755 } 3756 3757 if ((fstat(fd, &st_buf) != 0) || (!S_ISREG(st_buf.st_mode))) { 3758 close(fd); 3759 printf("%s: File operations failed\n", __func__); 3760 return buf; 3761 } 3762 3763 pkg_size = st_buf.st_size; 3764 if (pkg_size < 0) { 3765 close(fd); 3766 printf("%s: File operations failed\n", __func__); 3767 return buf; 3768 } 3769 3770 buf = (uint8_t *)malloc(pkg_size); 3771 if (!buf) { 3772 close(fd); 3773 printf("%s: Failed to malloc memory\n", __func__); 3774 return buf; 3775 } 3776 3777 ret = read(fd, buf, pkg_size); 3778 if (ret < 0) { 3779 close(fd); 3780 printf("%s: File read operation failed\n", __func__); 3781 close_file(buf); 3782 return NULL; 3783 } 3784 3785 if (size) 3786 *size = pkg_size; 3787 3788 close(fd); 3789 3790 return buf; 3791 } 3792 3793 int 3794 save_file(const char *file_path, uint8_t *buf, uint32_t size) 3795 { 3796 FILE *fh = fopen(file_path, "wb"); 3797 3798 if (fh == NULL) { 3799 printf("%s: Failed to open %s\n", __func__, file_path); 3800 return -1; 3801 } 3802 3803 if (fwrite(buf, 1, size, fh) != size) { 3804 fclose(fh); 3805 printf("%s: File write operation failed\n", __func__); 3806 return -1; 3807 } 3808 3809 fclose(fh); 3810 3811 return 0; 3812 } 3813 3814 int 3815 close_file(uint8_t *buf) 3816 { 3817 if (buf) { 3818 free((void *)buf); 3819 return 0; 3820 } 3821 3822 return -1; 3823 } 3824 3825 void 3826 port_queue_region_info_display(portid_t port_id, void *buf) 3827 { 3828 #ifdef RTE_LIBRTE_I40E_PMD 3829 uint16_t i, j; 3830 struct rte_pmd_i40e_queue_regions *info = 3831 (struct rte_pmd_i40e_queue_regions *)buf; 3832 static const char *queue_region_info_stats_border = "-------"; 3833 3834 if (!info->queue_region_number) 3835 printf("there is no region has been set before"); 3836 3837 printf("\n %s All queue region info for port=%2d %s", 3838 queue_region_info_stats_border, port_id, 3839 queue_region_info_stats_border); 3840 printf("\n queue_region_number: %-14u \n", 3841 info->queue_region_number); 3842 3843 for (i = 0; i < info->queue_region_number; i++) { 3844 printf("\n region_id: %-14u queue_number: %-14u " 3845 "queue_start_index: %-14u \n", 3846 info->region[i].region_id, 3847 info->region[i].queue_num, 3848 info->region[i].queue_start_index); 3849 3850 printf(" user_priority_num is %-14u :", 3851 info->region[i].user_priority_num); 3852 for (j = 0; j < info->region[i].user_priority_num; j++) 3853 printf(" %-14u ", info->region[i].user_priority[j]); 3854 3855 printf("\n flowtype_num is %-14u :", 3856 info->region[i].flowtype_num); 3857 for (j = 0; j < info->region[i].flowtype_num; j++) 3858 printf(" %-14u ", info->region[i].hw_flowtype[j]); 3859 } 3860 #else 3861 RTE_SET_USED(port_id); 3862 RTE_SET_USED(buf); 3863 #endif 3864 3865 printf("\n\n"); 3866 } 3867