1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. 5 * Copyright(c) 2014 6WIND S.A. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * * Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * * Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * * Neither the name of Intel Corporation nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 #include <stdarg.h> 36 #include <errno.h> 37 #include <stdio.h> 38 #include <stdint.h> 39 #include <stdarg.h> 40 #include <string.h> 41 #include <termios.h> 42 #include <unistd.h> 43 #include <inttypes.h> 44 #ifndef __linux__ 45 #ifndef __FreeBSD__ 46 #include <net/socket.h> 47 #else 48 #include <sys/socket.h> 49 #endif 50 #endif 51 #include <netinet/in.h> 52 53 #include <sys/queue.h> 54 55 #include <rte_common.h> 56 #include <rte_byteorder.h> 57 #include <rte_log.h> 58 #include <rte_debug.h> 59 #include <rte_cycles.h> 60 #include <rte_memory.h> 61 #include <rte_memzone.h> 62 #include <rte_launch.h> 63 #include <rte_tailq.h> 64 #include <rte_eal.h> 65 #include <rte_per_lcore.h> 66 #include <rte_lcore.h> 67 #include <rte_atomic.h> 68 #include <rte_branch_prediction.h> 69 #include <rte_ring.h> 70 #include <rte_mempool.h> 71 #include <rte_interrupts.h> 72 #include <rte_pci.h> 73 #include <rte_ether.h> 74 #include <rte_ethdev.h> 75 #include <rte_string_fns.h> 76 #include <rte_devargs.h> 77 78 #include <cmdline_rdline.h> 79 #include <cmdline_parse.h> 80 #include <cmdline_parse_num.h> 81 #include <cmdline_parse_string.h> 82 #include <cmdline_parse_ipaddr.h> 83 #include <cmdline_parse_etheraddr.h> 84 #include <cmdline_socket.h> 85 #include <cmdline.h> 86 #include <rte_pci_dev_ids.h> 87 88 #include "testpmd.h" 89 90 static void cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue); 91 92 #ifdef RTE_NIC_BYPASS 93 uint8_t bypass_is_supported(portid_t port_id); 94 #endif 95 96 /* *** Help command with introduction. *** */ 97 struct cmd_help_brief_result { 98 cmdline_fixed_string_t help; 99 }; 100 101 static void cmd_help_brief_parsed(__attribute__((unused)) void *parsed_result, 102 struct cmdline *cl, 103 __attribute__((unused)) void *data) 104 { 105 cmdline_printf( 106 cl, 107 "\n" 108 "Help is available for the following sections:\n\n" 109 " help control : Start and stop forwarding.\n" 110 " help display : Displaying port, stats and config " 111 "information.\n" 112 " help config : Configuration information.\n" 113 " help ports : Configuring ports.\n" 114 " help flowdir : Flow Director filter help.\n" 115 " help registers : Reading and setting port registers.\n" 116 " help all : All of the above sections.\n\n" 117 ); 118 119 } 120 121 cmdline_parse_token_string_t cmd_help_brief_help = 122 TOKEN_STRING_INITIALIZER(struct cmd_help_brief_result, help, "help"); 123 124 cmdline_parse_inst_t cmd_help_brief = { 125 .f = cmd_help_brief_parsed, 126 .data = NULL, 127 .help_str = "show help", 128 .tokens = { 129 (void *)&cmd_help_brief_help, 130 NULL, 131 }, 132 }; 133 134 /* *** Help command with help sections. *** */ 135 struct cmd_help_long_result { 136 cmdline_fixed_string_t help; 137 cmdline_fixed_string_t section; 138 }; 139 140 static void cmd_help_long_parsed(void *parsed_result, 141 struct cmdline *cl, 142 __attribute__((unused)) void *data) 143 { 144 int show_all = 0; 145 struct cmd_help_long_result *res = parsed_result; 146 147 if (!strcmp(res->section, "all")) 148 show_all = 1; 149 150 if (show_all || !strcmp(res->section, "control")) { 151 152 cmdline_printf( 153 cl, 154 "\n" 155 "Control forwarding:\n" 156 "-------------------\n\n" 157 158 "start\n" 159 " Start packet forwarding with current configuration.\n\n" 160 161 "start tx_first\n" 162 " Start packet forwarding with current config" 163 " after sending one burst of packets.\n\n" 164 165 "stop\n" 166 " Stop packet forwarding, and display accumulated" 167 " statistics.\n\n" 168 169 "quit\n" 170 " Quit to prompt in Linux and reboot on Baremetal.\n\n" 171 ); 172 } 173 174 if (show_all || !strcmp(res->section, "display")) { 175 176 cmdline_printf( 177 cl, 178 "\n" 179 "Display:\n" 180 "--------\n\n" 181 182 "show port (info|stats|fdir|stat_qmap) (port_id|all)\n" 183 " Display information for port_id, or all.\n\n" 184 185 "show port rss-hash [key]\n" 186 " Display the RSS hash functions and RSS hash key" 187 " of port X\n\n" 188 189 "clear port (info|stats|fdir|stat_qmap) (port_id|all)\n" 190 " Clear information for port_id, or all.\n\n" 191 192 "show config (rxtx|cores|fwd)\n" 193 " Display the given configuration.\n\n" 194 195 "read rxd (port_id) (queue_id) (rxd_id)\n" 196 " Display an RX descriptor of a port RX queue.\n\n" 197 198 "read txd (port_id) (queue_id) (txd_id)\n" 199 " Display a TX descriptor of a port TX queue.\n\n" 200 ); 201 } 202 203 if (show_all || !strcmp(res->section, "config")) { 204 cmdline_printf( 205 cl, 206 "\n" 207 "Configuration:\n" 208 "--------------\n" 209 "Configuration changes only become active when" 210 " forwarding is started/restarted.\n\n" 211 212 "set default\n" 213 " Reset forwarding to the default configuration.\n\n" 214 215 "set verbose (level)\n" 216 " Set the debug verbosity level X.\n\n" 217 218 "set nbport (num)\n" 219 " Set number of ports.\n\n" 220 221 "set nbcore (num)\n" 222 " Set number of cores.\n\n" 223 224 "set coremask (mask)\n" 225 " Set the forwarding cores hexadecimal mask.\n\n" 226 227 "set portmask (mask)\n" 228 " Set the forwarding ports hexadecimal mask.\n\n" 229 230 "set burst (num)\n" 231 " Set number of packets per burst.\n\n" 232 233 "set burst tx delay (microseconds) retry (num)\n" 234 " Set the transmit delay time and number of retries" 235 " in mac_retry forwarding mode.\n\n" 236 237 "set txpkts (x[,y]*)\n" 238 " Set the length of each segment of TXONLY" 239 " packets.\n\n" 240 241 "set corelist (x[,y]*)\n" 242 " Set the list of forwarding cores.\n\n" 243 244 "set portlist (x[,y]*)\n" 245 " Set the list of forwarding ports.\n\n" 246 247 "vlan set strip (on|off) (port_id)\n" 248 " Set the VLAN strip on a port.\n\n" 249 250 "vlan set stripq (on|off) (port_id,queue_id)\n" 251 " Set the VLAN strip for a queue on a port.\n\n" 252 253 "vlan set filter (on|off) (port_id)\n" 254 " Set the VLAN filter on a port.\n\n" 255 256 "vlan set qinq (on|off) (port_id)\n" 257 " Set the VLAN QinQ (extended queue in queue)" 258 " on a port.\n\n" 259 260 "vlan set tpid (value) (port_id)\n" 261 " Set the outer VLAN TPID for Packet Filtering on" 262 " a port\n\n" 263 264 "rx_vlan add (vlan_id|all) (port_id)\n" 265 " Add a vlan_id, or all identifiers, to the set" 266 " of VLAN identifiers filtered by port_id.\n\n" 267 268 "rx_vlan rm (vlan_id|all) (port_id)\n" 269 " Remove a vlan_id, or all identifiers, from the set" 270 " of VLAN identifiers filtered by port_id.\n\n" 271 272 "rx_vlan add (vlan_id) port (port_id) vf (vf_mask)\n" 273 " Add a vlan_id, to the set of VLAN identifiers" 274 "filtered for VF(s) from port_id.\n\n" 275 276 "rx_vlan rm (vlan_id) port (port_id) vf (vf_mask)\n" 277 " Remove a vlan_id, to the set of VLAN identifiers" 278 "filtered for VF(s) from port_id.\n\n" 279 280 "rx_vlan set tpid (value) (port_id)\n" 281 " Set the outer VLAN TPID for Packet Filtering on" 282 " a port\n\n" 283 284 "tx_vlan set vlan_id (port_id)\n" 285 " Set hardware insertion of VLAN ID in packets sent" 286 " on a port.\n\n" 287 288 "tx_vlan reset (port_id)\n" 289 " Disable hardware insertion of a VLAN header in" 290 " packets sent on a port.\n\n" 291 292 "tx_checksum set mask (port_id)\n" 293 " Enable hardware insertion of checksum offload with" 294 " the 4-bit mask, 0~0xf, in packets sent on a port.\n" 295 " bit 0 - insert ip checksum offload if set\n" 296 " bit 1 - insert udp checksum offload if set\n" 297 " bit 2 - insert tcp checksum offload if set\n" 298 " bit 3 - insert sctp checksum offload if set\n" 299 " Please check the NIC datasheet for HW limits.\n\n" 300 301 "set fwd (%s)\n" 302 " Set packet forwarding mode.\n\n" 303 304 "mac_addr add (port_id) (XX:XX:XX:XX:XX:XX)\n" 305 " Add a MAC address on port_id.\n\n" 306 307 "mac_addr remove (port_id) (XX:XX:XX:XX:XX:XX)\n" 308 " Remove a MAC address from port_id.\n\n" 309 310 "mac_addr add port (port_id) vf (vf_id) (mac_address)\n" 311 " Add a MAC address for a VF on the port.\n\n" 312 313 "set port (port_id) uta (mac_address|all) (on|off)\n" 314 " Add/Remove a or all unicast hash filter(s)" 315 "from port X.\n\n" 316 317 "set promisc (port_id|all) (on|off)\n" 318 " Set the promiscuous mode on port_id, or all.\n\n" 319 320 "set allmulti (port_id|all) (on|off)\n" 321 " Set the allmulti mode on port_id, or all.\n\n" 322 323 "set flow_ctrl rx (on|off) tx (on|off) (high_water)" 324 " (low_water) (pause_time) (send_xon) mac_ctrl_frame_fwd" 325 " (on|off) (port_id)\n" 326 " Set the link flow control parameter on a port.\n\n" 327 328 "set pfc_ctrl rx (on|off) tx (on|off) (high_water)" 329 " (low_water) (pause_time) (priority) (port_id)\n" 330 " Set the priority flow control parameter on a" 331 " port.\n\n" 332 333 "set stat_qmap (tx|rx) (port_id) (queue_id) (qmapping)\n" 334 " Set statistics mapping (qmapping 0..15) for RX/TX" 335 " queue on port.\n" 336 " e.g., 'set stat_qmap rx 0 2 5' sets rx queue 2" 337 " on port 0 to mapping 5.\n\n" 338 339 "set port (port_id) vf (vf_id) rx|tx on|off \n" 340 " Enable/Disable a VF receive/tranmit from a port\n\n" 341 342 "set port (port_id) vf (vf_id) rxmode (AUPE|ROPE|BAM" 343 "|MPE) (on|off)\n" 344 " AUPE:accepts untagged VLAN;" 345 "ROPE:accept unicast hash\n\n" 346 " BAM:accepts broadcast packets;" 347 "MPE:accepts all multicast packets\n\n" 348 " Enable/Disable a VF receive mode of a port\n\n" 349 350 "set port (port_id) queue (queue_id) rate (rate_num)\n" 351 " Set rate limit for a queue of a port\n\n" 352 353 "set port (port_id) vf (vf_id) rate (rate_num) " 354 "queue_mask (queue_mask_value)\n" 355 " Set rate limit for queues in VF of a port\n\n" 356 357 "set port (port_id) mirror-rule (rule_id)" 358 "(pool-mirror|vlan-mirror)\n" 359 " (poolmask|vlanid[,vlanid]*) dst-pool (pool_id) (on|off)\n" 360 " Set pool or vlan type mirror rule on a port.\n" 361 " e.g., 'set port 0 mirror-rule 0 vlan-mirror 0,1" 362 " dst-pool 0 on' enable mirror traffic with vlan 0,1" 363 " to pool 0.\n\n" 364 365 "set port (port_id) mirror-rule (rule_id)" 366 " (uplink-mirror|downlink-mirror) dst-pool" 367 " (pool_id) (on|off)\n" 368 " Set uplink or downlink type mirror rule on a port.\n" 369 " e.g., 'set port 0 mirror-rule 0 uplink-mirror dst-pool" 370 " 0 on' enable mirror income traffic to pool 0.\n\n" 371 372 "reset port (port_id) mirror-rule (rule_id)\n" 373 " Reset a mirror rule.\n\n" 374 375 "set flush_rx (on|off)\n" 376 " Flush (default) or don't flush RX streams before" 377 " forwarding. Mainly used with PCAP drivers.\n\n" 378 379 #ifdef RTE_NIC_BYPASS 380 "set bypass mode (normal|bypass|isolate) (port_id)\n" 381 " Set the bypass mode for the lowest port on bypass enabled" 382 " NIC.\n\n" 383 384 "set bypass event (timeout|os_on|os_off|power_on|power_off) " 385 "mode (normal|bypass|isolate) (port_id)\n" 386 " Set the event required to initiate specified bypass mode for" 387 " the lowest port on a bypass enabled NIC where:\n" 388 " timeout = enable bypass after watchdog timeout.\n" 389 " os_on = enable bypass when OS/board is powered on.\n" 390 " os_off = enable bypass when OS/board is powered off.\n" 391 " power_on = enable bypass when power supply is turned on.\n" 392 " power_off = enable bypass when power supply is turned off." 393 "\n\n" 394 395 "set bypass timeout (0|1.5|2|3|4|8|16|32)\n" 396 " Set the bypass watchdog timeout to 'n' seconds" 397 " where 0 = instant.\n\n" 398 399 "show bypass config (port_id)\n" 400 " Show the bypass configuration for a bypass enabled NIC" 401 " using the lowest port on the NIC.\n\n" 402 #endif 403 404 , list_pkt_forwarding_modes() 405 ); 406 } 407 408 409 if (show_all || !strcmp(res->section, "flowdir")) { 410 411 cmdline_printf( 412 cl, 413 "\n" 414 "Flow director mode:\n" 415 "-------------------\n\n" 416 417 "add_signature_filter (port_id) (ip|udp|tcp|sctp)" 418 " src (src_ip_address) (src_port)" 419 " dst (dst_ip_address) (dst_port)" 420 " flexbytes (flexbytes_values) vlan (vlan_id)" 421 " queue (queue_id)\n" 422 " Add a signature filter.\n\n" 423 424 "upd_signature_filter (port_id) (ip|udp|tcp|sctp)" 425 " src (src_ip_address) (src_port)" 426 " dst (dst_ip_address) (dst_port)" 427 " flexbytes (flexbytes_values) vlan (vlan_id)" 428 " queue (queue_id)\n" 429 " Update a signature filter.\n\n" 430 431 "rm_signature_filter (port_id) (ip|udp|tcp|sctp)" 432 " src (src_ip_address) (src_port)" 433 " dst (dst_ip_address) (dst_port)" 434 " flexbytes (flexbytes_values) vlan (vlan_id)\n" 435 " Remove a signature filter.\n\n" 436 437 "add_perfect_filter (port_id) (ip|udp|tcp|sctp)" 438 " src (src_ip_address) (src_port)" 439 " dst (dst_ip_address) (dst_port)" 440 " flexbytes (flexbytes_values) vlan (vlan_id)" 441 " queue (queue_id) soft (soft_id)\n" 442 " Add a perfect filter.\n\n" 443 444 "upd_perfect_filter (port_id) (ip|udp|tcp|sctp)" 445 " src (src_ip_address) (src_port)" 446 " dst (dst_ip_address) (dst_port)" 447 " flexbytes (flexbytes_values) vlan (vlan_id)" 448 " queue (queue_id)\n" 449 " Update a perfect filter.\n\n" 450 451 "rm_perfect_filter (port_id) (ip|udp|tcp|sctp)" 452 " src (src_ip_address) (src_port)" 453 " dst (dst_ip_address) (dst_port)" 454 " flexbytes (flexbytes_values) vlan (vlan_id)" 455 " soft (soft_id)\n" 456 " Remove a perfect filter.\n\n" 457 458 "set_masks_filter (port_id) only_ip_flow (0|1)" 459 " src_mask (ip_src_mask) (src_port_mask)" 460 " dst_mask (ip_dst_mask) (dst_port_mask)" 461 " flexbytes (0|1) vlan_id (0|1) vlan_prio (0|1)\n" 462 " Set IPv4 filter masks.\n\n" 463 464 "set_ipv6_masks_filter (port_id) only_ip_flow (0|1)" 465 " src_mask (ip_src_mask) (src_port_mask)" 466 " dst_mask (ip_dst_mask) (dst_port_mask)" 467 " flexbytes (0|1) vlan_id (0|1) vlan_prio (0|1)" 468 " compare_dst (0|1)\n" 469 " Set IPv6 filter masks.\n\n" 470 ); 471 } 472 473 if (show_all || !strcmp(res->section, "ports")) { 474 475 cmdline_printf( 476 cl, 477 "\n" 478 "Port Operations:\n" 479 "----------------\n\n" 480 481 "port start (port_id|all)\n" 482 " Start all ports or port_id.\n\n" 483 484 "port stop (port_id|all)\n" 485 " Stop all ports or port_id.\n\n" 486 487 "port close (port_id|all)\n" 488 " Close all ports or port_id.\n\n" 489 490 "port config (port_id|all) speed (10|100|1000|10000|auto)" 491 " duplex (half|full|auto)\n" 492 " Set speed and duplex for all ports or port_id\n\n" 493 494 "port config all (rxq|txq|rxd|txd) (value)\n" 495 " Set number for rxq/txq/rxd/txd.\n\n" 496 497 "port config all max-pkt-len (value)\n" 498 " Set the max packet length.\n\n" 499 500 "port config all (crc-strip|rx-cksum|hw-vlan|drop-en)" 501 " (on|off)\n" 502 " Set crc-strip/rx-checksum/hardware-vlan/drop_en" 503 " for ports.\n\n" 504 505 "port config all rss (ip|udp|none)\n" 506 " Set the RSS mode.\n\n" 507 508 "port config port-id rss reta (hash,queue)[,(hash,queue)]\n" 509 " Set the RSS redirection table.\n\n" 510 511 "port config (port_id) dcb vt (on|off) (traffic_class)" 512 " pfc (on|off)\n" 513 " Set the DCB mode.\n\n" 514 515 "port config all burst (value)\n" 516 " Set the number of packets per burst.\n\n" 517 518 "port config all (txpt|txht|txwt|rxpt|rxht|rxwt)" 519 " (value)\n" 520 " Set the ring prefetch/host/writeback threshold" 521 " for tx/rx queue.\n\n" 522 523 "port config all (txfreet|txrst|rxfreet) (value)\n" 524 " Set free threshold for rx/tx, or set" 525 " tx rs bit threshold.\n\n" 526 ); 527 } 528 529 if (show_all || !strcmp(res->section, "registers")) { 530 531 cmdline_printf( 532 cl, 533 "\n" 534 "Registers:\n" 535 "----------\n\n" 536 537 "read reg (port_id) (address)\n" 538 " Display value of a port register.\n\n" 539 540 "read regfield (port_id) (address) (bit_x) (bit_y)\n" 541 " Display a port register bit field.\n\n" 542 543 "read regbit (port_id) (address) (bit_x)\n" 544 " Display a single port register bit.\n\n" 545 546 "write reg (port_id) (address) (value)\n" 547 " Set value of a port register.\n\n" 548 549 "write regfield (port_id) (address) (bit_x) (bit_y)" 550 " (value)\n" 551 " Set bit field of a port register.\n\n" 552 553 "write regbit (port_id) (address) (bit_x) (value)\n" 554 " Set single bit value of a port register.\n\n" 555 ); 556 } 557 } 558 559 cmdline_parse_token_string_t cmd_help_long_help = 560 TOKEN_STRING_INITIALIZER(struct cmd_help_long_result, help, "help"); 561 562 cmdline_parse_token_string_t cmd_help_long_section = 563 TOKEN_STRING_INITIALIZER(struct cmd_help_long_result, section, 564 "all#control#display#config#flowdir#" 565 "ports#registers"); 566 567 cmdline_parse_inst_t cmd_help_long = { 568 .f = cmd_help_long_parsed, 569 .data = NULL, 570 .help_str = "show help", 571 .tokens = { 572 (void *)&cmd_help_long_help, 573 (void *)&cmd_help_long_section, 574 NULL, 575 }, 576 }; 577 578 579 /* *** start/stop/close all ports *** */ 580 struct cmd_operate_port_result { 581 cmdline_fixed_string_t keyword; 582 cmdline_fixed_string_t name; 583 cmdline_fixed_string_t value; 584 }; 585 586 static void cmd_operate_port_parsed(void *parsed_result, 587 __attribute__((unused)) struct cmdline *cl, 588 __attribute__((unused)) void *data) 589 { 590 struct cmd_operate_port_result *res = parsed_result; 591 592 if (!strcmp(res->name, "start")) 593 start_port(RTE_PORT_ALL); 594 else if (!strcmp(res->name, "stop")) 595 stop_port(RTE_PORT_ALL); 596 else if (!strcmp(res->name, "close")) 597 close_port(RTE_PORT_ALL); 598 else 599 printf("Unknown parameter\n"); 600 } 601 602 cmdline_parse_token_string_t cmd_operate_port_all_cmd = 603 TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, keyword, 604 "port"); 605 cmdline_parse_token_string_t cmd_operate_port_all_port = 606 TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, name, 607 "start#stop#close"); 608 cmdline_parse_token_string_t cmd_operate_port_all_all = 609 TOKEN_STRING_INITIALIZER(struct cmd_operate_port_result, value, "all"); 610 611 cmdline_parse_inst_t cmd_operate_port = { 612 .f = cmd_operate_port_parsed, 613 .data = NULL, 614 .help_str = "port start|stop|close all: start/stop/close all ports", 615 .tokens = { 616 (void *)&cmd_operate_port_all_cmd, 617 (void *)&cmd_operate_port_all_port, 618 (void *)&cmd_operate_port_all_all, 619 NULL, 620 }, 621 }; 622 623 /* *** start/stop/close specific port *** */ 624 struct cmd_operate_specific_port_result { 625 cmdline_fixed_string_t keyword; 626 cmdline_fixed_string_t name; 627 uint8_t value; 628 }; 629 630 static void cmd_operate_specific_port_parsed(void *parsed_result, 631 __attribute__((unused)) struct cmdline *cl, 632 __attribute__((unused)) void *data) 633 { 634 struct cmd_operate_specific_port_result *res = parsed_result; 635 636 if (!strcmp(res->name, "start")) 637 start_port(res->value); 638 else if (!strcmp(res->name, "stop")) 639 stop_port(res->value); 640 else if (!strcmp(res->name, "close")) 641 close_port(res->value); 642 else 643 printf("Unknown parameter\n"); 644 } 645 646 cmdline_parse_token_string_t cmd_operate_specific_port_cmd = 647 TOKEN_STRING_INITIALIZER(struct cmd_operate_specific_port_result, 648 keyword, "port"); 649 cmdline_parse_token_string_t cmd_operate_specific_port_port = 650 TOKEN_STRING_INITIALIZER(struct cmd_operate_specific_port_result, 651 name, "start#stop#close"); 652 cmdline_parse_token_num_t cmd_operate_specific_port_id = 653 TOKEN_NUM_INITIALIZER(struct cmd_operate_specific_port_result, 654 value, UINT8); 655 656 cmdline_parse_inst_t cmd_operate_specific_port = { 657 .f = cmd_operate_specific_port_parsed, 658 .data = NULL, 659 .help_str = "port start|stop|close X: start/stop/close port X", 660 .tokens = { 661 (void *)&cmd_operate_specific_port_cmd, 662 (void *)&cmd_operate_specific_port_port, 663 (void *)&cmd_operate_specific_port_id, 664 NULL, 665 }, 666 }; 667 668 /* *** configure speed for all ports *** */ 669 struct cmd_config_speed_all { 670 cmdline_fixed_string_t port; 671 cmdline_fixed_string_t keyword; 672 cmdline_fixed_string_t all; 673 cmdline_fixed_string_t item1; 674 cmdline_fixed_string_t item2; 675 cmdline_fixed_string_t value1; 676 cmdline_fixed_string_t value2; 677 }; 678 679 static void 680 cmd_config_speed_all_parsed(void *parsed_result, 681 __attribute__((unused)) struct cmdline *cl, 682 __attribute__((unused)) void *data) 683 { 684 struct cmd_config_speed_all *res = parsed_result; 685 uint16_t link_speed = ETH_LINK_SPEED_AUTONEG; 686 uint16_t link_duplex = 0; 687 portid_t pid; 688 689 if (!all_ports_stopped()) { 690 printf("Please stop all ports first\n"); 691 return; 692 } 693 694 if (!strcmp(res->value1, "10")) 695 link_speed = ETH_LINK_SPEED_10; 696 else if (!strcmp(res->value1, "100")) 697 link_speed = ETH_LINK_SPEED_100; 698 else if (!strcmp(res->value1, "1000")) 699 link_speed = ETH_LINK_SPEED_1000; 700 else if (!strcmp(res->value1, "10000")) 701 link_speed = ETH_LINK_SPEED_10000; 702 else if (!strcmp(res->value1, "auto")) 703 link_speed = ETH_LINK_SPEED_AUTONEG; 704 else { 705 printf("Unknown parameter\n"); 706 return; 707 } 708 709 if (!strcmp(res->value2, "half")) 710 link_duplex = ETH_LINK_HALF_DUPLEX; 711 else if (!strcmp(res->value2, "full")) 712 link_duplex = ETH_LINK_FULL_DUPLEX; 713 else if (!strcmp(res->value2, "auto")) 714 link_duplex = ETH_LINK_AUTONEG_DUPLEX; 715 else { 716 printf("Unknown parameter\n"); 717 return; 718 } 719 720 for (pid = 0; pid < nb_ports; pid++) { 721 ports[pid].dev_conf.link_speed = link_speed; 722 ports[pid].dev_conf.link_duplex = link_duplex; 723 } 724 725 cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); 726 } 727 728 cmdline_parse_token_string_t cmd_config_speed_all_port = 729 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, port, "port"); 730 cmdline_parse_token_string_t cmd_config_speed_all_keyword = 731 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, keyword, 732 "config"); 733 cmdline_parse_token_string_t cmd_config_speed_all_all = 734 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, all, "all"); 735 cmdline_parse_token_string_t cmd_config_speed_all_item1 = 736 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, item1, "speed"); 737 cmdline_parse_token_string_t cmd_config_speed_all_value1 = 738 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, value1, 739 "10#100#1000#10000#auto"); 740 cmdline_parse_token_string_t cmd_config_speed_all_item2 = 741 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, item2, "duplex"); 742 cmdline_parse_token_string_t cmd_config_speed_all_value2 = 743 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_all, value2, 744 "half#full#auto"); 745 746 cmdline_parse_inst_t cmd_config_speed_all = { 747 .f = cmd_config_speed_all_parsed, 748 .data = NULL, 749 .help_str = "port config all speed 10|100|1000|10000|auto duplex " 750 "half|full|auto", 751 .tokens = { 752 (void *)&cmd_config_speed_all_port, 753 (void *)&cmd_config_speed_all_keyword, 754 (void *)&cmd_config_speed_all_all, 755 (void *)&cmd_config_speed_all_item1, 756 (void *)&cmd_config_speed_all_value1, 757 (void *)&cmd_config_speed_all_item2, 758 (void *)&cmd_config_speed_all_value2, 759 NULL, 760 }, 761 }; 762 763 /* *** configure speed for specific port *** */ 764 struct cmd_config_speed_specific { 765 cmdline_fixed_string_t port; 766 cmdline_fixed_string_t keyword; 767 uint8_t id; 768 cmdline_fixed_string_t item1; 769 cmdline_fixed_string_t item2; 770 cmdline_fixed_string_t value1; 771 cmdline_fixed_string_t value2; 772 }; 773 774 static void 775 cmd_config_speed_specific_parsed(void *parsed_result, 776 __attribute__((unused)) struct cmdline *cl, 777 __attribute__((unused)) void *data) 778 { 779 struct cmd_config_speed_specific *res = parsed_result; 780 uint16_t link_speed = ETH_LINK_SPEED_AUTONEG; 781 uint16_t link_duplex = 0; 782 783 if (!all_ports_stopped()) { 784 printf("Please stop all ports first\n"); 785 return; 786 } 787 788 if (res->id >= nb_ports) { 789 printf("Port id %d must be less than %d\n", res->id, nb_ports); 790 return; 791 } 792 793 if (!strcmp(res->value1, "10")) 794 link_speed = ETH_LINK_SPEED_10; 795 else if (!strcmp(res->value1, "100")) 796 link_speed = ETH_LINK_SPEED_100; 797 else if (!strcmp(res->value1, "1000")) 798 link_speed = ETH_LINK_SPEED_1000; 799 else if (!strcmp(res->value1, "10000")) 800 link_speed = ETH_LINK_SPEED_10000; 801 else if (!strcmp(res->value1, "auto")) 802 link_speed = ETH_LINK_SPEED_AUTONEG; 803 else { 804 printf("Unknown parameter\n"); 805 return; 806 } 807 808 if (!strcmp(res->value2, "half")) 809 link_duplex = ETH_LINK_HALF_DUPLEX; 810 else if (!strcmp(res->value2, "full")) 811 link_duplex = ETH_LINK_FULL_DUPLEX; 812 else if (!strcmp(res->value2, "auto")) 813 link_duplex = ETH_LINK_AUTONEG_DUPLEX; 814 else { 815 printf("Unknown parameter\n"); 816 return; 817 } 818 819 ports[res->id].dev_conf.link_speed = link_speed; 820 ports[res->id].dev_conf.link_duplex = link_duplex; 821 822 cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); 823 } 824 825 826 cmdline_parse_token_string_t cmd_config_speed_specific_port = 827 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, port, 828 "port"); 829 cmdline_parse_token_string_t cmd_config_speed_specific_keyword = 830 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, keyword, 831 "config"); 832 cmdline_parse_token_num_t cmd_config_speed_specific_id = 833 TOKEN_NUM_INITIALIZER(struct cmd_config_speed_specific, id, UINT8); 834 cmdline_parse_token_string_t cmd_config_speed_specific_item1 = 835 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item1, 836 "speed"); 837 cmdline_parse_token_string_t cmd_config_speed_specific_value1 = 838 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, value1, 839 "10#100#1000#10000#auto"); 840 cmdline_parse_token_string_t cmd_config_speed_specific_item2 = 841 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item2, 842 "duplex"); 843 cmdline_parse_token_string_t cmd_config_speed_specific_value2 = 844 TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, value2, 845 "half#full#auto"); 846 847 cmdline_parse_inst_t cmd_config_speed_specific = { 848 .f = cmd_config_speed_specific_parsed, 849 .data = NULL, 850 .help_str = "port config X speed 10|100|1000|10000|auto duplex " 851 "half|full|auto", 852 .tokens = { 853 (void *)&cmd_config_speed_specific_port, 854 (void *)&cmd_config_speed_specific_keyword, 855 (void *)&cmd_config_speed_specific_id, 856 (void *)&cmd_config_speed_specific_item1, 857 (void *)&cmd_config_speed_specific_value1, 858 (void *)&cmd_config_speed_specific_item2, 859 (void *)&cmd_config_speed_specific_value2, 860 NULL, 861 }, 862 }; 863 864 /* *** configure txq/rxq, txd/rxd *** */ 865 struct cmd_config_rx_tx { 866 cmdline_fixed_string_t port; 867 cmdline_fixed_string_t keyword; 868 cmdline_fixed_string_t all; 869 cmdline_fixed_string_t name; 870 uint16_t value; 871 }; 872 873 static void 874 cmd_config_rx_tx_parsed(void *parsed_result, 875 __attribute__((unused)) struct cmdline *cl, 876 __attribute__((unused)) void *data) 877 { 878 struct cmd_config_rx_tx *res = parsed_result; 879 880 if (!all_ports_stopped()) { 881 printf("Please stop all ports first\n"); 882 return; 883 } 884 885 if (!strcmp(res->name, "rxq")) { 886 if (res->value <= 0) { 887 printf("rxq %d invalid - must be > 0\n", res->value); 888 return; 889 } 890 nb_rxq = res->value; 891 } 892 else if (!strcmp(res->name, "txq")) { 893 if (res->value <= 0) { 894 printf("txq %d invalid - must be > 0\n", res->value); 895 return; 896 } 897 nb_txq = res->value; 898 } 899 else if (!strcmp(res->name, "rxd")) { 900 if (res->value <= 0 || res->value > RTE_TEST_RX_DESC_MAX) { 901 printf("rxd %d invalid - must be > 0 && <= %d\n", 902 res->value, RTE_TEST_RX_DESC_MAX); 903 return; 904 } 905 nb_rxd = res->value; 906 } else if (!strcmp(res->name, "txd")) { 907 if (res->value <= 0 || res->value > RTE_TEST_TX_DESC_MAX) { 908 printf("txd %d invalid - must be > 0 && <= %d\n", 909 res->value, RTE_TEST_TX_DESC_MAX); 910 return; 911 } 912 nb_txd = res->value; 913 } else { 914 printf("Unknown parameter\n"); 915 return; 916 } 917 918 init_port_config(); 919 920 cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); 921 } 922 923 cmdline_parse_token_string_t cmd_config_rx_tx_port = 924 TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, port, "port"); 925 cmdline_parse_token_string_t cmd_config_rx_tx_keyword = 926 TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, keyword, "config"); 927 cmdline_parse_token_string_t cmd_config_rx_tx_all = 928 TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, all, "all"); 929 cmdline_parse_token_string_t cmd_config_rx_tx_name = 930 TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, name, 931 "rxq#txq#rxd#txd"); 932 cmdline_parse_token_num_t cmd_config_rx_tx_value = 933 TOKEN_NUM_INITIALIZER(struct cmd_config_rx_tx, value, UINT16); 934 935 cmdline_parse_inst_t cmd_config_rx_tx = { 936 .f = cmd_config_rx_tx_parsed, 937 .data = NULL, 938 .help_str = "port config all rxq|txq|rxd|txd value", 939 .tokens = { 940 (void *)&cmd_config_rx_tx_port, 941 (void *)&cmd_config_rx_tx_keyword, 942 (void *)&cmd_config_rx_tx_all, 943 (void *)&cmd_config_rx_tx_name, 944 (void *)&cmd_config_rx_tx_value, 945 NULL, 946 }, 947 }; 948 949 /* *** config max packet length *** */ 950 struct cmd_config_max_pkt_len_result { 951 cmdline_fixed_string_t port; 952 cmdline_fixed_string_t keyword; 953 cmdline_fixed_string_t all; 954 cmdline_fixed_string_t name; 955 uint32_t value; 956 }; 957 958 static void 959 cmd_config_max_pkt_len_parsed(void *parsed_result, 960 __attribute__((unused)) struct cmdline *cl, 961 __attribute__((unused)) void *data) 962 { 963 struct cmd_config_max_pkt_len_result *res = parsed_result; 964 965 if (!all_ports_stopped()) { 966 printf("Please stop all ports first\n"); 967 return; 968 } 969 970 if (!strcmp(res->name, "max-pkt-len")) { 971 if (res->value < ETHER_MIN_LEN) { 972 printf("max-pkt-len can not be less than %d\n", 973 ETHER_MIN_LEN); 974 return; 975 } 976 if (res->value == rx_mode.max_rx_pkt_len) 977 return; 978 979 rx_mode.max_rx_pkt_len = res->value; 980 if (res->value > ETHER_MAX_LEN) 981 rx_mode.jumbo_frame = 1; 982 else 983 rx_mode.jumbo_frame = 0; 984 } else { 985 printf("Unknown parameter\n"); 986 return; 987 } 988 989 init_port_config(); 990 991 cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); 992 } 993 994 cmdline_parse_token_string_t cmd_config_max_pkt_len_port = 995 TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, port, 996 "port"); 997 cmdline_parse_token_string_t cmd_config_max_pkt_len_keyword = 998 TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, keyword, 999 "config"); 1000 cmdline_parse_token_string_t cmd_config_max_pkt_len_all = 1001 TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, all, 1002 "all"); 1003 cmdline_parse_token_string_t cmd_config_max_pkt_len_name = 1004 TOKEN_STRING_INITIALIZER(struct cmd_config_max_pkt_len_result, name, 1005 "max-pkt-len"); 1006 cmdline_parse_token_num_t cmd_config_max_pkt_len_value = 1007 TOKEN_NUM_INITIALIZER(struct cmd_config_max_pkt_len_result, value, 1008 UINT32); 1009 1010 cmdline_parse_inst_t cmd_config_max_pkt_len = { 1011 .f = cmd_config_max_pkt_len_parsed, 1012 .data = NULL, 1013 .help_str = "port config all max-pkt-len value", 1014 .tokens = { 1015 (void *)&cmd_config_max_pkt_len_port, 1016 (void *)&cmd_config_max_pkt_len_keyword, 1017 (void *)&cmd_config_max_pkt_len_all, 1018 (void *)&cmd_config_max_pkt_len_name, 1019 (void *)&cmd_config_max_pkt_len_value, 1020 NULL, 1021 }, 1022 }; 1023 1024 /* *** configure rx mode *** */ 1025 struct cmd_config_rx_mode_flag { 1026 cmdline_fixed_string_t port; 1027 cmdline_fixed_string_t keyword; 1028 cmdline_fixed_string_t all; 1029 cmdline_fixed_string_t name; 1030 cmdline_fixed_string_t value; 1031 }; 1032 1033 static void 1034 cmd_config_rx_mode_flag_parsed(void *parsed_result, 1035 __attribute__((unused)) struct cmdline *cl, 1036 __attribute__((unused)) void *data) 1037 { 1038 struct cmd_config_rx_mode_flag *res = parsed_result; 1039 1040 if (!all_ports_stopped()) { 1041 printf("Please stop all ports first\n"); 1042 return; 1043 } 1044 1045 if (!strcmp(res->name, "crc-strip")) { 1046 if (!strcmp(res->value, "on")) 1047 rx_mode.hw_strip_crc = 1; 1048 else if (!strcmp(res->value, "off")) 1049 rx_mode.hw_strip_crc = 0; 1050 else { 1051 printf("Unknown parameter\n"); 1052 return; 1053 } 1054 } else if (!strcmp(res->name, "rx-cksum")) { 1055 if (!strcmp(res->value, "on")) 1056 rx_mode.hw_ip_checksum = 1; 1057 else if (!strcmp(res->value, "off")) 1058 rx_mode.hw_ip_checksum = 0; 1059 else { 1060 printf("Unknown parameter\n"); 1061 return; 1062 } 1063 } else if (!strcmp(res->name, "hw-vlan")) { 1064 if (!strcmp(res->value, "on")) { 1065 rx_mode.hw_vlan_filter = 1; 1066 rx_mode.hw_vlan_strip = 1; 1067 } 1068 else if (!strcmp(res->value, "off")) { 1069 rx_mode.hw_vlan_filter = 0; 1070 rx_mode.hw_vlan_strip = 0; 1071 } 1072 else { 1073 printf("Unknown parameter\n"); 1074 return; 1075 } 1076 } else if (!strcmp(res->name, "drop-en")) { 1077 if (!strcmp(res->value, "on")) 1078 rx_drop_en = 1; 1079 else if (!strcmp(res->value, "off")) 1080 rx_drop_en = 0; 1081 else { 1082 printf("Unknown parameter\n"); 1083 return; 1084 } 1085 } else { 1086 printf("Unknown parameter\n"); 1087 return; 1088 } 1089 1090 init_port_config(); 1091 1092 cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); 1093 } 1094 1095 cmdline_parse_token_string_t cmd_config_rx_mode_flag_port = 1096 TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, port, "port"); 1097 cmdline_parse_token_string_t cmd_config_rx_mode_flag_keyword = 1098 TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, keyword, 1099 "config"); 1100 cmdline_parse_token_string_t cmd_config_rx_mode_flag_all = 1101 TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, all, "all"); 1102 cmdline_parse_token_string_t cmd_config_rx_mode_flag_name = 1103 TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, name, 1104 "crc-strip#rx-cksum#hw-vlan"); 1105 cmdline_parse_token_string_t cmd_config_rx_mode_flag_value = 1106 TOKEN_STRING_INITIALIZER(struct cmd_config_rx_mode_flag, value, 1107 "on#off"); 1108 1109 cmdline_parse_inst_t cmd_config_rx_mode_flag = { 1110 .f = cmd_config_rx_mode_flag_parsed, 1111 .data = NULL, 1112 .help_str = "port config all crc-strip|rx-cksum|hw-vlan on|off", 1113 .tokens = { 1114 (void *)&cmd_config_rx_mode_flag_port, 1115 (void *)&cmd_config_rx_mode_flag_keyword, 1116 (void *)&cmd_config_rx_mode_flag_all, 1117 (void *)&cmd_config_rx_mode_flag_name, 1118 (void *)&cmd_config_rx_mode_flag_value, 1119 NULL, 1120 }, 1121 }; 1122 1123 /* *** configure rss *** */ 1124 struct cmd_config_rss { 1125 cmdline_fixed_string_t port; 1126 cmdline_fixed_string_t keyword; 1127 cmdline_fixed_string_t all; 1128 cmdline_fixed_string_t name; 1129 cmdline_fixed_string_t value; 1130 }; 1131 1132 static void 1133 cmd_config_rss_parsed(void *parsed_result, 1134 __attribute__((unused)) struct cmdline *cl, 1135 __attribute__((unused)) void *data) 1136 { 1137 struct cmd_config_rss *res = parsed_result; 1138 struct rte_eth_rss_conf rss_conf; 1139 uint8_t i; 1140 1141 if (!strcmp(res->value, "ip")) 1142 rss_conf.rss_hf = ETH_RSS_IPV4 | ETH_RSS_IPV6; 1143 else if (!strcmp(res->value, "udp")) 1144 rss_conf.rss_hf = ETH_RSS_IPV4_UDP | ETH_RSS_IPV6_UDP; 1145 else if (!strcmp(res->value, "none")) 1146 rss_conf.rss_hf = 0; 1147 else { 1148 printf("Unknown parameter\n"); 1149 return; 1150 } 1151 rss_conf.rss_key = NULL; 1152 for (i = 0; i < rte_eth_dev_count(); i++) 1153 rte_eth_dev_rss_hash_update(i, &rss_conf); 1154 } 1155 1156 cmdline_parse_token_string_t cmd_config_rss_port = 1157 TOKEN_STRING_INITIALIZER(struct cmd_config_rss, port, "port"); 1158 cmdline_parse_token_string_t cmd_config_rss_keyword = 1159 TOKEN_STRING_INITIALIZER(struct cmd_config_rss, keyword, "config"); 1160 cmdline_parse_token_string_t cmd_config_rss_all = 1161 TOKEN_STRING_INITIALIZER(struct cmd_config_rss, all, "all"); 1162 cmdline_parse_token_string_t cmd_config_rss_name = 1163 TOKEN_STRING_INITIALIZER(struct cmd_config_rss, name, "rss"); 1164 cmdline_parse_token_string_t cmd_config_rss_value = 1165 TOKEN_STRING_INITIALIZER(struct cmd_config_rss, value, "ip#udp#none"); 1166 1167 cmdline_parse_inst_t cmd_config_rss = { 1168 .f = cmd_config_rss_parsed, 1169 .data = NULL, 1170 .help_str = "port config all rss ip|udp|none", 1171 .tokens = { 1172 (void *)&cmd_config_rss_port, 1173 (void *)&cmd_config_rss_keyword, 1174 (void *)&cmd_config_rss_all, 1175 (void *)&cmd_config_rss_name, 1176 (void *)&cmd_config_rss_value, 1177 NULL, 1178 }, 1179 }; 1180 1181 /* *** configure rss hash key *** */ 1182 struct cmd_config_rss_hash_key { 1183 cmdline_fixed_string_t port; 1184 cmdline_fixed_string_t config; 1185 uint8_t port_id; 1186 cmdline_fixed_string_t rss_hash_key; 1187 cmdline_fixed_string_t key; 1188 }; 1189 1190 #define RSS_HASH_KEY_LENGTH 40 1191 static uint8_t 1192 hexa_digit_to_value(char hexa_digit) 1193 { 1194 if ((hexa_digit >= '0') && (hexa_digit <= '9')) 1195 return (uint8_t) (hexa_digit - '0'); 1196 if ((hexa_digit >= 'a') && (hexa_digit <= 'f')) 1197 return (uint8_t) ((hexa_digit - 'a') + 10); 1198 if ((hexa_digit >= 'A') && (hexa_digit <= 'F')) 1199 return (uint8_t) ((hexa_digit - 'A') + 10); 1200 /* Invalid hexa digit */ 1201 return 0xFF; 1202 } 1203 1204 static uint8_t 1205 parse_and_check_key_hexa_digit(char *key, int idx) 1206 { 1207 uint8_t hexa_v; 1208 1209 hexa_v = hexa_digit_to_value(key[idx]); 1210 if (hexa_v == 0xFF) 1211 printf("invalid key: character %c at position %d is not a " 1212 "valid hexa digit\n", key[idx], idx); 1213 return hexa_v; 1214 } 1215 1216 static void 1217 cmd_config_rss_hash_key_parsed(void *parsed_result, 1218 __attribute__((unused)) struct cmdline *cl, 1219 __attribute__((unused)) void *data) 1220 { 1221 struct cmd_config_rss_hash_key *res = parsed_result; 1222 uint8_t hash_key[RSS_HASH_KEY_LENGTH]; 1223 uint8_t xdgt0; 1224 uint8_t xdgt1; 1225 int i; 1226 1227 /* Check the length of the RSS hash key */ 1228 if (strlen(res->key) != (RSS_HASH_KEY_LENGTH * 2)) { 1229 printf("key length: %d invalid - key must be a string of %d" 1230 "hexa-decimal numbers\n", (int) strlen(res->key), 1231 RSS_HASH_KEY_LENGTH * 2); 1232 return; 1233 } 1234 /* Translate RSS hash key into binary representation */ 1235 for (i = 0; i < RSS_HASH_KEY_LENGTH; i++) { 1236 xdgt0 = parse_and_check_key_hexa_digit(res->key, (i * 2)); 1237 if (xdgt0 == 0xFF) 1238 return; 1239 xdgt1 = parse_and_check_key_hexa_digit(res->key, (i * 2) + 1); 1240 if (xdgt1 == 0xFF) 1241 return; 1242 hash_key[i] = (uint8_t) ((xdgt0 * 16) + xdgt1); 1243 } 1244 port_rss_hash_key_update(res->port_id, hash_key); 1245 } 1246 1247 cmdline_parse_token_string_t cmd_config_rss_hash_key_port = 1248 TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, port, "port"); 1249 cmdline_parse_token_string_t cmd_config_rss_hash_key_config = 1250 TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, config, 1251 "config"); 1252 cmdline_parse_token_string_t cmd_config_rss_hash_key_port_id = 1253 TOKEN_NUM_INITIALIZER(struct cmd_config_rss_hash_key, port_id, UINT8); 1254 cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_hash_key = 1255 TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, 1256 rss_hash_key, "rss-hash-key"); 1257 cmdline_parse_token_string_t cmd_config_rss_hash_key_value = 1258 TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, key, NULL); 1259 1260 cmdline_parse_inst_t cmd_config_rss_hash_key = { 1261 .f = cmd_config_rss_hash_key_parsed, 1262 .data = NULL, 1263 .help_str = "port config X rss-hash-key 80 hexa digits", 1264 .tokens = { 1265 (void *)&cmd_config_rss_hash_key_port, 1266 (void *)&cmd_config_rss_hash_key_config, 1267 (void *)&cmd_config_rss_hash_key_port_id, 1268 (void *)&cmd_config_rss_hash_key_rss_hash_key, 1269 (void *)&cmd_config_rss_hash_key_value, 1270 NULL, 1271 }, 1272 }; 1273 1274 /* *** Configure RSS RETA *** */ 1275 struct cmd_config_rss_reta { 1276 cmdline_fixed_string_t port; 1277 cmdline_fixed_string_t keyword; 1278 uint8_t port_id; 1279 cmdline_fixed_string_t name; 1280 cmdline_fixed_string_t list_name; 1281 cmdline_fixed_string_t list_of_items; 1282 }; 1283 1284 static int 1285 parse_reta_config(const char *str, struct rte_eth_rss_reta *reta_conf) 1286 { 1287 int i; 1288 unsigned size; 1289 uint8_t hash_index; 1290 uint8_t nb_queue; 1291 char s[256]; 1292 const char *p, *p0 = str; 1293 char *end; 1294 enum fieldnames { 1295 FLD_HASH_INDEX = 0, 1296 FLD_QUEUE, 1297 _NUM_FLD 1298 }; 1299 unsigned long int_fld[_NUM_FLD]; 1300 char *str_fld[_NUM_FLD]; 1301 1302 while ((p = strchr(p0,'(')) != NULL) { 1303 ++p; 1304 if((p0 = strchr(p,')')) == NULL) 1305 return -1; 1306 1307 size = p0 - p; 1308 if(size >= sizeof(s)) 1309 return -1; 1310 1311 rte_snprintf(s, sizeof(s), "%.*s", size, p); 1312 if (rte_strsplit(s, sizeof(s), str_fld, _NUM_FLD, ',') != _NUM_FLD) 1313 return -1; 1314 for (i = 0; i < _NUM_FLD; i++) { 1315 errno = 0; 1316 int_fld[i] = strtoul(str_fld[i], &end, 0); 1317 if (errno != 0 || end == str_fld[i] || int_fld[i] > 255) 1318 return -1; 1319 } 1320 1321 hash_index = (uint8_t)int_fld[FLD_HASH_INDEX]; 1322 nb_queue = (uint8_t)int_fld[FLD_QUEUE]; 1323 1324 if (hash_index >= ETH_RSS_RETA_NUM_ENTRIES) { 1325 printf("Invalid RETA hash index=%d",hash_index); 1326 return -1; 1327 } 1328 1329 if (hash_index < ETH_RSS_RETA_NUM_ENTRIES/2) 1330 reta_conf->mask_lo |= (1ULL << hash_index); 1331 else 1332 reta_conf->mask_hi |= (1ULL << (hash_index - ETH_RSS_RETA_NUM_ENTRIES/2)); 1333 1334 reta_conf->reta[hash_index] = nb_queue; 1335 } 1336 1337 return 0; 1338 } 1339 1340 static void 1341 cmd_set_rss_reta_parsed(void *parsed_result, 1342 __attribute__((unused)) struct cmdline *cl, 1343 __attribute__((unused)) void *data) 1344 { 1345 int ret; 1346 struct rte_eth_rss_reta reta_conf; 1347 struct cmd_config_rss_reta *res = parsed_result; 1348 1349 memset(&reta_conf,0,sizeof(struct rte_eth_rss_reta)); 1350 if (!strcmp(res->list_name, "reta")) { 1351 if (parse_reta_config(res->list_of_items, &reta_conf)) { 1352 printf("Invalid RSS Redirection Table config entered\n"); 1353 return; 1354 } 1355 ret = rte_eth_dev_rss_reta_update(res->port_id, &reta_conf); 1356 if (ret != 0) 1357 printf("Bad redirection table parameter, return code = %d \n",ret); 1358 } 1359 } 1360 1361 cmdline_parse_token_string_t cmd_config_rss_reta_port = 1362 TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, port, "port"); 1363 cmdline_parse_token_string_t cmd_config_rss_reta_keyword = 1364 TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, keyword, "config"); 1365 cmdline_parse_token_num_t cmd_config_rss_reta_port_id = 1366 TOKEN_NUM_INITIALIZER(struct cmd_config_rss_reta, port_id, UINT8); 1367 cmdline_parse_token_string_t cmd_config_rss_reta_name = 1368 TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, name, "rss"); 1369 cmdline_parse_token_string_t cmd_config_rss_reta_list_name = 1370 TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, list_name, "reta"); 1371 cmdline_parse_token_string_t cmd_config_rss_reta_list_of_items = 1372 TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, list_of_items, 1373 NULL); 1374 cmdline_parse_inst_t cmd_config_rss_reta = { 1375 .f = cmd_set_rss_reta_parsed, 1376 .data = NULL, 1377 .help_str = "port config X rss reta (hash,queue)[,(hash,queue)]", 1378 .tokens = { 1379 (void *)&cmd_config_rss_reta_port, 1380 (void *)&cmd_config_rss_reta_keyword, 1381 (void *)&cmd_config_rss_reta_port_id, 1382 (void *)&cmd_config_rss_reta_name, 1383 (void *)&cmd_config_rss_reta_list_name, 1384 (void *)&cmd_config_rss_reta_list_of_items, 1385 NULL, 1386 }, 1387 }; 1388 1389 /* *** SHOW PORT RETA INFO *** */ 1390 struct cmd_showport_reta { 1391 cmdline_fixed_string_t show; 1392 cmdline_fixed_string_t port; 1393 uint8_t port_id; 1394 cmdline_fixed_string_t rss; 1395 cmdline_fixed_string_t reta; 1396 uint64_t mask_lo; 1397 uint64_t mask_hi; 1398 }; 1399 1400 static void cmd_showport_reta_parsed(void *parsed_result, 1401 __attribute__((unused)) struct cmdline *cl, 1402 __attribute__((unused)) void *data) 1403 { 1404 struct cmd_showport_reta *res = parsed_result; 1405 struct rte_eth_rss_reta reta_conf; 1406 1407 if ((res->mask_lo == 0) && (res->mask_hi == 0)) { 1408 printf("Invalid RSS Redirection Table config entered\n"); 1409 return; 1410 } 1411 1412 reta_conf.mask_lo = res->mask_lo; 1413 reta_conf.mask_hi = res->mask_hi; 1414 1415 port_rss_reta_info(res->port_id,&reta_conf); 1416 } 1417 1418 cmdline_parse_token_string_t cmd_showport_reta_show = 1419 TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, show, "show"); 1420 cmdline_parse_token_string_t cmd_showport_reta_port = 1421 TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, port, "port"); 1422 cmdline_parse_token_num_t cmd_showport_reta_port_id = 1423 TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, port_id, UINT8); 1424 cmdline_parse_token_string_t cmd_showport_reta_rss = 1425 TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, rss, "rss"); 1426 cmdline_parse_token_string_t cmd_showport_reta_reta = 1427 TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, reta, "reta"); 1428 cmdline_parse_token_num_t cmd_showport_reta_mask_lo = 1429 TOKEN_NUM_INITIALIZER(struct cmd_showport_reta,mask_lo,UINT64); 1430 cmdline_parse_token_num_t cmd_showport_reta_mask_hi = 1431 TOKEN_NUM_INITIALIZER(struct cmd_showport_reta,mask_hi,UINT64); 1432 1433 cmdline_parse_inst_t cmd_showport_reta = { 1434 .f = cmd_showport_reta_parsed, 1435 .data = NULL, 1436 .help_str = "show port X rss reta mask_lo mask_hi (X = port number)\n\ 1437 (mask_lo and mask_hi is UINT64)", 1438 .tokens = { 1439 (void *)&cmd_showport_reta_show, 1440 (void *)&cmd_showport_reta_port, 1441 (void *)&cmd_showport_reta_port_id, 1442 (void *)&cmd_showport_reta_rss, 1443 (void *)&cmd_showport_reta_reta, 1444 (void *)&cmd_showport_reta_mask_lo, 1445 (void *)&cmd_showport_reta_mask_hi, 1446 NULL, 1447 }, 1448 }; 1449 1450 /* *** Show RSS hash configuration *** */ 1451 struct cmd_showport_rss_hash { 1452 cmdline_fixed_string_t show; 1453 cmdline_fixed_string_t port; 1454 uint8_t port_id; 1455 cmdline_fixed_string_t rss_hash; 1456 cmdline_fixed_string_t key; /* optional argument */ 1457 }; 1458 1459 static void cmd_showport_rss_hash_parsed(void *parsed_result, 1460 __attribute__((unused)) struct cmdline *cl, 1461 void *show_rss_key) 1462 { 1463 struct cmd_showport_rss_hash *res = parsed_result; 1464 1465 port_rss_hash_conf_show(res->port_id, show_rss_key != NULL); 1466 } 1467 1468 cmdline_parse_token_string_t cmd_showport_rss_hash_show = 1469 TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, show, "show"); 1470 cmdline_parse_token_string_t cmd_showport_rss_hash_port = 1471 TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, port, "port"); 1472 cmdline_parse_token_num_t cmd_showport_rss_hash_port_id = 1473 TOKEN_NUM_INITIALIZER(struct cmd_showport_rss_hash, port_id, UINT8); 1474 cmdline_parse_token_string_t cmd_showport_rss_hash_rss_hash = 1475 TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, rss_hash, 1476 "rss-hash"); 1477 cmdline_parse_token_string_t cmd_showport_rss_hash_rss_key = 1478 TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, key, "key"); 1479 1480 cmdline_parse_inst_t cmd_showport_rss_hash = { 1481 .f = cmd_showport_rss_hash_parsed, 1482 .data = NULL, 1483 .help_str = "show port X rss-hash (X = port number)\n", 1484 .tokens = { 1485 (void *)&cmd_showport_rss_hash_show, 1486 (void *)&cmd_showport_rss_hash_port, 1487 (void *)&cmd_showport_rss_hash_port_id, 1488 (void *)&cmd_showport_rss_hash_rss_hash, 1489 NULL, 1490 }, 1491 }; 1492 1493 cmdline_parse_inst_t cmd_showport_rss_hash_key = { 1494 .f = cmd_showport_rss_hash_parsed, 1495 .data = (void *)1, 1496 .help_str = "show port X rss-hash key (X = port number)\n", 1497 .tokens = { 1498 (void *)&cmd_showport_rss_hash_show, 1499 (void *)&cmd_showport_rss_hash_port, 1500 (void *)&cmd_showport_rss_hash_port_id, 1501 (void *)&cmd_showport_rss_hash_rss_hash, 1502 (void *)&cmd_showport_rss_hash_rss_key, 1503 NULL, 1504 }, 1505 }; 1506 1507 /* *** Configure DCB *** */ 1508 struct cmd_config_dcb { 1509 cmdline_fixed_string_t port; 1510 cmdline_fixed_string_t config; 1511 uint8_t port_id; 1512 cmdline_fixed_string_t dcb; 1513 cmdline_fixed_string_t vt; 1514 cmdline_fixed_string_t vt_en; 1515 uint8_t num_tcs; 1516 cmdline_fixed_string_t pfc; 1517 cmdline_fixed_string_t pfc_en; 1518 }; 1519 1520 static void 1521 cmd_config_dcb_parsed(void *parsed_result, 1522 __attribute__((unused)) struct cmdline *cl, 1523 __attribute__((unused)) void *data) 1524 { 1525 struct cmd_config_dcb *res = parsed_result; 1526 struct dcb_config dcb_conf; 1527 portid_t port_id = res->port_id; 1528 struct rte_port *port; 1529 1530 port = &ports[port_id]; 1531 /** Check if the port is not started **/ 1532 if (port->port_status != RTE_PORT_STOPPED) { 1533 printf("Please stop port %d first\n",port_id); 1534 return; 1535 } 1536 1537 dcb_conf.num_tcs = (enum rte_eth_nb_tcs) res->num_tcs; 1538 if ((dcb_conf.num_tcs != ETH_4_TCS) && (dcb_conf.num_tcs != ETH_8_TCS)){ 1539 printf("The invalid number of traffic class,only 4 or 8 allowed\n"); 1540 return; 1541 } 1542 1543 /* DCB in VT mode */ 1544 if (!strncmp(res->vt_en, "on",2)) 1545 dcb_conf.dcb_mode = DCB_VT_ENABLED; 1546 else 1547 dcb_conf.dcb_mode = DCB_ENABLED; 1548 1549 if (!strncmp(res->pfc_en, "on",2)) { 1550 dcb_conf.pfc_en = 1; 1551 } 1552 else 1553 dcb_conf.pfc_en = 0; 1554 1555 if (init_port_dcb_config(port_id,&dcb_conf) != 0) { 1556 printf("Cannot initialize network ports\n"); 1557 return; 1558 } 1559 1560 cmd_reconfig_device_queue(port_id, 1, 1); 1561 } 1562 1563 cmdline_parse_token_string_t cmd_config_dcb_port = 1564 TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, port, "port"); 1565 cmdline_parse_token_string_t cmd_config_dcb_config = 1566 TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, config, "config"); 1567 cmdline_parse_token_num_t cmd_config_dcb_port_id = 1568 TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, port_id, UINT8); 1569 cmdline_parse_token_string_t cmd_config_dcb_dcb = 1570 TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, dcb, "dcb"); 1571 cmdline_parse_token_string_t cmd_config_dcb_vt = 1572 TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, vt, "vt"); 1573 cmdline_parse_token_string_t cmd_config_dcb_vt_en = 1574 TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, vt_en, "on#off"); 1575 cmdline_parse_token_num_t cmd_config_dcb_num_tcs = 1576 TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, num_tcs, UINT8); 1577 cmdline_parse_token_string_t cmd_config_dcb_pfc= 1578 TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, pfc, "pfc"); 1579 cmdline_parse_token_string_t cmd_config_dcb_pfc_en = 1580 TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, pfc_en, "on#off"); 1581 1582 cmdline_parse_inst_t cmd_config_dcb = { 1583 .f = cmd_config_dcb_parsed, 1584 .data = NULL, 1585 .help_str = "port config port-id dcb vt on|off nb-tcs pfc on|off", 1586 .tokens = { 1587 (void *)&cmd_config_dcb_port, 1588 (void *)&cmd_config_dcb_config, 1589 (void *)&cmd_config_dcb_port_id, 1590 (void *)&cmd_config_dcb_dcb, 1591 (void *)&cmd_config_dcb_vt, 1592 (void *)&cmd_config_dcb_vt_en, 1593 (void *)&cmd_config_dcb_num_tcs, 1594 (void *)&cmd_config_dcb_pfc, 1595 (void *)&cmd_config_dcb_pfc_en, 1596 NULL, 1597 }, 1598 }; 1599 1600 /* *** configure number of packets per burst *** */ 1601 struct cmd_config_burst { 1602 cmdline_fixed_string_t port; 1603 cmdline_fixed_string_t keyword; 1604 cmdline_fixed_string_t all; 1605 cmdline_fixed_string_t name; 1606 uint16_t value; 1607 }; 1608 1609 static void 1610 cmd_config_burst_parsed(void *parsed_result, 1611 __attribute__((unused)) struct cmdline *cl, 1612 __attribute__((unused)) void *data) 1613 { 1614 struct cmd_config_burst *res = parsed_result; 1615 1616 if (!all_ports_stopped()) { 1617 printf("Please stop all ports first\n"); 1618 return; 1619 } 1620 1621 if (!strcmp(res->name, "burst")) { 1622 if (res->value < 1 || res->value > MAX_PKT_BURST) { 1623 printf("burst must be >= 1 && <= %d\n", MAX_PKT_BURST); 1624 return; 1625 } 1626 nb_pkt_per_burst = res->value; 1627 } else { 1628 printf("Unknown parameter\n"); 1629 return; 1630 } 1631 1632 init_port_config(); 1633 1634 cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); 1635 } 1636 1637 cmdline_parse_token_string_t cmd_config_burst_port = 1638 TOKEN_STRING_INITIALIZER(struct cmd_config_burst, port, "port"); 1639 cmdline_parse_token_string_t cmd_config_burst_keyword = 1640 TOKEN_STRING_INITIALIZER(struct cmd_config_burst, keyword, "config"); 1641 cmdline_parse_token_string_t cmd_config_burst_all = 1642 TOKEN_STRING_INITIALIZER(struct cmd_config_burst, all, "all"); 1643 cmdline_parse_token_string_t cmd_config_burst_name = 1644 TOKEN_STRING_INITIALIZER(struct cmd_config_burst, name, "burst"); 1645 cmdline_parse_token_num_t cmd_config_burst_value = 1646 TOKEN_NUM_INITIALIZER(struct cmd_config_burst, value, UINT16); 1647 1648 cmdline_parse_inst_t cmd_config_burst = { 1649 .f = cmd_config_burst_parsed, 1650 .data = NULL, 1651 .help_str = "port config all burst value", 1652 .tokens = { 1653 (void *)&cmd_config_burst_port, 1654 (void *)&cmd_config_burst_keyword, 1655 (void *)&cmd_config_burst_all, 1656 (void *)&cmd_config_burst_name, 1657 (void *)&cmd_config_burst_value, 1658 NULL, 1659 }, 1660 }; 1661 1662 /* *** configure rx/tx queues *** */ 1663 struct cmd_config_thresh { 1664 cmdline_fixed_string_t port; 1665 cmdline_fixed_string_t keyword; 1666 cmdline_fixed_string_t all; 1667 cmdline_fixed_string_t name; 1668 uint8_t value; 1669 }; 1670 1671 static void 1672 cmd_config_thresh_parsed(void *parsed_result, 1673 __attribute__((unused)) struct cmdline *cl, 1674 __attribute__((unused)) void *data) 1675 { 1676 struct cmd_config_thresh *res = parsed_result; 1677 1678 if (!all_ports_stopped()) { 1679 printf("Please stop all ports first\n"); 1680 return; 1681 } 1682 1683 if (!strcmp(res->name, "txpt")) 1684 tx_thresh.pthresh = res->value; 1685 else if(!strcmp(res->name, "txht")) 1686 tx_thresh.hthresh = res->value; 1687 else if(!strcmp(res->name, "txwt")) 1688 tx_thresh.wthresh = res->value; 1689 else if(!strcmp(res->name, "rxpt")) 1690 rx_thresh.pthresh = res->value; 1691 else if(!strcmp(res->name, "rxht")) 1692 rx_thresh.hthresh = res->value; 1693 else if(!strcmp(res->name, "rxwt")) 1694 rx_thresh.wthresh = res->value; 1695 else { 1696 printf("Unknown parameter\n"); 1697 return; 1698 } 1699 1700 init_port_config(); 1701 1702 cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); 1703 } 1704 1705 cmdline_parse_token_string_t cmd_config_thresh_port = 1706 TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, port, "port"); 1707 cmdline_parse_token_string_t cmd_config_thresh_keyword = 1708 TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, keyword, "config"); 1709 cmdline_parse_token_string_t cmd_config_thresh_all = 1710 TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, all, "all"); 1711 cmdline_parse_token_string_t cmd_config_thresh_name = 1712 TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, name, 1713 "txpt#txht#txwt#rxpt#rxht#rxwt"); 1714 cmdline_parse_token_num_t cmd_config_thresh_value = 1715 TOKEN_NUM_INITIALIZER(struct cmd_config_thresh, value, UINT8); 1716 1717 cmdline_parse_inst_t cmd_config_thresh = { 1718 .f = cmd_config_thresh_parsed, 1719 .data = NULL, 1720 .help_str = "port config all txpt|txht|txwt|rxpt|rxht|rxwt value", 1721 .tokens = { 1722 (void *)&cmd_config_thresh_port, 1723 (void *)&cmd_config_thresh_keyword, 1724 (void *)&cmd_config_thresh_all, 1725 (void *)&cmd_config_thresh_name, 1726 (void *)&cmd_config_thresh_value, 1727 NULL, 1728 }, 1729 }; 1730 1731 /* *** configure free/rs threshold *** */ 1732 struct cmd_config_threshold { 1733 cmdline_fixed_string_t port; 1734 cmdline_fixed_string_t keyword; 1735 cmdline_fixed_string_t all; 1736 cmdline_fixed_string_t name; 1737 uint16_t value; 1738 }; 1739 1740 static void 1741 cmd_config_threshold_parsed(void *parsed_result, 1742 __attribute__((unused)) struct cmdline *cl, 1743 __attribute__((unused)) void *data) 1744 { 1745 struct cmd_config_threshold *res = parsed_result; 1746 1747 if (!all_ports_stopped()) { 1748 printf("Please stop all ports first\n"); 1749 return; 1750 } 1751 1752 if (!strcmp(res->name, "txfreet")) 1753 tx_free_thresh = res->value; 1754 else if (!strcmp(res->name, "txrst")) 1755 tx_rs_thresh = res->value; 1756 else if (!strcmp(res->name, "rxfreet")) 1757 rx_free_thresh = res->value; 1758 else { 1759 printf("Unknown parameter\n"); 1760 return; 1761 } 1762 1763 init_port_config(); 1764 1765 cmd_reconfig_device_queue(RTE_PORT_ALL, 1, 1); 1766 } 1767 1768 cmdline_parse_token_string_t cmd_config_threshold_port = 1769 TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, port, "port"); 1770 cmdline_parse_token_string_t cmd_config_threshold_keyword = 1771 TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, keyword, 1772 "config"); 1773 cmdline_parse_token_string_t cmd_config_threshold_all = 1774 TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, all, "all"); 1775 cmdline_parse_token_string_t cmd_config_threshold_name = 1776 TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, name, 1777 "txfreet#txrst#rxfreet"); 1778 cmdline_parse_token_num_t cmd_config_threshold_value = 1779 TOKEN_NUM_INITIALIZER(struct cmd_config_threshold, value, UINT16); 1780 1781 cmdline_parse_inst_t cmd_config_threshold = { 1782 .f = cmd_config_threshold_parsed, 1783 .data = NULL, 1784 .help_str = "port config all txfreet|txrst|rxfreet value", 1785 .tokens = { 1786 (void *)&cmd_config_threshold_port, 1787 (void *)&cmd_config_threshold_keyword, 1788 (void *)&cmd_config_threshold_all, 1789 (void *)&cmd_config_threshold_name, 1790 (void *)&cmd_config_threshold_value, 1791 NULL, 1792 }, 1793 }; 1794 1795 /* *** stop *** */ 1796 struct cmd_stop_result { 1797 cmdline_fixed_string_t stop; 1798 }; 1799 1800 static void cmd_stop_parsed(__attribute__((unused)) void *parsed_result, 1801 __attribute__((unused)) struct cmdline *cl, 1802 __attribute__((unused)) void *data) 1803 { 1804 stop_packet_forwarding(); 1805 } 1806 1807 cmdline_parse_token_string_t cmd_stop_stop = 1808 TOKEN_STRING_INITIALIZER(struct cmd_stop_result, stop, "stop"); 1809 1810 cmdline_parse_inst_t cmd_stop = { 1811 .f = cmd_stop_parsed, 1812 .data = NULL, 1813 .help_str = "stop - stop packet forwarding", 1814 .tokens = { 1815 (void *)&cmd_stop_stop, 1816 NULL, 1817 }, 1818 }; 1819 1820 /* *** SET CORELIST and PORTLIST CONFIGURATION *** */ 1821 1822 static unsigned int 1823 parse_item_list(char* str, const char* item_name, unsigned int max_items, 1824 unsigned int *parsed_items, int check_unique_values) 1825 { 1826 unsigned int nb_item; 1827 unsigned int value; 1828 unsigned int i; 1829 unsigned int j; 1830 int value_ok; 1831 char c; 1832 1833 /* 1834 * First parse all items in the list and store their value. 1835 */ 1836 value = 0; 1837 nb_item = 0; 1838 value_ok = 0; 1839 for (i = 0; i < strnlen(str, STR_TOKEN_SIZE); i++) { 1840 c = str[i]; 1841 if ((c >= '0') && (c <= '9')) { 1842 value = (unsigned int) (value * 10 + (c - '0')); 1843 value_ok = 1; 1844 continue; 1845 } 1846 if (c != ',') { 1847 printf("character %c is not a decimal digit\n", c); 1848 return (0); 1849 } 1850 if (! value_ok) { 1851 printf("No valid value before comma\n"); 1852 return (0); 1853 } 1854 if (nb_item < max_items) { 1855 parsed_items[nb_item] = value; 1856 value_ok = 0; 1857 value = 0; 1858 } 1859 nb_item++; 1860 } 1861 if (nb_item >= max_items) { 1862 printf("Number of %s = %u > %u (maximum items)\n", 1863 item_name, nb_item + 1, max_items); 1864 return (0); 1865 } 1866 parsed_items[nb_item++] = value; 1867 if (! check_unique_values) 1868 return (nb_item); 1869 1870 /* 1871 * Then, check that all values in the list are differents. 1872 * No optimization here... 1873 */ 1874 for (i = 0; i < nb_item; i++) { 1875 for (j = i + 1; j < nb_item; j++) { 1876 if (parsed_items[j] == parsed_items[i]) { 1877 printf("duplicated %s %u at index %u and %u\n", 1878 item_name, parsed_items[i], i, j); 1879 return (0); 1880 } 1881 } 1882 } 1883 return (nb_item); 1884 } 1885 1886 struct cmd_set_list_result { 1887 cmdline_fixed_string_t cmd_keyword; 1888 cmdline_fixed_string_t list_name; 1889 cmdline_fixed_string_t list_of_items; 1890 }; 1891 1892 static void cmd_set_list_parsed(void *parsed_result, 1893 __attribute__((unused)) struct cmdline *cl, 1894 __attribute__((unused)) void *data) 1895 { 1896 struct cmd_set_list_result *res; 1897 union { 1898 unsigned int lcorelist[RTE_MAX_LCORE]; 1899 unsigned int portlist[RTE_MAX_ETHPORTS]; 1900 } parsed_items; 1901 unsigned int nb_item; 1902 1903 res = parsed_result; 1904 if (!strcmp(res->list_name, "corelist")) { 1905 nb_item = parse_item_list(res->list_of_items, "core", 1906 RTE_MAX_LCORE, 1907 parsed_items.lcorelist, 1); 1908 if (nb_item > 0) 1909 set_fwd_lcores_list(parsed_items.lcorelist, nb_item); 1910 return; 1911 } 1912 if (!strcmp(res->list_name, "portlist")) { 1913 nb_item = parse_item_list(res->list_of_items, "port", 1914 RTE_MAX_ETHPORTS, 1915 parsed_items.portlist, 1); 1916 if (nb_item > 0) 1917 set_fwd_ports_list(parsed_items.portlist, nb_item); 1918 } 1919 } 1920 1921 cmdline_parse_token_string_t cmd_set_list_keyword = 1922 TOKEN_STRING_INITIALIZER(struct cmd_set_list_result, cmd_keyword, 1923 "set"); 1924 cmdline_parse_token_string_t cmd_set_list_name = 1925 TOKEN_STRING_INITIALIZER(struct cmd_set_list_result, list_name, 1926 "corelist#portlist"); 1927 cmdline_parse_token_string_t cmd_set_list_of_items = 1928 TOKEN_STRING_INITIALIZER(struct cmd_set_list_result, list_of_items, 1929 NULL); 1930 1931 cmdline_parse_inst_t cmd_set_fwd_list = { 1932 .f = cmd_set_list_parsed, 1933 .data = NULL, 1934 .help_str = "set corelist|portlist x[,y]*", 1935 .tokens = { 1936 (void *)&cmd_set_list_keyword, 1937 (void *)&cmd_set_list_name, 1938 (void *)&cmd_set_list_of_items, 1939 NULL, 1940 }, 1941 }; 1942 1943 /* *** SET COREMASK and PORTMASK CONFIGURATION *** */ 1944 1945 struct cmd_setmask_result { 1946 cmdline_fixed_string_t set; 1947 cmdline_fixed_string_t mask; 1948 uint64_t hexavalue; 1949 }; 1950 1951 static void cmd_set_mask_parsed(void *parsed_result, 1952 __attribute__((unused)) struct cmdline *cl, 1953 __attribute__((unused)) void *data) 1954 { 1955 struct cmd_setmask_result *res = parsed_result; 1956 1957 if (!strcmp(res->mask, "coremask")) 1958 set_fwd_lcores_mask(res->hexavalue); 1959 else if (!strcmp(res->mask, "portmask")) 1960 set_fwd_ports_mask(res->hexavalue); 1961 } 1962 1963 cmdline_parse_token_string_t cmd_setmask_set = 1964 TOKEN_STRING_INITIALIZER(struct cmd_setmask_result, set, "set"); 1965 cmdline_parse_token_string_t cmd_setmask_mask = 1966 TOKEN_STRING_INITIALIZER(struct cmd_setmask_result, mask, 1967 "coremask#portmask"); 1968 cmdline_parse_token_num_t cmd_setmask_value = 1969 TOKEN_NUM_INITIALIZER(struct cmd_setmask_result, hexavalue, UINT64); 1970 1971 cmdline_parse_inst_t cmd_set_fwd_mask = { 1972 .f = cmd_set_mask_parsed, 1973 .data = NULL, 1974 .help_str = "set coremask|portmask hexadecimal value", 1975 .tokens = { 1976 (void *)&cmd_setmask_set, 1977 (void *)&cmd_setmask_mask, 1978 (void *)&cmd_setmask_value, 1979 NULL, 1980 }, 1981 }; 1982 1983 /* 1984 * SET NBPORT, NBCORE, PACKET BURST, and VERBOSE LEVEL CONFIGURATION 1985 */ 1986 struct cmd_set_result { 1987 cmdline_fixed_string_t set; 1988 cmdline_fixed_string_t what; 1989 uint16_t value; 1990 }; 1991 1992 static void cmd_set_parsed(void *parsed_result, 1993 __attribute__((unused)) struct cmdline *cl, 1994 __attribute__((unused)) void *data) 1995 { 1996 struct cmd_set_result *res = parsed_result; 1997 if (!strcmp(res->what, "nbport")) 1998 set_fwd_ports_number(res->value); 1999 else if (!strcmp(res->what, "nbcore")) 2000 set_fwd_lcores_number(res->value); 2001 else if (!strcmp(res->what, "burst")) 2002 set_nb_pkt_per_burst(res->value); 2003 else if (!strcmp(res->what, "verbose")) 2004 set_verbose_level(res->value); 2005 } 2006 2007 cmdline_parse_token_string_t cmd_set_set = 2008 TOKEN_STRING_INITIALIZER(struct cmd_set_result, set, "set"); 2009 cmdline_parse_token_string_t cmd_set_what = 2010 TOKEN_STRING_INITIALIZER(struct cmd_set_result, what, 2011 "nbport#nbcore#burst#verbose"); 2012 cmdline_parse_token_num_t cmd_set_value = 2013 TOKEN_NUM_INITIALIZER(struct cmd_set_result, value, UINT16); 2014 2015 cmdline_parse_inst_t cmd_set_numbers = { 2016 .f = cmd_set_parsed, 2017 .data = NULL, 2018 .help_str = "set nbport|nbcore|burst|verbose value", 2019 .tokens = { 2020 (void *)&cmd_set_set, 2021 (void *)&cmd_set_what, 2022 (void *)&cmd_set_value, 2023 NULL, 2024 }, 2025 }; 2026 2027 /* *** SET SEGMENT LENGTHS OF TXONLY PACKETS *** */ 2028 2029 struct cmd_set_txpkts_result { 2030 cmdline_fixed_string_t cmd_keyword; 2031 cmdline_fixed_string_t txpkts; 2032 cmdline_fixed_string_t seg_lengths; 2033 }; 2034 2035 static void 2036 cmd_set_txpkts_parsed(void *parsed_result, 2037 __attribute__((unused)) struct cmdline *cl, 2038 __attribute__((unused)) void *data) 2039 { 2040 struct cmd_set_txpkts_result *res; 2041 unsigned seg_lengths[RTE_MAX_SEGS_PER_PKT]; 2042 unsigned int nb_segs; 2043 2044 res = parsed_result; 2045 nb_segs = parse_item_list(res->seg_lengths, "segment lengths", 2046 RTE_MAX_SEGS_PER_PKT, seg_lengths, 0); 2047 if (nb_segs > 0) 2048 set_tx_pkt_segments(seg_lengths, nb_segs); 2049 } 2050 2051 cmdline_parse_token_string_t cmd_set_txpkts_keyword = 2052 TOKEN_STRING_INITIALIZER(struct cmd_set_txpkts_result, 2053 cmd_keyword, "set"); 2054 cmdline_parse_token_string_t cmd_set_txpkts_name = 2055 TOKEN_STRING_INITIALIZER(struct cmd_set_txpkts_result, 2056 txpkts, "txpkts"); 2057 cmdline_parse_token_string_t cmd_set_txpkts_lengths = 2058 TOKEN_STRING_INITIALIZER(struct cmd_set_txpkts_result, 2059 seg_lengths, NULL); 2060 2061 cmdline_parse_inst_t cmd_set_txpkts = { 2062 .f = cmd_set_txpkts_parsed, 2063 .data = NULL, 2064 .help_str = "set txpkts x[,y]*", 2065 .tokens = { 2066 (void *)&cmd_set_txpkts_keyword, 2067 (void *)&cmd_set_txpkts_name, 2068 (void *)&cmd_set_txpkts_lengths, 2069 NULL, 2070 }, 2071 }; 2072 2073 /* *** ADD/REMOVE ALL VLAN IDENTIFIERS TO/FROM A PORT VLAN RX FILTER *** */ 2074 struct cmd_rx_vlan_filter_all_result { 2075 cmdline_fixed_string_t rx_vlan; 2076 cmdline_fixed_string_t what; 2077 cmdline_fixed_string_t all; 2078 uint8_t port_id; 2079 }; 2080 2081 static void 2082 cmd_rx_vlan_filter_all_parsed(void *parsed_result, 2083 __attribute__((unused)) struct cmdline *cl, 2084 __attribute__((unused)) void *data) 2085 { 2086 struct cmd_rx_vlan_filter_all_result *res = parsed_result; 2087 2088 if (!strcmp(res->what, "add")) 2089 rx_vlan_all_filter_set(res->port_id, 1); 2090 else 2091 rx_vlan_all_filter_set(res->port_id, 0); 2092 } 2093 2094 cmdline_parse_token_string_t cmd_rx_vlan_filter_all_rx_vlan = 2095 TOKEN_STRING_INITIALIZER(struct cmd_rx_vlan_filter_all_result, 2096 rx_vlan, "rx_vlan"); 2097 cmdline_parse_token_string_t cmd_rx_vlan_filter_all_what = 2098 TOKEN_STRING_INITIALIZER(struct cmd_rx_vlan_filter_all_result, 2099 what, "add#rm"); 2100 cmdline_parse_token_string_t cmd_rx_vlan_filter_all_all = 2101 TOKEN_STRING_INITIALIZER(struct cmd_rx_vlan_filter_all_result, 2102 all, "all"); 2103 cmdline_parse_token_num_t cmd_rx_vlan_filter_all_portid = 2104 TOKEN_NUM_INITIALIZER(struct cmd_rx_vlan_filter_all_result, 2105 port_id, UINT8); 2106 2107 cmdline_parse_inst_t cmd_rx_vlan_filter_all = { 2108 .f = cmd_rx_vlan_filter_all_parsed, 2109 .data = NULL, 2110 .help_str = "add/remove all identifiers to/from the set of VLAN " 2111 "Identifiers filtered by a port", 2112 .tokens = { 2113 (void *)&cmd_rx_vlan_filter_all_rx_vlan, 2114 (void *)&cmd_rx_vlan_filter_all_what, 2115 (void *)&cmd_rx_vlan_filter_all_all, 2116 (void *)&cmd_rx_vlan_filter_all_portid, 2117 NULL, 2118 }, 2119 }; 2120 2121 /* *** VLAN OFFLOAD SET ON A PORT *** */ 2122 struct cmd_vlan_offload_result { 2123 cmdline_fixed_string_t vlan; 2124 cmdline_fixed_string_t set; 2125 cmdline_fixed_string_t what; 2126 cmdline_fixed_string_t on; 2127 cmdline_fixed_string_t port_id; 2128 }; 2129 2130 static void 2131 cmd_vlan_offload_parsed(void *parsed_result, 2132 __attribute__((unused)) struct cmdline *cl, 2133 __attribute__((unused)) void *data) 2134 { 2135 int on; 2136 struct cmd_vlan_offload_result *res = parsed_result; 2137 char *str; 2138 int i, len = 0; 2139 portid_t port_id = 0; 2140 unsigned int tmp; 2141 2142 str = res->port_id; 2143 len = strnlen(str, STR_TOKEN_SIZE); 2144 i = 0; 2145 /* Get port_id first */ 2146 while(i < len){ 2147 if(str[i] == ',') 2148 break; 2149 2150 i++; 2151 } 2152 str[i]='\0'; 2153 tmp = strtoul(str, NULL, 0); 2154 /* If port_id greater that what portid_t can represent, return */ 2155 if(tmp >= RTE_MAX_ETHPORTS) 2156 return; 2157 port_id = (portid_t)tmp; 2158 2159 if (!strcmp(res->on, "on")) 2160 on = 1; 2161 else 2162 on = 0; 2163 2164 if (!strcmp(res->what, "strip")) 2165 rx_vlan_strip_set(port_id, on); 2166 else if(!strcmp(res->what, "stripq")){ 2167 uint16_t queue_id = 0; 2168 2169 /* No queue_id, return */ 2170 if(i + 1 >= len) { 2171 printf("must specify (port,queue_id)\n"); 2172 return; 2173 } 2174 tmp = strtoul(str + i + 1, NULL, 0); 2175 /* If queue_id greater that what 16-bits can represent, return */ 2176 if(tmp > 0xffff) 2177 return; 2178 2179 queue_id = (uint16_t)tmp; 2180 rx_vlan_strip_set_on_queue(port_id, queue_id, on); 2181 } 2182 else if (!strcmp(res->what, "filter")) 2183 rx_vlan_filter_set(port_id, on); 2184 else 2185 vlan_extend_set(port_id, on); 2186 2187 return; 2188 } 2189 2190 cmdline_parse_token_string_t cmd_vlan_offload_vlan = 2191 TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result, 2192 vlan, "vlan"); 2193 cmdline_parse_token_string_t cmd_vlan_offload_set = 2194 TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result, 2195 set, "set"); 2196 cmdline_parse_token_string_t cmd_vlan_offload_what = 2197 TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result, 2198 what, "strip#filter#qinq#stripq"); 2199 cmdline_parse_token_string_t cmd_vlan_offload_on = 2200 TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result, 2201 on, "on#off"); 2202 cmdline_parse_token_string_t cmd_vlan_offload_portid = 2203 TOKEN_STRING_INITIALIZER(struct cmd_vlan_offload_result, 2204 port_id, NULL); 2205 2206 cmdline_parse_inst_t cmd_vlan_offload = { 2207 .f = cmd_vlan_offload_parsed, 2208 .data = NULL, 2209 .help_str = "set strip|filter|qinq|stripq on|off port_id[,queue_id], filter/strip for rx side" 2210 " qinq(extended) for both rx/tx sides ", 2211 .tokens = { 2212 (void *)&cmd_vlan_offload_vlan, 2213 (void *)&cmd_vlan_offload_set, 2214 (void *)&cmd_vlan_offload_what, 2215 (void *)&cmd_vlan_offload_on, 2216 (void *)&cmd_vlan_offload_portid, 2217 NULL, 2218 }, 2219 }; 2220 2221 /* *** VLAN TPID SET ON A PORT *** */ 2222 struct cmd_vlan_tpid_result { 2223 cmdline_fixed_string_t vlan; 2224 cmdline_fixed_string_t set; 2225 cmdline_fixed_string_t what; 2226 uint16_t tp_id; 2227 uint8_t port_id; 2228 }; 2229 2230 static void 2231 cmd_vlan_tpid_parsed(void *parsed_result, 2232 __attribute__((unused)) struct cmdline *cl, 2233 __attribute__((unused)) void *data) 2234 { 2235 struct cmd_vlan_tpid_result *res = parsed_result; 2236 vlan_tpid_set(res->port_id, res->tp_id); 2237 return; 2238 } 2239 2240 cmdline_parse_token_string_t cmd_vlan_tpid_vlan = 2241 TOKEN_STRING_INITIALIZER(struct cmd_vlan_tpid_result, 2242 vlan, "vlan"); 2243 cmdline_parse_token_string_t cmd_vlan_tpid_set = 2244 TOKEN_STRING_INITIALIZER(struct cmd_vlan_tpid_result, 2245 set, "set"); 2246 cmdline_parse_token_string_t cmd_vlan_tpid_what = 2247 TOKEN_STRING_INITIALIZER(struct cmd_vlan_tpid_result, 2248 what, "tpid"); 2249 cmdline_parse_token_num_t cmd_vlan_tpid_tpid = 2250 TOKEN_NUM_INITIALIZER(struct cmd_vlan_tpid_result, 2251 tp_id, UINT16); 2252 cmdline_parse_token_num_t cmd_vlan_tpid_portid = 2253 TOKEN_NUM_INITIALIZER(struct cmd_vlan_tpid_result, 2254 port_id, UINT8); 2255 2256 cmdline_parse_inst_t cmd_vlan_tpid = { 2257 .f = cmd_vlan_tpid_parsed, 2258 .data = NULL, 2259 .help_str = "set tpid tp_id port_id, set the Outer VLAN Ether type", 2260 .tokens = { 2261 (void *)&cmd_vlan_tpid_vlan, 2262 (void *)&cmd_vlan_tpid_set, 2263 (void *)&cmd_vlan_tpid_what, 2264 (void *)&cmd_vlan_tpid_tpid, 2265 (void *)&cmd_vlan_tpid_portid, 2266 NULL, 2267 }, 2268 }; 2269 2270 /* *** ADD/REMOVE A VLAN IDENTIFIER TO/FROM A PORT VLAN RX FILTER *** */ 2271 struct cmd_rx_vlan_filter_result { 2272 cmdline_fixed_string_t rx_vlan; 2273 cmdline_fixed_string_t what; 2274 uint16_t vlan_id; 2275 uint8_t port_id; 2276 }; 2277 2278 static void 2279 cmd_rx_vlan_filter_parsed(void *parsed_result, 2280 __attribute__((unused)) struct cmdline *cl, 2281 __attribute__((unused)) void *data) 2282 { 2283 struct cmd_rx_vlan_filter_result *res = parsed_result; 2284 2285 if (!strcmp(res->what, "add")) 2286 rx_vft_set(res->port_id, res->vlan_id, 1); 2287 else 2288 rx_vft_set(res->port_id, res->vlan_id, 0); 2289 } 2290 2291 cmdline_parse_token_string_t cmd_rx_vlan_filter_rx_vlan = 2292 TOKEN_STRING_INITIALIZER(struct cmd_rx_vlan_filter_result, 2293 rx_vlan, "rx_vlan"); 2294 cmdline_parse_token_string_t cmd_rx_vlan_filter_what = 2295 TOKEN_STRING_INITIALIZER(struct cmd_rx_vlan_filter_result, 2296 what, "add#rm"); 2297 cmdline_parse_token_num_t cmd_rx_vlan_filter_vlanid = 2298 TOKEN_NUM_INITIALIZER(struct cmd_rx_vlan_filter_result, 2299 vlan_id, UINT16); 2300 cmdline_parse_token_num_t cmd_rx_vlan_filter_portid = 2301 TOKEN_NUM_INITIALIZER(struct cmd_rx_vlan_filter_result, 2302 port_id, UINT8); 2303 2304 cmdline_parse_inst_t cmd_rx_vlan_filter = { 2305 .f = cmd_rx_vlan_filter_parsed, 2306 .data = NULL, 2307 .help_str = "add/remove a VLAN identifier to/from the set of VLAN " 2308 "Identifiers filtered by a port", 2309 .tokens = { 2310 (void *)&cmd_rx_vlan_filter_rx_vlan, 2311 (void *)&cmd_rx_vlan_filter_what, 2312 (void *)&cmd_rx_vlan_filter_vlanid, 2313 (void *)&cmd_rx_vlan_filter_portid, 2314 NULL, 2315 }, 2316 }; 2317 2318 /* *** ENABLE HARDWARE INSERTION OF VLAN HEADER IN TX PACKETS *** */ 2319 struct cmd_tx_vlan_set_result { 2320 cmdline_fixed_string_t tx_vlan; 2321 cmdline_fixed_string_t set; 2322 uint16_t vlan_id; 2323 uint8_t port_id; 2324 }; 2325 2326 static void 2327 cmd_tx_vlan_set_parsed(void *parsed_result, 2328 __attribute__((unused)) struct cmdline *cl, 2329 __attribute__((unused)) void *data) 2330 { 2331 struct cmd_tx_vlan_set_result *res = parsed_result; 2332 tx_vlan_set(res->port_id, res->vlan_id); 2333 } 2334 2335 cmdline_parse_token_string_t cmd_tx_vlan_set_tx_vlan = 2336 TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_result, 2337 tx_vlan, "tx_vlan"); 2338 cmdline_parse_token_string_t cmd_tx_vlan_set_set = 2339 TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_result, 2340 set, "set"); 2341 cmdline_parse_token_num_t cmd_tx_vlan_set_vlanid = 2342 TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_result, 2343 vlan_id, UINT16); 2344 cmdline_parse_token_num_t cmd_tx_vlan_set_portid = 2345 TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_result, 2346 port_id, UINT8); 2347 2348 cmdline_parse_inst_t cmd_tx_vlan_set = { 2349 .f = cmd_tx_vlan_set_parsed, 2350 .data = NULL, 2351 .help_str = "enable hardware insertion of a VLAN header with a given " 2352 "TAG Identifier in packets sent on a port", 2353 .tokens = { 2354 (void *)&cmd_tx_vlan_set_tx_vlan, 2355 (void *)&cmd_tx_vlan_set_set, 2356 (void *)&cmd_tx_vlan_set_vlanid, 2357 (void *)&cmd_tx_vlan_set_portid, 2358 NULL, 2359 }, 2360 }; 2361 2362 /* *** DISABLE HARDWARE INSERTION OF VLAN HEADER IN TX PACKETS *** */ 2363 struct cmd_tx_vlan_reset_result { 2364 cmdline_fixed_string_t tx_vlan; 2365 cmdline_fixed_string_t reset; 2366 uint8_t port_id; 2367 }; 2368 2369 static void 2370 cmd_tx_vlan_reset_parsed(void *parsed_result, 2371 __attribute__((unused)) struct cmdline *cl, 2372 __attribute__((unused)) void *data) 2373 { 2374 struct cmd_tx_vlan_reset_result *res = parsed_result; 2375 2376 tx_vlan_reset(res->port_id); 2377 } 2378 2379 cmdline_parse_token_string_t cmd_tx_vlan_reset_tx_vlan = 2380 TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_reset_result, 2381 tx_vlan, "tx_vlan"); 2382 cmdline_parse_token_string_t cmd_tx_vlan_reset_reset = 2383 TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_reset_result, 2384 reset, "reset"); 2385 cmdline_parse_token_num_t cmd_tx_vlan_reset_portid = 2386 TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_reset_result, 2387 port_id, UINT8); 2388 2389 cmdline_parse_inst_t cmd_tx_vlan_reset = { 2390 .f = cmd_tx_vlan_reset_parsed, 2391 .data = NULL, 2392 .help_str = "disable hardware insertion of a VLAN header in packets " 2393 "sent on a port", 2394 .tokens = { 2395 (void *)&cmd_tx_vlan_reset_tx_vlan, 2396 (void *)&cmd_tx_vlan_reset_reset, 2397 (void *)&cmd_tx_vlan_reset_portid, 2398 NULL, 2399 }, 2400 }; 2401 2402 2403 /* *** ENABLE HARDWARE INSERTION OF CHECKSUM IN TX PACKETS *** */ 2404 struct cmd_tx_cksum_set_result { 2405 cmdline_fixed_string_t tx_cksum; 2406 cmdline_fixed_string_t set; 2407 uint8_t cksum_mask; 2408 uint8_t port_id; 2409 }; 2410 2411 static void 2412 cmd_tx_cksum_set_parsed(void *parsed_result, 2413 __attribute__((unused)) struct cmdline *cl, 2414 __attribute__((unused)) void *data) 2415 { 2416 struct cmd_tx_cksum_set_result *res = parsed_result; 2417 2418 tx_cksum_set(res->port_id, res->cksum_mask); 2419 } 2420 2421 cmdline_parse_token_string_t cmd_tx_cksum_set_tx_cksum = 2422 TOKEN_STRING_INITIALIZER(struct cmd_tx_cksum_set_result, 2423 tx_cksum, "tx_checksum"); 2424 cmdline_parse_token_string_t cmd_tx_cksum_set_set = 2425 TOKEN_STRING_INITIALIZER(struct cmd_tx_cksum_set_result, 2426 set, "set"); 2427 cmdline_parse_token_num_t cmd_tx_cksum_set_cksum_mask = 2428 TOKEN_NUM_INITIALIZER(struct cmd_tx_cksum_set_result, 2429 cksum_mask, UINT8); 2430 cmdline_parse_token_num_t cmd_tx_cksum_set_portid = 2431 TOKEN_NUM_INITIALIZER(struct cmd_tx_cksum_set_result, 2432 port_id, UINT8); 2433 2434 cmdline_parse_inst_t cmd_tx_cksum_set = { 2435 .f = cmd_tx_cksum_set_parsed, 2436 .data = NULL, 2437 .help_str = "enable hardware insertion of L3/L4checksum with a given " 2438 "mask in packets sent on a port, the bit mapping is given as, Bit 0 for ip" 2439 "Bit 1 for UDP, Bit 2 for TCP, Bit 3 for SCTP", 2440 .tokens = { 2441 (void *)&cmd_tx_cksum_set_tx_cksum, 2442 (void *)&cmd_tx_cksum_set_set, 2443 (void *)&cmd_tx_cksum_set_cksum_mask, 2444 (void *)&cmd_tx_cksum_set_portid, 2445 NULL, 2446 }, 2447 }; 2448 2449 /* *** ENABLE/DISABLE FLUSH ON RX STREAMS *** */ 2450 struct cmd_set_flush_rx { 2451 cmdline_fixed_string_t set; 2452 cmdline_fixed_string_t flush_rx; 2453 cmdline_fixed_string_t mode; 2454 }; 2455 2456 static void 2457 cmd_set_flush_rx_parsed(void *parsed_result, 2458 __attribute__((unused)) struct cmdline *cl, 2459 __attribute__((unused)) void *data) 2460 { 2461 struct cmd_set_flush_rx *res = parsed_result; 2462 no_flush_rx = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1); 2463 } 2464 2465 cmdline_parse_token_string_t cmd_setflushrx_set = 2466 TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx, 2467 set, "set"); 2468 cmdline_parse_token_string_t cmd_setflushrx_flush_rx = 2469 TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx, 2470 flush_rx, "flush_rx"); 2471 cmdline_parse_token_string_t cmd_setflushrx_mode = 2472 TOKEN_STRING_INITIALIZER(struct cmd_set_flush_rx, 2473 mode, "on#off"); 2474 2475 2476 cmdline_parse_inst_t cmd_set_flush_rx = { 2477 .f = cmd_set_flush_rx_parsed, 2478 .help_str = "set flush_rx on|off: enable/disable flush on rx streams", 2479 .data = NULL, 2480 .tokens = { 2481 (void *)&cmd_setflushrx_set, 2482 (void *)&cmd_setflushrx_flush_rx, 2483 (void *)&cmd_setflushrx_mode, 2484 NULL, 2485 }, 2486 }; 2487 2488 /* *** ENABLE/DISABLE LINK STATUS CHECK *** */ 2489 struct cmd_set_link_check { 2490 cmdline_fixed_string_t set; 2491 cmdline_fixed_string_t link_check; 2492 cmdline_fixed_string_t mode; 2493 }; 2494 2495 static void 2496 cmd_set_link_check_parsed(void *parsed_result, 2497 __attribute__((unused)) struct cmdline *cl, 2498 __attribute__((unused)) void *data) 2499 { 2500 struct cmd_set_link_check *res = parsed_result; 2501 no_link_check = (uint8_t)((strcmp(res->mode, "on") == 0) ? 0 : 1); 2502 } 2503 2504 cmdline_parse_token_string_t cmd_setlinkcheck_set = 2505 TOKEN_STRING_INITIALIZER(struct cmd_set_link_check, 2506 set, "set"); 2507 cmdline_parse_token_string_t cmd_setlinkcheck_link_check = 2508 TOKEN_STRING_INITIALIZER(struct cmd_set_link_check, 2509 link_check, "link_check"); 2510 cmdline_parse_token_string_t cmd_setlinkcheck_mode = 2511 TOKEN_STRING_INITIALIZER(struct cmd_set_link_check, 2512 mode, "on#off"); 2513 2514 2515 cmdline_parse_inst_t cmd_set_link_check = { 2516 .f = cmd_set_link_check_parsed, 2517 .help_str = "set link_check on|off: enable/disable link status check " 2518 "when starting/stopping a port", 2519 .data = NULL, 2520 .tokens = { 2521 (void *)&cmd_setlinkcheck_set, 2522 (void *)&cmd_setlinkcheck_link_check, 2523 (void *)&cmd_setlinkcheck_mode, 2524 NULL, 2525 }, 2526 }; 2527 2528 #ifdef RTE_NIC_BYPASS 2529 /* *** SET NIC BYPASS MODE *** */ 2530 struct cmd_set_bypass_mode_result { 2531 cmdline_fixed_string_t set; 2532 cmdline_fixed_string_t bypass; 2533 cmdline_fixed_string_t mode; 2534 cmdline_fixed_string_t value; 2535 uint8_t port_id; 2536 }; 2537 2538 static void 2539 cmd_set_bypass_mode_parsed(void *parsed_result, 2540 __attribute__((unused)) struct cmdline *cl, 2541 __attribute__((unused)) void *data) 2542 { 2543 struct cmd_set_bypass_mode_result *res = parsed_result; 2544 portid_t port_id = res->port_id; 2545 uint32_t bypass_mode = RTE_BYPASS_MODE_NORMAL; 2546 2547 if (!bypass_is_supported(port_id)) 2548 return; 2549 2550 if (!strcmp(res->value, "bypass")) 2551 bypass_mode = RTE_BYPASS_MODE_BYPASS; 2552 else if (!strcmp(res->value, "isolate")) 2553 bypass_mode = RTE_BYPASS_MODE_ISOLATE; 2554 else 2555 bypass_mode = RTE_BYPASS_MODE_NORMAL; 2556 2557 /* Set the bypass mode for the relevant port. */ 2558 if (0 != rte_eth_dev_bypass_state_set(port_id, &bypass_mode)) { 2559 printf("\t Failed to set bypass mode for port = %d.\n", port_id); 2560 } 2561 } 2562 2563 cmdline_parse_token_string_t cmd_setbypass_mode_set = 2564 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result, 2565 set, "set"); 2566 cmdline_parse_token_string_t cmd_setbypass_mode_bypass = 2567 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result, 2568 bypass, "bypass"); 2569 cmdline_parse_token_string_t cmd_setbypass_mode_mode = 2570 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result, 2571 mode, "mode"); 2572 cmdline_parse_token_string_t cmd_setbypass_mode_value = 2573 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_mode_result, 2574 value, "normal#bypass#isolate"); 2575 cmdline_parse_token_num_t cmd_setbypass_mode_port = 2576 TOKEN_NUM_INITIALIZER(struct cmd_set_bypass_mode_result, 2577 port_id, UINT8); 2578 2579 cmdline_parse_inst_t cmd_set_bypass_mode = { 2580 .f = cmd_set_bypass_mode_parsed, 2581 .help_str = "set bypass mode (normal|bypass|isolate) (port_id): " 2582 "Set the NIC bypass mode for port_id", 2583 .data = NULL, 2584 .tokens = { 2585 (void *)&cmd_setbypass_mode_set, 2586 (void *)&cmd_setbypass_mode_bypass, 2587 (void *)&cmd_setbypass_mode_mode, 2588 (void *)&cmd_setbypass_mode_value, 2589 (void *)&cmd_setbypass_mode_port, 2590 NULL, 2591 }, 2592 }; 2593 2594 /* *** SET NIC BYPASS EVENT *** */ 2595 struct cmd_set_bypass_event_result { 2596 cmdline_fixed_string_t set; 2597 cmdline_fixed_string_t bypass; 2598 cmdline_fixed_string_t event; 2599 cmdline_fixed_string_t event_value; 2600 cmdline_fixed_string_t mode; 2601 cmdline_fixed_string_t mode_value; 2602 uint8_t port_id; 2603 }; 2604 2605 static void 2606 cmd_set_bypass_event_parsed(void *parsed_result, 2607 __attribute__((unused)) struct cmdline *cl, 2608 __attribute__((unused)) void *data) 2609 { 2610 int32_t rc; 2611 struct cmd_set_bypass_event_result *res = parsed_result; 2612 portid_t port_id = res->port_id; 2613 uint32_t bypass_event = RTE_BYPASS_EVENT_NONE; 2614 uint32_t bypass_mode = RTE_BYPASS_MODE_NORMAL; 2615 2616 if (!bypass_is_supported(port_id)) 2617 return; 2618 2619 if (!strcmp(res->event_value, "timeout")) 2620 bypass_event = RTE_BYPASS_EVENT_TIMEOUT; 2621 else if (!strcmp(res->event_value, "os_on")) 2622 bypass_event = RTE_BYPASS_EVENT_OS_ON; 2623 else if (!strcmp(res->event_value, "os_off")) 2624 bypass_event = RTE_BYPASS_EVENT_OS_OFF; 2625 else if (!strcmp(res->event_value, "power_on")) 2626 bypass_event = RTE_BYPASS_EVENT_POWER_ON; 2627 else if (!strcmp(res->event_value, "power_off")) 2628 bypass_event = RTE_BYPASS_EVENT_POWER_OFF; 2629 else 2630 bypass_event = RTE_BYPASS_EVENT_NONE; 2631 2632 if (!strcmp(res->mode_value, "bypass")) 2633 bypass_mode = RTE_BYPASS_MODE_BYPASS; 2634 else if (!strcmp(res->mode_value, "isolate")) 2635 bypass_mode = RTE_BYPASS_MODE_ISOLATE; 2636 else 2637 bypass_mode = RTE_BYPASS_MODE_NORMAL; 2638 2639 /* Set the watchdog timeout. */ 2640 if (bypass_event == RTE_BYPASS_EVENT_TIMEOUT) { 2641 2642 rc = -EINVAL; 2643 if (!RTE_BYPASS_TMT_VALID(bypass_timeout) || 2644 (rc = rte_eth_dev_wd_timeout_store(port_id, 2645 bypass_timeout)) != 0) { 2646 printf("Failed to set timeout value %u " 2647 "for port %d, errto code: %d.\n", 2648 bypass_timeout, port_id, rc); 2649 } 2650 } 2651 2652 /* Set the bypass event to transition to bypass mode. */ 2653 if (0 != rte_eth_dev_bypass_event_store(port_id, 2654 bypass_event, bypass_mode)) { 2655 printf("\t Failed to set bypass event for port = %d.\n", port_id); 2656 } 2657 2658 } 2659 2660 cmdline_parse_token_string_t cmd_setbypass_event_set = 2661 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result, 2662 set, "set"); 2663 cmdline_parse_token_string_t cmd_setbypass_event_bypass = 2664 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result, 2665 bypass, "bypass"); 2666 cmdline_parse_token_string_t cmd_setbypass_event_event = 2667 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result, 2668 event, "event"); 2669 cmdline_parse_token_string_t cmd_setbypass_event_event_value = 2670 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result, 2671 event_value, "none#timeout#os_off#os_on#power_on#power_off"); 2672 cmdline_parse_token_string_t cmd_setbypass_event_mode = 2673 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result, 2674 mode, "mode"); 2675 cmdline_parse_token_string_t cmd_setbypass_event_mode_value = 2676 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_event_result, 2677 mode_value, "normal#bypass#isolate"); 2678 cmdline_parse_token_num_t cmd_setbypass_event_port = 2679 TOKEN_NUM_INITIALIZER(struct cmd_set_bypass_event_result, 2680 port_id, UINT8); 2681 2682 cmdline_parse_inst_t cmd_set_bypass_event = { 2683 .f = cmd_set_bypass_event_parsed, 2684 .help_str = "set bypass event (timeout|os_on|os_off|power_on|power_off) " 2685 "mode (normal|bypass|isolate) (port_id): " 2686 "Set the NIC bypass event mode for port_id", 2687 .data = NULL, 2688 .tokens = { 2689 (void *)&cmd_setbypass_event_set, 2690 (void *)&cmd_setbypass_event_bypass, 2691 (void *)&cmd_setbypass_event_event, 2692 (void *)&cmd_setbypass_event_event_value, 2693 (void *)&cmd_setbypass_event_mode, 2694 (void *)&cmd_setbypass_event_mode_value, 2695 (void *)&cmd_setbypass_event_port, 2696 NULL, 2697 }, 2698 }; 2699 2700 2701 /* *** SET NIC BYPASS TIMEOUT *** */ 2702 struct cmd_set_bypass_timeout_result { 2703 cmdline_fixed_string_t set; 2704 cmdline_fixed_string_t bypass; 2705 cmdline_fixed_string_t timeout; 2706 cmdline_fixed_string_t value; 2707 }; 2708 2709 static void 2710 cmd_set_bypass_timeout_parsed(void *parsed_result, 2711 __attribute__((unused)) struct cmdline *cl, 2712 __attribute__((unused)) void *data) 2713 { 2714 struct cmd_set_bypass_timeout_result *res = parsed_result; 2715 2716 if (!strcmp(res->value, "1.5")) 2717 bypass_timeout = RTE_BYPASS_TMT_1_5_SEC; 2718 else if (!strcmp(res->value, "2")) 2719 bypass_timeout = RTE_BYPASS_TMT_2_SEC; 2720 else if (!strcmp(res->value, "3")) 2721 bypass_timeout = RTE_BYPASS_TMT_3_SEC; 2722 else if (!strcmp(res->value, "4")) 2723 bypass_timeout = RTE_BYPASS_TMT_4_SEC; 2724 else if (!strcmp(res->value, "8")) 2725 bypass_timeout = RTE_BYPASS_TMT_8_SEC; 2726 else if (!strcmp(res->value, "16")) 2727 bypass_timeout = RTE_BYPASS_TMT_16_SEC; 2728 else if (!strcmp(res->value, "32")) 2729 bypass_timeout = RTE_BYPASS_TMT_32_SEC; 2730 else 2731 bypass_timeout = RTE_BYPASS_TMT_OFF; 2732 } 2733 2734 cmdline_parse_token_string_t cmd_setbypass_timeout_set = 2735 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result, 2736 set, "set"); 2737 cmdline_parse_token_string_t cmd_setbypass_timeout_bypass = 2738 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result, 2739 bypass, "bypass"); 2740 cmdline_parse_token_string_t cmd_setbypass_timeout_timeout = 2741 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result, 2742 timeout, "timeout"); 2743 cmdline_parse_token_string_t cmd_setbypass_timeout_value = 2744 TOKEN_STRING_INITIALIZER(struct cmd_set_bypass_timeout_result, 2745 value, "0#1.5#2#3#4#8#16#32"); 2746 2747 cmdline_parse_inst_t cmd_set_bypass_timeout = { 2748 .f = cmd_set_bypass_timeout_parsed, 2749 .help_str = "set bypass timeout (0|1.5|2|3|4|8|16|32) seconds: " 2750 "Set the NIC bypass watchdog timeout", 2751 .data = NULL, 2752 .tokens = { 2753 (void *)&cmd_setbypass_timeout_set, 2754 (void *)&cmd_setbypass_timeout_bypass, 2755 (void *)&cmd_setbypass_timeout_timeout, 2756 (void *)&cmd_setbypass_timeout_value, 2757 NULL, 2758 }, 2759 }; 2760 2761 /* *** SHOW NIC BYPASS MODE *** */ 2762 struct cmd_show_bypass_config_result { 2763 cmdline_fixed_string_t show; 2764 cmdline_fixed_string_t bypass; 2765 cmdline_fixed_string_t config; 2766 uint8_t port_id; 2767 }; 2768 2769 static void 2770 cmd_show_bypass_config_parsed(void *parsed_result, 2771 __attribute__((unused)) struct cmdline *cl, 2772 __attribute__((unused)) void *data) 2773 { 2774 struct cmd_show_bypass_config_result *res = parsed_result; 2775 uint32_t event_mode; 2776 uint32_t bypass_mode; 2777 portid_t port_id = res->port_id; 2778 uint32_t timeout = bypass_timeout; 2779 int i; 2780 2781 static const char * const timeouts[RTE_BYPASS_TMT_NUM] = 2782 {"off", "1.5", "2", "3", "4", "8", "16", "32"}; 2783 static const char * const modes[RTE_BYPASS_MODE_NUM] = 2784 {"UNKNOWN", "normal", "bypass", "isolate"}; 2785 static const char * const events[RTE_BYPASS_EVENT_NUM] = { 2786 "NONE", 2787 "OS/board on", 2788 "power supply on", 2789 "OS/board off", 2790 "power supply off", 2791 "timeout"}; 2792 int num_events = (sizeof events) / (sizeof events[0]); 2793 2794 if (!bypass_is_supported(port_id)) 2795 return; 2796 2797 /* Display the bypass mode.*/ 2798 if (0 != rte_eth_dev_bypass_state_show(port_id, &bypass_mode)) { 2799 printf("\tFailed to get bypass mode for port = %d\n", port_id); 2800 return; 2801 } 2802 else { 2803 if (!RTE_BYPASS_MODE_VALID(bypass_mode)) 2804 bypass_mode = RTE_BYPASS_MODE_NONE; 2805 2806 printf("\tbypass mode = %s\n", modes[bypass_mode]); 2807 } 2808 2809 /* Display the bypass timeout.*/ 2810 if (!RTE_BYPASS_TMT_VALID(timeout)) 2811 timeout = RTE_BYPASS_TMT_OFF; 2812 2813 printf("\tbypass timeout = %s\n", timeouts[timeout]); 2814 2815 /* Display the bypass events and associated modes. */ 2816 for (i = RTE_BYPASS_EVENT_START; i < num_events; i++) { 2817 2818 if (0 != rte_eth_dev_bypass_event_show(port_id, i, &event_mode)) { 2819 printf("\tFailed to get bypass mode for event = %s\n", 2820 events[i]); 2821 } else { 2822 if (!RTE_BYPASS_MODE_VALID(event_mode)) 2823 event_mode = RTE_BYPASS_MODE_NONE; 2824 2825 printf("\tbypass event: %-16s = %s\n", events[i], 2826 modes[event_mode]); 2827 } 2828 } 2829 } 2830 2831 cmdline_parse_token_string_t cmd_showbypass_config_show = 2832 TOKEN_STRING_INITIALIZER(struct cmd_show_bypass_config_result, 2833 show, "show"); 2834 cmdline_parse_token_string_t cmd_showbypass_config_bypass = 2835 TOKEN_STRING_INITIALIZER(struct cmd_show_bypass_config_result, 2836 bypass, "bypass"); 2837 cmdline_parse_token_string_t cmd_showbypass_config_config = 2838 TOKEN_STRING_INITIALIZER(struct cmd_show_bypass_config_result, 2839 config, "config"); 2840 cmdline_parse_token_num_t cmd_showbypass_config_port = 2841 TOKEN_NUM_INITIALIZER(struct cmd_show_bypass_config_result, 2842 port_id, UINT8); 2843 2844 cmdline_parse_inst_t cmd_show_bypass_config = { 2845 .f = cmd_show_bypass_config_parsed, 2846 .help_str = "show bypass config (port_id): " 2847 "Show the NIC bypass config for port_id", 2848 .data = NULL, 2849 .tokens = { 2850 (void *)&cmd_showbypass_config_show, 2851 (void *)&cmd_showbypass_config_bypass, 2852 (void *)&cmd_showbypass_config_config, 2853 (void *)&cmd_showbypass_config_port, 2854 NULL, 2855 }, 2856 }; 2857 #endif 2858 2859 /* *** SET FORWARDING MODE *** */ 2860 struct cmd_set_fwd_mode_result { 2861 cmdline_fixed_string_t set; 2862 cmdline_fixed_string_t fwd; 2863 cmdline_fixed_string_t mode; 2864 }; 2865 2866 static void cmd_set_fwd_mode_parsed(void *parsed_result, 2867 __attribute__((unused)) struct cmdline *cl, 2868 __attribute__((unused)) void *data) 2869 { 2870 struct cmd_set_fwd_mode_result *res = parsed_result; 2871 2872 set_pkt_forwarding_mode(res->mode); 2873 } 2874 2875 cmdline_parse_token_string_t cmd_setfwd_set = 2876 TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, set, "set"); 2877 cmdline_parse_token_string_t cmd_setfwd_fwd = 2878 TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, fwd, "fwd"); 2879 cmdline_parse_token_string_t cmd_setfwd_mode = 2880 TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, mode, 2881 "" /* defined at init */); 2882 2883 cmdline_parse_inst_t cmd_set_fwd_mode = { 2884 .f = cmd_set_fwd_mode_parsed, 2885 .data = NULL, 2886 .help_str = NULL, /* defined at init */ 2887 .tokens = { 2888 (void *)&cmd_setfwd_set, 2889 (void *)&cmd_setfwd_fwd, 2890 (void *)&cmd_setfwd_mode, 2891 NULL, 2892 }, 2893 }; 2894 2895 static void cmd_set_fwd_mode_init(void) 2896 { 2897 char *modes, *c; 2898 static char token[128]; 2899 static char help[256]; 2900 cmdline_parse_token_string_t *token_struct; 2901 2902 modes = list_pkt_forwarding_modes(); 2903 rte_snprintf(help, sizeof help, "set fwd %s - " 2904 "set packet forwarding mode", modes); 2905 cmd_set_fwd_mode.help_str = help; 2906 2907 /* string token separator is # */ 2908 for (c = token; *modes != '\0'; modes++) 2909 if (*modes == '|') 2910 *c++ = '#'; 2911 else 2912 *c++ = *modes; 2913 token_struct = (cmdline_parse_token_string_t*)cmd_set_fwd_mode.tokens[2]; 2914 token_struct->string_data.str = token; 2915 } 2916 2917 /* *** SET BURST TX DELAY TIME RETRY NUMBER *** */ 2918 struct cmd_set_burst_tx_retry_result { 2919 cmdline_fixed_string_t set; 2920 cmdline_fixed_string_t burst; 2921 cmdline_fixed_string_t tx; 2922 cmdline_fixed_string_t delay; 2923 uint32_t time; 2924 cmdline_fixed_string_t retry; 2925 uint32_t retry_num; 2926 }; 2927 2928 static void cmd_set_burst_tx_retry_parsed(void *parsed_result, 2929 __attribute__((unused)) struct cmdline *cl, 2930 __attribute__((unused)) void *data) 2931 { 2932 struct cmd_set_burst_tx_retry_result *res = parsed_result; 2933 2934 if (!strcmp(res->set, "set") && !strcmp(res->burst, "burst") 2935 && !strcmp(res->tx, "tx")) { 2936 if (!strcmp(res->delay, "delay")) 2937 burst_tx_delay_time = res->time; 2938 if (!strcmp(res->retry, "retry")) 2939 burst_tx_retry_num = res->retry_num; 2940 } 2941 2942 } 2943 2944 cmdline_parse_token_string_t cmd_set_burst_tx_retry_set = 2945 TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, set, "set"); 2946 cmdline_parse_token_string_t cmd_set_burst_tx_retry_burst = 2947 TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, burst, 2948 "burst"); 2949 cmdline_parse_token_string_t cmd_set_burst_tx_retry_tx = 2950 TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, tx, "tx"); 2951 cmdline_parse_token_string_t cmd_set_burst_tx_retry_delay = 2952 TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, delay, "delay"); 2953 cmdline_parse_token_num_t cmd_set_burst_tx_retry_time = 2954 TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, time, UINT32); 2955 cmdline_parse_token_string_t cmd_set_burst_tx_retry_retry = 2956 TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry, "retry"); 2957 cmdline_parse_token_num_t cmd_set_burst_tx_retry_retry_num = 2958 TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry_num, UINT32); 2959 2960 cmdline_parse_inst_t cmd_set_burst_tx_retry = { 2961 .f = cmd_set_burst_tx_retry_parsed, 2962 .help_str = "set burst tx delay (time_by_useconds) retry (retry_num)", 2963 .tokens = { 2964 (void *)&cmd_set_burst_tx_retry_set, 2965 (void *)&cmd_set_burst_tx_retry_burst, 2966 (void *)&cmd_set_burst_tx_retry_tx, 2967 (void *)&cmd_set_burst_tx_retry_delay, 2968 (void *)&cmd_set_burst_tx_retry_time, 2969 (void *)&cmd_set_burst_tx_retry_retry, 2970 (void *)&cmd_set_burst_tx_retry_retry_num, 2971 NULL, 2972 }, 2973 }; 2974 2975 /* *** SET PROMISC MODE *** */ 2976 struct cmd_set_promisc_mode_result { 2977 cmdline_fixed_string_t set; 2978 cmdline_fixed_string_t promisc; 2979 cmdline_fixed_string_t port_all; /* valid if "allports" argument == 1 */ 2980 uint8_t port_num; /* valid if "allports" argument == 0 */ 2981 cmdline_fixed_string_t mode; 2982 }; 2983 2984 static void cmd_set_promisc_mode_parsed(void *parsed_result, 2985 __attribute__((unused)) struct cmdline *cl, 2986 void *allports) 2987 { 2988 struct cmd_set_promisc_mode_result *res = parsed_result; 2989 int enable; 2990 portid_t i; 2991 2992 if (!strcmp(res->mode, "on")) 2993 enable = 1; 2994 else 2995 enable = 0; 2996 2997 /* all ports */ 2998 if (allports) { 2999 for (i = 0; i < nb_ports; i++) { 3000 if (enable) 3001 rte_eth_promiscuous_enable(i); 3002 else 3003 rte_eth_promiscuous_disable(i); 3004 } 3005 } 3006 else { 3007 if (enable) 3008 rte_eth_promiscuous_enable(res->port_num); 3009 else 3010 rte_eth_promiscuous_disable(res->port_num); 3011 } 3012 } 3013 3014 cmdline_parse_token_string_t cmd_setpromisc_set = 3015 TOKEN_STRING_INITIALIZER(struct cmd_set_promisc_mode_result, set, "set"); 3016 cmdline_parse_token_string_t cmd_setpromisc_promisc = 3017 TOKEN_STRING_INITIALIZER(struct cmd_set_promisc_mode_result, promisc, 3018 "promisc"); 3019 cmdline_parse_token_string_t cmd_setpromisc_portall = 3020 TOKEN_STRING_INITIALIZER(struct cmd_set_promisc_mode_result, port_all, 3021 "all"); 3022 cmdline_parse_token_num_t cmd_setpromisc_portnum = 3023 TOKEN_NUM_INITIALIZER(struct cmd_set_promisc_mode_result, port_num, 3024 UINT8); 3025 cmdline_parse_token_string_t cmd_setpromisc_mode = 3026 TOKEN_STRING_INITIALIZER(struct cmd_set_promisc_mode_result, mode, 3027 "on#off"); 3028 3029 cmdline_parse_inst_t cmd_set_promisc_mode_all = { 3030 .f = cmd_set_promisc_mode_parsed, 3031 .data = (void *)1, 3032 .help_str = "set promisc all on|off: set promisc mode for all ports", 3033 .tokens = { 3034 (void *)&cmd_setpromisc_set, 3035 (void *)&cmd_setpromisc_promisc, 3036 (void *)&cmd_setpromisc_portall, 3037 (void *)&cmd_setpromisc_mode, 3038 NULL, 3039 }, 3040 }; 3041 3042 cmdline_parse_inst_t cmd_set_promisc_mode_one = { 3043 .f = cmd_set_promisc_mode_parsed, 3044 .data = (void *)0, 3045 .help_str = "set promisc X on|off: set promisc mode on port X", 3046 .tokens = { 3047 (void *)&cmd_setpromisc_set, 3048 (void *)&cmd_setpromisc_promisc, 3049 (void *)&cmd_setpromisc_portnum, 3050 (void *)&cmd_setpromisc_mode, 3051 NULL, 3052 }, 3053 }; 3054 3055 /* *** SET ALLMULTI MODE *** */ 3056 struct cmd_set_allmulti_mode_result { 3057 cmdline_fixed_string_t set; 3058 cmdline_fixed_string_t allmulti; 3059 cmdline_fixed_string_t port_all; /* valid if "allports" argument == 1 */ 3060 uint8_t port_num; /* valid if "allports" argument == 0 */ 3061 cmdline_fixed_string_t mode; 3062 }; 3063 3064 static void cmd_set_allmulti_mode_parsed(void *parsed_result, 3065 __attribute__((unused)) struct cmdline *cl, 3066 void *allports) 3067 { 3068 struct cmd_set_allmulti_mode_result *res = parsed_result; 3069 int enable; 3070 portid_t i; 3071 3072 if (!strcmp(res->mode, "on")) 3073 enable = 1; 3074 else 3075 enable = 0; 3076 3077 /* all ports */ 3078 if (allports) { 3079 for (i = 0; i < nb_ports; i++) { 3080 if (enable) 3081 rte_eth_allmulticast_enable(i); 3082 else 3083 rte_eth_allmulticast_disable(i); 3084 } 3085 } 3086 else { 3087 if (enable) 3088 rte_eth_allmulticast_enable(res->port_num); 3089 else 3090 rte_eth_allmulticast_disable(res->port_num); 3091 } 3092 } 3093 3094 cmdline_parse_token_string_t cmd_setallmulti_set = 3095 TOKEN_STRING_INITIALIZER(struct cmd_set_allmulti_mode_result, set, "set"); 3096 cmdline_parse_token_string_t cmd_setallmulti_allmulti = 3097 TOKEN_STRING_INITIALIZER(struct cmd_set_allmulti_mode_result, allmulti, 3098 "allmulti"); 3099 cmdline_parse_token_string_t cmd_setallmulti_portall = 3100 TOKEN_STRING_INITIALIZER(struct cmd_set_allmulti_mode_result, port_all, 3101 "all"); 3102 cmdline_parse_token_num_t cmd_setallmulti_portnum = 3103 TOKEN_NUM_INITIALIZER(struct cmd_set_allmulti_mode_result, port_num, 3104 UINT8); 3105 cmdline_parse_token_string_t cmd_setallmulti_mode = 3106 TOKEN_STRING_INITIALIZER(struct cmd_set_allmulti_mode_result, mode, 3107 "on#off"); 3108 3109 cmdline_parse_inst_t cmd_set_allmulti_mode_all = { 3110 .f = cmd_set_allmulti_mode_parsed, 3111 .data = (void *)1, 3112 .help_str = "set allmulti all on|off: set allmulti mode for all ports", 3113 .tokens = { 3114 (void *)&cmd_setallmulti_set, 3115 (void *)&cmd_setallmulti_allmulti, 3116 (void *)&cmd_setallmulti_portall, 3117 (void *)&cmd_setallmulti_mode, 3118 NULL, 3119 }, 3120 }; 3121 3122 cmdline_parse_inst_t cmd_set_allmulti_mode_one = { 3123 .f = cmd_set_allmulti_mode_parsed, 3124 .data = (void *)0, 3125 .help_str = "set allmulti X on|off: set allmulti mode on port X", 3126 .tokens = { 3127 (void *)&cmd_setallmulti_set, 3128 (void *)&cmd_setallmulti_allmulti, 3129 (void *)&cmd_setallmulti_portnum, 3130 (void *)&cmd_setallmulti_mode, 3131 NULL, 3132 }, 3133 }; 3134 3135 /* *** ADD/REMOVE A PKT FILTER *** */ 3136 struct cmd_pkt_filter_result { 3137 cmdline_fixed_string_t pkt_filter; 3138 uint8_t port_id; 3139 cmdline_fixed_string_t protocol; 3140 cmdline_fixed_string_t src; 3141 cmdline_ipaddr_t ip_src; 3142 uint16_t port_src; 3143 cmdline_fixed_string_t dst; 3144 cmdline_ipaddr_t ip_dst; 3145 uint16_t port_dst; 3146 cmdline_fixed_string_t flexbytes; 3147 uint16_t flexbytes_value; 3148 cmdline_fixed_string_t vlan; 3149 uint16_t vlan_id; 3150 cmdline_fixed_string_t queue; 3151 int8_t queue_id; 3152 cmdline_fixed_string_t soft; 3153 uint8_t soft_id; 3154 }; 3155 3156 static void 3157 cmd_pkt_filter_parsed(void *parsed_result, 3158 __attribute__((unused)) struct cmdline *cl, 3159 __attribute__((unused)) void *data) 3160 { 3161 struct rte_fdir_filter fdir_filter; 3162 struct cmd_pkt_filter_result *res = parsed_result; 3163 3164 memset(&fdir_filter, 0, sizeof(struct rte_fdir_filter)); 3165 3166 if (res->ip_src.family == AF_INET) 3167 fdir_filter.ip_src.ipv4_addr = res->ip_src.addr.ipv4.s_addr; 3168 else 3169 memcpy(&(fdir_filter.ip_src.ipv6_addr), 3170 &(res->ip_src.addr.ipv6), 3171 sizeof(struct in6_addr)); 3172 3173 if (res->ip_dst.family == AF_INET) 3174 fdir_filter.ip_dst.ipv4_addr = res->ip_dst.addr.ipv4.s_addr; 3175 else 3176 memcpy(&(fdir_filter.ip_dst.ipv6_addr), 3177 &(res->ip_dst.addr.ipv6), 3178 sizeof(struct in6_addr)); 3179 3180 fdir_filter.port_dst = rte_cpu_to_be_16(res->port_dst); 3181 fdir_filter.port_src = rte_cpu_to_be_16(res->port_src); 3182 3183 if (!strcmp(res->protocol, "udp")) 3184 fdir_filter.l4type = RTE_FDIR_L4TYPE_UDP; 3185 else if (!strcmp(res->protocol, "tcp")) 3186 fdir_filter.l4type = RTE_FDIR_L4TYPE_TCP; 3187 else if (!strcmp(res->protocol, "sctp")) 3188 fdir_filter.l4type = RTE_FDIR_L4TYPE_SCTP; 3189 else /* default only IP */ 3190 fdir_filter.l4type = RTE_FDIR_L4TYPE_NONE; 3191 3192 if (res->ip_dst.family == AF_INET6) 3193 fdir_filter.iptype = RTE_FDIR_IPTYPE_IPV6; 3194 else 3195 fdir_filter.iptype = RTE_FDIR_IPTYPE_IPV4; 3196 3197 fdir_filter.vlan_id = rte_cpu_to_be_16(res->vlan_id); 3198 fdir_filter.flex_bytes = rte_cpu_to_be_16(res->flexbytes_value); 3199 3200 if (!strcmp(res->pkt_filter, "add_signature_filter")) 3201 fdir_add_signature_filter(res->port_id, res->queue_id, 3202 &fdir_filter); 3203 else if (!strcmp(res->pkt_filter, "upd_signature_filter")) 3204 fdir_update_signature_filter(res->port_id, res->queue_id, 3205 &fdir_filter); 3206 else if (!strcmp(res->pkt_filter, "rm_signature_filter")) 3207 fdir_remove_signature_filter(res->port_id, &fdir_filter); 3208 else if (!strcmp(res->pkt_filter, "add_perfect_filter")) 3209 fdir_add_perfect_filter(res->port_id, res->soft_id, 3210 res->queue_id, 3211 (uint8_t) (res->queue_id < 0), 3212 &fdir_filter); 3213 else if (!strcmp(res->pkt_filter, "upd_perfect_filter")) 3214 fdir_update_perfect_filter(res->port_id, res->soft_id, 3215 res->queue_id, 3216 (uint8_t) (res->queue_id < 0), 3217 &fdir_filter); 3218 else if (!strcmp(res->pkt_filter, "rm_perfect_filter")) 3219 fdir_remove_perfect_filter(res->port_id, res->soft_id, 3220 &fdir_filter); 3221 3222 } 3223 3224 3225 cmdline_parse_token_num_t cmd_pkt_filter_port_id = 3226 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_result, 3227 port_id, UINT8); 3228 cmdline_parse_token_string_t cmd_pkt_filter_protocol = 3229 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3230 protocol, "ip#tcp#udp#sctp"); 3231 cmdline_parse_token_string_t cmd_pkt_filter_src = 3232 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3233 src, "src"); 3234 cmdline_parse_token_ipaddr_t cmd_pkt_filter_ip_src = 3235 TOKEN_IPADDR_INITIALIZER(struct cmd_pkt_filter_result, 3236 ip_src); 3237 cmdline_parse_token_num_t cmd_pkt_filter_port_src = 3238 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_result, 3239 port_src, UINT16); 3240 cmdline_parse_token_string_t cmd_pkt_filter_dst = 3241 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3242 dst, "dst"); 3243 cmdline_parse_token_ipaddr_t cmd_pkt_filter_ip_dst = 3244 TOKEN_IPADDR_INITIALIZER(struct cmd_pkt_filter_result, 3245 ip_dst); 3246 cmdline_parse_token_num_t cmd_pkt_filter_port_dst = 3247 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_result, 3248 port_dst, UINT16); 3249 cmdline_parse_token_string_t cmd_pkt_filter_flexbytes = 3250 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3251 flexbytes, "flexbytes"); 3252 cmdline_parse_token_num_t cmd_pkt_filter_flexbytes_value = 3253 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_result, 3254 flexbytes_value, UINT16); 3255 cmdline_parse_token_string_t cmd_pkt_filter_vlan = 3256 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3257 vlan, "vlan"); 3258 cmdline_parse_token_num_t cmd_pkt_filter_vlan_id = 3259 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_result, 3260 vlan_id, UINT16); 3261 cmdline_parse_token_string_t cmd_pkt_filter_queue = 3262 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3263 queue, "queue"); 3264 cmdline_parse_token_num_t cmd_pkt_filter_queue_id = 3265 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_result, 3266 queue_id, INT8); 3267 cmdline_parse_token_string_t cmd_pkt_filter_soft = 3268 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3269 soft, "soft"); 3270 cmdline_parse_token_num_t cmd_pkt_filter_soft_id = 3271 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_result, 3272 soft_id, UINT16); 3273 3274 3275 cmdline_parse_token_string_t cmd_pkt_filter_add_signature_filter = 3276 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3277 pkt_filter, "add_signature_filter"); 3278 cmdline_parse_inst_t cmd_add_signature_filter = { 3279 .f = cmd_pkt_filter_parsed, 3280 .data = NULL, 3281 .help_str = "add a signature filter", 3282 .tokens = { 3283 (void *)&cmd_pkt_filter_add_signature_filter, 3284 (void *)&cmd_pkt_filter_port_id, 3285 (void *)&cmd_pkt_filter_protocol, 3286 (void *)&cmd_pkt_filter_src, 3287 (void *)&cmd_pkt_filter_ip_src, 3288 (void *)&cmd_pkt_filter_port_src, 3289 (void *)&cmd_pkt_filter_dst, 3290 (void *)&cmd_pkt_filter_ip_dst, 3291 (void *)&cmd_pkt_filter_port_dst, 3292 (void *)&cmd_pkt_filter_flexbytes, 3293 (void *)&cmd_pkt_filter_flexbytes_value, 3294 (void *)&cmd_pkt_filter_vlan, 3295 (void *)&cmd_pkt_filter_vlan_id, 3296 (void *)&cmd_pkt_filter_queue, 3297 (void *)&cmd_pkt_filter_queue_id, 3298 NULL, 3299 }, 3300 }; 3301 3302 3303 cmdline_parse_token_string_t cmd_pkt_filter_upd_signature_filter = 3304 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3305 pkt_filter, "upd_signature_filter"); 3306 cmdline_parse_inst_t cmd_upd_signature_filter = { 3307 .f = cmd_pkt_filter_parsed, 3308 .data = NULL, 3309 .help_str = "update a signature filter", 3310 .tokens = { 3311 (void *)&cmd_pkt_filter_upd_signature_filter, 3312 (void *)&cmd_pkt_filter_port_id, 3313 (void *)&cmd_pkt_filter_protocol, 3314 (void *)&cmd_pkt_filter_src, 3315 (void *)&cmd_pkt_filter_ip_src, 3316 (void *)&cmd_pkt_filter_port_src, 3317 (void *)&cmd_pkt_filter_dst, 3318 (void *)&cmd_pkt_filter_ip_dst, 3319 (void *)&cmd_pkt_filter_port_dst, 3320 (void *)&cmd_pkt_filter_flexbytes, 3321 (void *)&cmd_pkt_filter_flexbytes_value, 3322 (void *)&cmd_pkt_filter_vlan, 3323 (void *)&cmd_pkt_filter_vlan_id, 3324 (void *)&cmd_pkt_filter_queue, 3325 (void *)&cmd_pkt_filter_queue_id, 3326 NULL, 3327 }, 3328 }; 3329 3330 3331 cmdline_parse_token_string_t cmd_pkt_filter_rm_signature_filter = 3332 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3333 pkt_filter, "rm_signature_filter"); 3334 cmdline_parse_inst_t cmd_rm_signature_filter = { 3335 .f = cmd_pkt_filter_parsed, 3336 .data = NULL, 3337 .help_str = "remove a signature filter", 3338 .tokens = { 3339 (void *)&cmd_pkt_filter_rm_signature_filter, 3340 (void *)&cmd_pkt_filter_port_id, 3341 (void *)&cmd_pkt_filter_protocol, 3342 (void *)&cmd_pkt_filter_src, 3343 (void *)&cmd_pkt_filter_ip_src, 3344 (void *)&cmd_pkt_filter_port_src, 3345 (void *)&cmd_pkt_filter_dst, 3346 (void *)&cmd_pkt_filter_ip_dst, 3347 (void *)&cmd_pkt_filter_port_dst, 3348 (void *)&cmd_pkt_filter_flexbytes, 3349 (void *)&cmd_pkt_filter_flexbytes_value, 3350 (void *)&cmd_pkt_filter_vlan, 3351 (void *)&cmd_pkt_filter_vlan_id, 3352 NULL 3353 }, 3354 }; 3355 3356 3357 cmdline_parse_token_string_t cmd_pkt_filter_add_perfect_filter = 3358 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3359 pkt_filter, "add_perfect_filter"); 3360 cmdline_parse_inst_t cmd_add_perfect_filter = { 3361 .f = cmd_pkt_filter_parsed, 3362 .data = NULL, 3363 .help_str = "add a perfect filter", 3364 .tokens = { 3365 (void *)&cmd_pkt_filter_add_perfect_filter, 3366 (void *)&cmd_pkt_filter_port_id, 3367 (void *)&cmd_pkt_filter_protocol, 3368 (void *)&cmd_pkt_filter_src, 3369 (void *)&cmd_pkt_filter_ip_src, 3370 (void *)&cmd_pkt_filter_port_src, 3371 (void *)&cmd_pkt_filter_dst, 3372 (void *)&cmd_pkt_filter_ip_dst, 3373 (void *)&cmd_pkt_filter_port_dst, 3374 (void *)&cmd_pkt_filter_flexbytes, 3375 (void *)&cmd_pkt_filter_flexbytes_value, 3376 (void *)&cmd_pkt_filter_vlan, 3377 (void *)&cmd_pkt_filter_vlan_id, 3378 (void *)&cmd_pkt_filter_queue, 3379 (void *)&cmd_pkt_filter_queue_id, 3380 (void *)&cmd_pkt_filter_soft, 3381 (void *)&cmd_pkt_filter_soft_id, 3382 NULL, 3383 }, 3384 }; 3385 3386 3387 cmdline_parse_token_string_t cmd_pkt_filter_upd_perfect_filter = 3388 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3389 pkt_filter, "upd_perfect_filter"); 3390 cmdline_parse_inst_t cmd_upd_perfect_filter = { 3391 .f = cmd_pkt_filter_parsed, 3392 .data = NULL, 3393 .help_str = "update a perfect filter", 3394 .tokens = { 3395 (void *)&cmd_pkt_filter_upd_perfect_filter, 3396 (void *)&cmd_pkt_filter_port_id, 3397 (void *)&cmd_pkt_filter_protocol, 3398 (void *)&cmd_pkt_filter_src, 3399 (void *)&cmd_pkt_filter_ip_src, 3400 (void *)&cmd_pkt_filter_port_src, 3401 (void *)&cmd_pkt_filter_dst, 3402 (void *)&cmd_pkt_filter_ip_dst, 3403 (void *)&cmd_pkt_filter_port_dst, 3404 (void *)&cmd_pkt_filter_flexbytes, 3405 (void *)&cmd_pkt_filter_flexbytes_value, 3406 (void *)&cmd_pkt_filter_vlan, 3407 (void *)&cmd_pkt_filter_vlan_id, 3408 (void *)&cmd_pkt_filter_queue, 3409 (void *)&cmd_pkt_filter_queue_id, 3410 (void *)&cmd_pkt_filter_soft, 3411 (void *)&cmd_pkt_filter_soft_id, 3412 NULL, 3413 }, 3414 }; 3415 3416 3417 cmdline_parse_token_string_t cmd_pkt_filter_rm_perfect_filter = 3418 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_result, 3419 pkt_filter, "rm_perfect_filter"); 3420 cmdline_parse_inst_t cmd_rm_perfect_filter = { 3421 .f = cmd_pkt_filter_parsed, 3422 .data = NULL, 3423 .help_str = "remove a perfect filter", 3424 .tokens = { 3425 (void *)&cmd_pkt_filter_rm_perfect_filter, 3426 (void *)&cmd_pkt_filter_port_id, 3427 (void *)&cmd_pkt_filter_protocol, 3428 (void *)&cmd_pkt_filter_src, 3429 (void *)&cmd_pkt_filter_ip_src, 3430 (void *)&cmd_pkt_filter_port_src, 3431 (void *)&cmd_pkt_filter_dst, 3432 (void *)&cmd_pkt_filter_ip_dst, 3433 (void *)&cmd_pkt_filter_port_dst, 3434 (void *)&cmd_pkt_filter_flexbytes, 3435 (void *)&cmd_pkt_filter_flexbytes_value, 3436 (void *)&cmd_pkt_filter_vlan, 3437 (void *)&cmd_pkt_filter_vlan_id, 3438 (void *)&cmd_pkt_filter_soft, 3439 (void *)&cmd_pkt_filter_soft_id, 3440 NULL, 3441 }, 3442 }; 3443 3444 /* *** SETUP MASKS FILTER *** */ 3445 struct cmd_pkt_filter_masks_result { 3446 cmdline_fixed_string_t filter_mask; 3447 uint8_t port_id; 3448 cmdline_fixed_string_t src_mask; 3449 uint32_t ip_src_mask; 3450 uint16_t ipv6_src_mask; 3451 uint16_t port_src_mask; 3452 cmdline_fixed_string_t dst_mask; 3453 uint32_t ip_dst_mask; 3454 uint16_t ipv6_dst_mask; 3455 uint16_t port_dst_mask; 3456 cmdline_fixed_string_t flexbytes; 3457 uint8_t flexbytes_value; 3458 cmdline_fixed_string_t vlan_id; 3459 uint8_t vlan_id_value; 3460 cmdline_fixed_string_t vlan_prio; 3461 uint8_t vlan_prio_value; 3462 cmdline_fixed_string_t only_ip_flow; 3463 uint8_t only_ip_flow_value; 3464 cmdline_fixed_string_t comp_ipv6_dst; 3465 uint8_t comp_ipv6_dst_value; 3466 }; 3467 3468 static void 3469 cmd_pkt_filter_masks_parsed(void *parsed_result, 3470 __attribute__((unused)) struct cmdline *cl, 3471 __attribute__((unused)) void *data) 3472 { 3473 struct rte_fdir_masks fdir_masks; 3474 struct cmd_pkt_filter_masks_result *res = parsed_result; 3475 3476 memset(&fdir_masks, 0, sizeof(struct rte_fdir_masks)); 3477 3478 fdir_masks.only_ip_flow = res->only_ip_flow_value; 3479 fdir_masks.vlan_id = res->vlan_id_value; 3480 fdir_masks.vlan_prio = res->vlan_prio_value; 3481 fdir_masks.dst_ipv4_mask = res->ip_dst_mask; 3482 fdir_masks.src_ipv4_mask = res->ip_src_mask; 3483 fdir_masks.src_port_mask = res->port_src_mask; 3484 fdir_masks.dst_port_mask = res->port_dst_mask; 3485 fdir_masks.flexbytes = res->flexbytes_value; 3486 3487 fdir_set_masks(res->port_id, &fdir_masks); 3488 } 3489 3490 cmdline_parse_token_string_t cmd_pkt_filter_masks_filter_mask = 3491 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result, 3492 filter_mask, "set_masks_filter"); 3493 cmdline_parse_token_num_t cmd_pkt_filter_masks_port_id = 3494 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3495 port_id, UINT8); 3496 cmdline_parse_token_string_t cmd_pkt_filter_masks_only_ip_flow = 3497 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result, 3498 only_ip_flow, "only_ip_flow"); 3499 cmdline_parse_token_num_t cmd_pkt_filter_masks_only_ip_flow_value = 3500 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3501 only_ip_flow_value, UINT8); 3502 cmdline_parse_token_string_t cmd_pkt_filter_masks_src_mask = 3503 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result, 3504 src_mask, "src_mask"); 3505 cmdline_parse_token_num_t cmd_pkt_filter_masks_ip_src_mask = 3506 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3507 ip_src_mask, UINT32); 3508 cmdline_parse_token_num_t cmd_pkt_filter_masks_port_src_mask = 3509 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3510 port_src_mask, UINT16); 3511 cmdline_parse_token_string_t cmd_pkt_filter_masks_dst_mask = 3512 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result, 3513 dst_mask, "dst_mask"); 3514 cmdline_parse_token_num_t cmd_pkt_filter_masks_ip_dst_mask = 3515 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3516 ip_dst_mask, UINT32); 3517 cmdline_parse_token_num_t cmd_pkt_filter_masks_port_dst_mask = 3518 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3519 port_dst_mask, UINT16); 3520 cmdline_parse_token_string_t cmd_pkt_filter_masks_flexbytes = 3521 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result, 3522 flexbytes, "flexbytes"); 3523 cmdline_parse_token_num_t cmd_pkt_filter_masks_flexbytes_value = 3524 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3525 flexbytes_value, UINT8); 3526 cmdline_parse_token_string_t cmd_pkt_filter_masks_vlan_id = 3527 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result, 3528 vlan_id, "vlan_id"); 3529 cmdline_parse_token_num_t cmd_pkt_filter_masks_vlan_id_value = 3530 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3531 vlan_id_value, UINT8); 3532 cmdline_parse_token_string_t cmd_pkt_filter_masks_vlan_prio = 3533 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result, 3534 vlan_prio, "vlan_prio"); 3535 cmdline_parse_token_num_t cmd_pkt_filter_masks_vlan_prio_value = 3536 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3537 vlan_prio_value, UINT8); 3538 3539 cmdline_parse_inst_t cmd_set_masks_filter = { 3540 .f = cmd_pkt_filter_masks_parsed, 3541 .data = NULL, 3542 .help_str = "setup masks filter", 3543 .tokens = { 3544 (void *)&cmd_pkt_filter_masks_filter_mask, 3545 (void *)&cmd_pkt_filter_masks_port_id, 3546 (void *)&cmd_pkt_filter_masks_only_ip_flow, 3547 (void *)&cmd_pkt_filter_masks_only_ip_flow_value, 3548 (void *)&cmd_pkt_filter_masks_src_mask, 3549 (void *)&cmd_pkt_filter_masks_ip_src_mask, 3550 (void *)&cmd_pkt_filter_masks_port_src_mask, 3551 (void *)&cmd_pkt_filter_masks_dst_mask, 3552 (void *)&cmd_pkt_filter_masks_ip_dst_mask, 3553 (void *)&cmd_pkt_filter_masks_port_dst_mask, 3554 (void *)&cmd_pkt_filter_masks_flexbytes, 3555 (void *)&cmd_pkt_filter_masks_flexbytes_value, 3556 (void *)&cmd_pkt_filter_masks_vlan_id, 3557 (void *)&cmd_pkt_filter_masks_vlan_id_value, 3558 (void *)&cmd_pkt_filter_masks_vlan_prio, 3559 (void *)&cmd_pkt_filter_masks_vlan_prio_value, 3560 NULL, 3561 }, 3562 }; 3563 3564 static void 3565 cmd_pkt_filter_masks_ipv6_parsed(void *parsed_result, 3566 __attribute__((unused)) struct cmdline *cl, 3567 __attribute__((unused)) void *data) 3568 { 3569 struct rte_fdir_masks fdir_masks; 3570 struct cmd_pkt_filter_masks_result *res = parsed_result; 3571 3572 memset(&fdir_masks, 0, sizeof(struct rte_fdir_masks)); 3573 3574 fdir_masks.set_ipv6_mask = 1; 3575 fdir_masks.only_ip_flow = res->only_ip_flow_value; 3576 fdir_masks.vlan_id = res->vlan_id_value; 3577 fdir_masks.vlan_prio = res->vlan_prio_value; 3578 fdir_masks.dst_ipv6_mask = res->ipv6_dst_mask; 3579 fdir_masks.src_ipv6_mask = res->ipv6_src_mask; 3580 fdir_masks.src_port_mask = res->port_src_mask; 3581 fdir_masks.dst_port_mask = res->port_dst_mask; 3582 fdir_masks.flexbytes = res->flexbytes_value; 3583 fdir_masks.comp_ipv6_dst = res->comp_ipv6_dst_value; 3584 3585 fdir_set_masks(res->port_id, &fdir_masks); 3586 } 3587 3588 cmdline_parse_token_string_t cmd_pkt_filter_masks_filter_mask_ipv6 = 3589 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result, 3590 filter_mask, "set_ipv6_masks_filter"); 3591 cmdline_parse_token_num_t cmd_pkt_filter_masks_src_mask_ipv6_value = 3592 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3593 ipv6_src_mask, UINT16); 3594 cmdline_parse_token_num_t cmd_pkt_filter_masks_dst_mask_ipv6_value = 3595 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3596 ipv6_dst_mask, UINT16); 3597 3598 cmdline_parse_token_string_t cmd_pkt_filter_masks_comp_ipv6_dst = 3599 TOKEN_STRING_INITIALIZER(struct cmd_pkt_filter_masks_result, 3600 comp_ipv6_dst, "compare_dst"); 3601 cmdline_parse_token_num_t cmd_pkt_filter_masks_comp_ipv6_dst_value = 3602 TOKEN_NUM_INITIALIZER(struct cmd_pkt_filter_masks_result, 3603 comp_ipv6_dst_value, UINT8); 3604 3605 cmdline_parse_inst_t cmd_set_ipv6_masks_filter = { 3606 .f = cmd_pkt_filter_masks_ipv6_parsed, 3607 .data = NULL, 3608 .help_str = "setup ipv6 masks filter", 3609 .tokens = { 3610 (void *)&cmd_pkt_filter_masks_filter_mask_ipv6, 3611 (void *)&cmd_pkt_filter_masks_port_id, 3612 (void *)&cmd_pkt_filter_masks_only_ip_flow, 3613 (void *)&cmd_pkt_filter_masks_only_ip_flow_value, 3614 (void *)&cmd_pkt_filter_masks_src_mask, 3615 (void *)&cmd_pkt_filter_masks_src_mask_ipv6_value, 3616 (void *)&cmd_pkt_filter_masks_port_src_mask, 3617 (void *)&cmd_pkt_filter_masks_dst_mask, 3618 (void *)&cmd_pkt_filter_masks_dst_mask_ipv6_value, 3619 (void *)&cmd_pkt_filter_masks_port_dst_mask, 3620 (void *)&cmd_pkt_filter_masks_flexbytes, 3621 (void *)&cmd_pkt_filter_masks_flexbytes_value, 3622 (void *)&cmd_pkt_filter_masks_vlan_id, 3623 (void *)&cmd_pkt_filter_masks_vlan_id_value, 3624 (void *)&cmd_pkt_filter_masks_vlan_prio, 3625 (void *)&cmd_pkt_filter_masks_vlan_prio_value, 3626 (void *)&cmd_pkt_filter_masks_comp_ipv6_dst, 3627 (void *)&cmd_pkt_filter_masks_comp_ipv6_dst_value, 3628 NULL, 3629 }, 3630 }; 3631 3632 /* *** SETUP ETHERNET LINK FLOW CONTROL *** */ 3633 struct cmd_link_flow_ctrl_set_result { 3634 cmdline_fixed_string_t set; 3635 cmdline_fixed_string_t flow_ctrl; 3636 cmdline_fixed_string_t rx; 3637 cmdline_fixed_string_t rx_lfc_mode; 3638 cmdline_fixed_string_t tx; 3639 cmdline_fixed_string_t tx_lfc_mode; 3640 cmdline_fixed_string_t mac_ctrl_frame_fwd; 3641 cmdline_fixed_string_t mac_ctrl_frame_fwd_mode; 3642 uint32_t high_water; 3643 uint32_t low_water; 3644 uint16_t pause_time; 3645 uint16_t send_xon; 3646 uint8_t port_id; 3647 }; 3648 3649 static void 3650 cmd_link_flow_ctrl_set_parsed(void *parsed_result, 3651 __attribute__((unused)) struct cmdline *cl, 3652 __attribute__((unused)) void *data) 3653 { 3654 struct cmd_link_flow_ctrl_set_result *res = parsed_result; 3655 struct rte_eth_fc_conf fc_conf; 3656 int rx_fc_enable, tx_fc_enable, mac_ctrl_frame_fwd; 3657 int ret; 3658 3659 /* 3660 * Rx on/off, flow control is enabled/disabled on RX side. This can indicate 3661 * the RTE_FC_TX_PAUSE, Transmit pause frame at the Rx side. 3662 * Tx on/off, flow control is enabled/disabled on TX side. This can indicate 3663 * the RTE_FC_RX_PAUSE, Respond to the pause frame at the Tx side. 3664 */ 3665 static enum rte_eth_fc_mode rx_tx_onoff_2_lfc_mode[2][2] = { 3666 {RTE_FC_NONE, RTE_FC_TX_PAUSE}, {RTE_FC_RX_PAUSE, RTE_FC_FULL} 3667 }; 3668 3669 rx_fc_enable = (!strcmp(res->rx_lfc_mode, "on")) ? 1 : 0; 3670 tx_fc_enable = (!strcmp(res->tx_lfc_mode, "on")) ? 1 : 0; 3671 mac_ctrl_frame_fwd = (!strcmp(res->mac_ctrl_frame_fwd_mode, "on")) ? 1 : 0; 3672 3673 fc_conf.mode = rx_tx_onoff_2_lfc_mode[rx_fc_enable][tx_fc_enable]; 3674 fc_conf.high_water = res->high_water; 3675 fc_conf.low_water = res->low_water; 3676 fc_conf.pause_time = res->pause_time; 3677 fc_conf.send_xon = res->send_xon; 3678 fc_conf.mac_ctrl_frame_fwd = (uint8_t)mac_ctrl_frame_fwd; 3679 3680 ret = rte_eth_dev_flow_ctrl_set(res->port_id, &fc_conf); 3681 if (ret != 0) 3682 printf("bad flow contrl parameter, return code = %d \n", ret); 3683 } 3684 3685 cmdline_parse_token_string_t cmd_lfc_set_set = 3686 TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3687 set, "set"); 3688 cmdline_parse_token_string_t cmd_lfc_set_flow_ctrl = 3689 TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3690 flow_ctrl, "flow_ctrl"); 3691 cmdline_parse_token_string_t cmd_lfc_set_rx = 3692 TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3693 rx, "rx"); 3694 cmdline_parse_token_string_t cmd_lfc_set_rx_mode = 3695 TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3696 rx_lfc_mode, "on#off"); 3697 cmdline_parse_token_string_t cmd_lfc_set_tx = 3698 TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3699 tx, "tx"); 3700 cmdline_parse_token_string_t cmd_lfc_set_tx_mode = 3701 TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3702 tx_lfc_mode, "on#off"); 3703 cmdline_parse_token_num_t cmd_lfc_set_high_water = 3704 TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3705 high_water, UINT32); 3706 cmdline_parse_token_num_t cmd_lfc_set_low_water = 3707 TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3708 low_water, UINT32); 3709 cmdline_parse_token_num_t cmd_lfc_set_pause_time = 3710 TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3711 pause_time, UINT16); 3712 cmdline_parse_token_num_t cmd_lfc_set_send_xon = 3713 TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3714 send_xon, UINT16); 3715 cmdline_parse_token_string_t cmd_lfc_set_mac_ctrl_frame_fwd_mode = 3716 TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3717 mac_ctrl_frame_fwd, "mac_ctrl_frame_fwd"); 3718 cmdline_parse_token_string_t cmd_lfc_set_mac_ctrl_frame_fwd = 3719 TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3720 mac_ctrl_frame_fwd_mode, "on#off"); 3721 cmdline_parse_token_num_t cmd_lfc_set_portid = 3722 TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result, 3723 port_id, UINT8); 3724 3725 cmdline_parse_inst_t cmd_link_flow_control_set = { 3726 .f = cmd_link_flow_ctrl_set_parsed, 3727 .data = NULL, 3728 .help_str = "Configure the Ethernet flow control: set flow_ctrl rx on|off \ 3729 tx on|off high_water low_water pause_time send_xon mac_ctrl_frame_fwd on|off \ 3730 port_id", 3731 .tokens = { 3732 (void *)&cmd_lfc_set_set, 3733 (void *)&cmd_lfc_set_flow_ctrl, 3734 (void *)&cmd_lfc_set_rx, 3735 (void *)&cmd_lfc_set_rx_mode, 3736 (void *)&cmd_lfc_set_tx, 3737 (void *)&cmd_lfc_set_tx_mode, 3738 (void *)&cmd_lfc_set_high_water, 3739 (void *)&cmd_lfc_set_low_water, 3740 (void *)&cmd_lfc_set_pause_time, 3741 (void *)&cmd_lfc_set_send_xon, 3742 (void *)&cmd_lfc_set_mac_ctrl_frame_fwd_mode, 3743 (void *)&cmd_lfc_set_mac_ctrl_frame_fwd, 3744 (void *)&cmd_lfc_set_portid, 3745 NULL, 3746 }, 3747 }; 3748 3749 /* *** SETUP ETHERNET PIRORITY FLOW CONTROL *** */ 3750 struct cmd_priority_flow_ctrl_set_result { 3751 cmdline_fixed_string_t set; 3752 cmdline_fixed_string_t pfc_ctrl; 3753 cmdline_fixed_string_t rx; 3754 cmdline_fixed_string_t rx_pfc_mode; 3755 cmdline_fixed_string_t tx; 3756 cmdline_fixed_string_t tx_pfc_mode; 3757 uint32_t high_water; 3758 uint32_t low_water; 3759 uint16_t pause_time; 3760 uint8_t priority; 3761 uint8_t port_id; 3762 }; 3763 3764 static void 3765 cmd_priority_flow_ctrl_set_parsed(void *parsed_result, 3766 __attribute__((unused)) struct cmdline *cl, 3767 __attribute__((unused)) void *data) 3768 { 3769 struct cmd_priority_flow_ctrl_set_result *res = parsed_result; 3770 struct rte_eth_pfc_conf pfc_conf; 3771 int rx_fc_enable, tx_fc_enable; 3772 int ret; 3773 3774 /* 3775 * Rx on/off, flow control is enabled/disabled on RX side. This can indicate 3776 * the RTE_FC_TX_PAUSE, Transmit pause frame at the Rx side. 3777 * Tx on/off, flow control is enabled/disabled on TX side. This can indicate 3778 * the RTE_FC_RX_PAUSE, Respond to the pause frame at the Tx side. 3779 */ 3780 static enum rte_eth_fc_mode rx_tx_onoff_2_pfc_mode[2][2] = { 3781 {RTE_FC_NONE, RTE_FC_RX_PAUSE}, {RTE_FC_TX_PAUSE, RTE_FC_FULL} 3782 }; 3783 3784 rx_fc_enable = (!strncmp(res->rx_pfc_mode, "on",2)) ? 1 : 0; 3785 tx_fc_enable = (!strncmp(res->tx_pfc_mode, "on",2)) ? 1 : 0; 3786 pfc_conf.fc.mode = rx_tx_onoff_2_pfc_mode[rx_fc_enable][tx_fc_enable]; 3787 pfc_conf.fc.high_water = res->high_water; 3788 pfc_conf.fc.low_water = res->low_water; 3789 pfc_conf.fc.pause_time = res->pause_time; 3790 pfc_conf.priority = res->priority; 3791 3792 ret = rte_eth_dev_priority_flow_ctrl_set(res->port_id, &pfc_conf); 3793 if (ret != 0) 3794 printf("bad priority flow contrl parameter, return code = %d \n", ret); 3795 } 3796 3797 cmdline_parse_token_string_t cmd_pfc_set_set = 3798 TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, 3799 set, "set"); 3800 cmdline_parse_token_string_t cmd_pfc_set_flow_ctrl = 3801 TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, 3802 pfc_ctrl, "pfc_ctrl"); 3803 cmdline_parse_token_string_t cmd_pfc_set_rx = 3804 TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, 3805 rx, "rx"); 3806 cmdline_parse_token_string_t cmd_pfc_set_rx_mode = 3807 TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, 3808 rx_pfc_mode, "on#off"); 3809 cmdline_parse_token_string_t cmd_pfc_set_tx = 3810 TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, 3811 tx, "tx"); 3812 cmdline_parse_token_string_t cmd_pfc_set_tx_mode = 3813 TOKEN_STRING_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, 3814 tx_pfc_mode, "on#off"); 3815 cmdline_parse_token_num_t cmd_pfc_set_high_water = 3816 TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, 3817 high_water, UINT32); 3818 cmdline_parse_token_num_t cmd_pfc_set_low_water = 3819 TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, 3820 low_water, UINT32); 3821 cmdline_parse_token_num_t cmd_pfc_set_pause_time = 3822 TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, 3823 pause_time, UINT16); 3824 cmdline_parse_token_num_t cmd_pfc_set_priority = 3825 TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, 3826 priority, UINT8); 3827 cmdline_parse_token_num_t cmd_pfc_set_portid = 3828 TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result, 3829 port_id, UINT8); 3830 3831 cmdline_parse_inst_t cmd_priority_flow_control_set = { 3832 .f = cmd_priority_flow_ctrl_set_parsed, 3833 .data = NULL, 3834 .help_str = "Configure the Ethernet priority flow control: set pfc_ctrl rx on|off\n\ 3835 tx on|off high_water low_water pause_time priority port_id", 3836 .tokens = { 3837 (void *)&cmd_pfc_set_set, 3838 (void *)&cmd_pfc_set_flow_ctrl, 3839 (void *)&cmd_pfc_set_rx, 3840 (void *)&cmd_pfc_set_rx_mode, 3841 (void *)&cmd_pfc_set_tx, 3842 (void *)&cmd_pfc_set_tx_mode, 3843 (void *)&cmd_pfc_set_high_water, 3844 (void *)&cmd_pfc_set_low_water, 3845 (void *)&cmd_pfc_set_pause_time, 3846 (void *)&cmd_pfc_set_priority, 3847 (void *)&cmd_pfc_set_portid, 3848 NULL, 3849 }, 3850 }; 3851 3852 /* *** RESET CONFIGURATION *** */ 3853 struct cmd_reset_result { 3854 cmdline_fixed_string_t reset; 3855 cmdline_fixed_string_t def; 3856 }; 3857 3858 static void cmd_reset_parsed(__attribute__((unused)) void *parsed_result, 3859 struct cmdline *cl, 3860 __attribute__((unused)) void *data) 3861 { 3862 cmdline_printf(cl, "Reset to default forwarding configuration...\n"); 3863 set_def_fwd_config(); 3864 } 3865 3866 cmdline_parse_token_string_t cmd_reset_set = 3867 TOKEN_STRING_INITIALIZER(struct cmd_reset_result, reset, "set"); 3868 cmdline_parse_token_string_t cmd_reset_def = 3869 TOKEN_STRING_INITIALIZER(struct cmd_reset_result, def, 3870 "default"); 3871 3872 cmdline_parse_inst_t cmd_reset = { 3873 .f = cmd_reset_parsed, 3874 .data = NULL, 3875 .help_str = "set default: reset default forwarding configuration", 3876 .tokens = { 3877 (void *)&cmd_reset_set, 3878 (void *)&cmd_reset_def, 3879 NULL, 3880 }, 3881 }; 3882 3883 /* *** START FORWARDING *** */ 3884 struct cmd_start_result { 3885 cmdline_fixed_string_t start; 3886 }; 3887 3888 cmdline_parse_token_string_t cmd_start_start = 3889 TOKEN_STRING_INITIALIZER(struct cmd_start_result, start, "start"); 3890 3891 static void cmd_start_parsed(__attribute__((unused)) void *parsed_result, 3892 __attribute__((unused)) struct cmdline *cl, 3893 __attribute__((unused)) void *data) 3894 { 3895 start_packet_forwarding(0); 3896 } 3897 3898 cmdline_parse_inst_t cmd_start = { 3899 .f = cmd_start_parsed, 3900 .data = NULL, 3901 .help_str = "start packet forwarding", 3902 .tokens = { 3903 (void *)&cmd_start_start, 3904 NULL, 3905 }, 3906 }; 3907 3908 /* *** START FORWARDING WITH ONE TX BURST FIRST *** */ 3909 struct cmd_start_tx_first_result { 3910 cmdline_fixed_string_t start; 3911 cmdline_fixed_string_t tx_first; 3912 }; 3913 3914 static void 3915 cmd_start_tx_first_parsed(__attribute__((unused)) void *parsed_result, 3916 __attribute__((unused)) struct cmdline *cl, 3917 __attribute__((unused)) void *data) 3918 { 3919 start_packet_forwarding(1); 3920 } 3921 3922 cmdline_parse_token_string_t cmd_start_tx_first_start = 3923 TOKEN_STRING_INITIALIZER(struct cmd_start_tx_first_result, start, 3924 "start"); 3925 cmdline_parse_token_string_t cmd_start_tx_first_tx_first = 3926 TOKEN_STRING_INITIALIZER(struct cmd_start_tx_first_result, 3927 tx_first, "tx_first"); 3928 3929 cmdline_parse_inst_t cmd_start_tx_first = { 3930 .f = cmd_start_tx_first_parsed, 3931 .data = NULL, 3932 .help_str = "start packet forwarding, after sending 1 burst of packets", 3933 .tokens = { 3934 (void *)&cmd_start_tx_first_start, 3935 (void *)&cmd_start_tx_first_tx_first, 3936 NULL, 3937 }, 3938 }; 3939 3940 /* *** SET LINK UP *** */ 3941 struct cmd_set_link_up_result { 3942 cmdline_fixed_string_t set; 3943 cmdline_fixed_string_t link_up; 3944 cmdline_fixed_string_t port; 3945 uint8_t port_id; 3946 }; 3947 3948 cmdline_parse_token_string_t cmd_set_link_up_set = 3949 TOKEN_STRING_INITIALIZER(struct cmd_set_link_up_result, set, "set"); 3950 cmdline_parse_token_string_t cmd_set_link_up_link_up = 3951 TOKEN_STRING_INITIALIZER(struct cmd_set_link_up_result, link_up, 3952 "link-up"); 3953 cmdline_parse_token_string_t cmd_set_link_up_port = 3954 TOKEN_STRING_INITIALIZER(struct cmd_set_link_up_result, port, "port"); 3955 cmdline_parse_token_num_t cmd_set_link_up_port_id = 3956 TOKEN_NUM_INITIALIZER(struct cmd_set_link_up_result, port_id, UINT8); 3957 3958 static void cmd_set_link_up_parsed(__attribute__((unused)) void *parsed_result, 3959 __attribute__((unused)) struct cmdline *cl, 3960 __attribute__((unused)) void *data) 3961 { 3962 struct cmd_set_link_up_result *res = parsed_result; 3963 dev_set_link_up(res->port_id); 3964 } 3965 3966 cmdline_parse_inst_t cmd_set_link_up = { 3967 .f = cmd_set_link_up_parsed, 3968 .data = NULL, 3969 .help_str = "set link-up port (port id)", 3970 .tokens = { 3971 (void *)&cmd_set_link_up_set, 3972 (void *)&cmd_set_link_up_link_up, 3973 (void *)&cmd_set_link_up_port, 3974 (void *)&cmd_set_link_up_port_id, 3975 NULL, 3976 }, 3977 }; 3978 3979 /* *** SET LINK DOWN *** */ 3980 struct cmd_set_link_down_result { 3981 cmdline_fixed_string_t set; 3982 cmdline_fixed_string_t link_down; 3983 cmdline_fixed_string_t port; 3984 uint8_t port_id; 3985 }; 3986 3987 cmdline_parse_token_string_t cmd_set_link_down_set = 3988 TOKEN_STRING_INITIALIZER(struct cmd_set_link_down_result, set, "set"); 3989 cmdline_parse_token_string_t cmd_set_link_down_link_down = 3990 TOKEN_STRING_INITIALIZER(struct cmd_set_link_down_result, link_down, 3991 "link-down"); 3992 cmdline_parse_token_string_t cmd_set_link_down_port = 3993 TOKEN_STRING_INITIALIZER(struct cmd_set_link_down_result, port, "port"); 3994 cmdline_parse_token_num_t cmd_set_link_down_port_id = 3995 TOKEN_NUM_INITIALIZER(struct cmd_set_link_down_result, port_id, UINT8); 3996 3997 static void cmd_set_link_down_parsed( 3998 __attribute__((unused)) void *parsed_result, 3999 __attribute__((unused)) struct cmdline *cl, 4000 __attribute__((unused)) void *data) 4001 { 4002 struct cmd_set_link_down_result *res = parsed_result; 4003 dev_set_link_down(res->port_id); 4004 } 4005 4006 cmdline_parse_inst_t cmd_set_link_down = { 4007 .f = cmd_set_link_down_parsed, 4008 .data = NULL, 4009 .help_str = "set link-down port (port id)", 4010 .tokens = { 4011 (void *)&cmd_set_link_down_set, 4012 (void *)&cmd_set_link_down_link_down, 4013 (void *)&cmd_set_link_down_port, 4014 (void *)&cmd_set_link_down_port_id, 4015 NULL, 4016 }, 4017 }; 4018 4019 /* *** SHOW CFG *** */ 4020 struct cmd_showcfg_result { 4021 cmdline_fixed_string_t show; 4022 cmdline_fixed_string_t cfg; 4023 cmdline_fixed_string_t what; 4024 }; 4025 4026 static void cmd_showcfg_parsed(void *parsed_result, 4027 __attribute__((unused)) struct cmdline *cl, 4028 __attribute__((unused)) void *data) 4029 { 4030 struct cmd_showcfg_result *res = parsed_result; 4031 if (!strcmp(res->what, "rxtx")) 4032 rxtx_config_display(); 4033 else if (!strcmp(res->what, "cores")) 4034 fwd_lcores_config_display(); 4035 else if (!strcmp(res->what, "fwd")) 4036 fwd_config_display(); 4037 } 4038 4039 cmdline_parse_token_string_t cmd_showcfg_show = 4040 TOKEN_STRING_INITIALIZER(struct cmd_showcfg_result, show, "show"); 4041 cmdline_parse_token_string_t cmd_showcfg_port = 4042 TOKEN_STRING_INITIALIZER(struct cmd_showcfg_result, cfg, "config"); 4043 cmdline_parse_token_string_t cmd_showcfg_what = 4044 TOKEN_STRING_INITIALIZER(struct cmd_showcfg_result, what, 4045 "rxtx#cores#fwd"); 4046 4047 cmdline_parse_inst_t cmd_showcfg = { 4048 .f = cmd_showcfg_parsed, 4049 .data = NULL, 4050 .help_str = "show config rxtx|cores|fwd", 4051 .tokens = { 4052 (void *)&cmd_showcfg_show, 4053 (void *)&cmd_showcfg_port, 4054 (void *)&cmd_showcfg_what, 4055 NULL, 4056 }, 4057 }; 4058 4059 /* *** SHOW ALL PORT INFO *** */ 4060 struct cmd_showportall_result { 4061 cmdline_fixed_string_t show; 4062 cmdline_fixed_string_t port; 4063 cmdline_fixed_string_t what; 4064 cmdline_fixed_string_t all; 4065 }; 4066 4067 static void cmd_showportall_parsed(void *parsed_result, 4068 __attribute__((unused)) struct cmdline *cl, 4069 __attribute__((unused)) void *data) 4070 { 4071 portid_t i; 4072 4073 struct cmd_showportall_result *res = parsed_result; 4074 if (!strcmp(res->show, "clear")) { 4075 if (!strcmp(res->what, "stats")) 4076 for (i = 0; i < nb_ports; i++) 4077 nic_stats_clear(i); 4078 } else if (!strcmp(res->what, "info")) 4079 for (i = 0; i < nb_ports; i++) 4080 port_infos_display(i); 4081 else if (!strcmp(res->what, "stats")) 4082 for (i = 0; i < nb_ports; i++) 4083 nic_stats_display(i); 4084 else if (!strcmp(res->what, "fdir")) 4085 for (i = 0; i < nb_ports; i++) 4086 fdir_get_infos(i); 4087 else if (!strcmp(res->what, "stat_qmap")) 4088 for (i = 0; i < nb_ports; i++) 4089 nic_stats_mapping_display(i); 4090 } 4091 4092 cmdline_parse_token_string_t cmd_showportall_show = 4093 TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, show, 4094 "show#clear"); 4095 cmdline_parse_token_string_t cmd_showportall_port = 4096 TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, port, "port"); 4097 cmdline_parse_token_string_t cmd_showportall_what = 4098 TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, what, 4099 "info#stats#fdir#stat_qmap"); 4100 cmdline_parse_token_string_t cmd_showportall_all = 4101 TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, all, "all"); 4102 cmdline_parse_inst_t cmd_showportall = { 4103 .f = cmd_showportall_parsed, 4104 .data = NULL, 4105 .help_str = "show|clear port info|stats|fdir|stat_qmap all", 4106 .tokens = { 4107 (void *)&cmd_showportall_show, 4108 (void *)&cmd_showportall_port, 4109 (void *)&cmd_showportall_what, 4110 (void *)&cmd_showportall_all, 4111 NULL, 4112 }, 4113 }; 4114 4115 /* *** SHOW PORT INFO *** */ 4116 struct cmd_showport_result { 4117 cmdline_fixed_string_t show; 4118 cmdline_fixed_string_t port; 4119 cmdline_fixed_string_t what; 4120 uint8_t portnum; 4121 }; 4122 4123 static void cmd_showport_parsed(void *parsed_result, 4124 __attribute__((unused)) struct cmdline *cl, 4125 __attribute__((unused)) void *data) 4126 { 4127 struct cmd_showport_result *res = parsed_result; 4128 if (!strcmp(res->show, "clear")) { 4129 if (!strcmp(res->what, "stats")) 4130 nic_stats_clear(res->portnum); 4131 } else if (!strcmp(res->what, "info")) 4132 port_infos_display(res->portnum); 4133 else if (!strcmp(res->what, "stats")) 4134 nic_stats_display(res->portnum); 4135 else if (!strcmp(res->what, "fdir")) 4136 fdir_get_infos(res->portnum); 4137 else if (!strcmp(res->what, "stat_qmap")) 4138 nic_stats_mapping_display(res->portnum); 4139 } 4140 4141 cmdline_parse_token_string_t cmd_showport_show = 4142 TOKEN_STRING_INITIALIZER(struct cmd_showport_result, show, 4143 "show#clear"); 4144 cmdline_parse_token_string_t cmd_showport_port = 4145 TOKEN_STRING_INITIALIZER(struct cmd_showport_result, port, "port"); 4146 cmdline_parse_token_string_t cmd_showport_what = 4147 TOKEN_STRING_INITIALIZER(struct cmd_showport_result, what, 4148 "info#stats#fdir#stat_qmap"); 4149 cmdline_parse_token_num_t cmd_showport_portnum = 4150 TOKEN_NUM_INITIALIZER(struct cmd_showport_result, portnum, INT32); 4151 4152 cmdline_parse_inst_t cmd_showport = { 4153 .f = cmd_showport_parsed, 4154 .data = NULL, 4155 .help_str = "show|clear port info|stats|fdir|stat_qmap X (X = port number)", 4156 .tokens = { 4157 (void *)&cmd_showport_show, 4158 (void *)&cmd_showport_port, 4159 (void *)&cmd_showport_what, 4160 (void *)&cmd_showport_portnum, 4161 NULL, 4162 }, 4163 }; 4164 4165 /* *** READ PORT REGISTER *** */ 4166 struct cmd_read_reg_result { 4167 cmdline_fixed_string_t read; 4168 cmdline_fixed_string_t reg; 4169 uint8_t port_id; 4170 uint32_t reg_off; 4171 }; 4172 4173 static void 4174 cmd_read_reg_parsed(void *parsed_result, 4175 __attribute__((unused)) struct cmdline *cl, 4176 __attribute__((unused)) void *data) 4177 { 4178 struct cmd_read_reg_result *res = parsed_result; 4179 port_reg_display(res->port_id, res->reg_off); 4180 } 4181 4182 cmdline_parse_token_string_t cmd_read_reg_read = 4183 TOKEN_STRING_INITIALIZER(struct cmd_read_reg_result, read, "read"); 4184 cmdline_parse_token_string_t cmd_read_reg_reg = 4185 TOKEN_STRING_INITIALIZER(struct cmd_read_reg_result, reg, "reg"); 4186 cmdline_parse_token_num_t cmd_read_reg_port_id = 4187 TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, port_id, UINT8); 4188 cmdline_parse_token_num_t cmd_read_reg_reg_off = 4189 TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, reg_off, UINT32); 4190 4191 cmdline_parse_inst_t cmd_read_reg = { 4192 .f = cmd_read_reg_parsed, 4193 .data = NULL, 4194 .help_str = "read reg port_id reg_off", 4195 .tokens = { 4196 (void *)&cmd_read_reg_read, 4197 (void *)&cmd_read_reg_reg, 4198 (void *)&cmd_read_reg_port_id, 4199 (void *)&cmd_read_reg_reg_off, 4200 NULL, 4201 }, 4202 }; 4203 4204 /* *** READ PORT REGISTER BIT FIELD *** */ 4205 struct cmd_read_reg_bit_field_result { 4206 cmdline_fixed_string_t read; 4207 cmdline_fixed_string_t regfield; 4208 uint8_t port_id; 4209 uint32_t reg_off; 4210 uint8_t bit1_pos; 4211 uint8_t bit2_pos; 4212 }; 4213 4214 static void 4215 cmd_read_reg_bit_field_parsed(void *parsed_result, 4216 __attribute__((unused)) struct cmdline *cl, 4217 __attribute__((unused)) void *data) 4218 { 4219 struct cmd_read_reg_bit_field_result *res = parsed_result; 4220 port_reg_bit_field_display(res->port_id, res->reg_off, 4221 res->bit1_pos, res->bit2_pos); 4222 } 4223 4224 cmdline_parse_token_string_t cmd_read_reg_bit_field_read = 4225 TOKEN_STRING_INITIALIZER(struct cmd_read_reg_bit_field_result, read, 4226 "read"); 4227 cmdline_parse_token_string_t cmd_read_reg_bit_field_regfield = 4228 TOKEN_STRING_INITIALIZER(struct cmd_read_reg_bit_field_result, 4229 regfield, "regfield"); 4230 cmdline_parse_token_num_t cmd_read_reg_bit_field_port_id = 4231 TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, port_id, 4232 UINT8); 4233 cmdline_parse_token_num_t cmd_read_reg_bit_field_reg_off = 4234 TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, reg_off, 4235 UINT32); 4236 cmdline_parse_token_num_t cmd_read_reg_bit_field_bit1_pos = 4237 TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, bit1_pos, 4238 UINT8); 4239 cmdline_parse_token_num_t cmd_read_reg_bit_field_bit2_pos = 4240 TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, bit2_pos, 4241 UINT8); 4242 4243 cmdline_parse_inst_t cmd_read_reg_bit_field = { 4244 .f = cmd_read_reg_bit_field_parsed, 4245 .data = NULL, 4246 .help_str = "read regfield port_id reg_off bit_x bit_y " 4247 "(read register bit field between bit_x and bit_y included)", 4248 .tokens = { 4249 (void *)&cmd_read_reg_bit_field_read, 4250 (void *)&cmd_read_reg_bit_field_regfield, 4251 (void *)&cmd_read_reg_bit_field_port_id, 4252 (void *)&cmd_read_reg_bit_field_reg_off, 4253 (void *)&cmd_read_reg_bit_field_bit1_pos, 4254 (void *)&cmd_read_reg_bit_field_bit2_pos, 4255 NULL, 4256 }, 4257 }; 4258 4259 /* *** READ PORT REGISTER BIT *** */ 4260 struct cmd_read_reg_bit_result { 4261 cmdline_fixed_string_t read; 4262 cmdline_fixed_string_t regbit; 4263 uint8_t port_id; 4264 uint32_t reg_off; 4265 uint8_t bit_pos; 4266 }; 4267 4268 static void 4269 cmd_read_reg_bit_parsed(void *parsed_result, 4270 __attribute__((unused)) struct cmdline *cl, 4271 __attribute__((unused)) void *data) 4272 { 4273 struct cmd_read_reg_bit_result *res = parsed_result; 4274 port_reg_bit_display(res->port_id, res->reg_off, res->bit_pos); 4275 } 4276 4277 cmdline_parse_token_string_t cmd_read_reg_bit_read = 4278 TOKEN_STRING_INITIALIZER(struct cmd_read_reg_bit_result, read, "read"); 4279 cmdline_parse_token_string_t cmd_read_reg_bit_regbit = 4280 TOKEN_STRING_INITIALIZER(struct cmd_read_reg_bit_result, 4281 regbit, "regbit"); 4282 cmdline_parse_token_num_t cmd_read_reg_bit_port_id = 4283 TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, port_id, UINT8); 4284 cmdline_parse_token_num_t cmd_read_reg_bit_reg_off = 4285 TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, reg_off, UINT32); 4286 cmdline_parse_token_num_t cmd_read_reg_bit_bit_pos = 4287 TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, bit_pos, UINT8); 4288 4289 cmdline_parse_inst_t cmd_read_reg_bit = { 4290 .f = cmd_read_reg_bit_parsed, 4291 .data = NULL, 4292 .help_str = "read regbit port_id reg_off bit_x (0 <= bit_x <= 31)", 4293 .tokens = { 4294 (void *)&cmd_read_reg_bit_read, 4295 (void *)&cmd_read_reg_bit_regbit, 4296 (void *)&cmd_read_reg_bit_port_id, 4297 (void *)&cmd_read_reg_bit_reg_off, 4298 (void *)&cmd_read_reg_bit_bit_pos, 4299 NULL, 4300 }, 4301 }; 4302 4303 /* *** WRITE PORT REGISTER *** */ 4304 struct cmd_write_reg_result { 4305 cmdline_fixed_string_t write; 4306 cmdline_fixed_string_t reg; 4307 uint8_t port_id; 4308 uint32_t reg_off; 4309 uint32_t value; 4310 }; 4311 4312 static void 4313 cmd_write_reg_parsed(void *parsed_result, 4314 __attribute__((unused)) struct cmdline *cl, 4315 __attribute__((unused)) void *data) 4316 { 4317 struct cmd_write_reg_result *res = parsed_result; 4318 port_reg_set(res->port_id, res->reg_off, res->value); 4319 } 4320 4321 cmdline_parse_token_string_t cmd_write_reg_write = 4322 TOKEN_STRING_INITIALIZER(struct cmd_write_reg_result, write, "write"); 4323 cmdline_parse_token_string_t cmd_write_reg_reg = 4324 TOKEN_STRING_INITIALIZER(struct cmd_write_reg_result, reg, "reg"); 4325 cmdline_parse_token_num_t cmd_write_reg_port_id = 4326 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, port_id, UINT8); 4327 cmdline_parse_token_num_t cmd_write_reg_reg_off = 4328 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, reg_off, UINT32); 4329 cmdline_parse_token_num_t cmd_write_reg_value = 4330 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, value, UINT32); 4331 4332 cmdline_parse_inst_t cmd_write_reg = { 4333 .f = cmd_write_reg_parsed, 4334 .data = NULL, 4335 .help_str = "write reg port_id reg_off reg_value", 4336 .tokens = { 4337 (void *)&cmd_write_reg_write, 4338 (void *)&cmd_write_reg_reg, 4339 (void *)&cmd_write_reg_port_id, 4340 (void *)&cmd_write_reg_reg_off, 4341 (void *)&cmd_write_reg_value, 4342 NULL, 4343 }, 4344 }; 4345 4346 /* *** WRITE PORT REGISTER BIT FIELD *** */ 4347 struct cmd_write_reg_bit_field_result { 4348 cmdline_fixed_string_t write; 4349 cmdline_fixed_string_t regfield; 4350 uint8_t port_id; 4351 uint32_t reg_off; 4352 uint8_t bit1_pos; 4353 uint8_t bit2_pos; 4354 uint32_t value; 4355 }; 4356 4357 static void 4358 cmd_write_reg_bit_field_parsed(void *parsed_result, 4359 __attribute__((unused)) struct cmdline *cl, 4360 __attribute__((unused)) void *data) 4361 { 4362 struct cmd_write_reg_bit_field_result *res = parsed_result; 4363 port_reg_bit_field_set(res->port_id, res->reg_off, 4364 res->bit1_pos, res->bit2_pos, res->value); 4365 } 4366 4367 cmdline_parse_token_string_t cmd_write_reg_bit_field_write = 4368 TOKEN_STRING_INITIALIZER(struct cmd_write_reg_bit_field_result, write, 4369 "write"); 4370 cmdline_parse_token_string_t cmd_write_reg_bit_field_regfield = 4371 TOKEN_STRING_INITIALIZER(struct cmd_write_reg_bit_field_result, 4372 regfield, "regfield"); 4373 cmdline_parse_token_num_t cmd_write_reg_bit_field_port_id = 4374 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, port_id, 4375 UINT8); 4376 cmdline_parse_token_num_t cmd_write_reg_bit_field_reg_off = 4377 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, reg_off, 4378 UINT32); 4379 cmdline_parse_token_num_t cmd_write_reg_bit_field_bit1_pos = 4380 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, bit1_pos, 4381 UINT8); 4382 cmdline_parse_token_num_t cmd_write_reg_bit_field_bit2_pos = 4383 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, bit2_pos, 4384 UINT8); 4385 cmdline_parse_token_num_t cmd_write_reg_bit_field_value = 4386 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, value, 4387 UINT32); 4388 4389 cmdline_parse_inst_t cmd_write_reg_bit_field = { 4390 .f = cmd_write_reg_bit_field_parsed, 4391 .data = NULL, 4392 .help_str = "write regfield port_id reg_off bit_x bit_y reg_value" 4393 "(set register bit field between bit_x and bit_y included)", 4394 .tokens = { 4395 (void *)&cmd_write_reg_bit_field_write, 4396 (void *)&cmd_write_reg_bit_field_regfield, 4397 (void *)&cmd_write_reg_bit_field_port_id, 4398 (void *)&cmd_write_reg_bit_field_reg_off, 4399 (void *)&cmd_write_reg_bit_field_bit1_pos, 4400 (void *)&cmd_write_reg_bit_field_bit2_pos, 4401 (void *)&cmd_write_reg_bit_field_value, 4402 NULL, 4403 }, 4404 }; 4405 4406 /* *** WRITE PORT REGISTER BIT *** */ 4407 struct cmd_write_reg_bit_result { 4408 cmdline_fixed_string_t write; 4409 cmdline_fixed_string_t regbit; 4410 uint8_t port_id; 4411 uint32_t reg_off; 4412 uint8_t bit_pos; 4413 uint8_t value; 4414 }; 4415 4416 static void 4417 cmd_write_reg_bit_parsed(void *parsed_result, 4418 __attribute__((unused)) struct cmdline *cl, 4419 __attribute__((unused)) void *data) 4420 { 4421 struct cmd_write_reg_bit_result *res = parsed_result; 4422 port_reg_bit_set(res->port_id, res->reg_off, res->bit_pos, res->value); 4423 } 4424 4425 cmdline_parse_token_string_t cmd_write_reg_bit_write = 4426 TOKEN_STRING_INITIALIZER(struct cmd_write_reg_bit_result, write, 4427 "write"); 4428 cmdline_parse_token_string_t cmd_write_reg_bit_regbit = 4429 TOKEN_STRING_INITIALIZER(struct cmd_write_reg_bit_result, 4430 regbit, "regbit"); 4431 cmdline_parse_token_num_t cmd_write_reg_bit_port_id = 4432 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, port_id, UINT8); 4433 cmdline_parse_token_num_t cmd_write_reg_bit_reg_off = 4434 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, reg_off, UINT32); 4435 cmdline_parse_token_num_t cmd_write_reg_bit_bit_pos = 4436 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, bit_pos, UINT8); 4437 cmdline_parse_token_num_t cmd_write_reg_bit_value = 4438 TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, value, UINT8); 4439 4440 cmdline_parse_inst_t cmd_write_reg_bit = { 4441 .f = cmd_write_reg_bit_parsed, 4442 .data = NULL, 4443 .help_str = "write regbit port_id reg_off bit_x 0/1 (0 <= bit_x <= 31)", 4444 .tokens = { 4445 (void *)&cmd_write_reg_bit_write, 4446 (void *)&cmd_write_reg_bit_regbit, 4447 (void *)&cmd_write_reg_bit_port_id, 4448 (void *)&cmd_write_reg_bit_reg_off, 4449 (void *)&cmd_write_reg_bit_bit_pos, 4450 (void *)&cmd_write_reg_bit_value, 4451 NULL, 4452 }, 4453 }; 4454 4455 /* *** READ A RING DESCRIPTOR OF A PORT RX/TX QUEUE *** */ 4456 struct cmd_read_rxd_txd_result { 4457 cmdline_fixed_string_t read; 4458 cmdline_fixed_string_t rxd_txd; 4459 uint8_t port_id; 4460 uint16_t queue_id; 4461 uint16_t desc_id; 4462 }; 4463 4464 static void 4465 cmd_read_rxd_txd_parsed(void *parsed_result, 4466 __attribute__((unused)) struct cmdline *cl, 4467 __attribute__((unused)) void *data) 4468 { 4469 struct cmd_read_rxd_txd_result *res = parsed_result; 4470 4471 if (!strcmp(res->rxd_txd, "rxd")) 4472 rx_ring_desc_display(res->port_id, res->queue_id, res->desc_id); 4473 else if (!strcmp(res->rxd_txd, "txd")) 4474 tx_ring_desc_display(res->port_id, res->queue_id, res->desc_id); 4475 } 4476 4477 cmdline_parse_token_string_t cmd_read_rxd_txd_read = 4478 TOKEN_STRING_INITIALIZER(struct cmd_read_rxd_txd_result, read, "read"); 4479 cmdline_parse_token_string_t cmd_read_rxd_txd_rxd_txd = 4480 TOKEN_STRING_INITIALIZER(struct cmd_read_rxd_txd_result, rxd_txd, 4481 "rxd#txd"); 4482 cmdline_parse_token_num_t cmd_read_rxd_txd_port_id = 4483 TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, port_id, UINT8); 4484 cmdline_parse_token_num_t cmd_read_rxd_txd_queue_id = 4485 TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, queue_id, UINT16); 4486 cmdline_parse_token_num_t cmd_read_rxd_txd_desc_id = 4487 TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, desc_id, UINT16); 4488 4489 cmdline_parse_inst_t cmd_read_rxd_txd = { 4490 .f = cmd_read_rxd_txd_parsed, 4491 .data = NULL, 4492 .help_str = "read rxd|txd port_id queue_id rxd_id", 4493 .tokens = { 4494 (void *)&cmd_read_rxd_txd_read, 4495 (void *)&cmd_read_rxd_txd_rxd_txd, 4496 (void *)&cmd_read_rxd_txd_port_id, 4497 (void *)&cmd_read_rxd_txd_queue_id, 4498 (void *)&cmd_read_rxd_txd_desc_id, 4499 NULL, 4500 }, 4501 }; 4502 4503 /* *** QUIT *** */ 4504 struct cmd_quit_result { 4505 cmdline_fixed_string_t quit; 4506 }; 4507 4508 static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result, 4509 struct cmdline *cl, 4510 __attribute__((unused)) void *data) 4511 { 4512 pmd_test_exit(); 4513 cmdline_quit(cl); 4514 } 4515 4516 cmdline_parse_token_string_t cmd_quit_quit = 4517 TOKEN_STRING_INITIALIZER(struct cmd_quit_result, quit, "quit"); 4518 4519 cmdline_parse_inst_t cmd_quit = { 4520 .f = cmd_quit_parsed, 4521 .data = NULL, 4522 .help_str = "exit application", 4523 .tokens = { 4524 (void *)&cmd_quit_quit, 4525 NULL, 4526 }, 4527 }; 4528 4529 /* *** ADD/REMOVE MAC ADDRESS FROM A PORT *** */ 4530 struct cmd_mac_addr_result { 4531 cmdline_fixed_string_t mac_addr_cmd; 4532 cmdline_fixed_string_t what; 4533 uint8_t port_num; 4534 struct ether_addr address; 4535 }; 4536 4537 static void cmd_mac_addr_parsed(void *parsed_result, 4538 __attribute__((unused)) struct cmdline *cl, 4539 __attribute__((unused)) void *data) 4540 { 4541 struct cmd_mac_addr_result *res = parsed_result; 4542 int ret; 4543 4544 if (strcmp(res->what, "add") == 0) 4545 ret = rte_eth_dev_mac_addr_add(res->port_num, &res->address, 0); 4546 else 4547 ret = rte_eth_dev_mac_addr_remove(res->port_num, &res->address); 4548 4549 /* check the return value and print it if is < 0 */ 4550 if(ret < 0) 4551 printf("mac_addr_cmd error: (%s)\n", strerror(-ret)); 4552 4553 } 4554 4555 cmdline_parse_token_string_t cmd_mac_addr_cmd = 4556 TOKEN_STRING_INITIALIZER(struct cmd_mac_addr_result, mac_addr_cmd, 4557 "mac_addr"); 4558 cmdline_parse_token_string_t cmd_mac_addr_what = 4559 TOKEN_STRING_INITIALIZER(struct cmd_mac_addr_result, what, 4560 "add#remove"); 4561 cmdline_parse_token_num_t cmd_mac_addr_portnum = 4562 TOKEN_NUM_INITIALIZER(struct cmd_mac_addr_result, port_num, UINT8); 4563 cmdline_parse_token_etheraddr_t cmd_mac_addr_addr = 4564 TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address); 4565 4566 cmdline_parse_inst_t cmd_mac_addr = { 4567 .f = cmd_mac_addr_parsed, 4568 .data = (void *)0, 4569 .help_str = "mac_addr add|remove X <address>: " 4570 "add/remove MAC address on port X", 4571 .tokens = { 4572 (void *)&cmd_mac_addr_cmd, 4573 (void *)&cmd_mac_addr_what, 4574 (void *)&cmd_mac_addr_portnum, 4575 (void *)&cmd_mac_addr_addr, 4576 NULL, 4577 }, 4578 }; 4579 4580 4581 /* *** CONFIGURE QUEUE STATS COUNTER MAPPINGS *** */ 4582 struct cmd_set_qmap_result { 4583 cmdline_fixed_string_t set; 4584 cmdline_fixed_string_t qmap; 4585 cmdline_fixed_string_t what; 4586 uint8_t port_id; 4587 uint16_t queue_id; 4588 uint8_t map_value; 4589 }; 4590 4591 static void 4592 cmd_set_qmap_parsed(void *parsed_result, 4593 __attribute__((unused)) struct cmdline *cl, 4594 __attribute__((unused)) void *data) 4595 { 4596 struct cmd_set_qmap_result *res = parsed_result; 4597 int is_rx = (strcmp(res->what, "tx") == 0) ? 0 : 1; 4598 4599 set_qmap(res->port_id, (uint8_t)is_rx, res->queue_id, res->map_value); 4600 } 4601 4602 cmdline_parse_token_string_t cmd_setqmap_set = 4603 TOKEN_STRING_INITIALIZER(struct cmd_set_qmap_result, 4604 set, "set"); 4605 cmdline_parse_token_string_t cmd_setqmap_qmap = 4606 TOKEN_STRING_INITIALIZER(struct cmd_set_qmap_result, 4607 qmap, "stat_qmap"); 4608 cmdline_parse_token_string_t cmd_setqmap_what = 4609 TOKEN_STRING_INITIALIZER(struct cmd_set_qmap_result, 4610 what, "tx#rx"); 4611 cmdline_parse_token_num_t cmd_setqmap_portid = 4612 TOKEN_NUM_INITIALIZER(struct cmd_set_qmap_result, 4613 port_id, UINT8); 4614 cmdline_parse_token_num_t cmd_setqmap_queueid = 4615 TOKEN_NUM_INITIALIZER(struct cmd_set_qmap_result, 4616 queue_id, UINT16); 4617 cmdline_parse_token_num_t cmd_setqmap_mapvalue = 4618 TOKEN_NUM_INITIALIZER(struct cmd_set_qmap_result, 4619 map_value, UINT8); 4620 4621 cmdline_parse_inst_t cmd_set_qmap = { 4622 .f = cmd_set_qmap_parsed, 4623 .data = NULL, 4624 .help_str = "Set statistics mapping value on tx|rx queue_id of port_id", 4625 .tokens = { 4626 (void *)&cmd_setqmap_set, 4627 (void *)&cmd_setqmap_qmap, 4628 (void *)&cmd_setqmap_what, 4629 (void *)&cmd_setqmap_portid, 4630 (void *)&cmd_setqmap_queueid, 4631 (void *)&cmd_setqmap_mapvalue, 4632 NULL, 4633 }, 4634 }; 4635 4636 /* *** CONFIGURE UNICAST HASH TABLE *** */ 4637 struct cmd_set_uc_hash_table { 4638 cmdline_fixed_string_t set; 4639 cmdline_fixed_string_t port; 4640 uint8_t port_id; 4641 cmdline_fixed_string_t what; 4642 struct ether_addr address; 4643 cmdline_fixed_string_t mode; 4644 }; 4645 4646 static void 4647 cmd_set_uc_hash_parsed(void *parsed_result, 4648 __attribute__((unused)) struct cmdline *cl, 4649 __attribute__((unused)) void *data) 4650 { 4651 int ret=0; 4652 struct cmd_set_uc_hash_table *res = parsed_result; 4653 4654 int is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0; 4655 4656 if (strcmp(res->what, "uta") == 0) 4657 ret = rte_eth_dev_uc_hash_table_set(res->port_id, 4658 &res->address,(uint8_t)is_on); 4659 if (ret < 0) 4660 printf("bad unicast hash table parameter, return code = %d \n", ret); 4661 4662 } 4663 4664 cmdline_parse_token_string_t cmd_set_uc_hash_set = 4665 TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table, 4666 set, "set"); 4667 cmdline_parse_token_string_t cmd_set_uc_hash_port = 4668 TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table, 4669 port, "port"); 4670 cmdline_parse_token_num_t cmd_set_uc_hash_portid = 4671 TOKEN_NUM_INITIALIZER(struct cmd_set_uc_hash_table, 4672 port_id, UINT8); 4673 cmdline_parse_token_string_t cmd_set_uc_hash_what = 4674 TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table, 4675 what, "uta"); 4676 cmdline_parse_token_etheraddr_t cmd_set_uc_hash_mac = 4677 TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_uc_hash_table, 4678 address); 4679 cmdline_parse_token_string_t cmd_set_uc_hash_mode = 4680 TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table, 4681 mode, "on#off"); 4682 4683 cmdline_parse_inst_t cmd_set_uc_hash_filter = { 4684 .f = cmd_set_uc_hash_parsed, 4685 .data = NULL, 4686 .help_str = "set port X uta Y on|off(X = port number,Y = MAC address)", 4687 .tokens = { 4688 (void *)&cmd_set_uc_hash_set, 4689 (void *)&cmd_set_uc_hash_port, 4690 (void *)&cmd_set_uc_hash_portid, 4691 (void *)&cmd_set_uc_hash_what, 4692 (void *)&cmd_set_uc_hash_mac, 4693 (void *)&cmd_set_uc_hash_mode, 4694 NULL, 4695 }, 4696 }; 4697 4698 struct cmd_set_uc_all_hash_table { 4699 cmdline_fixed_string_t set; 4700 cmdline_fixed_string_t port; 4701 uint8_t port_id; 4702 cmdline_fixed_string_t what; 4703 cmdline_fixed_string_t value; 4704 cmdline_fixed_string_t mode; 4705 }; 4706 4707 static void 4708 cmd_set_uc_all_hash_parsed(void *parsed_result, 4709 __attribute__((unused)) struct cmdline *cl, 4710 __attribute__((unused)) void *data) 4711 { 4712 int ret=0; 4713 struct cmd_set_uc_all_hash_table *res = parsed_result; 4714 4715 int is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0; 4716 4717 if ((strcmp(res->what, "uta") == 0) && 4718 (strcmp(res->value, "all") == 0)) 4719 ret = rte_eth_dev_uc_all_hash_table_set(res->port_id,(uint8_t) is_on); 4720 if (ret < 0) 4721 printf("bad unicast hash table parameter," 4722 "return code = %d \n", ret); 4723 } 4724 4725 cmdline_parse_token_string_t cmd_set_uc_all_hash_set = 4726 TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table, 4727 set, "set"); 4728 cmdline_parse_token_string_t cmd_set_uc_all_hash_port = 4729 TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table, 4730 port, "port"); 4731 cmdline_parse_token_num_t cmd_set_uc_all_hash_portid = 4732 TOKEN_NUM_INITIALIZER(struct cmd_set_uc_all_hash_table, 4733 port_id, UINT8); 4734 cmdline_parse_token_string_t cmd_set_uc_all_hash_what = 4735 TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table, 4736 what, "uta"); 4737 cmdline_parse_token_string_t cmd_set_uc_all_hash_value = 4738 TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table, 4739 value,"all"); 4740 cmdline_parse_token_string_t cmd_set_uc_all_hash_mode = 4741 TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table, 4742 mode, "on#off"); 4743 4744 cmdline_parse_inst_t cmd_set_uc_all_hash_filter = { 4745 .f = cmd_set_uc_all_hash_parsed, 4746 .data = NULL, 4747 .help_str = "set port X uta all on|off (X = port number)", 4748 .tokens = { 4749 (void *)&cmd_set_uc_all_hash_set, 4750 (void *)&cmd_set_uc_all_hash_port, 4751 (void *)&cmd_set_uc_all_hash_portid, 4752 (void *)&cmd_set_uc_all_hash_what, 4753 (void *)&cmd_set_uc_all_hash_value, 4754 (void *)&cmd_set_uc_all_hash_mode, 4755 NULL, 4756 }, 4757 }; 4758 4759 /* *** CONFIGURE VF TRAFFIC CONTROL *** */ 4760 struct cmd_set_vf_traffic { 4761 cmdline_fixed_string_t set; 4762 cmdline_fixed_string_t port; 4763 uint8_t port_id; 4764 cmdline_fixed_string_t vf; 4765 uint8_t vf_id; 4766 cmdline_fixed_string_t what; 4767 cmdline_fixed_string_t mode; 4768 }; 4769 4770 static void 4771 cmd_set_vf_traffic_parsed(void *parsed_result, 4772 __attribute__((unused)) struct cmdline *cl, 4773 __attribute__((unused)) void *data) 4774 { 4775 struct cmd_set_vf_traffic *res = parsed_result; 4776 int is_rx = (strcmp(res->what, "rx") == 0) ? 1 : 0; 4777 int is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0; 4778 4779 set_vf_traffic(res->port_id, (uint8_t)is_rx, res->vf_id,(uint8_t) is_on); 4780 } 4781 4782 cmdline_parse_token_string_t cmd_setvf_traffic_set = 4783 TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic, 4784 set, "set"); 4785 cmdline_parse_token_string_t cmd_setvf_traffic_port = 4786 TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic, 4787 port, "port"); 4788 cmdline_parse_token_num_t cmd_setvf_traffic_portid = 4789 TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic, 4790 port_id, UINT8); 4791 cmdline_parse_token_string_t cmd_setvf_traffic_vf = 4792 TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic, 4793 vf, "vf"); 4794 cmdline_parse_token_num_t cmd_setvf_traffic_vfid = 4795 TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic, 4796 vf_id, UINT8); 4797 cmdline_parse_token_string_t cmd_setvf_traffic_what = 4798 TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic, 4799 what, "tx#rx"); 4800 cmdline_parse_token_string_t cmd_setvf_traffic_mode = 4801 TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic, 4802 mode, "on#off"); 4803 4804 cmdline_parse_inst_t cmd_set_vf_traffic = { 4805 .f = cmd_set_vf_traffic_parsed, 4806 .data = NULL, 4807 .help_str = "set port X vf Y rx|tx on|off (X = port number,Y = vf id)", 4808 .tokens = { 4809 (void *)&cmd_setvf_traffic_set, 4810 (void *)&cmd_setvf_traffic_port, 4811 (void *)&cmd_setvf_traffic_portid, 4812 (void *)&cmd_setvf_traffic_vf, 4813 (void *)&cmd_setvf_traffic_vfid, 4814 (void *)&cmd_setvf_traffic_what, 4815 (void *)&cmd_setvf_traffic_mode, 4816 NULL, 4817 }, 4818 }; 4819 4820 /* *** CONFIGURE VF RECEIVE MODE *** */ 4821 struct cmd_set_vf_rxmode { 4822 cmdline_fixed_string_t set; 4823 cmdline_fixed_string_t port; 4824 uint8_t port_id; 4825 cmdline_fixed_string_t vf; 4826 uint8_t vf_id; 4827 cmdline_fixed_string_t what; 4828 cmdline_fixed_string_t mode; 4829 cmdline_fixed_string_t on; 4830 }; 4831 4832 static void 4833 cmd_set_vf_rxmode_parsed(void *parsed_result, 4834 __attribute__((unused)) struct cmdline *cl, 4835 __attribute__((unused)) void *data) 4836 { 4837 int ret; 4838 uint16_t rx_mode = 0; 4839 struct cmd_set_vf_rxmode *res = parsed_result; 4840 4841 int is_on = (strcmp(res->on, "on") == 0) ? 1 : 0; 4842 if (!strcmp(res->what,"rxmode")) { 4843 if (!strcmp(res->mode, "AUPE")) 4844 rx_mode |= ETH_VMDQ_ACCEPT_UNTAG; 4845 else if (!strcmp(res->mode, "ROPE")) 4846 rx_mode |= ETH_VMDQ_ACCEPT_HASH_UC; 4847 else if (!strcmp(res->mode, "BAM")) 4848 rx_mode |= ETH_VMDQ_ACCEPT_BROADCAST; 4849 else if (!strncmp(res->mode, "MPE",3)) 4850 rx_mode |= ETH_VMDQ_ACCEPT_MULTICAST; 4851 } 4852 4853 ret = rte_eth_dev_set_vf_rxmode(res->port_id,res->vf_id,rx_mode,(uint8_t)is_on); 4854 if (ret < 0) 4855 printf("bad VF receive mode parameter, return code = %d \n", 4856 ret); 4857 } 4858 4859 cmdline_parse_token_string_t cmd_set_vf_rxmode_set = 4860 TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, 4861 set, "set"); 4862 cmdline_parse_token_string_t cmd_set_vf_rxmode_port = 4863 TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, 4864 port, "port"); 4865 cmdline_parse_token_num_t cmd_set_vf_rxmode_portid = 4866 TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode, 4867 port_id, UINT8); 4868 cmdline_parse_token_string_t cmd_set_vf_rxmode_vf = 4869 TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, 4870 vf, "vf"); 4871 cmdline_parse_token_num_t cmd_set_vf_rxmode_vfid = 4872 TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode, 4873 vf_id, UINT8); 4874 cmdline_parse_token_string_t cmd_set_vf_rxmode_what = 4875 TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, 4876 what, "rxmode"); 4877 cmdline_parse_token_string_t cmd_set_vf_rxmode_mode = 4878 TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, 4879 mode, "AUPE#ROPE#BAM#MPE"); 4880 cmdline_parse_token_string_t cmd_set_vf_rxmode_on = 4881 TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode, 4882 on, "on#off"); 4883 4884 cmdline_parse_inst_t cmd_set_vf_rxmode = { 4885 .f = cmd_set_vf_rxmode_parsed, 4886 .data = NULL, 4887 .help_str = "set port X vf Y rxmode AUPE|ROPE|BAM|MPE on|off", 4888 .tokens = { 4889 (void *)&cmd_set_vf_rxmode_set, 4890 (void *)&cmd_set_vf_rxmode_port, 4891 (void *)&cmd_set_vf_rxmode_portid, 4892 (void *)&cmd_set_vf_rxmode_vf, 4893 (void *)&cmd_set_vf_rxmode_vfid, 4894 (void *)&cmd_set_vf_rxmode_what, 4895 (void *)&cmd_set_vf_rxmode_mode, 4896 (void *)&cmd_set_vf_rxmode_on, 4897 NULL, 4898 }, 4899 }; 4900 4901 /* *** ADD MAC ADDRESS FILTER FOR A VF OF A PORT *** */ 4902 struct cmd_vf_mac_addr_result { 4903 cmdline_fixed_string_t mac_addr_cmd; 4904 cmdline_fixed_string_t what; 4905 cmdline_fixed_string_t port; 4906 uint8_t port_num; 4907 cmdline_fixed_string_t vf; 4908 uint8_t vf_num; 4909 struct ether_addr address; 4910 }; 4911 4912 static void cmd_vf_mac_addr_parsed(void *parsed_result, 4913 __attribute__((unused)) struct cmdline *cl, 4914 __attribute__((unused)) void *data) 4915 { 4916 struct cmd_vf_mac_addr_result *res = parsed_result; 4917 int ret = 0; 4918 4919 if (strcmp(res->what, "add") == 0) 4920 ret = rte_eth_dev_mac_addr_add(res->port_num, 4921 &res->address, res->vf_num); 4922 if(ret < 0) 4923 printf("vf_mac_addr_cmd error: (%s)\n", strerror(-ret)); 4924 4925 } 4926 4927 cmdline_parse_token_string_t cmd_vf_mac_addr_cmd = 4928 TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result, 4929 mac_addr_cmd,"mac_addr"); 4930 cmdline_parse_token_string_t cmd_vf_mac_addr_what = 4931 TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result, 4932 what,"add"); 4933 cmdline_parse_token_string_t cmd_vf_mac_addr_port = 4934 TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result, 4935 port,"port"); 4936 cmdline_parse_token_num_t cmd_vf_mac_addr_portnum = 4937 TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result, 4938 port_num, UINT8); 4939 cmdline_parse_token_string_t cmd_vf_mac_addr_vf = 4940 TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result, 4941 vf,"vf"); 4942 cmdline_parse_token_num_t cmd_vf_mac_addr_vfnum = 4943 TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result, 4944 vf_num, UINT8); 4945 cmdline_parse_token_etheraddr_t cmd_vf_mac_addr_addr = 4946 TOKEN_ETHERADDR_INITIALIZER(struct cmd_vf_mac_addr_result, 4947 address); 4948 4949 cmdline_parse_inst_t cmd_vf_mac_addr_filter = { 4950 .f = cmd_vf_mac_addr_parsed, 4951 .data = (void *)0, 4952 .help_str = "mac_addr add port X vf Y ethaddr:(X = port number," 4953 "Y = VF number)add MAC address filtering for a VF on port X", 4954 .tokens = { 4955 (void *)&cmd_vf_mac_addr_cmd, 4956 (void *)&cmd_vf_mac_addr_what, 4957 (void *)&cmd_vf_mac_addr_port, 4958 (void *)&cmd_vf_mac_addr_portnum, 4959 (void *)&cmd_vf_mac_addr_vf, 4960 (void *)&cmd_vf_mac_addr_vfnum, 4961 (void *)&cmd_vf_mac_addr_addr, 4962 NULL, 4963 }, 4964 }; 4965 4966 /* *** ADD/REMOVE A VLAN IDENTIFIER TO/FROM A PORT VLAN RX FILTER *** */ 4967 struct cmd_vf_rx_vlan_filter { 4968 cmdline_fixed_string_t rx_vlan; 4969 cmdline_fixed_string_t what; 4970 uint16_t vlan_id; 4971 cmdline_fixed_string_t port; 4972 uint8_t port_id; 4973 cmdline_fixed_string_t vf; 4974 uint64_t vf_mask; 4975 }; 4976 4977 static void 4978 cmd_vf_rx_vlan_filter_parsed(void *parsed_result, 4979 __attribute__((unused)) struct cmdline *cl, 4980 __attribute__((unused)) void *data) 4981 { 4982 struct cmd_vf_rx_vlan_filter *res = parsed_result; 4983 4984 if (!strcmp(res->what, "add")) 4985 set_vf_rx_vlan(res->port_id, res->vlan_id,res->vf_mask, 1); 4986 else 4987 set_vf_rx_vlan(res->port_id, res->vlan_id,res->vf_mask, 0); 4988 } 4989 4990 cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_rx_vlan = 4991 TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter, 4992 rx_vlan, "rx_vlan"); 4993 cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_what = 4994 TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter, 4995 what, "add#rm"); 4996 cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vlanid = 4997 TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter, 4998 vlan_id, UINT16); 4999 cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_port = 5000 TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter, 5001 port, "port"); 5002 cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_portid = 5003 TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter, 5004 port_id, UINT8); 5005 cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_vf = 5006 TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter, 5007 vf, "vf"); 5008 cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vf_mask = 5009 TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter, 5010 vf_mask, UINT64); 5011 5012 cmdline_parse_inst_t cmd_vf_rxvlan_filter = { 5013 .f = cmd_vf_rx_vlan_filter_parsed, 5014 .data = NULL, 5015 .help_str = "rx_vlan add|rm X port Y vf Z (X = VLAN ID," 5016 "Y = port number,Z = hexadecimal VF mask)", 5017 .tokens = { 5018 (void *)&cmd_vf_rx_vlan_filter_rx_vlan, 5019 (void *)&cmd_vf_rx_vlan_filter_what, 5020 (void *)&cmd_vf_rx_vlan_filter_vlanid, 5021 (void *)&cmd_vf_rx_vlan_filter_port, 5022 (void *)&cmd_vf_rx_vlan_filter_portid, 5023 (void *)&cmd_vf_rx_vlan_filter_vf, 5024 (void *)&cmd_vf_rx_vlan_filter_vf_mask, 5025 NULL, 5026 }, 5027 }; 5028 5029 /* *** SET RATE LIMIT FOR A QUEUE OF A PORT *** */ 5030 struct cmd_queue_rate_limit_result { 5031 cmdline_fixed_string_t set; 5032 cmdline_fixed_string_t port; 5033 uint8_t port_num; 5034 cmdline_fixed_string_t queue; 5035 uint8_t queue_num; 5036 cmdline_fixed_string_t rate; 5037 uint16_t rate_num; 5038 }; 5039 5040 static void cmd_queue_rate_limit_parsed(void *parsed_result, 5041 __attribute__((unused)) struct cmdline *cl, 5042 __attribute__((unused)) void *data) 5043 { 5044 struct cmd_queue_rate_limit_result *res = parsed_result; 5045 int ret = 0; 5046 5047 if ((strcmp(res->set, "set") == 0) && (strcmp(res->port, "port") == 0) 5048 && (strcmp(res->queue, "queue") == 0) 5049 && (strcmp(res->rate, "rate") == 0)) 5050 ret = set_queue_rate_limit(res->port_num, res->queue_num, 5051 res->rate_num); 5052 if (ret < 0) 5053 printf("queue_rate_limit_cmd error: (%s)\n", strerror(-ret)); 5054 5055 } 5056 5057 cmdline_parse_token_string_t cmd_queue_rate_limit_set = 5058 TOKEN_STRING_INITIALIZER(struct cmd_queue_rate_limit_result, 5059 set, "set"); 5060 cmdline_parse_token_string_t cmd_queue_rate_limit_port = 5061 TOKEN_STRING_INITIALIZER(struct cmd_queue_rate_limit_result, 5062 port, "port"); 5063 cmdline_parse_token_num_t cmd_queue_rate_limit_portnum = 5064 TOKEN_NUM_INITIALIZER(struct cmd_queue_rate_limit_result, 5065 port_num, UINT8); 5066 cmdline_parse_token_string_t cmd_queue_rate_limit_queue = 5067 TOKEN_STRING_INITIALIZER(struct cmd_queue_rate_limit_result, 5068 queue, "queue"); 5069 cmdline_parse_token_num_t cmd_queue_rate_limit_queuenum = 5070 TOKEN_NUM_INITIALIZER(struct cmd_queue_rate_limit_result, 5071 queue_num, UINT8); 5072 cmdline_parse_token_string_t cmd_queue_rate_limit_rate = 5073 TOKEN_STRING_INITIALIZER(struct cmd_queue_rate_limit_result, 5074 rate, "rate"); 5075 cmdline_parse_token_num_t cmd_queue_rate_limit_ratenum = 5076 TOKEN_NUM_INITIALIZER(struct cmd_queue_rate_limit_result, 5077 rate_num, UINT16); 5078 5079 cmdline_parse_inst_t cmd_queue_rate_limit = { 5080 .f = cmd_queue_rate_limit_parsed, 5081 .data = (void *)0, 5082 .help_str = "set port X queue Y rate Z:(X = port number," 5083 "Y = queue number,Z = rate number)set rate limit for a queue on port X", 5084 .tokens = { 5085 (void *)&cmd_queue_rate_limit_set, 5086 (void *)&cmd_queue_rate_limit_port, 5087 (void *)&cmd_queue_rate_limit_portnum, 5088 (void *)&cmd_queue_rate_limit_queue, 5089 (void *)&cmd_queue_rate_limit_queuenum, 5090 (void *)&cmd_queue_rate_limit_rate, 5091 (void *)&cmd_queue_rate_limit_ratenum, 5092 NULL, 5093 }, 5094 }; 5095 5096 /* *** SET RATE LIMIT FOR A VF OF A PORT *** */ 5097 struct cmd_vf_rate_limit_result { 5098 cmdline_fixed_string_t set; 5099 cmdline_fixed_string_t port; 5100 uint8_t port_num; 5101 cmdline_fixed_string_t vf; 5102 uint8_t vf_num; 5103 cmdline_fixed_string_t rate; 5104 uint16_t rate_num; 5105 cmdline_fixed_string_t q_msk; 5106 uint64_t q_msk_val; 5107 }; 5108 5109 static void cmd_vf_rate_limit_parsed(void *parsed_result, 5110 __attribute__((unused)) struct cmdline *cl, 5111 __attribute__((unused)) void *data) 5112 { 5113 struct cmd_vf_rate_limit_result *res = parsed_result; 5114 int ret = 0; 5115 5116 if ((strcmp(res->set, "set") == 0) && (strcmp(res->port, "port") == 0) 5117 && (strcmp(res->vf, "vf") == 0) 5118 && (strcmp(res->rate, "rate") == 0) 5119 && (strcmp(res->q_msk, "queue_mask") == 0)) 5120 ret = set_vf_rate_limit(res->port_num, res->vf_num, 5121 res->rate_num, res->q_msk_val); 5122 if (ret < 0) 5123 printf("vf_rate_limit_cmd error: (%s)\n", strerror(-ret)); 5124 5125 } 5126 5127 cmdline_parse_token_string_t cmd_vf_rate_limit_set = 5128 TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result, 5129 set, "set"); 5130 cmdline_parse_token_string_t cmd_vf_rate_limit_port = 5131 TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result, 5132 port, "port"); 5133 cmdline_parse_token_num_t cmd_vf_rate_limit_portnum = 5134 TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result, 5135 port_num, UINT8); 5136 cmdline_parse_token_string_t cmd_vf_rate_limit_vf = 5137 TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result, 5138 vf, "vf"); 5139 cmdline_parse_token_num_t cmd_vf_rate_limit_vfnum = 5140 TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result, 5141 vf_num, UINT8); 5142 cmdline_parse_token_string_t cmd_vf_rate_limit_rate = 5143 TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result, 5144 rate, "rate"); 5145 cmdline_parse_token_num_t cmd_vf_rate_limit_ratenum = 5146 TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result, 5147 rate_num, UINT16); 5148 cmdline_parse_token_string_t cmd_vf_rate_limit_q_msk = 5149 TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result, 5150 q_msk, "queue_mask"); 5151 cmdline_parse_token_num_t cmd_vf_rate_limit_q_msk_val = 5152 TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result, 5153 q_msk_val, UINT64); 5154 5155 cmdline_parse_inst_t cmd_vf_rate_limit = { 5156 .f = cmd_vf_rate_limit_parsed, 5157 .data = (void *)0, 5158 .help_str = "set port X vf Y rate Z queue_mask V:(X = port number," 5159 "Y = VF number,Z = rate number, V = queue mask value)set rate limit " 5160 "for queues of VF on port X", 5161 .tokens = { 5162 (void *)&cmd_vf_rate_limit_set, 5163 (void *)&cmd_vf_rate_limit_port, 5164 (void *)&cmd_vf_rate_limit_portnum, 5165 (void *)&cmd_vf_rate_limit_vf, 5166 (void *)&cmd_vf_rate_limit_vfnum, 5167 (void *)&cmd_vf_rate_limit_rate, 5168 (void *)&cmd_vf_rate_limit_ratenum, 5169 (void *)&cmd_vf_rate_limit_q_msk, 5170 (void *)&cmd_vf_rate_limit_q_msk_val, 5171 NULL, 5172 }, 5173 }; 5174 5175 /* *** CONFIGURE VM MIRROR VLAN/POOL RULE *** */ 5176 struct cmd_set_mirror_mask_result { 5177 cmdline_fixed_string_t set; 5178 cmdline_fixed_string_t port; 5179 uint8_t port_id; 5180 cmdline_fixed_string_t mirror; 5181 uint8_t rule_id; 5182 cmdline_fixed_string_t what; 5183 cmdline_fixed_string_t value; 5184 cmdline_fixed_string_t dstpool; 5185 uint8_t dstpool_id; 5186 cmdline_fixed_string_t on; 5187 }; 5188 5189 cmdline_parse_token_string_t cmd_mirror_mask_set = 5190 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, 5191 set, "set"); 5192 cmdline_parse_token_string_t cmd_mirror_mask_port = 5193 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, 5194 port, "port"); 5195 cmdline_parse_token_string_t cmd_mirror_mask_portid = 5196 TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result, 5197 port_id, UINT8); 5198 cmdline_parse_token_string_t cmd_mirror_mask_mirror = 5199 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, 5200 mirror, "mirror-rule"); 5201 cmdline_parse_token_num_t cmd_mirror_mask_ruleid = 5202 TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result, 5203 rule_id, UINT8); 5204 cmdline_parse_token_string_t cmd_mirror_mask_what = 5205 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, 5206 what, "pool-mirror#vlan-mirror"); 5207 cmdline_parse_token_string_t cmd_mirror_mask_value = 5208 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, 5209 value, NULL); 5210 cmdline_parse_token_string_t cmd_mirror_mask_dstpool = 5211 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, 5212 dstpool, "dst-pool"); 5213 cmdline_parse_token_num_t cmd_mirror_mask_poolid = 5214 TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result, 5215 dstpool_id, UINT8); 5216 cmdline_parse_token_string_t cmd_mirror_mask_on = 5217 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result, 5218 on, "on#off"); 5219 5220 static void 5221 cmd_set_mirror_mask_parsed(void *parsed_result, 5222 __attribute__((unused)) struct cmdline *cl, 5223 __attribute__((unused)) void *data) 5224 { 5225 int ret,nb_item,i; 5226 struct cmd_set_mirror_mask_result *res = parsed_result; 5227 struct rte_eth_vmdq_mirror_conf mr_conf; 5228 5229 memset(&mr_conf,0,sizeof(struct rte_eth_vmdq_mirror_conf)); 5230 5231 unsigned int vlan_list[ETH_VMDQ_MAX_VLAN_FILTERS]; 5232 5233 mr_conf.dst_pool = res->dstpool_id; 5234 5235 if (!strcmp(res->what, "pool-mirror")) { 5236 mr_conf.pool_mask = strtoull(res->value,NULL,16); 5237 mr_conf.rule_type_mask = ETH_VMDQ_POOL_MIRROR; 5238 } else if(!strcmp(res->what, "vlan-mirror")) { 5239 mr_conf.rule_type_mask = ETH_VMDQ_VLAN_MIRROR; 5240 nb_item = parse_item_list(res->value, "core", 5241 ETH_VMDQ_MAX_VLAN_FILTERS,vlan_list,1); 5242 if (nb_item <= 0) 5243 return; 5244 5245 for(i=0; i < nb_item; i++) { 5246 if (vlan_list[i] > ETHER_MAX_VLAN_ID) { 5247 printf("Invalid vlan_id: must be < 4096\n"); 5248 return; 5249 } 5250 5251 mr_conf.vlan.vlan_id[i] = (uint16_t)vlan_list[i]; 5252 mr_conf.vlan.vlan_mask |= 1ULL << i; 5253 } 5254 } 5255 5256 if(!strcmp(res->on, "on")) 5257 ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf, 5258 res->rule_id, 1); 5259 else 5260 ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf, 5261 res->rule_id, 0); 5262 if(ret < 0) 5263 printf("mirror rule add error: (%s)\n", strerror(-ret)); 5264 } 5265 5266 cmdline_parse_inst_t cmd_set_mirror_mask = { 5267 .f = cmd_set_mirror_mask_parsed, 5268 .data = NULL, 5269 .help_str = "set port X mirror-rule Y pool-mirror|vlan-mirror " 5270 "pool_mask|vlan_id[,vlan_id]* dst-pool Z on|off", 5271 .tokens = { 5272 (void *)&cmd_mirror_mask_set, 5273 (void *)&cmd_mirror_mask_port, 5274 (void *)&cmd_mirror_mask_portid, 5275 (void *)&cmd_mirror_mask_mirror, 5276 (void *)&cmd_mirror_mask_ruleid, 5277 (void *)&cmd_mirror_mask_what, 5278 (void *)&cmd_mirror_mask_value, 5279 (void *)&cmd_mirror_mask_dstpool, 5280 (void *)&cmd_mirror_mask_poolid, 5281 (void *)&cmd_mirror_mask_on, 5282 NULL, 5283 }, 5284 }; 5285 5286 /* *** CONFIGURE VM MIRROR UDLINK/DOWNLINK RULE *** */ 5287 struct cmd_set_mirror_link_result { 5288 cmdline_fixed_string_t set; 5289 cmdline_fixed_string_t port; 5290 uint8_t port_id; 5291 cmdline_fixed_string_t mirror; 5292 uint8_t rule_id; 5293 cmdline_fixed_string_t what; 5294 cmdline_fixed_string_t dstpool; 5295 uint8_t dstpool_id; 5296 cmdline_fixed_string_t on; 5297 }; 5298 5299 cmdline_parse_token_string_t cmd_mirror_link_set = 5300 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, 5301 set, "set"); 5302 cmdline_parse_token_string_t cmd_mirror_link_port = 5303 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, 5304 port, "port"); 5305 cmdline_parse_token_string_t cmd_mirror_link_portid = 5306 TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result, 5307 port_id, UINT8); 5308 cmdline_parse_token_string_t cmd_mirror_link_mirror = 5309 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, 5310 mirror, "mirror-rule"); 5311 cmdline_parse_token_num_t cmd_mirror_link_ruleid = 5312 TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result, 5313 rule_id, UINT8); 5314 cmdline_parse_token_string_t cmd_mirror_link_what = 5315 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, 5316 what, "uplink-mirror#downlink-mirror"); 5317 cmdline_parse_token_string_t cmd_mirror_link_dstpool = 5318 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, 5319 dstpool, "dst-pool"); 5320 cmdline_parse_token_num_t cmd_mirror_link_poolid = 5321 TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result, 5322 dstpool_id, UINT8); 5323 cmdline_parse_token_string_t cmd_mirror_link_on = 5324 TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result, 5325 on, "on#off"); 5326 5327 static void 5328 cmd_set_mirror_link_parsed(void *parsed_result, 5329 __attribute__((unused)) struct cmdline *cl, 5330 __attribute__((unused)) void *data) 5331 { 5332 int ret; 5333 struct cmd_set_mirror_link_result *res = parsed_result; 5334 struct rte_eth_vmdq_mirror_conf mr_conf; 5335 5336 memset(&mr_conf,0,sizeof(struct rte_eth_vmdq_mirror_conf)); 5337 if(!strcmp(res->what, "uplink-mirror")) { 5338 mr_conf.rule_type_mask = ETH_VMDQ_UPLINK_MIRROR; 5339 }else if(!strcmp(res->what, "downlink-mirror")) 5340 mr_conf.rule_type_mask = ETH_VMDQ_DOWNLIN_MIRROR; 5341 5342 mr_conf.dst_pool = res->dstpool_id; 5343 5344 if(!strcmp(res->on, "on")) 5345 ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf, 5346 res->rule_id, 1); 5347 else 5348 ret = rte_eth_mirror_rule_set(res->port_id,&mr_conf, 5349 res->rule_id, 0); 5350 5351 /* check the return value and print it if is < 0 */ 5352 if(ret < 0) 5353 printf("mirror rule add error: (%s)\n", strerror(-ret)); 5354 5355 } 5356 5357 cmdline_parse_inst_t cmd_set_mirror_link = { 5358 .f = cmd_set_mirror_link_parsed, 5359 .data = NULL, 5360 .help_str = "set port X mirror-rule Y uplink-mirror|" 5361 "downlink-mirror dst-pool Z on|off", 5362 .tokens = { 5363 (void *)&cmd_mirror_link_set, 5364 (void *)&cmd_mirror_link_port, 5365 (void *)&cmd_mirror_link_portid, 5366 (void *)&cmd_mirror_link_mirror, 5367 (void *)&cmd_mirror_link_ruleid, 5368 (void *)&cmd_mirror_link_what, 5369 (void *)&cmd_mirror_link_dstpool, 5370 (void *)&cmd_mirror_link_poolid, 5371 (void *)&cmd_mirror_link_on, 5372 NULL, 5373 }, 5374 }; 5375 5376 /* *** RESET VM MIRROR RULE *** */ 5377 struct cmd_rm_mirror_rule_result { 5378 cmdline_fixed_string_t reset; 5379 cmdline_fixed_string_t port; 5380 uint8_t port_id; 5381 cmdline_fixed_string_t mirror; 5382 uint8_t rule_id; 5383 }; 5384 5385 cmdline_parse_token_string_t cmd_rm_mirror_rule_reset = 5386 TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result, 5387 reset, "reset"); 5388 cmdline_parse_token_string_t cmd_rm_mirror_rule_port = 5389 TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result, 5390 port, "port"); 5391 cmdline_parse_token_string_t cmd_rm_mirror_rule_portid = 5392 TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result, 5393 port_id, UINT8); 5394 cmdline_parse_token_string_t cmd_rm_mirror_rule_mirror = 5395 TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result, 5396 mirror, "mirror-rule"); 5397 cmdline_parse_token_num_t cmd_rm_mirror_rule_ruleid = 5398 TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result, 5399 rule_id, UINT8); 5400 5401 static void 5402 cmd_reset_mirror_rule_parsed(void *parsed_result, 5403 __attribute__((unused)) struct cmdline *cl, 5404 __attribute__((unused)) void *data) 5405 { 5406 int ret; 5407 struct cmd_set_mirror_link_result *res = parsed_result; 5408 /* check rule_id */ 5409 ret = rte_eth_mirror_rule_reset(res->port_id,res->rule_id); 5410 if(ret < 0) 5411 printf("mirror rule remove error: (%s)\n", strerror(-ret)); 5412 } 5413 5414 cmdline_parse_inst_t cmd_reset_mirror_rule = { 5415 .f = cmd_reset_mirror_rule_parsed, 5416 .data = NULL, 5417 .help_str = "reset port X mirror-rule Y", 5418 .tokens = { 5419 (void *)&cmd_rm_mirror_rule_reset, 5420 (void *)&cmd_rm_mirror_rule_port, 5421 (void *)&cmd_rm_mirror_rule_portid, 5422 (void *)&cmd_rm_mirror_rule_mirror, 5423 (void *)&cmd_rm_mirror_rule_ruleid, 5424 NULL, 5425 }, 5426 }; 5427 5428 /* ******************************************************************************** */ 5429 5430 struct cmd_dump_result { 5431 cmdline_fixed_string_t dump; 5432 }; 5433 5434 static void 5435 dump_struct_sizes(void) 5436 { 5437 #define DUMP_SIZE(t) printf("sizeof(" #t ") = %u\n", (unsigned)sizeof(t)); 5438 DUMP_SIZE(struct rte_mbuf); 5439 DUMP_SIZE(struct rte_pktmbuf); 5440 DUMP_SIZE(struct rte_ctrlmbuf); 5441 DUMP_SIZE(struct rte_mempool); 5442 DUMP_SIZE(struct rte_ring); 5443 #undef DUMP_SIZE 5444 } 5445 5446 static void cmd_dump_parsed(void *parsed_result, 5447 __attribute__((unused)) struct cmdline *cl, 5448 __attribute__((unused)) void *data) 5449 { 5450 struct cmd_dump_result *res = parsed_result; 5451 5452 if (!strcmp(res->dump, "dump_physmem")) 5453 rte_dump_physmem_layout(stdout); 5454 else if (!strcmp(res->dump, "dump_memzone")) 5455 rte_memzone_dump(stdout); 5456 else if (!strcmp(res->dump, "dump_log_history")) 5457 rte_log_dump_history(stdout); 5458 else if (!strcmp(res->dump, "dump_struct_sizes")) 5459 dump_struct_sizes(); 5460 else if (!strcmp(res->dump, "dump_ring")) 5461 rte_ring_list_dump(stdout); 5462 else if (!strcmp(res->dump, "dump_mempool")) 5463 rte_mempool_list_dump(stdout); 5464 else if (!strcmp(res->dump, "dump_devargs")) 5465 rte_eal_devargs_dump(stdout); 5466 } 5467 5468 cmdline_parse_token_string_t cmd_dump_dump = 5469 TOKEN_STRING_INITIALIZER(struct cmd_dump_result, dump, 5470 "dump_physmem#" 5471 "dump_memzone#" 5472 "dump_log_history#" 5473 "dump_struct_sizes#" 5474 "dump_ring#" 5475 "dump_mempool#" 5476 "dump_devargs"); 5477 5478 cmdline_parse_inst_t cmd_dump = { 5479 .f = cmd_dump_parsed, /* function to call */ 5480 .data = NULL, /* 2nd arg of func */ 5481 .help_str = "dump status", 5482 .tokens = { /* token list, NULL terminated */ 5483 (void *)&cmd_dump_dump, 5484 NULL, 5485 }, 5486 }; 5487 5488 /* ******************************************************************************** */ 5489 5490 struct cmd_dump_one_result { 5491 cmdline_fixed_string_t dump; 5492 cmdline_fixed_string_t name; 5493 }; 5494 5495 static void cmd_dump_one_parsed(void *parsed_result, struct cmdline *cl, 5496 __attribute__((unused)) void *data) 5497 { 5498 struct cmd_dump_one_result *res = parsed_result; 5499 5500 if (!strcmp(res->dump, "dump_ring")) { 5501 struct rte_ring *r; 5502 r = rte_ring_lookup(res->name); 5503 if (r == NULL) { 5504 cmdline_printf(cl, "Cannot find ring\n"); 5505 return; 5506 } 5507 rte_ring_dump(stdout, r); 5508 } else if (!strcmp(res->dump, "dump_mempool")) { 5509 struct rte_mempool *mp; 5510 mp = rte_mempool_lookup(res->name); 5511 if (mp == NULL) { 5512 cmdline_printf(cl, "Cannot find mempool\n"); 5513 return; 5514 } 5515 rte_mempool_dump(stdout, mp); 5516 } 5517 } 5518 5519 cmdline_parse_token_string_t cmd_dump_one_dump = 5520 TOKEN_STRING_INITIALIZER(struct cmd_dump_one_result, dump, 5521 "dump_ring#dump_mempool"); 5522 5523 cmdline_parse_token_string_t cmd_dump_one_name = 5524 TOKEN_STRING_INITIALIZER(struct cmd_dump_one_result, name, NULL); 5525 5526 cmdline_parse_inst_t cmd_dump_one = { 5527 .f = cmd_dump_one_parsed, /* function to call */ 5528 .data = NULL, /* 2nd arg of func */ 5529 .help_str = "dump one ring/mempool: dump_ring|dump_mempool <name>", 5530 .tokens = { /* token list, NULL terminated */ 5531 (void *)&cmd_dump_one_dump, 5532 (void *)&cmd_dump_one_name, 5533 NULL, 5534 }, 5535 }; 5536 5537 /* ******************************************************************************** */ 5538 5539 /* list of instructions */ 5540 cmdline_parse_ctx_t main_ctx[] = { 5541 (cmdline_parse_inst_t *)&cmd_help_brief, 5542 (cmdline_parse_inst_t *)&cmd_help_long, 5543 (cmdline_parse_inst_t *)&cmd_quit, 5544 (cmdline_parse_inst_t *)&cmd_showport, 5545 (cmdline_parse_inst_t *)&cmd_showportall, 5546 (cmdline_parse_inst_t *)&cmd_showcfg, 5547 (cmdline_parse_inst_t *)&cmd_start, 5548 (cmdline_parse_inst_t *)&cmd_start_tx_first, 5549 (cmdline_parse_inst_t *)&cmd_set_link_up, 5550 (cmdline_parse_inst_t *)&cmd_set_link_down, 5551 (cmdline_parse_inst_t *)&cmd_reset, 5552 (cmdline_parse_inst_t *)&cmd_set_numbers, 5553 (cmdline_parse_inst_t *)&cmd_set_txpkts, 5554 (cmdline_parse_inst_t *)&cmd_set_fwd_list, 5555 (cmdline_parse_inst_t *)&cmd_set_fwd_mask, 5556 (cmdline_parse_inst_t *)&cmd_set_fwd_mode, 5557 (cmdline_parse_inst_t *)&cmd_set_burst_tx_retry, 5558 (cmdline_parse_inst_t *)&cmd_set_promisc_mode_one, 5559 (cmdline_parse_inst_t *)&cmd_set_promisc_mode_all, 5560 (cmdline_parse_inst_t *)&cmd_set_allmulti_mode_one, 5561 (cmdline_parse_inst_t *)&cmd_set_allmulti_mode_all, 5562 (cmdline_parse_inst_t *)&cmd_set_flush_rx, 5563 (cmdline_parse_inst_t *)&cmd_set_link_check, 5564 #ifdef RTE_NIC_BYPASS 5565 (cmdline_parse_inst_t *)&cmd_set_bypass_mode, 5566 (cmdline_parse_inst_t *)&cmd_set_bypass_event, 5567 (cmdline_parse_inst_t *)&cmd_set_bypass_timeout, 5568 (cmdline_parse_inst_t *)&cmd_show_bypass_config, 5569 #endif 5570 (cmdline_parse_inst_t *)&cmd_vlan_offload, 5571 (cmdline_parse_inst_t *)&cmd_vlan_tpid, 5572 (cmdline_parse_inst_t *)&cmd_rx_vlan_filter_all, 5573 (cmdline_parse_inst_t *)&cmd_rx_vlan_filter, 5574 (cmdline_parse_inst_t *)&cmd_tx_vlan_set, 5575 (cmdline_parse_inst_t *)&cmd_tx_vlan_reset, 5576 (cmdline_parse_inst_t *)&cmd_tx_cksum_set, 5577 (cmdline_parse_inst_t *)&cmd_link_flow_control_set, 5578 (cmdline_parse_inst_t *)&cmd_priority_flow_control_set, 5579 (cmdline_parse_inst_t *)&cmd_config_dcb, 5580 (cmdline_parse_inst_t *)&cmd_read_reg, 5581 (cmdline_parse_inst_t *)&cmd_read_reg_bit_field, 5582 (cmdline_parse_inst_t *)&cmd_read_reg_bit, 5583 (cmdline_parse_inst_t *)&cmd_write_reg, 5584 (cmdline_parse_inst_t *)&cmd_write_reg_bit_field, 5585 (cmdline_parse_inst_t *)&cmd_write_reg_bit, 5586 (cmdline_parse_inst_t *)&cmd_read_rxd_txd, 5587 (cmdline_parse_inst_t *)&cmd_add_signature_filter, 5588 (cmdline_parse_inst_t *)&cmd_upd_signature_filter, 5589 (cmdline_parse_inst_t *)&cmd_rm_signature_filter, 5590 (cmdline_parse_inst_t *)&cmd_add_perfect_filter, 5591 (cmdline_parse_inst_t *)&cmd_upd_perfect_filter, 5592 (cmdline_parse_inst_t *)&cmd_rm_perfect_filter, 5593 (cmdline_parse_inst_t *)&cmd_set_masks_filter, 5594 (cmdline_parse_inst_t *)&cmd_set_ipv6_masks_filter, 5595 (cmdline_parse_inst_t *)&cmd_stop, 5596 (cmdline_parse_inst_t *)&cmd_mac_addr, 5597 (cmdline_parse_inst_t *)&cmd_set_qmap, 5598 (cmdline_parse_inst_t *)&cmd_operate_port, 5599 (cmdline_parse_inst_t *)&cmd_operate_specific_port, 5600 (cmdline_parse_inst_t *)&cmd_config_speed_all, 5601 (cmdline_parse_inst_t *)&cmd_config_speed_specific, 5602 (cmdline_parse_inst_t *)&cmd_config_rx_tx, 5603 (cmdline_parse_inst_t *)&cmd_config_max_pkt_len, 5604 (cmdline_parse_inst_t *)&cmd_config_rx_mode_flag, 5605 (cmdline_parse_inst_t *)&cmd_config_rss, 5606 (cmdline_parse_inst_t *)&cmd_config_rss_reta, 5607 (cmdline_parse_inst_t *)&cmd_showport_reta, 5608 (cmdline_parse_inst_t *)&cmd_config_burst, 5609 (cmdline_parse_inst_t *)&cmd_config_thresh, 5610 (cmdline_parse_inst_t *)&cmd_config_threshold, 5611 (cmdline_parse_inst_t *)&cmd_set_vf_rxmode, 5612 (cmdline_parse_inst_t *)&cmd_set_uc_hash_filter, 5613 (cmdline_parse_inst_t *)&cmd_set_uc_all_hash_filter, 5614 (cmdline_parse_inst_t *)&cmd_vf_mac_addr_filter , 5615 (cmdline_parse_inst_t *)&cmd_set_vf_traffic, 5616 (cmdline_parse_inst_t *)&cmd_vf_rxvlan_filter, 5617 (cmdline_parse_inst_t *)&cmd_queue_rate_limit, 5618 (cmdline_parse_inst_t *)&cmd_vf_rate_limit, 5619 (cmdline_parse_inst_t *)&cmd_set_mirror_mask, 5620 (cmdline_parse_inst_t *)&cmd_set_mirror_link, 5621 (cmdline_parse_inst_t *)&cmd_reset_mirror_rule, 5622 (cmdline_parse_inst_t *)&cmd_showport_rss_hash, 5623 (cmdline_parse_inst_t *)&cmd_showport_rss_hash_key, 5624 (cmdline_parse_inst_t *)&cmd_config_rss_hash_key, 5625 (cmdline_parse_inst_t *)&cmd_dump, 5626 (cmdline_parse_inst_t *)&cmd_dump_one, 5627 NULL, 5628 }; 5629 5630 /* prompt function, called from main on MASTER lcore */ 5631 void 5632 prompt(void) 5633 { 5634 struct cmdline *cl; 5635 5636 /* initialize non-constant commands */ 5637 cmd_set_fwd_mode_init(); 5638 5639 cl = cmdline_stdin_new(main_ctx, "testpmd> "); 5640 if (cl == NULL) { 5641 return; 5642 } 5643 cmdline_interact(cl); 5644 cmdline_stdin_exit(cl); 5645 } 5646 5647 static void 5648 cmd_reconfig_device_queue(portid_t id, uint8_t dev, uint8_t queue) 5649 { 5650 if (id < nb_ports) { 5651 /* check if need_reconfig has been set to 1 */ 5652 if (ports[id].need_reconfig == 0) 5653 ports[id].need_reconfig = dev; 5654 /* check if need_reconfig_queues has been set to 1 */ 5655 if (ports[id].need_reconfig_queues == 0) 5656 ports[id].need_reconfig_queues = queue; 5657 } else { 5658 portid_t pid; 5659 5660 for (pid = 0; pid < nb_ports; pid++) { 5661 /* check if need_reconfig has been set to 1 */ 5662 if (ports[pid].need_reconfig == 0) 5663 ports[pid].need_reconfig = dev; 5664 /* check if need_reconfig_queues has been set to 1 */ 5665 if (ports[pid].need_reconfig_queues == 0) 5666 ports[pid].need_reconfig_queues = queue; 5667 } 5668 } 5669 } 5670 5671 #ifdef RTE_NIC_BYPASS 5672 uint8_t 5673 bypass_is_supported(portid_t port_id) 5674 { 5675 struct rte_port *port; 5676 struct rte_pci_id *pci_id; 5677 5678 if (port_id >= nb_ports) { 5679 printf("\tPort id must be less than %d.\n", nb_ports); 5680 return 0; 5681 } 5682 5683 /* Get the device id. */ 5684 port = &ports[port_id]; 5685 pci_id = &port->dev_info.pci_dev->id; 5686 5687 /* Check if NIC supports bypass. */ 5688 if (pci_id->device_id == IXGBE_DEV_ID_82599_BYPASS) { 5689 return 1; 5690 } 5691 else { 5692 printf("\tBypass not supported for port_id = %d.\n", port_id); 5693 return 0; 5694 } 5695 } 5696 #endif 5697